tiny.choir.product

1pub const Storage = struct {2    pub const Limits = struct {3        segments: [segment_count]Segment,4    };56    pub const Capacity = struct {7        offsets: [segment_count]usize,8        byte_lengths: [segment_count]usize,9        alignments: [segment_count]std.mem.Alignment,10        total_bytes: usize,11        allocation_alignment: std.mem.Alignment,1213        pub fn derive(limits: Limits) error{CapacityOverflow}!Capacity {14            var offsets: [segment_count]usize = undefined;15            var byte_lengths: [segment_count]usize = undefined;16            var alignments: [segment_count]std.mem.Alignment = undefined;17            var cursor: usize = 0;18            var allocation_alignment: usize = 1;19            for (limits.segments, &offsets, &byte_lengths, &alignments) |segment_value, *offset, *byte_length, *alignment| {20                byte_length.* = std.math.mul(21                    usize,22                    segment_value.count,23                    segment_value.element_bytes,24                ) catch return error.CapacityOverflow;25                offset.* = try placeBytes(26                    byte_length.*,27                    segment_value.alignment.toByteUnits(),28                    &cursor,29                    &allocation_alignment,30                );31                alignment.* = segment_value.alignment;32            }33            return .{34                .offsets = offsets,35                .byte_lengths = byte_lengths,36                .alignments = alignments,37                .total_bytes = cursor,38                .allocation_alignment = .fromByteUnits(allocation_alignment),39            };40        }41    };4243    pub const InitError = Allocator.Error || error{CapacityOverflow};4445    pub const claim: alloc_phase.capacity.Declaration = .{46        .source = .{47            .id = "choir.product_metadata_storage",48            .kind = .phase_static,49            .limit_source = .caller,50            .storage = .{51                .covered = &.{52                    .{53                        .id = "durable_product_graph_records_and_names",54                        .lifetime = .steady,55                        .detail = "durable product graph records and names",56                    },57                    .{58                        .id = "durable_refresh_plan_records_and_names",59                        .lifetime = .steady,60                        .detail = "durable refresh plan records and names",61                    },62                    .{63                        .id = "durable_refresh_report_projections",64                        .lifetime = .steady,65                        .detail = "durable refresh report projections",66                    },67                },68                .excluded = &.{69                    "borrowing product graph builders and closure workspaces",70                    "caller-owned source metadata and allocator implementation state",71                    "retained exact records in separately bounded revision stores",72                },73            },74            .capacity = .{75                .inputs = &.{},76                .type_selectors = &.{},77                .nodes = &.{78                    .{ .constant = 0 },79                },80                .assertions = &.{.{81                    .scope = .closure_total,82                    .measure = .retained,83                    .relation = .exact,84                    .expression = 0,85                }},86            },87            .overload = .{88                .kind = .reject_before_seal,89                .detail = "count, name-byte, layout, or allocation failure returns before a durable product value is published",90            },91            .risks = .{92                .transitive = .{93                    .status = .witnessed,94                    .detail = "graph queries read retained immutable revision records; teardown releases those handles after the local region",95                },96                .foreign = .{97                    .status = .excluded,98                    .detail = "product metadata construction and queries cross no operating-system or foreign callback boundary",99                },100            },101            .obligations = &.{102                .{ .key = "choir_product_metadata_capacity", .role = .capacity_model },103                .{ .key = "choir_product_metadata_acquisition", .role = .custom },104                .{ .key = "choir_product_metadata_boundary", .role = .overload },105                .{ .key = "choir_product_metadata_oom", .role = .overload },106                .{ .key = "choir_product_graph_lifetime_transitive_risk", .role = .transitive_risk },107                .{ .key = "choir_product_graph_lifetime_foreign_risk", .role = .foreign_risk },108                .{ .key = "choir_product_refresh_lifetime", .role = .transitive_risk },109                .{ .key = "choir_product_report_composition_lifetime", .role = .transitive_risk },110                .{ .key = "choir_product_metadata_integration", .role = .custom },111            },112        },113        .bindings = .{114            .owner = @This(),115            .seal = .{116                .family = alloc_phase.capacity.selector(@This().activate),117                .premise = .{118                    .class = .checked_semantic_fact,119                    .authority = .checker,120                },121            },122            .teardown = .{123                .family = alloc_phase.capacity.selector(@This().deinit),124                .premise = .{125                    .class = .checked_semantic_fact,126                    .authority = .checker,127                },128            },129        },130    };131132    phase: alloc_phase.capacity.Phase,133    capacity: Capacity,134    bytes: [*]u8,135136    pub fn init(allocator: Allocator, limits: Limits) InitError!Storage {137        const capacity = try Capacity.derive(limits);138        std.debug.assert(capacity.total_bytes > 0);139        const bytes = allocator.rawAlloc(140            capacity.total_bytes,141            capacity.allocation_alignment,142            @returnAddress(),143        ) orelse return error.OutOfMemory;144        return .{145            .phase = .initialization,146            .capacity = capacity,147            .bytes = bytes,148        };149    }150151    pub fn region(self: *Storage, comptime T: type, comptime index: usize, count: usize) []T {152        comptime std.debug.assert(index < segment_count);153        std.debug.assert(self.phase == .initialization);154        const byte_length = std.math.mul(usize, count, @sizeOf(T)) catch unreachable;155        std.debug.assert(byte_length == self.capacity.byte_lengths[index]);156        std.debug.assert(@alignOf(T) == self.capacity.alignments[index].toByteUnits());157        const offset = self.capacity.offsets[index];158        const address = std.math.add(usize, @intFromPtr(self.bytes), offset) catch unreachable;159        const raw: [*]u8 = @ptrFromInt(address);160        const items: [*]T = @ptrCast(@alignCast(raw));161        return items[0..count];162    }163164    pub fn activate(self: *Storage) void {165        std.debug.assert(self.phase == .initialization);166        self.phase = .steady;167    }168169    pub fn status(self: *const Storage) alloc_phase.capacity.Phase {170        return self.phase;171    }172173    pub fn deinit(self: *Storage, allocator: Allocator) void {174        std.debug.assert(self.phase != .teardown);175        self.phase = .teardown;176        allocator.rawFree(177            self.bytes[0..self.capacity.total_bytes],178            self.capacity.allocation_alignment,179            @returnAddress(),180        );181        self.* = undefined;182    }183};

1pub const hashing = @import("hashing/root.zig");2pub const incremental = @import("incremental.zig");3pub const entity = @import("entity.zig");4pub const operation = @import("operation.zig");56pub const StableHasher = hashing.StableHasher;7pub const StableValueNumbering = hashing.StableValueNumbering;8pub const OperationFingerprintError = hashing.OperationFingerprintError;9pub const operationFingerprint = hashing.operationFingerprint;1011pub const EntityNamespace = revision.record.Namespace;12pub const EntityRef = revision.store.Entity;13pub const EntityImage = entity.Image;14pub const OperationProduct = operation.Product;15pub const OperationJob = operation.Job;16pub const OperationConfiguration = operation.Configuration;1718pub const Fingerprint = incremental.Fingerprint;19pub const FingerprintBuilder = incremental.FingerprintBuilder;20pub const ProductStamp = incremental.ProductStamp;21pub const ProductRef = incremental.ProductRef;22pub const ProductKey = incremental.ProductKey;23pub const ProductDependency = incremental.ProductDependency;24pub const ProductRefreshReason = incremental.ProductRefreshReason;25pub const ProductMaterialization = incremental.ProductMaterialization;26pub const ProductDependencyChange = incremental.ProductDependencyChange;27pub const ProductRefreshDecision = incremental.ProductRefreshDecision;28pub const ProductMetadataError = incremental.ProductMetadataError;29pub const ProductRefreshPlan = incremental.ProductRefreshPlan;30pub const ProductGraph = incremental.ProductGraph;31pub const ProductGraphBuilderError = incremental.ProductGraphBuilderError;32pub const ProductGraphBuilder = incremental.ProductGraphBuilder;33pub const ProductRefreshReport = incremental.ProductRefreshReport;34pub const productStamp = incremental.productStamp;35pub const productRef = incremental.productRef;36pub const cloneProductRef = incremental.cloneProductRef;37pub const deinitProductRef = incremental.deinitProductRef;38pub const productKey = incremental.productKey;39pub const cloneProductKey = incremental.cloneProductKey;40pub const deinitProductKey = incremental.deinitProductKey;41pub const productDependency = incremental.productDependency;42pub const derivedProductStamp = incremental.derivedProductStamp;43pub const productRefsContain = incremental.productRefsContain;44pub const fingerprintBytes = incremental.fingerprintBytes;4546pub const ProductMetadataStorage = @import("storage.zig").Storage;47pub const revision = @import("revision/root.zig");48pub const recipe = @import("recipe.zig");49pub const compiler = @import("compiler.zig");

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