tiny.choir.backends.wasm.emission

1pub const Capacity = struct {2    facts: emission.Facts,3    frame_count: usize,4    function_index_slots: usize,5    value_index_slots: usize,6    function_plan_bytes: usize,7    function_index_bytes: usize,8    value_plan_bytes: usize,9    value_index_bytes: usize,10    frame_bytes: usize,11    working_bytes: usize,1213    pub fn derive(limits: Limits) error{CapacityOverflow}!Capacity {14        const frame_count = if (limits.facts.definition_count == 0)15            016        else frame_count: {17            const controls = std.math.mul(18                usize,19                limits.facts.nesting_depth,20                2,21            ) catch return error.CapacityOverflow;22            break :frame_count std.math.add(usize, controls, 1) catch23                return error.CapacityOverflow;24        };25        const function_plan_bytes = try bytesFor(26            emission.FunctionPlan,27            limits.facts.function_count,28        );29        const function_index_slots = try emission.plan.index.slotsFor(30            limits.facts.function_count,31        );32        const function_index_bytes = try bytesFor(u32, function_index_slots);33        const value_plan_bytes = try bytesFor(emission.ValuePlan, limits.facts.value_count);34        const value_index_slots = try emission.plan.index.slotsFor(limits.facts.value_count);35        const value_index_bytes = try bytesFor(u32, value_index_slots);36        const frame_bytes = try bytesFor(emission.function.Frame, frame_count);37        var working_bytes = try add(function_plan_bytes, function_index_bytes);38        working_bytes = try add(working_bytes, value_plan_bytes);39        working_bytes = try add(working_bytes, value_index_bytes);40        working_bytes = try add(working_bytes, frame_bytes);41        return .{42            .facts = limits.facts,43            .frame_count = frame_count,44            .function_index_slots = function_index_slots,45            .value_index_slots = value_index_slots,46            .function_plan_bytes = function_plan_bytes,47            .function_index_bytes = function_index_bytes,48            .value_plan_bytes = value_plan_bytes,49            .value_index_bytes = value_index_bytes,50            .frame_bytes = frame_bytes,51            .working_bytes = working_bytes,52        };53    }54};

1pub const Limits = struct {2    module: *ir.Operation,3    options: emission.Options,4    facts: emission.Facts,56    pub fn inspect(module: *ir.Operation, options: emission.Options) emission.Error!Limits {7        return .{8            .module = module,9            .options = options,10            .facts = try emission.inspection.inspect(module, options),11        };12    }13};

1pub const OutputCapacity = struct {2    output_bytes: usize,3    initialization_bytes: usize,4    steady_bytes: usize,56    pub fn derive(7        capacity: Capacity,8        output_bytes: usize,9    ) error{CapacityOverflow}!OutputCapacity {10        return .{11            .output_bytes = output_bytes,12            .initialization_bytes = try add(capacity.working_bytes, output_bytes),13            .steady_bytes = output_bytes,14        };15    }16};

1pub const Error = error{2    AlreadyActive,3    AlreadyEmitted,4    CapacityOverflow,5    CodeGenFailed,6    FunctionNotFound,7    InputChanged,8    NestingLimitExceeded,9    NotActive,10    OutOfMemory,11    OutputOverflow,12    OutputUnderflow,13    UnsupportedOperation,14};

1pub const Facts = struct {2    function_count: usize,3    import_count: usize,4    definition_count: usize,5    value_count: usize,6    local_count: usize,7    nesting_depth: usize,8    needs_memory: bool,9};

1pub const SectionSizes = struct {2    type: usize = 0,3    import: usize = 0,4    function: usize = 0,5    memory: usize = 0,6    export_: usize = 0,7    code: usize = 0,8};

1pub const Module = struct {2    bytes: []u8,34    pub fn deinit(self: *Module, allocator: Allocator) void {5        allocator.free(self.bytes);6        self.* = undefined;7    }8};

1pub const ModuleEmitter = struct {2    pub const claim: alloc_phase.capacity.Declaration = .{3        .source = .{4            .id = "choir.wasm_module_emitter",5            .kind = .phase_static,6            .limit_source = .caller,7            .storage = .{8                .covered = &.{9                    .{10                        .id = "exact_function_and_value_plans_indices_and_control_frames",11                        .lifetime = .initialization,12                        .detail = "exact function and value plans, indices, and control frames",13                    },14                    .{15                        .id = "exact_count_and_fixed_encoded_output_snapshot",16                        .lifetime = .steady,17                        .detail = "exact Count and Fixed encoded output snapshot",18                    },19                    .{20                        .id = "the_same_exact_output_allocation_after_take",21                        .lifetime = .transferred,22                        .detail = "the same exact output allocation after take",23                    },24                },25                .excluded = &.{26                    "borrowed IR and options after initialization",27                    "dynamic artifact and linkage copies outside ModuleEmitter",28                },29            },30            .capacity = .{31                .inputs = &.{32                    alloc_phase.capacity.bindInput(Limits, "facts_definition_count", "facts.definition_count"),33                    alloc_phase.capacity.bindInput(Limits, "facts_function_count", "facts.function_count"),34                    alloc_phase.capacity.bindInput(Limits, "facts_import_count", "facts.import_count"),35                    alloc_phase.capacity.bindInput(Limits, "facts_local_count", "facts.local_count"),36                    alloc_phase.capacity.bindInput(Limits, "facts_nesting_depth", "facts.nesting_depth"),37                    alloc_phase.capacity.bindInput(Limits, "facts_value_count", "facts.value_count"),38                },39                .type_selectors = &.{},40                .nodes = &.{41                    .{ .input = 0 },42                    .{ .input = 1 },43                    .{ .input = 2 },44                    .{ .input = 3 },45                    .{ .input = 4 },46                    .{ .input = 5 },47                    .{ .add = .{ .left = 0, .right = 1 } },48                    .{ .add = .{ .left = 6, .right = 2 } },49                    .{ .add = .{ .left = 7, .right = 3 } },50                    .{ .add = .{ .left = 8, .right = 4 } },51                    .{ .add = .{ .left = 9, .right = 5 } },52                },53                .assertions = &.{.{54                    .scope = .closure_total,55                    .measure = .retained,56                    .relation = .upper_bound,57                    .expression = 10,58                }},59            },60            .overload = .{61                .kind = .reject_before_seal,62                .detail = "unsupported input, nesting, index, byte, arithmetic, or OOM failure occurs before activation",63            },64            .risks = .{65                .transitive = .{66                    .status = .open,67                    .detail = "emit and take are source-reviewed simple roots, but the ledger does not fail closed over their complete call graph",68                },69                .foreign = .{70                    .status = .open,71                    .detail = "source review found no callback, indirect, policy, raw heap, or OS edge, but no machine witness excludes future foreign edges",72                },73            },74            .obligations = &.{75                .{ .key = "wasm_capacity", .role = .capacity_model },76                .{ .key = "wasm_sealed_emit_transitive_risk", .role = .transitive_risk },77                .{ .key = "wasm_sealed_emit_foreign_risk", .role = .foreign_risk },78                .{ .key = "wasm_nesting_boundary", .role = .overload },79                .{ .key = "wasm_snapshot_lifetime", .role = .custom },80                .{ .key = "wasm_oom_retry", .role = .overload },81            },82        },83        .bindings = .{84            .owner = @This(),85            .seal = .{86                .family = alloc_phase.capacity.selector(@This().activate),87                .premise = .{88                    .class = .checked_semantic_fact,89                    .authority = .checker,90                },91            },92            .teardown = .{93                .family = alloc_phase.capacity.selector(@This().deinit),94                .premise = .{95                    .class = .checked_semantic_fact,96                    .authority = .checker,97                },98            },99        },100    };101    phase: alloc_phase.capacity.Phase,102    capacity: Capacity,103    output_capacity: OutputCapacity,104    output: []u8,105    output_taken: bool,106107    pub const Limits = emission.Limits;108    pub const Capacity = emission.Capacity;109    pub const OutputCapacity = emission.OutputCapacity;110111    const Self = @This();112113    pub fn init(allocator: Allocator, limits: Limits) emission.Error!Self {114        const capacity = try Capacity.derive(limits);115116        const functions = try allocator.alloc(117            emission.FunctionPlan,118            capacity.facts.function_count,119        );120        errdefer allocator.free(functions);121        const function_index = try allocator.alloc(u32, capacity.function_index_slots);122        errdefer allocator.free(function_index);123        const values = try allocator.alloc(emission.ValuePlan, capacity.facts.value_count);124        errdefer allocator.free(values);125        const value_index = try allocator.alloc(u32, capacity.value_index_slots);126        errdefer allocator.free(value_index);127        const frames = try allocator.alloc(emission.function.Frame, capacity.frame_count);128        errdefer allocator.free(frames);129130        var plan = try emission.plan.planning.fill(131            limits.module,132            functions,133            function_index,134            values,135            value_index,136            capacity.facts,137        );138        const measured = try emission.module_encoding.preparePlan(139            &plan,140            limits.module,141            limits.options,142            frames,143        );144        const output_capacity = try OutputCapacity.derive(capacity, measured);145        const output = try allocator.alloc(u8, output_capacity.output_bytes);146        errdefer allocator.free(output);147148        var out = wasm.binary.Fixed.init(output);149        try emission.module_encoding.write(150            &out,151            &plan,152            limits.module,153            limits.options,154            frames,155        );156        _ = try out.finish();157158        allocator.free(frames);159        allocator.free(value_index);160        allocator.free(values);161        allocator.free(function_index);162        allocator.free(functions);163164        return .{165            .phase = .initialization,166            .capacity = capacity,167            .output_capacity = output_capacity,168            .output = output,169            .output_taken = false,170        };171    }172173    pub fn activate(self: *Self) emission.Error!void {174        if (self.phase != .initialization) return error.AlreadyActive;175        self.phase = .steady;176    }177178    pub fn emit(self: *const Self) emission.Error![]const u8 {179        if (self.phase != .steady) return error.NotActive;180        if (self.output_taken) return error.AlreadyEmitted;181        return self.output;182    }183184    pub fn take(self: *Self) emission.Error!Module {185        _ = try self.emit();186        self.output_taken = true;187        return .{ .bytes = self.output };188    }189190    pub fn deinit(self: *Self, allocator: Allocator) void {191        if (self.phase == .teardown) @panic("WASM module emitter teardown is terminal");192        self.phase = .teardown;193        if (!self.output_taken) allocator.free(self.output);194        self.output = undefined;195    }196};

1pub const max_nesting_depth: usize = 256;

1pub const Options = backends.interface.EmitOptions;

1const capacity = @import("capacity.zig");2const inspection_module = @import("inspection.zig");3const model = @import("model.zig");4const module = @import("module/root.zig");5const owner = @import("owner.zig");67pub const function = @import("function/root.zig");8pub const inspection = inspection_module;9pub const module_encoding = module;10pub const plan = @import("plan/root.zig");11pub const symbols = @import("symbols.zig");12pub const types = @import("types.zig");1314pub const Capacity = capacity.Capacity;15pub const OutputCapacity = capacity.OutputCapacity;1617pub const Error = model.Error;18pub const Facts = model.Facts;19pub const Limits = capacity.Limits;20pub const Module = owner.Module;21pub const ModuleEmitter = owner.ModuleEmitter;22pub const Options = model.Options;23pub const SectionSizes = model.SectionSizes;24pub const max_nesting_depth = model.max_nesting_depth;2526pub const FunctionPlan = plan.FunctionPlan;27pub const Plan = plan.Plan;28pub const ValuePlan = plan.ValuePlan;

1pub const emission = @import("emission/root.zig");