tiny.pdf.FilterStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: capacity_mod.Capacity,4    bytes: []align(capacity_mod.storage_alignment) u8,5    output: []u8,6    in_use: bool = false,78    pub const Limits: type = capacity_mod.Limits;9    pub const Capacity: type = capacity_mod.Capacity;10    pub const Exhaustion: type = model.Exhaustion;11    pub const InitError: type = std.mem.Allocator.Error;12    pub const AcquireError = model.Exhaustion || error{DecodeStorageInUse};1314    pub const claim: alloc_phase.capacity.Declaration = .{15        .source = .{16            .id = "pdf.filter_storage",17            .kind = .phase_static,18            .limit_source = .caller,19            .storage = .{20                .covered = &.{21                    .{22                        .id = "decoded_stream_output",23                        .lifetime = .steady,24                        .detail = "decoded stream output",25                    },26                },27                .excluded = &.{28                    "caller-owned PDF input bytes",29                    "PDF object graph, caches, and extracted text",30                    "filesystem and presentation storage",31                },32            },33            .capacity = .{34                .inputs = &.{35                    alloc_phase.capacity.bindInput(Limits, "bounds_decoded_bytes", "bounds.decoded_bytes"),36                },37                .type_selectors = &.{},38                .nodes = &.{39                    .{ .input = 0 },40                },41                .assertions = &.{.{42                    .scope = .closure_total,43                    .measure = .retained,44                    .relation = .exact,45                    .expression = 0,46                }},47            },48            .overload = .{49                .kind = .reject_before_mutation,50                .detail = "Input rejects first; decode overflow remains private and unpublished.",51            },52            .risks = .{53                .transitive = .{54                    .status = .witnessed,55                    .detail = "One region covers DEFLATE and predictor reconstruction.",56                },57                .foreign = .{58                    .status = .excluded,59                    .detail = "stream decoding is process-local and crosses no callback or OS edge",60                },61            },62            .obligations = &.{63                .{ .key = "pdf_filter_capacity", .role = .capacity_model },64                .{ .key = "pdf_filter_acquisition", .role = .custom },65                .{ .key = "pdf_filter_oom", .role = .custom },66                .{ .key = "pdf_filter_boundaries", .role = .overload },67                .{ .key = "pdf_filter_reuse", .role = .overload },68                .{ .key = "pdf_filter_decode_overflow", .role = .overload },69                .{ .key = "pdf_filter_sealed", .role = .transitive_risk },70                .{ .key = "pdf_filter_root", .role = .custom },71                .{ .key = "pdf_filter_consumer", .role = .foreign_risk },72            },73        },74        .bindings = .{75            .owner = @This(),76            .seal = .{77                .family = alloc_phase.capacity.selector(@This().activate),78                .premise = .{79                    .class = .checked_semantic_fact,80                    .authority = .checker,81                },82            },83            .teardown = .{84                .family = alloc_phase.capacity.selector(@This().deinit),85                .premise = .{86                    .class = .checked_semantic_fact,87                    .authority = .checker,88                },89            },90        },91    };9293    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Storage {94        const capacity = Capacity.derive(limits);95        const bytes = try allocator.alignedAlloc(96            u8,97            .fromByteUnits(capacity_mod.storage_alignment),98            capacity.storage_bytes,99        );100        return .{101            .phase = .initialization,102            .capacity = capacity,103            .bytes = bytes,104            .output = bytes[0..capacity.bounds.decoded_bytes],105        };106    }107108    pub fn activate(self: *Storage) void {109        std.debug.assert(self.phase == .initialization);110        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);111        self.phase = .steady;112    }113114    pub fn acquire(self: *Storage, input_bytes: usize) AcquireError!Regions {115        std.debug.assert(self.phase == .steady);116        if (self.in_use) return error.DecodeStorageInUse;117        if (input_bytes > self.capacity.bounds.input_bytes) {118            return error.InputByteCapacityExceeded;119        }120        self.in_use = true;121        return .{ .output = self.output };122    }123124    pub fn reset(self: *Storage) void {125        std.debug.assert(self.phase == .steady);126        std.debug.assert(self.in_use);127        self.in_use = false;128    }129130    pub fn status(self: *const Storage) Status {131        return .{132            .phase = self.phase,133            .in_use = self.in_use,134            .input_bytes = self.capacity.bounds.input_bytes,135            .decoded_bytes = self.capacity.bounds.decoded_bytes,136            .storage_bytes = self.capacity.storage_bytes,137        };138    }139140    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {141        std.debug.assert(self.phase != .teardown);142        std.debug.assert(!self.in_use);143        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);144        self.phase = .teardown;145        allocator.free(self.bytes);146        self.bytes = &.{};147        self.output = &.{};148    }149};

1pub const FilterStorage = filter.Storage;