tiny.http.WebSocketStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: StorageCapacity,4    bytes: []u8,56    pub const Limits: type = StorageLimits;7    pub const Capacity: type = StorageCapacity;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.websocket_storage",14            .kind = .phase_static,15            .limit_source = .caller,16            .storage = .{17                .covered = &.{18                    .{19                        .id = "one_websocket_wire_frame_and_fragmented_message_byte_region",20                        .lifetime = .steady,21                        .detail = "one WebSocket wire-frame and fragmented-message byte region",22                    },23                },24                .excluded = &.{25                    "Connection unread bytes and router session objects",26                    "caller-owned outbound payloads and handler-retained message copies",27                    "socket and kernel queues, protocol callbacks, and application effects",28                },29            },30            .capacity = .{31                .inputs = &.{32                    alloc_phase.capacity.bindInput(StorageLimits, "frame_payload_bytes", "frame_payload_bytes"),33                    alloc_phase.capacity.bindInput(StorageLimits, "message_payload_bytes", "message_payload_bytes"),34                },35                .type_selectors = &.{},36                .nodes = &.{37                    .{ .constant = 14 },38                    .{ .input = 0 },39                    .{ .input = 1 },40                    .{ .add = .{ .left = 0, .right = 1 } },41                    .{ .add = .{ .left = 3, .right = 2 } },42                },43                .assertions = &.{.{44                    .scope = .closure_total,45                    .measure = .retained,46                    .relation = .exact,47                    .expression = 4,48                }},49            },50            .overload = .{51                .kind = .reject_before_mutation,52                .detail = "oversize admission preserves prior fragmented-message bytes",53            },54            .risks = .{55                .transitive = .{56                    .status = .open,57                    .detail = "router handlers can retain borrowed messages or allocate independently",58                },59                .foreign = .{60                    .status = .open,61                    .detail = "frame I/O crosses socket, kernel, scheduler, and peer storage",62                },63            },64            .obligations = &.{65                .{ .key = "http_websocket_capacity", .role = .capacity_model },66                .{ .key = "http_websocket_oom_retry", .role = .custom },67                .{ .key = "http_websocket_sealed", .role = .overload },68                .{ .key = "http_websocket_fragmented", .role = .custom },69                .{ .key = "http_websocket_upgrade", .role = .custom },70                .{ .key = "http_websocket_semantics", .role = .custom },71            },72        },73        .bindings = .{74            .owner = @This(),75            .seal = .{76                .family = alloc_phase.capacity.selector(@This().activate),77                .premise = .{78                    .class = .checked_semantic_fact,79                    .authority = .checker,80                },81            },82            .teardown = .{83                .family = alloc_phase.capacity.selector(@This().deinit),84                .premise = .{85                    .class = .checked_semantic_fact,86                    .authority = .checker,87                },88            },89        },90    };9192    pub fn init(allocator: std.mem.Allocator, limits: StorageLimits) InitError!Storage {93        const capacity = try StorageCapacity.derive(limits);94        const bytes = if (capacity.storage_bytes == 0)95            @as([]u8, &.{})96        else97            try allocator.alloc(u8, capacity.storage_bytes);98        return .{99            .phase = .initialization,100            .capacity = capacity,101            .bytes = bytes,102        };103    }104105    pub fn activate(self: *Storage) void {106        std.debug.assert(self.phase == .initialization);107        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);108        self.phase = .steady;109    }110111    pub fn frame(self: *Storage, payload_bytes: usize) Exhaustion![]u8 {112        std.debug.assert(self.phase != .teardown);113        if (payload_bytes > self.capacity.frame_payload_bytes) {114            return error.FramePayloadCapacityExceeded;115        }116        return self.bytes[0 .. maximum_frame_header_bytes + payload_bytes];117    }118119    pub fn message(self: *Storage, payload_bytes: usize) Exhaustion![]u8 {120        std.debug.assert(self.phase != .teardown);121        if (payload_bytes > self.capacity.message_payload_bytes) {122            return error.MessagePayloadCapacityExceeded;123        }124        const start = self.capacity.frame_bytes;125        return self.bytes[start..][0..payload_bytes];126    }127128    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {129        std.debug.assert(self.phase != .teardown);130        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);131        self.phase = .teardown;132        if (self.bytes.len != 0) allocator.free(self.bytes);133        self.bytes = &.{};134    }135};

1pub const WebSocketStorage = websocket.Storage;