tiny.closure.baseline

1pub const AuditInput = struct {2    generation: schema.GenerationId,3    source_reference: schema.Descriptor,4    source_revision: schema.Digest,5    zig_version: schema.Descriptor,6    optimize: schema.Descriptor,7    artifact_bytes: u64,8    artifact_digest: schema.Digest,9    ranges: []const Range,10    evidence: []const Evidence,11};

1pub const Evidence = struct {2    kind: EvidenceKind,3    digest: schema.Digest,4};

1pub const EvidenceKind = enum {2    symbols,3    relocations,4};

1pub const Range = struct {2    offset: u64,3    length: u64,4    digest: schema.Digest,5    executable: bool,6};

1pub const Storage = struct {2    nodes: [limits.nodes_max]schema.Node = undefined,3    edges: [limits.edges_max]schema.Edge = undefined,4    artifacts: [limits.artifacts_max]schema.Artifact = undefined,5    ranges: [limits.ranges_max]schema.ByteRange = undefined,6    digests: [limits.digests_max]schema.DigestRecord = undefined,7    provenance: [limits.provenance_parents_max]schema.ProvenanceParent = undefined,8    sources: [limits.source_records_max]schema.SourceRecord = undefined,9    builds: [limits.build_records_max]schema.BuildRecord = undefined,10    authorities: [limits.authorities_max]schema.Authority = undefined,11    lineages: [limits.lineage_references_max]schema.LineageReference = undefined,12    services: [limits.service_descriptors_max]schema.ServiceDescriptor = undefined,13    roots: [limits.residual_roots_max]schema.ResidualRoot = undefined,14    claims: [limits.claims_max]schema.Claim = undefined,15    claim_nodes: [limits.claim_nodes_max]schema.ClaimNode = undefined,16    node_count: u16 = 0,17    edge_count: u16 = 0,18    artifact_count: u16 = 0,19    range_count: u16 = 0,20    digest_count: u16 = 0,21    provenance_count: u16 = 0,22    source_count: u16 = 0,23    build_count: u16 = 0,24    authority_count: u16 = 0,25    lineage_count: u16 = 0,26    service_count: u16 = 0,27    root_count: u16 = 0,28    claim_count: u16 = 0,29    claim_node_count: u16 = 0,3031    fn reset(self: *Storage) void {32        self.node_count = 0;33        self.edge_count = 0;34        self.artifact_count = 0;35        self.range_count = 0;36        self.digest_count = 0;37        self.provenance_count = 0;38        self.source_count = 0;39        self.build_count = 0;40        self.authority_count = 0;41        self.lineage_count = 0;42        self.service_count = 0;43        self.root_count = 0;44        self.claim_count = 0;45        self.claim_node_count = 0;46    }4748    fn addNode(self: *Storage, value: schema.Node) Error!schema.NodeId {49        if (self.node_count == self.nodes.len) {50            return error.NodeCapacityExceeded;51        }52        const id: schema.NodeId = @as(u32, self.node_count) + 1;53        var stored = value;54        stored.id = id;55        self.nodes[self.node_count] = stored;56        self.node_count += 1;57        return id;58    }5960    fn addEdge(self: *Storage, value: schema.Edge) Error!schema.RecordId {61        if (self.edge_count == self.edges.len) {62            return error.EdgeCapacityExceeded;63        }64        const id: schema.RecordId = @as(u32, self.edge_count) + 1;65        var stored = value;66        stored.id = id;67        self.edges[self.edge_count] = stored;68        self.edge_count += 1;69        return id;70    }7172    fn addArtifact(73        self: *Storage,74        value: schema.Artifact,75    ) Error!schema.RecordId {76        if (self.artifact_count == self.artifacts.len) {77            return error.ArtifactCapacityExceeded;78        }79        const id: schema.RecordId = @as(u32, self.artifact_count) + 1;80        var stored = value;81        stored.id = id;82        self.artifacts[self.artifact_count] = stored;83        self.artifact_count += 1;84        return id;85    }8687    fn addRange(88        self: *Storage,89        value: schema.ByteRange,90    ) Error!schema.RecordId {91        if (self.range_count == self.ranges.len) {92            return error.RangeCapacityExceeded;93        }94        const id: schema.RecordId = @as(u32, self.range_count) + 1;95        var stored = value;96        stored.id = id;97        self.ranges[self.range_count] = stored;98        self.range_count += 1;99        return id;100    }101102    fn addDigest(103        self: *Storage,104        value: schema.DigestRecord,105    ) Error!schema.RecordId {106        if (self.digest_count == self.digests.len) {107            return error.DigestCapacityExceeded;108        }109        const id: schema.RecordId = @as(u32, self.digest_count) + 1;110        var stored = value;111        stored.id = id;112        self.digests[self.digest_count] = stored;113        self.digest_count += 1;114        return id;115    }116117    fn addProvenance(118        self: *Storage,119        value: schema.ProvenanceParent,120    ) Error!schema.RecordId {121        if (self.provenance_count == self.provenance.len) {122            return error.ProvenanceCapacityExceeded;123        }124        const id: schema.RecordId = @as(u32, self.provenance_count) + 1;125        var stored = value;126        stored.id = id;127        self.provenance[self.provenance_count] = stored;128        self.provenance_count += 1;129        return id;130    }131132    fn addSource(133        self: *Storage,134        value: schema.SourceRecord,135    ) Error!schema.RecordId {136        if (self.source_count == self.sources.len) {137            return error.SourceCapacityExceeded;138        }139        const id: schema.RecordId = @as(u32, self.source_count) + 1;140        var stored = value;141        stored.id = id;142        self.sources[self.source_count] = stored;143        self.source_count += 1;144        return id;145    }146147    fn addBuild(148        self: *Storage,149        value: schema.BuildRecord,150    ) Error!schema.RecordId {151        if (self.build_count == self.builds.len) {152            return error.BuildCapacityExceeded;153        }154        const id: schema.RecordId = @as(u32, self.build_count) + 1;155        var stored = value;156        stored.id = id;157        self.builds[self.build_count] = stored;158        self.build_count += 1;159        return id;160    }161162    fn addLineage(163        self: *Storage,164        value: schema.LineageReference,165    ) Error!schema.RecordId {166        if (self.lineage_count == self.lineages.len) {167            return error.LineageCapacityExceeded;168        }169        const id: schema.RecordId = @as(u32, self.lineage_count) + 1;170        var stored = value;171        stored.id = id;172        self.lineages[self.lineage_count] = stored;173        self.lineage_count += 1;174        return id;175    }176177    fn addService(178        self: *Storage,179        value: schema.ServiceDescriptor,180    ) Error!schema.RecordId {181        if (self.service_count == self.services.len) {182            return error.ServiceCapacityExceeded;183        }184        const id: schema.RecordId = @as(u32, self.service_count) + 1;185        var stored = value;186        stored.id = id;187        self.services[self.service_count] = stored;188        self.service_count += 1;189        return id;190    }191192    fn addRoot(193        self: *Storage,194        value: schema.ResidualRoot,195    ) Error!schema.RecordId {196        if (self.root_count == self.roots.len) {197            return error.RootCapacityExceeded;198        }199        const id: schema.RecordId = @as(u32, self.root_count) + 1;200        var stored = value;201        stored.id = id;202        self.roots[self.root_count] = stored;203        self.root_count += 1;204        return id;205    }206207    fn addClaim(self: *Storage, value: schema.Claim) Error!schema.ClaimId {208        if (self.claim_count == self.claims.len) {209            return error.ClaimCapacityExceeded;210        }211        const id: schema.ClaimId = @as(u32, self.claim_count) + 1;212        var stored = value;213        stored.id = id;214        self.claims[self.claim_count] = stored;215        self.claim_count += 1;216        return id;217    }218219    fn addClaimNode(220        self: *Storage,221        value: schema.ClaimNode,222    ) Error!schema.RecordId {223        if (self.claim_node_count == self.claim_nodes.len) {224            return error.ClaimNodeCapacityExceeded;225        }226        const id: schema.RecordId = @as(u32, self.claim_node_count) + 1;227        var stored = value;228        stored.id = id;229        self.claim_nodes[self.claim_node_count] = stored;230        self.claim_node_count += 1;231        return id;232    }233234    fn input(235        self: *const Storage,236        generation: schema.GenerationId,237        root: schema.Digest,238    ) schema.GenerationInput {239        return .{240            .id = generation,241            .root = root,242            .nodes = self.nodes[0..self.node_count],243            .edges = self.edges[0..self.edge_count],244            .artifacts = self.artifacts[0..self.artifact_count],245            .ranges = self.ranges[0..self.range_count],246            .digests = self.digests[0..self.digest_count],247            .provenance_parents = self.provenance[0..self.provenance_count],248            .source_records = self.sources[0..self.source_count],249            .build_records = self.builds[0..self.build_count],250            .authorities = self.authorities[0..self.authority_count],251            .lineage_references = self.lineages[0..self.lineage_count],252            .service_descriptors = self.services[0..self.service_count],253            .residual_roots = self.roots[0..self.root_count],254            .claims = self.claims[0..self.claim_count],255            .claim_nodes = self.claim_nodes[0..self.claim_node_count],256        };257    }258};

1pub const Error = schema.Name.Error || schema.Descriptor.Error ||2    schema.Digest.ParseError || AssemblyError;

1pub fn assemble(2    storage: *Storage,3    audit: AuditInput,4) Error!schema.GenerationInput {5    try preflight(audit);6    storage.reset();7    const profiles = try loadProfiles();8    const graph = try addGraph(storage, audit, profiles);9    const artifact = try addArtifact(storage, audit, graph.auditor);10    try addEvidence(storage, audit, profiles, graph);11    try addEdges(storage, graph);12    const claim = try addClaim(13        storage,14        artifact,15        audit.artifact_digest,16        profiles,17    );18    try addTreatments(storage, graph, claim);19    var generation = storage.input(20        audit.generation,21        schema.Digest.zero(),22    );23    generation.root = canonical.generation(generation);24    return generation;25}

1const assembly = @import("assemble.zig");23pub const AuditInput = assembly.AuditInput;4pub const Error = assembly.Error;5pub const Evidence = assembly.Evidence;6pub const EvidenceKind = assembly.EvidenceKind;7pub const Range = assembly.Range;8pub const Storage = assembly.Storage;9pub const assemble = assembly.assemble;

1pub const baseline = @import("baseline/root.zig");