tiny.trace.TraceReaderStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: capacity_mod.Capacity,4    bytes: []u8,5    in_use: bool = false,67    pub const Limits: type = capacity_mod.Limits;8    pub const Capacity: type = capacity_mod.Capacity;9    pub const Exhaustion: type = @import("storage.zig").Exhaustion;10    pub const InitError = std.mem.Allocator.Error || capacity_mod.DeriveError;1112    pub const claim: alloc_phase.capacity.Declaration = .{13        .source = .{14            .id = "trace.trace_reader_storage",15            .kind = .phase_static,16            .limit_source = .caller,17            .storage = .{18                .covered = &.{19                    .{20                        .id = "retained_trace_root_path",21                        .lifetime = .steady,22                        .detail = "retained trace root path",23                    },24                    .{25                        .id = "phase_shared_bounded_manifest_and_binary_event_block_input",26                        .lifetime = .steady,27                        .detail = "phase-shared bounded manifest and binary event-block input",28                    },29                    .{30                        .id = "joined_path_construction_and_manifest_json_nesting_bits",31                        .lifetime = .steady,32                        .detail = "joined-path construction and manifest JSON nesting bits",33                    },34                    .{35                        .id = "bounded_lib_sql_pager_and_read_heap",36                        .lifetime = .steady,37                        .detail = "bounded lib/sql pager and read heap",38                    },39                },40                .excluded = &.{41                    "filesystem implementation and kernel file state",42                    "replay Session state and consumer-owned event clones",43                    "trace writer encoding storage",44                },45            },46            .capacity = .{47                .inputs = &.{48                    alloc_phase.capacity.bindInput(Limits, "chunk_bytes", "chunk_bytes"),49                    alloc_phase.capacity.bindInput(Limits, "event_bytes", "event_bytes"),50                    alloc_phase.capacity.bindInput(Limits, "json_nesting", "json_nesting"),51                    alloc_phase.capacity.bindInput(Limits, "root_path_bytes", "root_path_bytes"),52                },53                .type_selectors = &.{},54                .nodes = &.{55                    .{ .input = 0 },56                    .{ .input = 1 },57                    .{ .input = 2 },58                    .{ .input = 3 },59                    .{ .add = .{ .left = 0, .right = 1 } },60                    .{ .add = .{ .left = 4, .right = 2 } },61                    .{ .add = .{ .left = 5, .right = 3 } },62                },63                .assertions = &.{.{64                    .scope = .closure_total,65                    .measure = .retained,66                    .relation = .upper_bound,67                    .expression = 6,68                }},69            },70            .overload = .{71                .kind = .reject_before_mutation,72                .detail = "open rejects root path and manifest event/chunk limits at max plus one before publishing reader state",73            },74            .risks = .{75                .transitive = .{76                    .status = .witnessed,77                    .detail = "open, SQL block identity admission, binary event decoding, logical chunk rollover, and verification consume only acquired reader regions after activation",78                },79                .foreign = .{80                    .status = .excluded,81                    .detail = "filesystem calls and kernel buffering remain effects outside the caller allocator and this storage owner",82                },83            },84            .dependencies = &.{ "sql.wal_writer", "sql.file_transaction_staging" },85            .obligations = &.{86                .{ .key = "trace_trace_reader_capacity", .role = .capacity_model },87                .{ .key = "trace_trace_reader_acquisition", .role = .custom },88                .{ .key = "trace_trace_reader_oom", .role = .custom },89                .{ .key = "trace_trace_reader_boundary", .role = .overload },90                .{ .key = "trace_trace_reader_nesting", .role = .overload },91                .{ .key = "trace_trace_reader_open_atomic", .role = .overload },92                .{ .key = "trace_trace_reader_sealed", .role = .transitive_risk },93                .{ .key = "trace_trace_reader_rollover", .role = .foreign_risk },94                .{ .key = "trace_trace_reader_root", .role = .custom },95                .{ .key = "trace_trace_reader_tuning", .role = .custom },96            },97        },98        .bindings = .{99            .owner = @This(),100            .seal = .{101                .family = alloc_phase.capacity.selector(@This().activate),102                .premise = .{103                    .class = .checked_semantic_fact,104                    .authority = .checker,105                },106            },107            .teardown = .{108                .family = alloc_phase.capacity.selector(@This().deinit),109                .premise = .{110                    .class = .checked_semantic_fact,111                    .authority = .checker,112                },113            },114        },115    };116117    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Storage {118        const capacity = try Capacity.derive(limits);119        return .{120            .phase = .initialization,121            .capacity = capacity,122            .bytes = try allocator.alloc(u8, capacity.storage_bytes),123        };124    }125126    pub fn activate(self: *Storage) void {127        std.debug.assert(self.phase == .initialization);128        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);129        self.phase = .steady;130    }131132    pub fn acquire(self: *Storage, usage: Usage) Storage.Exhaustion!Regions {133        std.debug.assert(self.phase == .steady);134        if (self.in_use) return error.ReaderStorageInUse;135        if (usage.root_path_bytes > self.capacity.root_path_bytes) return error.RootPathCapacityExceeded;136        self.in_use = true;137        return .{138            .root_path = self.region(self.capacity.root_path_offset, usage.root_path_bytes),139            .input = self.region(self.capacity.input_offset, self.capacity.input_bytes),140            .path = self.region(self.capacity.path_offset, self.capacity.path_bytes),141            .json_stack = self.region(self.capacity.json_stack_offset, self.capacity.json_stack_bytes),142            .sql = self.region(self.capacity.sql_offset, self.capacity.sql_bytes),143        };144    }145146    pub fn admit(self: *const Storage, limits: format.Limits) Storage.Exhaustion!void {147        std.debug.assert(self.phase == .steady);148        std.debug.assert(self.in_use);149        if (limits.max_event_bytes > self.capacity.event_bytes) return error.EventCapacityExceeded;150        if (limits.max_chunk_bytes > self.capacity.chunk_bytes) return error.ChunkCapacityExceeded;151    }152153    pub fn release(self: *Storage) void {154        std.debug.assert(self.phase == .steady);155        std.debug.assert(self.in_use);156        self.in_use = false;157    }158159    pub fn status(self: *const Storage) Status {160        return .{161            .phase = self.phase,162            .in_use = self.in_use,163            .storage_bytes = self.capacity.storage_bytes,164            .event_bytes = self.capacity.event_bytes,165            .chunk_bytes = self.capacity.chunk_bytes,166            .block_bytes = self.capacity.block_bytes,167            .json_nesting = self.capacity.json_nesting,168            .sql_bytes = self.capacity.sql_bytes,169        };170    }171172    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {173        std.debug.assert(self.phase != .teardown);174        std.debug.assert(!self.in_use);175        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);176        self.phase = .teardown;177        allocator.free(self.bytes);178        self.bytes = &.{};179    }180181    fn region(self: *Storage, offset: usize, count: usize) []u8 {182        return self.bytes[offset..][0..count];183    }184};

1pub const TraceReaderStorage = store.ReaderStorage;