tiny.filigree.FallbackWorkspace

1pub const Workspace = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: capacity_mod.Capacity,4    bytes: []align(capacity_mod.storage_alignment) u8,5    scalars: std.ArrayList(model.Scalar),6    clusters: std.ArrayList(model.SourceCluster),7    ranges: std.ArrayList(model.SegmentRange),89    pub const Limits: type = capacity_mod.Limits;10    pub const Capacity: type = capacity_mod.Capacity;11    pub const Exhaustion: type = model.Exhaustion;12    pub const InitError = std.mem.Allocator.Error || capacity_mod.DeriveError;1314    pub const claim: alloc_phase.capacity.Declaration = .{15        .source = .{16            .id = "filigree.fallback_workspace",17            .kind = .phase_static,18            .limit_source = .caller,19            .storage = .{20                .covered = &.{21                    .{22                        .id = "decoded_fallback_scalars",23                        .lifetime = .steady,24                        .detail = "decoded scalar descriptors used for face coverage",25                    },26                    .{27                        .id = "grapheme_safe_fallback_clusters",28                        .lifetime = .steady,29                        .detail = "grapheme and joining-cluster descriptors",30                    },31                    .{32                        .id = "fallback_face_segment_ranges",33                        .lifetime = .steady,34                        .detail = "script and selected-face segment descriptors",35                    },36                },37                .excluded = &.{38                    "caller-owned source units and fallback candidates",39                    "shape engine, shape output, and script-run storage",40                    "caller-owned reported face segments",41                },42            },43            .capacity = .{44                .inputs = &.{45                    alloc_phase.capacity.bindInput(Limits, "max_source_units", "max_source_units"),46                },47                .type_selectors = &.{48                    alloc_phase.capacity.bindType(model.Scalar, "scalar"),49                    alloc_phase.capacity.bindType(model.SourceCluster, "sourcecluster"),50                    alloc_phase.capacity.bindType(model.SegmentRange, "segmentrange"),51                },52                .nodes = &.{53                    .{ .input = 0 },54                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 0 } } },55                    .{ .alignment = .{ .node = 1, .alignment = .{ .concrete_type = 1 } } },56                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 1 } } },57                    .{ .add = .{ .left = 2, .right = 3 } },58                    .{ .alignment = .{ .node = 4, .alignment = .{ .concrete_type = 2 } } },59                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 2 } } },60                    .{ .add = .{ .left = 5, .right = 6 } },61                },62                .assertions = &.{.{63                    .scope = .closure_total,64                    .measure = .retained,65                    .relation = .exact,66                    .expression = 7,67                }},68            },69            .overload = .{70                .kind = .reject_before_mutation,71                .detail = "a max-plus-one source rejects before prior scalar, cluster, or face-range state changes",72            },73            .risks = .{74                .transitive = .{75                    .status = .witnessed,76                    .detail = "fallback collection and segmentation use only activated typed regions",77                },78                .foreign = .{79                    .status = .excluded,80                    .detail = "workspace collection and segmentation cross no operating-system or foreign callback boundary",81                },82            },83            .obligations = &.{84                .{ .key = "filigree_fallback_workspace_capacity", .role = .capacity_model },85                .{ .key = "filigree_fallback_workspace_acquisition", .role = .custom },86                .{ .key = "filigree_fallback_workspace_oom", .role = .custom },87                .{ .key = "filigree_fallback_workspace_boundaries", .role = .overload },88                .{ .key = "filigree_fallback_workspace_reuse", .role = .overload },89                .{ .key = "filigree_fallback_workspace_sealed_transitive_risk", .role = .transitive_risk },90                .{ .key = "filigree_fallback_workspace_sealed_foreign_risk", .role = .foreign_risk },91                .{ .key = "filigree_fallback_workspace_root", .role = .custom },92            },93        },94        .bindings = .{95            .owner = @This(),96            .seal = .{97                .family = alloc_phase.capacity.selector(@This().activate),98                .premise = .{99                    .class = .checked_semantic_fact,100                    .authority = .checker,101                },102            },103            .teardown = .{104                .family = alloc_phase.capacity.selector(@This().deinit),105                .premise = .{106                    .class = .checked_semantic_fact,107                    .authority = .checker,108                },109            },110        },111    };112113    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Workspace {114        const capacity = try Capacity.derive(limits);115        const bytes = try allocator.alignedAlloc(116            u8,117            .fromByteUnits(capacity_mod.storage_alignment),118            capacity.storage_bytes,119        );120        return .{121            .phase = .initialization,122            .capacity = capacity,123            .bytes = bytes,124            .scalars = .initBuffer(typedSlice(model.Scalar, bytes, capacity.scalar_offset, limits.max_source_units)),125            .clusters = .initBuffer(typedSlice(model.SourceCluster, bytes, capacity.cluster_offset, limits.max_source_units)),126            .ranges = .initBuffer(typedSlice(model.SegmentRange, bytes, capacity.range_offset, limits.max_source_units)),127        };128    }129130    pub fn activate(self: *Workspace) void {131        std.debug.assert(self.phase == .initialization);132        self.assertStorage();133        self.phase = .steady;134    }135136    pub fn deinit(self: *Workspace, allocator: std.mem.Allocator) void {137        std.debug.assert(self.phase != .teardown);138        self.assertStorage();139        self.phase = .teardown;140        allocator.free(self.bytes);141        self.bytes = &.{};142        self.scalars = .empty;143        self.clusters = .empty;144        self.ranges = .empty;145    }146147    pub fn begin(self: *Workspace, source_units: usize) Exhaustion!void {148        std.debug.assert(self.phase == .steady);149        if (source_units > self.capacity.limits.max_source_units) {150            return error.SourceUnitCapacityExceeded;151        }152        self.reset();153    }154155    pub fn reset(self: *Workspace) void {156        std.debug.assert(self.phase == .steady);157        self.scalars.clearRetainingCapacity();158        self.clusters.clearRetainingCapacity();159        self.ranges.clearRetainingCapacity();160    }161162    pub fn status(self: *const Workspace) Status {163        return .{164            .phase = self.phase,165            .storage_bytes = self.capacity.storage_bytes,166            .max_source_units = self.capacity.limits.max_source_units,167            .scalar_count = self.scalars.items.len,168            .cluster_count = self.clusters.items.len,169            .range_count = self.ranges.items.len,170        };171    }172173    fn assertStorage(self: *const Workspace) void {174        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);175        std.debug.assert(self.scalars.capacity == self.capacity.limits.max_source_units);176        std.debug.assert(self.clusters.capacity == self.capacity.limits.max_source_units);177        std.debug.assert(self.ranges.capacity == self.capacity.limits.max_source_units);178        std.debug.assert(self.scalars.items.len <= self.scalars.capacity);179        std.debug.assert(self.clusters.items.len <= self.clusters.capacity);180        std.debug.assert(self.ranges.items.len <= self.ranges.capacity);181    }182};

1pub const FallbackWorkspace = fallback.Workspace;