tiny.http.ClientStreamStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: model.Capacity,4    bytes: []align(@alignOf(Header)) u8,56    pub const Limits: type = model.Limits;7    pub const Capacity: type = model.Capacity;8    pub const Exhaustion: type = StorageExhaustion;9    pub const InitError = std.mem.Allocator.Error || error{CapacityOverflow};1011    pub const claim: alloc_phase.capacity.Declaration = .{12        .source = .{13            .id = "http.client_stream_storage",14            .kind = .phase_static,15            .limit_source = .caller,16            .storage = .{17                .covered = &.{18                    .{19                        .id = "fixed_parsed_streaming_response_header_entries_for_e9a56e6dd10f",20                        .lifetime = .steady,21                        .detail = "fixed parsed streaming-response header entries for every stream slot",22                    },23                    .{24                        .id = "fixed_response_head_bytes_retaining_borrowed_callba_581ad8ca32dc",25                        .lifetime = .steady,26                        .detail = "fixed response-head bytes retaining borrowed callback header names and values",27                    },28                },29                .excluded = &.{30                    "request serialization, URL targets, TLS state, certificate bundles, sockets, and kernel queues",31                    "fixed scalar chunk-fragmentation state and handler-owned streamed output",32                },33            },34            .capacity = .{35                .inputs = &.{36                    alloc_phase.capacity.bindInput(Limits, "stream_count", "stream_count"),37                    alloc_phase.capacity.bindInput(Limits, "header_count_per_stream", "header_count_per_stream"),38                    alloc_phase.capacity.bindInput(Limits, "head_bytes_per_stream", "head_bytes_per_stream"),39                },40                .type_selectors = &.{41                    alloc_phase.capacity.bindType(Header, "header"),42                },43                .nodes = &.{44                    .{ .input = 0 },45                    .{ .input = 1 },46                    .{ .product = .{ .left = 0, .right = 1 } },47                    .{ .constant = 1 },48                    .{ .scale = .{ .node = 3, .coefficient = .{ .size_of_concrete_type = 0 } } },49                    .{ .product = .{ .left = 2, .right = 4 } },50                    .{ .input = 2 },51                    .{ .product = .{ .left = 0, .right = 6 } },52                    .{ .add = .{ .left = 5, .right = 7 } },53                },54                .assertions = &.{.{55                    .scope = .closure_total,56                    .measure = .retained,57                    .relation = .exact,58                    .expression = 8,59                }},60            },61            .overload = .{62                .kind = .terminal,63                .detail = "an over-capacity response terminates that one-shot stream before publishing the head callback",64            },65            .risks = .{66                .transitive = .{67                    .status = .witnessed,68                    .detail = "stream head parsing and fragmented chunk decoding allocate no storage after activation",69                },70                .foreign = .{71                    .status = .excluded,72                    .detail = "handler callbacks own any retained headers or body output and preserve their own error identity",73                },74            },75            .obligations = &.{76                .{ .key = "http_client_stream_capacity", .role = .capacity_model },77                .{ .key = "http_client_stream_oom_retry", .role = .custom },78                .{ .key = "http_client_stream_partition", .role = .custom },79                .{ .key = "http_client_stream_sealed", .role = .transitive_risk },80                .{ .key = "http_client_stream_atomic", .role = .overload },81                .{ .key = "http_client_stream_boundary", .role = .custom },82                .{ .key = "http_client_stream_callback", .role = .foreign_risk },83                .{ .key = "http_client_stream_network", .role = .overload },84            },85        },86        .bindings = .{87            .owner = @This(),88            .seal = .{89                .family = alloc_phase.capacity.selector(@This().activate),90                .premise = .{91                    .class = .checked_semantic_fact,92                    .authority = .checker,93                },94            },95            .teardown = .{96                .family = alloc_phase.capacity.selector(@This().deinit),97                .premise = .{98                    .class = .checked_semantic_fact,99                    .authority = .checker,100                },101            },102        },103    };104105    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Storage {106        const capacity = try Capacity.derive(limits);107        const bytes = if (capacity.storage_bytes == 0)108            @as([]align(@alignOf(Header)) u8, &.{})109        else110            try allocator.alignedAlloc(u8, .of(Header), capacity.storage_bytes);111        return .{112            .phase = .initialization,113            .capacity = capacity,114            .bytes = bytes,115        };116    }117118    pub fn activate(self: *Storage) void {119        std.debug.assert(self.phase == .initialization);120        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);121        self.phase = .steady;122    }123124    pub fn stream(self: *Storage, index: usize) Exhaustion!Scratch {125        std.debug.assert(self.phase == .steady);126        if (index >= self.capacity.stream_count) {127            return error.ClientStreamCapacityExceeded;128        }129        const all_headers = std.mem.bytesAsSlice(130            Header,131            self.bytes[0..self.capacity.header_bytes],132        );133        const header_start = index * self.capacity.header_count_per_stream;134        const head_start = self.capacity.header_bytes +135            index * self.capacity.head_bytes_per_stream;136        return .{137            .headers = all_headers[header_start..][0..self.capacity.header_count_per_stream],138            .head = self.bytes[head_start..][0..self.capacity.head_bytes_per_stream],139        };140    }141142    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {143        std.debug.assert(self.phase != .teardown);144        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);145        self.phase = .teardown;146        if (self.bytes.len != 0) allocator.free(self.bytes);147        self.bytes = &.{};148    }149};

1pub const ClientStreamStorage = client.StreamStorage;