semantifold 0.3.0 → 0.5.0

package/build/src/backends/wasm.js

@@ -0,0 +1,2164 @@
+// @ts-check
+import { addSegment, GenMapping, maybeAddSegment, setSourceContent, toEncodedMap } from "@jridgewell/gen-mapping";
+import { createByteMapping } from "../binary-mapping.js";
+import { unsupportedCapability } from "../diagnostic.js";
+import { finalizeMapping, toSourceMapV3 } from "../mapping.js";
+import { createGenerationIndex, primaryLocation, semanticEntries } from "../semantic/provenance.js";
+import { validateNativeGraph } from "./native-validation.js";
+import { validateBackendModule } from "./shared.js";
+import { SourceWriter } from "./writer.js";
+/** @typedef {import("../semantic/types.js").SemanticModule} SemanticModule */
+/** @typedef {import("../semantic/types.js").SemanticNode} SemanticNode */
+/** @typedef {import("../semantic/types.js").Expression} Expression */
+/** @typedef {import("../semantic/types.js").SemanticTypeName} Scalar */
+/** @typedef {import("../semantic/types.js").GeneratedByteRange} GeneratedByteRange */
+/** @typedef {import("../semantic/types.js").SemanticNodeProvenance} SemanticNodeProvenance */
+/** @typedef {{type: Scalar, knownBoolean?: boolean, knownInteger?: bigint, knownString?: string, stringLength?: number}} AbstractValue */
+/** @typedef {{allocated: number, env: Map<string, AbstractValue>, returned?: AbstractValue}} AnalysisState */
+/** @typedef {{type: Scalar, indexes: number[]}} LocalBinding */
+const encoder = new TextEncoder();
+const scratchCapacity = 1_048_576;
+const maximumCallDepth = 64;
+const wasmPageSize = 65_536;
+const maximumAnalysisSteps = 100_000;
+const valueTypes = Object.freeze({ i32: 0x7f, i64: 0x7e });
+const helperNames = Object.freeze(["$concat", "$string_equal", "$checked_add", "$checked_subtract", "$checked_multiply", "$checked_negate"]);
+const helperCount = helperNames.length;
+const importCount = 3;
+const concatFunctionIndex = importCount;
+const stringEqualFunctionIndex = concatFunctionIndex + 1;
+const checkedAddFunctionIndex = stringEqualFunctionIndex + 1;
+const checkedSubtractFunctionIndex = checkedAddFunctionIndex + 1;
+const checkedMultiplyFunctionIndex = checkedSubtractFunctionIndex + 1;
+const checkedNegateFunctionIndex = checkedMultiplyFunctionIndex + 1;
+const cursorGlobalIndex = 0;
+const depthGlobalIndex = 1;
+const activeGlobalIndex = 2;
+/**
+ * Generates the complete deterministic browser Wasm artifact set.
+ * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Backend request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], metadata: Readonly<Record<string, unknown>>, target: string}} Candidate artifact set.
+ */
+export function generateBrowserWasm({ filename, mapDirective, module, sourceMapFilename, sources }) {
+    validateNativeGraph(module, "wasm");
+    validateBackendModule(module, "wasm");
+    if (filename !== undefined && filename != "program.wasm") {
+        unsupportedCapability("wasm", "artifact filename other than program.wasm", module.location);
+    }
+    if (mapDirective !== undefined)
+        unsupportedCapability("wasm", "source-map directive option", module.location);
+    if (sourceMapFilename !== undefined)
+        unsupportedCapability("wasm", "alternate source-map filename", module.location);
+    analyzeScratchUse(module);
+    const index = createGenerationIndex(module, sources);
+    const literalLayout = collectLiteralLayout(module, index);
+    const scratchBase = align(literalLayout.boundary, 16);
+    const memoryBytes = checkedSize(scratchBase + scratchCapacity, module, "linear memory size");
+    const memoryPages = Math.ceil(memoryBytes / wasmPageSize);
+    const encoded = encodeModule(module, index, literalLayout, scratchBase, memoryPages);
+    validateEncodedModule(encoded.bytes, module);
+    const byteMapping = createByteMapping({ byteLength: encoded.bytes.byteLength, path: "program.wasm", ranges: encoded.ranges });
+    const wasmMap = createWasmSourceMap(byteMapping, index.provenance);
+    const loader = textArtifact(semantifoldLoader, "semantifold-loader.mjs", "javascript", "loader", module, sources, "Versioned browser Wasm ABI loader and exact scalar bridge.");
+    const html = textArtifact(browserHarness, "index.html", "html", "entry", module, sources, "Deterministic local browser acceptance harness.");
+    const metadata = /** @type {const} */ ({
+        abi: "semantifold.browser.v1",
+        exports: ["memory", "run"],
+        imports: [
+            { module: "semantifold", name: "print_i64", parameters: ["i64"], results: [] },
+            { module: "semantifold", name: "print_bool", parameters: ["i32"], results: [] },
+            { module: "semantifold", name: "print_string", parameters: ["i32", "i32"], results: [] }
+        ],
+        maximumCallDepth,
+        memory: {
+            initialPages: memoryPages,
+            literalBoundary: literalLayout.boundary,
+            maximumPages: memoryPages,
+            scratchBase,
+            scratchCapacity
+        },
+        schema: "SemantifoldBrowserWasmABI",
+        version: 1
+    });
+    return {
+        artifacts: [{
+                content: encoded.bytes,
+                contentKind: "binary",
+                mediaType: "application/wasm",
+                ownership: "generated",
+                path: "program.wasm",
+                provenance: { kind: "bytes", mapping: byteMapping },
+                role: "resource"
+            }, {
+                content: `${JSON.stringify(wasmMap)}\n`,
+                contentKind: "text",
+                mediaType: "application/json",
+                ownership: "generated",
+                path: "program.wasm.map",
+                provenance: {
+                    kind: "synthetic",
+                    reason: "Source Map v3 projection of program.wasm byte provenance.",
+                    relatedOrigins: relatedOrigins(index.recordFor(module, ""))
+                },
+                role: "mapping"
+            }, loader, html],
+        metadata,
+        target: "wasm"
+    };
+}
+/**
+ * Independently checks the completed module before any bytes enter an artifact.
+ * @param {Uint8Array} bytes - Completed module bytes.
+ * @param {SemanticModule} module - Related semantic module.
+ * @returns {void}
+ */
+function validateEncodedModule(bytes, module) {
+    const moduleBytes = new Uint8Array(bytes.byteLength);
+    moduleBytes.set(bytes);
+    if (!WebAssembly.validate(moduleBytes))
+        unsupportedCapability("wasm", "invalid encoded section, index, stack, or control shape", module.location);
+    /** @type {WebAssembly.Module} */
+    let compiled;
+    try {
+        compiled = new WebAssembly.Module(moduleBytes);
+    }
+    catch (_error) {
+        unsupportedCapability("wasm", "invalid completed WebAssembly module", module.location);
+    }
+    const imports = WebAssembly.Module.imports(compiled).map(({ kind, module: namespace, name }) => [namespace, name, kind]);
+    const exports = WebAssembly.Module.exports(compiled).map(({ kind, name }) => [name, kind]);
+    if (JSON.stringify(imports) != JSON.stringify([
+        ["semantifold", "print_i64", "function"],
+        ["semantifold", "print_bool", "function"],
+        ["semantifold", "print_string", "function"]
+    ]) || JSON.stringify(exports) != JSON.stringify([["memory", "memory"], ["run", "function"]])) {
+        unsupportedCapability("wasm", "invalid encoded ABI import or export set", module.location);
+    }
+}
+/**
+ * Encodes one validated semantic module directly to portable core WebAssembly.
+ * @param {SemanticModule} module - Validated module.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Canonical provenance index.
+ * @param {ReturnType<typeof collectLiteralLayout>} literals - Static literal layout.
+ * @param {number} scratchBase - Aligned scratch arena base.
+ * @param {number} memoryPages - Fixed memory page count.
+ * @returns {{bytes: Uint8Array, ranges: GeneratedByteRange[]}} Encoded module and rich byte ranges.
+ */
+function encodeModule(module, index, literals, scratchBase, memoryPages) {
+    const writer = new BinaryWriter(index);
+    const root = { node: module, path: "" };
+    writer.synthetic([0x00, 0x61, 0x73, 0x6d], "WebAssembly binary magic", root, "module header");
+    writer.synthetic([0x01, 0x00, 0x00, 0x00], "Pinned WebAssembly core binary version 1", root, "module header");
+    const types = new TypePool();
+    const importTypes = [
+        types.add(["i64"], []),
+        types.add(["i32"], []),
+        types.add(["i32", "i32"], [])
+    ];
+    const helperTypes = [
+        types.add(["i32", "i32", "i32", "i32"], ["i32", "i32"]),
+        types.add(["i32", "i32", "i32", "i32"], ["i32"]),
+        types.add(["i64", "i64"], ["i64"]),
+        types.add(["i64", "i64"], ["i64"]),
+        types.add(["i64", "i64"], ["i64"]),
+        types.add(["i64"], ["i64"])
+    ];
+    const semanticTypeIndexes = module.functions.map((declaration) => types.add(declaration.parameters.flatMap(({ type, location }) => wasmTypes(wasmScalarType(type, location))), wasmTypes(wasmReturnType(declaration))));
+    const runType = types.add([], []);
+    const functionIndexes = new Map(module.functions.map((declaration, offset) => [declaration.name, importCount + helperCount + offset]));
+    const runFunctionIndex = importCount + helperCount + module.functions.length;
+    appendSection(writer, 1, "type", encodeTypeSection(types, index, root), root);
+    appendSection(writer, 2, "import", encodeImportSection(importTypes, index, root), root);
+    appendSection(writer, 3, "function", encodeFunctionSection(helperTypes, semanticTypeIndexes, runType, module, index), root);
+    appendSection(writer, 5, "memory", encodeMemorySection(memoryPages, index, root), root);
+    appendSection(writer, 6, "global", encodeGlobalSection(scratchBase, index, root), root);
+    appendSection(writer, 7, "export", encodeExportSection(runFunctionIndex, index, root), root);
+    const code = new BinaryWriter(index);
+    code.synthetic(u32(helperCount + module.functions.length + 1), "Defined function count", root, "function count");
+    appendFunctionBody(code, helperConcat(index, module, scratchBase), ["i32", "i32", "i32", "i32"], root, "$concat");
+    appendFunctionBody(code, helperStringEqual(index, module), ["i32"], root, "$string_equal");
+    appendFunctionBody(code, helperCheckedAdd(index, module), ["i64"], root, "$checked_add");
+    appendFunctionBody(code, helperCheckedSubtract(index, module), ["i64"], root, "$checked_subtract");
+    appendFunctionBody(code, helperCheckedMultiply(index, module), ["i64"], root, "$checked_multiply");
+    appendFunctionBody(code, helperCheckedNegate(index, module), [], root, "$checked_negate");
+    for (let functionOffset = 0; functionOffset < module.functions.length; functionOffset += 1) {
+        const declaration = module.functions[functionOffset];
+        const path = `/functions/${functionOffset}`;
+        const emitter = new FunctionEmitter({ functionIndexes, index, literals: literals.byValue, module, scratchBase });
+        emitter.bindParameters(declaration.parameters);
+        emitter.block(declaration.body, `${path}/body`);
+        emitter.syntheticUnreachable(declaration, path);
+        emitter.syntheticEnd(declaration, path);
+        appendFunctionBody(code, emitter.writer, emitter.locals, { node: declaration, path }, declaration.name);
+    }
+    const runEmitter = new FunctionEmitter({ functionIndexes, index, literals: literals.byValue, module, scratchBase });
+    runEmitter.run(module.entryPoint, "/entryPoint");
+    appendFunctionBody(code, runEmitter.writer, runEmitter.locals, { node: module.entryPoint, path: "/entryPoint" }, "run");
+    appendSection(writer, 10, "code", code, root);
+    appendSection(writer, 11, "data", encodeDataSection(literals.entries, index, root), root);
+    appendCustomSection(writer, "name", encodeNamePayload(module, runFunctionIndex, index), root);
+    appendCustomSection(writer, "sourceMappingURL", namedPayload("program.wasm.map", index, root), root);
+    return { bytes: writer.finish(), ranges: writer.ranges };
+}
+/** Direct semantic function and entry-point instruction emitter. */
+class FunctionEmitter {
+    /**
+     * Creates an instruction emitter.
+     * @param {object} options - Encoding context.
+     * @param {Map<string, number>} options.functionIndexes - Semantic function indexes.
+     * @param {ReturnType<typeof createGenerationIndex>} options.index - Provenance index.
+     * @param {Map<string, {address: number, bytes: Uint8Array}>} options.literals - Literal addresses.
+     * @param {SemanticModule} options.module - Complete module.
+     * @param {number} options.scratchBase - Scratch base.
+     */
+    constructor({ functionIndexes, index, literals, module, scratchBase }) {
+        this.functionIndexes = functionIndexes;
+        this.functions = new Map(module.functions.map((declaration) => [declaration.name, declaration]));
+        this.index = index;
+        this.literals = literals;
+        this.module = module;
+        this.scratchBase = scratchBase;
+        this.writer = new BinaryWriter(index);
+        /** @type {("i32" | "i64")[]} */
+        this.locals = [];
+        /** @type {Map<string, LocalBinding>} */
+        this.bindings = new Map();
+        this.parameterCount = 0;
+    }
+    /**
+     * Binds flattened semantic parameters to Wasm parameter indexes.
+     * @param {import("../semantic/types.js").Parameter[]} parameters - Semantic parameters.
+     * @returns {void}
+     */
+    bindParameters(parameters) {
+        let index = 0;
+        for (const parameter of parameters) {
+            const scalar = wasmScalarType(parameter.type, parameter.location);
+            const types = wasmTypes(scalar);
+            const indexes = types.map(() => index++);
+            this.bindings.set(parameter.name, { indexes, type: scalar });
+        }
+        this.parameterCount = index;
+    }
+    /**
+     * Emits the guarded exported run body.
+     * @param {import("../semantic/types.js").EntryPoint} entryPoint - Semantic entry point.
+     * @param {string} path - Entry-point path.
+     * @returns {void}
+     */
+    run(entryPoint, path) {
+        this.syntheticOp(0x23, entryPoint, path, "active guard read");
+        this.syntheticImmediate(u32(activeGlobalIndex), entryPoint, path, "active guard global index");
+        this.syntheticOp(0x04, entryPoint, path, "active guard branch");
+        this.syntheticImmediate([0x40], entryPoint, path, "empty block type");
+        this.syntheticOp(0x00, entryPoint, path, "reentrant invocation trap");
+        this.syntheticOp(0x0b, entryPoint, path, "active guard branch end");
+        this.syntheticI32(1, entryPoint, path, "mark run active");
+        this.syntheticGlobalSet(activeGlobalIndex, entryPoint, path, "active guard");
+        this.syntheticI32(this.scratchBase, entryPoint, path, "reset scratch cursor");
+        this.syntheticGlobalSet(cursorGlobalIndex, entryPoint, path, "scratch cursor");
+        this.syntheticI32(0, entryPoint, path, "reset semantic call depth");
+        this.syntheticGlobalSet(depthGlobalIndex, entryPoint, path, "call depth");
+        this.block(entryPoint.body, `${path}/body`);
+        this.syntheticI32(0, entryPoint, path, "clear semantic call depth");
+        this.syntheticGlobalSet(depthGlobalIndex, entryPoint, path, "call depth");
+        this.syntheticI32(0, entryPoint, path, "mark run inactive");
+        this.syntheticGlobalSet(activeGlobalIndex, entryPoint, path, "active guard");
+        this.syntheticEnd(entryPoint, path);
+    }
+    /**
+     * Emits one semantic block.
+     * @param {import("../semantic/types.js").Block} block - Semantic block.
+     * @param {string} path - Occurrence path.
+     * @returns {void}
+     */
+    block(block, path) {
+        for (let index = 0; index < block.statements.length; index += 1) {
+            const statement = block.statements[index];
+            const statementPath = `${path}/statements/${index}`;
+            if (statement.kind == "LocalDeclaration") {
+                this.expression(statement.initializer, `${statementPath}/initializer`);
+                const binding = this.allocateBinding(wasmScalarType(statement.type, statement.location));
+                this.bindings.set(statement.name, binding);
+                this.setBinding(binding, statement, statementPath, "name");
+            }
+            else if (statement.kind == "AssignmentStatement") {
+                this.expression(statement.expression, `${statementPath}/expression`);
+                const binding = this.bindings.get(statement.target.name);
+                if (!binding)
+                    throw new Error("Validated Wasm assignment omitted its binding.");
+                this.setBinding(binding, statement.target, `${statementPath}/target`, "name");
+            }
+            else if (statement.kind == "PrintStatement") {
+                const type = expressionType(statement.expression, this.bindings, this.functions);
+                this.expression(statement.expression, `${statementPath}/expression`);
+                const importIndex = type == "integer" ? 0 : type == "boolean" ? 1 : 2;
+                this.mappedOp(0x10, statement, statementPath, "print instruction");
+                this.mappedImmediate(u32(importIndex), statement, statementPath, "print import index");
+            }
+            else if (statement.kind == "ReturnStatement") {
+                if (!statement.expression)
+                    throw new TypeError("Wasm bare return reached emission.");
+                this.expression(statement.expression, `${statementPath}/expression`);
+                this.mappedOp(0x0f, statement, statementPath, "return instruction");
+            }
+            else if (statement.kind == "ExpressionStatement") {
+                throw new TypeError("Wasm Task 005 expression statement reached emission.");
+            }
+            else if (statement.kind == "IfStatement") {
+                this.expression(statement.condition, `${statementPath}/condition`);
+                this.mappedOp(0x04, statement.condition, `${statementPath}/condition`, "conditional instruction");
+                this.syntheticImmediate([0x40], statement, statementPath, "empty conditional block type");
+                this.block(statement.consequent, `${statementPath}/consequent`);
+                if (statement.alternate) {
+                    this.mappedOp(0x05, statement, statementPath, "alternate instruction");
+                    this.block(statement.alternate, `${statementPath}/alternate`);
+                }
+                this.mappedOp(0x0b, statement, statementPath, "conditional end");
+            }
+            else {
+                throw new TypeError("Unsupported Wasm statement reached emission.");
+            }
+        }
+    }
+    /**
+     * Emits one expression and leaves its flattened result on the operand stack.
+     * @param {Expression} expression - Semantic expression.
+     * @param {string} path - Occurrence path.
+     * @returns {void}
+     */
+    expression(expression, path) {
+        if (expression.kind == "IdentifierExpression") {
+            const binding = this.bindings.get(expression.name);
+            if (!binding)
+                throw new Error("Validated Wasm identifier omitted its binding.");
+            for (const localIndex of binding.indexes) {
+                this.mappedOp(0x20, expression, path, "local read", "name");
+                this.mappedImmediate(u32(localIndex), expression, path, "local index", "name");
+            }
+            return;
+        }
+        if (expression.kind == "IntegerLiteral") {
+            this.mappedOp(0x42, expression, path, "i64 constant", "literal");
+            this.mappedImmediate(s64(BigInt(expression.value)), expression, path, "i64 immediate", "literal");
+            return;
+        }
+        if (expression.kind == "BooleanLiteral") {
+            this.mappedOp(0x41, expression, path, "canonical Boolean constant", "literal");
+            this.mappedImmediate(s32(expression.value ? 1 : 0), expression, path, "i32 immediate", "literal");
+            return;
+        }
+        if (expression.kind == "StringLiteral") {
+            const literal = this.literals.get(expression.value);
+            if (!literal)
+                throw new Error("Validated Wasm string literal omitted its static layout.");
+            this.mappedOp(0x41, expression, path, "string pointer constant", "literal");
+            this.mappedImmediate(s32(literal.address), expression, path, "string pointer immediate", "literal");
+            this.mappedOp(0x41, expression, path, "string length constant", "literal");
+            this.mappedImmediate(s32(literal.bytes.byteLength), expression, path, "string length immediate", "literal");
+            return;
+        }
+        if (expression.kind == "CallExpression") {
+            for (let index = 0; index < expression.arguments.length; index += 1) {
+                this.expression(expression.arguments[index], `${path}/arguments/${index}`);
+            }
+            this.semanticCall(expression, path);
+            return;
+        }
+        if (expression.kind == "UnaryExpression") {
+            this.expression(expression.operand, `${path}/operand`);
+            if (expression.operation == "BooleanNot")
+                this.mappedOp(0x45, expression, path, "Boolean not instruction", "operator");
+            else {
+                this.mappedOp(0x10, expression, path, "checked integer negate instruction", "operator");
+                this.mappedImmediate(u32(checkedNegateFunctionIndex), expression, path, "checked helper index", "operator");
+            }
+            return;
+        }
+        if (expression.kind != "BinaryExpression") {
+            return unsupportedCapability("wasm", "collection expression reached scalar emission", expression.location);
+        }
+        if (expression.operation == "BooleanAnd" || expression.operation == "BooleanOr") {
+            this.expression(expression.left, `${path}/left`);
+            this.mappedOp(0x04, expression, path, "short-circuit conditional", "operator");
+            this.syntheticImmediate([valueTypes.i32], expression, path, "Boolean conditional result type");
+            if (expression.operation == "BooleanAnd") {
+                this.expression(expression.right, `${path}/right`);
+                this.mappedOp(0x05, expression, path, "short-circuit alternate", "operator");
+                this.syntheticI32(0, expression, path, "canonical false result");
+            }
+            else {
+                this.syntheticI32(1, expression, path, "canonical true result");
+                this.mappedOp(0x05, expression, path, "short-circuit alternate", "operator");
+                this.expression(expression.right, `${path}/right`);
+            }
+            this.mappedOp(0x0b, expression, path, "short-circuit end", "operator");
+            return;
+        }
+        this.expression(expression.left, `${path}/left`);
+        this.expression(expression.right, `${path}/right`);
+        const directOpcode = new Map([
+            ["IntegerEqual", 0x51], ["IntegerNotEqual", 0x52], ["IntegerLessThan", 0x53],
+            ["IntegerGreaterThan", 0x55], ["IntegerLessThanOrEqual", 0x57], ["IntegerGreaterThanOrEqual", 0x59],
+            ["BooleanEqual", 0x46], ["BooleanNotEqual", 0x47]
+        ]).get(expression.operation);
+        if (directOpcode !== undefined)
+            this.mappedOp(directOpcode, expression, path, `${expression.operation} instruction`, "operator");
+        else {
+            const helperIndex = expression.operation == "StringConcat" ? concatFunctionIndex :
+                expression.operation == "StringEqual" || expression.operation == "StringNotEqual" ? stringEqualFunctionIndex :
+                    expression.operation == "IntegerAdd" ? checkedAddFunctionIndex :
+                        expression.operation == "IntegerSubtract" ? checkedSubtractFunctionIndex : checkedMultiplyFunctionIndex;
+            this.mappedOp(0x10, expression, path, `${expression.operation} helper call`, "operator");
+            this.mappedImmediate(u32(helperIndex), expression, path, "helper function index", "operator");
+            if (expression.operation == "StringNotEqual")
+                this.mappedOp(0x45, expression, path, "String inequality inversion", "operator");
+        }
+    }
+    /**
+     * Emits checked semantic-call depth accounting without changing argument order.
+     * @param {import("../semantic/types.js").CallExpression} expression - Call expression.
+     * @param {string} path - Call occurrence path.
+     * @returns {void}
+     */
+    semanticCall(expression, path) {
+        const declaration = this.functions.get(expression.callee);
+        const functionIndex = this.functionIndexes.get(expression.callee);
+        if (!declaration || functionIndex === undefined)
+            throw new Error("Validated Wasm call omitted its declaration.");
+        this.syntheticOp(0x23, expression, path, "read semantic call depth");
+        this.syntheticImmediate(u32(depthGlobalIndex), expression, path, "call-depth global index");
+        this.syntheticI32(maximumCallDepth, expression, path, "maximum semantic call depth");
+        this.syntheticOp(0x4f, expression, path, "semantic call-depth limit comparison");
+        this.syntheticOp(0x04, expression, path, "semantic call-depth guard");
+        this.syntheticImmediate([0x40], expression, path, "empty call-depth guard block type");
+        this.syntheticOp(0x00, expression, path, "semantic call-depth trap");
+        this.syntheticOp(0x0b, expression, path, "semantic call-depth guard end");
+        this.syntheticOp(0x23, expression, path, "read semantic call depth");
+        this.syntheticImmediate(u32(depthGlobalIndex), expression, path, "call-depth global index");
+        this.syntheticI32(1, expression, path, "semantic call-depth increment");
+        this.syntheticOp(0x6a, expression, path, "increment semantic call depth");
+        this.syntheticGlobalSet(depthGlobalIndex, expression, path, "call depth");
+        this.mappedOp(0x10, expression, path, "semantic call instruction", "callee");
+        this.mappedImmediate(u32(functionIndex), expression, path, "semantic callee index", "callee");
+        const result = this.allocateBinding(wasmReturnType(declaration));
+        this.setBinding(result, expression, path);
+        this.syntheticOp(0x23, expression, path, "read semantic call depth");
+        this.syntheticImmediate(u32(depthGlobalIndex), expression, path, "call-depth global index");
+        this.syntheticI32(1, expression, path, "semantic call-depth decrement");
+        this.syntheticOp(0x6b, expression, path, "decrement semantic call depth");
+        this.syntheticGlobalSet(depthGlobalIndex, expression, path, "call depth");
+        for (const localIndex of result.indexes) {
+            this.syntheticOp(0x20, expression, path, "restore semantic call result");
+            this.syntheticImmediate(u32(localIndex), expression, path, "result temporary local index");
+        }
+    }
+    /**
+     * Allocates flattened Wasm locals for one semantic value.
+     * @param {Scalar} type - Semantic type.
+     * @returns {LocalBinding} Local binding.
+     */
+    allocateBinding(type) {
+        const indexes = wasmTypes(type).map((wasmType) => {
+            const index = this.parameterCount + this.locals.length;
+            this.locals.push(wasmType);
+            return index;
+        });
+        return { indexes, type };
+    }
+    /**
+     * Pops a flattened value into its locals.
+     * @param {LocalBinding} binding - Destination.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Occurrence path.
+     * @param {string} [sourceRole] - Exact parser-owned token role, when this is a semantic binding.
+     * @returns {void}
+     */
+    setBinding(binding, node, path, sourceRole) {
+        for (let index = binding.indexes.length - 1; index >= 0; index -= 1) {
+            if (sourceRole) {
+                this.mappedOp(0x21, node, path, "local write", sourceRole);
+                this.mappedImmediate(u32(binding.indexes[index]), node, path, "local index", sourceRole);
+            }
+            else {
+                this.syntheticOp(0x21, node, path, "store semantic call result");
+                this.syntheticImmediate(u32(binding.indexes[index]), node, path, "result temporary local index");
+            }
+        }
+    }
+    /**
+     * Writes a source-mapped instruction opcode.
+     * @param {number} opcode - Wasm opcode.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Node occurrence path.
+     * @param {string} role - Mapping role.
+     * @param {string} [sourceRole] - Exact parser-owned token role.
+     * @returns {void}
+     */
+    mappedOp(opcode, node, path, role, sourceRole) { this.writer.mapped([opcode], node, path, role, sourceRole); }
+    /**
+     * Writes a source-mapped instruction immediate.
+     * @param {number[]} bytes - Encoded immediate bytes.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Node occurrence path.
+     * @param {string} role - Mapping role.
+     * @param {string} [sourceRole] - Exact parser-owned token role.
+     * @returns {void}
+     */
+    mappedImmediate(bytes, node, path, role, sourceRole) { this.writer.mapped(bytes, node, path, role, sourceRole); }
+    /**
+     * Writes a synthetic instruction opcode with semantic context.
+     * @param {number} opcode - Wasm opcode.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Node occurrence path.
+     * @param {string} reason - Synthetic provenance reason.
+     * @returns {void}
+     */
+    syntheticOp(opcode, node, path, reason) { this.writer.synthetic([opcode], reason, { node, path }, "instruction"); }
+    /**
+     * Writes a synthetic immediate with semantic context.
+     * @param {number[]} bytes - Encoded immediate bytes.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Node occurrence path.
+     * @param {string} reason - Synthetic provenance reason.
+     * @returns {void}
+     */
+    syntheticImmediate(bytes, node, path, reason) { this.writer.synthetic(bytes, reason, { node, path }, "immediate"); }
+    /**
+     * Writes a synthetic i32 constant instruction.
+     * @param {number} value - Constant value.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Node occurrence path.
+     * @param {string} reason - Synthetic provenance reason.
+     * @returns {void}
+     */
+    syntheticI32(value, node, path, reason) {
+        this.syntheticOp(0x41, node, path, reason);
+        this.syntheticImmediate(s32(value), node, path, `${reason} immediate`);
+    }
+    /**
+     * Writes a synthetic global assignment.
+     * @param {number} index - Global index.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Node occurrence path.
+     * @param {string} reason - Synthetic provenance reason.
+     * @returns {void}
+     */
+    syntheticGlobalSet(index, node, path, reason) {
+        this.syntheticOp(0x24, node, path, `set ${reason}`);
+        this.syntheticImmediate(u32(index), node, path, `${reason} global index`);
+    }
+    /**
+     * Writes a synthetic function-end instruction.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Node occurrence path.
+     * @returns {void}
+     */
+    syntheticEnd(node, path) { this.syntheticOp(0x0b, node, path, "function end"); }
+    /**
+     * Writes a synthetic unreachable instruction.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Node occurrence path.
+     * @returns {void}
+     */
+    syntheticUnreachable(node, path) { this.syntheticOp(0x00, node, path, "validated non-void fallthrough trap"); }
+}
+/** Byte writer that preserves one non-overlapping provenance annotation per write. */
+class BinaryWriter {
+    /**
+     * Creates an annotated binary writer.
+     * @param {ReturnType<typeof createGenerationIndex>} index - Canonical provenance index.
+     */
+    constructor(index) {
+        this.index = index;
+        /** @type {number[]} */
+        this.bytes = [];
+        /** @type {GeneratedByteRange[]} */
+        this.ranges = [];
+    }
+    /**
+     * Writes source-backed bytes.
+     * @param {number[] | Uint8Array} bytes - Exact bytes.
+     * @param {SemanticNode} node - Semantic node.
+     * @param {string} path - Occurrence path.
+     * @param {string} role - Binary role.
+     * @param {string} [sourceRole] - Exact parser-owned token role.
+     * @returns {void}
+     */
+    mapped(bytes, node, path, role, sourceRole) {
+        const record = this.index.recordFor(node, path);
+        const origin = sourceRole ? originForRole(this.index, record, sourceRole) : record.origin;
+        this.write(bytes, { nodeId: record.id, origin, role, symbolId: record.symbolId });
+    }
+    /**
+     * Writes explicit backend scaffolding bytes.
+     * @param {number[] | Uint8Array} bytes - Exact bytes.
+     * @param {string} reason - Synthetic reason.
+     * @param {{node: SemanticNode, path: string}} related - Related occurrence.
+     * @param {string} role - Binary role.
+     * @returns {void}
+     */
+    synthetic(bytes, reason, related, role) {
+        const record = this.index.recordFor(related.node, related.path);
+        this.write(bytes, {
+            origin: { kind: "synthetic", reason, relatedOrigins: relatedOrigins(record) },
+            role
+        });
+    }
+    /**
+     * Appends another annotated writer.
+     * @param {BinaryWriter} child - Child bytes.
+     * @returns {void}
+     */
+    append(child) {
+        const offset = this.bytes.length;
+        for (const byte of child.bytes)
+            this.bytes.push(byte);
+        for (const range of child.ranges) {
+            this.ranges.push({ ...range, generated: { start: range.generated.start + offset, end: range.generated.end + offset } });
+        }
+    }
+    /**
+     * Returns detached encoded bytes.
+     * @returns {Uint8Array} Detached bytes.
+     */
+    finish() { return Uint8Array.from(this.bytes); }
+    /**
+     * Writes one non-empty annotated range.
+     * @param {number[] | Uint8Array} bytes - Exact bytes.
+     * @param {Omit<GeneratedByteRange, "generated">} annotation - Provenance.
+     * @returns {void}
+     */
+    write(bytes, annotation) {
+        if (bytes.length == 0)
+            return;
+        const start = this.bytes.length;
+        for (const byte of bytes) {
+            if (!Number.isInteger(byte) || byte < 0 || byte > 255)
+                throw new RangeError("Invalid WebAssembly byte.");
+            this.bytes.push(byte);
+        }
+        this.ranges.push({ ...annotation, generated: { start, end: this.bytes.length } });
+    }
+}
+/** Deterministic function-type interner. */
+class TypePool {
+    constructor() {
+        /** @type {{parameters: ("i32" | "i64")[], results: ("i32" | "i64")[]}[]} */
+        this.entries = [];
+        /** @type {Map<string, number>} */
+        this.indexes = new Map();
+    }
+    /**
+     * Interns one function type.
+     * @param {("i32" | "i64")[]} parameters - Parameters.
+     * @param {("i32" | "i64")[]} results - Results.
+     * @returns {number} Type index.
+     */
+    add(parameters, results) {
+        const key = `${parameters.join(",")}->${results.join(",")}`;
+        const prior = this.indexes.get(key);
+        if (prior !== undefined)
+            return prior;
+        const index = this.entries.length;
+        this.entries.push({ parameters, results });
+        this.indexes.set(key, index);
+        return index;
+    }
+}
+/**
+ * Encodes the function-type section payload.
+ * @param {TypePool} types - Interned function types.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {{node: SemanticNode, path: string}} root - Related module occurrence.
+ * @returns {BinaryWriter} Encoded payload.
+ */
+function encodeTypeSection(types, index, root) {
+    const writer = new BinaryWriter(index);
+    writer.synthetic(u32(types.entries.length), "Function type count", root, "type count");
+    for (const type of types.entries) {
+        writer.synthetic([0x60], "Function type form", root, "type form");
+        writer.synthetic(u32(type.parameters.length), "Function parameter count", root, "type parameter count");
+        for (const parameter of type.parameters)
+            writer.synthetic([valueTypes[parameter]], "Function parameter value type", root, "value type");
+        writer.synthetic(u32(type.results.length), "Function result count", root, "type result count");
+        for (const result of type.results)
+            writer.synthetic([valueTypes[result]], "Function result value type", root, "value type");
+    }
+    return writer;
+}
+/**
+ * Encodes the fixed ABI import section payload.
+ * @param {number[]} typeIndexes - Import function type indexes.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {{node: SemanticNode, path: string}} root - Related module occurrence.
+ * @returns {BinaryWriter} Encoded payload.
+ */
+function encodeImportSection(typeIndexes, index, root) {
+    const writer = new BinaryWriter(index);
+    const names = ["print_i64", "print_bool", "print_string"];
+    writer.synthetic(u32(names.length), "ABI import count", root, "import count");
+    for (let offset = 0; offset < names.length; offset += 1) {
+        writer.synthetic(nameBytes("semantifold"), "ABI import module name", root, "import module");
+        writer.synthetic(nameBytes(names[offset]), "ABI import function name", root, "import name");
+        writer.synthetic([0x00], "Function import kind", root, "import kind");
+        writer.synthetic(u32(typeIndexes[offset]), "ABI import type index", root, "type index");
+    }
+    return writer;
+}
+/**
+ * Encodes defined-function type indexes.
+ * @param {number[]} helperTypes - Private helper type indexes.
+ * @param {number[]} semanticTypes - Semantic function type indexes.
+ * @param {number} runType - Exported run function type index.
+ * @param {SemanticModule} module - Semantic module.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @returns {BinaryWriter} Encoded payload.
+ */
+function encodeFunctionSection(helperTypes, semanticTypes, runType, module, index) {
+    const writer = new BinaryWriter(index);
+    const root = { node: module, path: "" };
+    writer.synthetic(u32(helperTypes.length + semanticTypes.length + 1), "Defined function count", root, "function count");
+    for (const typeIndex of helperTypes)
+        writer.synthetic(u32(typeIndex), "Private ABI helper type index", root, "type index");
+    for (let offset = 0; offset < semanticTypes.length; offset += 1) {
+        const declaration = module.functions[offset];
+        writer.synthetic(u32(semanticTypes[offset]), "Semantic function type index", { node: declaration, path: `/functions/${offset}` }, "type index");
+    }
+    writer.synthetic(u32(runType), "Exported run type index", { node: module.entryPoint, path: "/entryPoint" }, "type index");
+    return writer;
+}
+/**
+ * Encodes one fixed-memory declaration.
+ * @param {number} pages - Equal initial and maximum page count.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {{node: SemanticNode, path: string}} root - Related module occurrence.
+ * @returns {BinaryWriter} Encoded payload.
+ */
+function encodeMemorySection(pages, index, root) {
+    const writer = new BinaryWriter(index);
+    writer.synthetic(u32(1), "Single fixed linear memory", root, "memory count");
+    writer.synthetic([0x01], "Memory limits include equal maximum", root, "memory limits flags");
+    writer.synthetic(u32(pages), "Initial memory page count", root, "memory initial pages");
+    writer.synthetic(u32(pages), "Maximum memory page count", root, "memory maximum pages");
+    return writer;
+}
+/**
+ * Encodes private mutable ABI globals.
+ * @param {number} scratchBase - Initial scratch cursor.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {{node: SemanticNode, path: string}} root - Related module occurrence.
+ * @returns {BinaryWriter} Encoded payload.
+ */
+function encodeGlobalSection(scratchBase, index, root) {
+    const writer = new BinaryWriter(index);
+    const globals = [
+        { initial: scratchBase, reason: "Private scratch cursor" },
+        { initial: 0, reason: "Private semantic call depth" },
+        { initial: 0, reason: "Private run active guard" }
+    ];
+    writer.synthetic(u32(globals.length), "Private mutable global count", root, "global count");
+    for (const global of globals) {
+        writer.synthetic([valueTypes.i32, 0x01], `${global.reason} type and mutability`, root, "global type");
+        writer.synthetic([0x41], `${global.reason} initializer instruction`, root, "instruction");
+        writer.synthetic(s32(global.initial), `${global.reason} initializer immediate`, root, "immediate");
+        writer.synthetic([0x0b], `${global.reason} initializer end`, root, "instruction");
+    }
+    return writer;
+}
+/**
+ * Encodes exactly the public memory and run exports.
+ * @param {number} runIndex - Exported run function index.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {{node: SemanticNode, path: string}} root - Related module occurrence.
+ * @returns {BinaryWriter} Encoded payload.
+ */
+function encodeExportSection(runIndex, index, root) {
+    const writer = new BinaryWriter(index);
+    writer.synthetic(u32(2), "Exact ABI export count", root, "export count");
+    writer.synthetic(nameBytes("memory"), "Exported memory name", root, "export name");
+    writer.synthetic([0x02], "Memory export kind", root, "export kind");
+    writer.synthetic(u32(0), "Exported memory index", root, "memory index");
+    writer.synthetic(nameBytes("run"), "Exported run name", root, "export name");
+    writer.synthetic([0x00], "Function export kind", root, "export kind");
+    writer.synthetic(u32(runIndex), "Exported run function index", root, "function index");
+    return writer;
+}
+/**
+ * Encodes immutable UTF-8 literal data segments.
+ * @param {ReturnType<typeof collectLiteralLayout>["entries"]} entries - Ordered literal entries.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {{node: SemanticNode, path: string}} root - Related module occurrence.
+ * @returns {BinaryWriter} Encoded payload.
+ */
+function encodeDataSection(entries, index, root) {
+    const writer = new BinaryWriter(index);
+    const nonempty = entries.filter(({ bytes }) => bytes.byteLength > 0);
+    writer.synthetic(u32(nonempty.length), "Immutable literal data segment count", root, "data segment count");
+    for (const entry of nonempty) {
+        writer.synthetic([0x00, 0x41], "Active literal data segment and offset instruction", root, "data segment header");
+        writer.synthetic(s32(entry.address), "Literal data address", root, "data segment offset");
+        writer.synthetic([0x0b], "Literal offset expression end", root, "instruction");
+        writer.synthetic(u32(entry.bytes.byteLength), "Literal data byte length", root, "data segment length");
+        writer.write(entry.bytes, {
+            origin: entry.origin,
+            role: "immutable UTF-8 literal data"
+        });
+    }
+    return writer;
+}
+/**
+ * Encodes deterministic internal and semantic function names.
+ * @param {SemanticModule} module - Semantic module.
+ * @param {number} runIndex - Exported run function index.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @returns {BinaryWriter} Encoded custom-section payload.
+ */
+function encodeNamePayload(module, runIndex, index) {
+    const writer = new BinaryWriter(index);
+    const root = { node: module, path: "" };
+    const subsection = new BinaryWriter(index);
+    /** @type {{declaration?: import("../semantic/types.js").FunctionDeclaration, index: number, name: string, path?: string}[]} */
+    const names = [
+        ...helperNames.map((name, offset) => ({ index: importCount + offset, name })),
+        ...module.functions.map((declaration, offset) => ({ declaration, index: importCount + helperCount + offset, name: declaration.name, path: `/functions/${offset}` })),
+        { index: runIndex, name: "run" }
+    ];
+    subsection.synthetic(u32(names.length), "Named function count", root, "name count");
+    for (const name of names) {
+        subsection.synthetic(u32(name.index), "Named function index", root, "function index");
+        if (name.declaration) {
+            const bytes = encoder.encode(name.name);
+            const related = { node: name.declaration, path: /** @type {string} */ (name.path) };
+            subsection.synthetic(u32(bytes.byteLength), "Semantic function name byte length", related, "function name length");
+            subsection.mapped(bytes, name.declaration, related.path, "semantic function name", "name");
+        }
+        else
+            subsection.synthetic(nameBytes(name.name), "Private ABI function name", root, "function name");
+    }
+    writer.synthetic([0x01], "Function names subsection ID", root, "custom subsection id");
+    writer.synthetic(u32(subsection.bytes.length), "Function names subsection size", root, "custom subsection size");
+    writer.append(subsection);
+    return writer;
+}
+/**
+ * Encodes one source-map URL custom-section payload.
+ * @param {string} content - Relative map URL.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {{node: SemanticNode, path: string}} root - Related module occurrence.
+ * @returns {BinaryWriter} Encoded payload.
+ */
+function namedPayload(content, index, root) {
+    const writer = new BinaryWriter(index);
+    writer.synthetic(encoder.encode(content), "Relative external Wasm source-map URL", root, "custom section payload");
+    return writer;
+}
+/**
+ * Appends one sized module section.
+ * @param {BinaryWriter} moduleWriter - Complete module writer.
+ * @param {number} id - Core section ID.
+ * @param {string} name - Diagnostic section name.
+ * @param {BinaryWriter} payload - Encoded section payload.
+ * @param {{node: SemanticNode, path: string}} root - Related module occurrence.
+ * @returns {void}
+ */
+function appendSection(moduleWriter, id, name, payload, root) {
+    moduleWriter.synthetic([id], `${name} section ID`, root, `${name} section`);
+    moduleWriter.synthetic(u32(payload.bytes.length), `${name} section byte length`, root, `${name} section length`);
+    moduleWriter.append(payload);
+}
+/**
+ * Appends one named custom section.
+ * @param {BinaryWriter} writer - Complete module writer.
+ * @param {string} name - Custom-section name.
+ * @param {BinaryWriter} payload - Custom-section payload.
+ * @param {{node: SemanticNode, path: string}} root - Related module occurrence.
+ * @returns {void}
+ */
+function appendCustomSection(writer, name, payload, root) {
+    const complete = new BinaryWriter(writer.index);
+    complete.synthetic(nameBytes(name), `Custom section name '${name}'`, root, "custom section name");
+    complete.append(payload);
+    appendSection(writer, 0, `custom ${name}`, complete, root);
+}
+/**
+ * Appends one sized function body and its flattened locals.
+ * @param {BinaryWriter} code - Code-section payload writer.
+ * @param {BinaryWriter} instructions - Function instructions.
+ * @param {("i32" | "i64")[]} locals - Flattened local types.
+ * @param {{node: SemanticNode, path: string}} related - Related semantic occurrence.
+ * @param {string} name - Function name for provenance.
+ * @returns {void}
+ */
+function appendFunctionBody(code, instructions, locals, related, name) {
+    const body = new BinaryWriter(code.index);
+    body.synthetic(u32(locals.length), `Local declaration group count for ${name}`, related, "function locals");
+    for (const local of locals) {
+        body.synthetic(u32(1), `Local count for ${name}`, related, "local count");
+        body.synthetic([valueTypes[local]], `Local value type for ${name}`, related, "local type");
+    }
+    body.append(instructions);
+    code.synthetic(u32(body.bytes.length), `Function body byte length for ${name}`, related, "function body length");
+    code.append(body);
+}
+/**
+ * Encodes checked scratch allocation and string concatenation.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {SemanticModule} module - Semantic module.
+ * @param {number} scratchBase - Arena start address.
+ * @returns {BinaryWriter} Encoded helper body.
+ */
+function helperConcat(index, module, scratchBase) {
+    const e = new SyntheticEmitter(index, module, "$concat");
+    const total = 4;
+    const start = 5;
+    const end = 6;
+    const cursor = 7;
+    e.localGet(1);
+    e.localGet(3);
+    e.op(0x6a, "add string lengths");
+    e.localTee(total);
+    e.localGet(1);
+    e.op(0x49, "detect unsigned string-length overflow");
+    e.trapIf("string-length overflow");
+    e.globalGet(cursorGlobalIndex);
+    e.localTee(start);
+    e.localGet(total);
+    e.op(0x6a, "add scratch cursor and allocation length");
+    e.localTee(end);
+    e.localGet(start);
+    e.op(0x49, "detect unsigned scratch-cursor overflow");
+    e.trapIf("scratch cursor overflow");
+    e.localGet(end);
+    e.i32(scratchBase + scratchCapacity);
+    e.op(0x4b, "compare allocation end with arena end");
+    e.trapIf("scratch capacity exceeded");
+    e.i32(0);
+    e.localSet(cursor);
+    e.copyLoop(cursor, 0, 1, start, undefined);
+    e.i32(0);
+    e.localSet(cursor);
+    e.copyLoop(cursor, 2, 3, start, 1);
+    e.localGet(end);
+    e.globalSet(cursorGlobalIndex);
+    e.localGet(start);
+    e.localGet(total);
+    e.end();
+    return e.writer;
+}
+/**
+ * Encodes byte-exact string equality.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {SemanticModule} module - Semantic module.
+ * @returns {BinaryWriter} Encoded helper body.
+ */
+function helperStringEqual(index, module) {
+    const e = new SyntheticEmitter(index, module, "$string_equal");
+    const cursor = 4;
+    e.localGet(1);
+    e.localGet(3);
+    e.op(0x47, "compare string lengths");
+    e.op(0x04, "branch for unequal string lengths");
+    e.immediate([0x40], "empty block type");
+    e.i32(0);
+    e.op(0x0f, "return false for unequal lengths");
+    e.op(0x0b, "end length branch");
+    e.i32(0);
+    e.localSet(cursor);
+    e.op(0x02, "string comparison exit block");
+    e.immediate([0x40], "empty block type");
+    e.op(0x03, "string comparison loop");
+    e.immediate([0x40], "empty block type");
+    e.localGet(cursor);
+    e.localGet(1);
+    e.op(0x4f, "compare cursor with string length");
+    e.op(0x0d, "exit completed comparison");
+    e.immediate(u32(1), "comparison block depth");
+    e.localGet(0);
+    e.localGet(cursor);
+    e.op(0x6a, "left byte address");
+    e.load8();
+    e.localGet(2);
+    e.localGet(cursor);
+    e.op(0x6a, "right byte address");
+    e.load8();
+    e.op(0x47, "compare UTF-8 bytes");
+    e.op(0x04, "branch for unequal UTF-8 bytes");
+    e.immediate([0x40], "empty block type");
+    e.i32(0);
+    e.op(0x0f, "return false for unequal bytes");
+    e.op(0x0b, "end byte branch");
+    e.localGet(cursor);
+    e.i32(1);
+    e.op(0x6a, "increment comparison cursor");
+    e.localSet(cursor);
+    e.op(0x0c, "continue string comparison");
+    e.immediate(u32(0), "comparison loop depth");
+    e.op(0x0b, "end comparison loop");
+    e.op(0x0b, "end comparison block");
+    e.i32(1);
+    e.end();
+    return e.writer;
+}
+/**
+ * Encodes checked signed i64 addition.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {SemanticModule} module - Semantic module.
+ * @returns {BinaryWriter} Encoded helper body.
+ */
+function helperCheckedAdd(index, module) {
+    const e = new SyntheticEmitter(index, module, "$checked_add");
+    e.localGet(0);
+    e.localGet(1);
+    e.op(0x7c, "signed i64 addition");
+    e.localSet(2);
+    e.localGet(0);
+    e.localGet(2);
+    e.op(0x85, "addition overflow xor");
+    e.localGet(1);
+    e.localGet(2);
+    e.op(0x85, "addition overflow xor");
+    e.op(0x83, "addition overflow mask");
+    e.i64(0n);
+    e.op(0x53, "addition overflow sign test");
+    e.trapIf("signed i64 addition overflow");
+    e.localGet(2);
+    e.end();
+    return e.writer;
+}
+/**
+ * Encodes checked signed i64 subtraction.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {SemanticModule} module - Semantic module.
+ * @returns {BinaryWriter} Encoded helper body.
+ */
+function helperCheckedSubtract(index, module) {
+    const e = new SyntheticEmitter(index, module, "$checked_subtract");
+    e.localGet(0);
+    e.localGet(1);
+    e.op(0x7d, "signed i64 subtraction");
+    e.localSet(2);
+    e.localGet(0);
+    e.localGet(1);
+    e.op(0x85, "subtraction overflow xor");
+    e.localGet(0);
+    e.localGet(2);
+    e.op(0x85, "subtraction overflow xor");
+    e.op(0x83, "subtraction overflow mask");
+    e.i64(0n);
+    e.op(0x53, "subtraction overflow sign test");
+    e.trapIf("signed i64 subtraction overflow");
+    e.localGet(2);
+    e.end();
+    return e.writer;
+}
+/**
+ * Encodes checked signed i64 multiplication.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {SemanticModule} module - Semantic module.
+ * @returns {BinaryWriter} Encoded helper body.
+ */
+function helperCheckedMultiply(index, module) {
+    const e = new SyntheticEmitter(index, module, "$checked_multiply");
+    e.localGet(0);
+    e.op(0x50, "left operand zero test");
+    e.localGet(1);
+    e.op(0x50, "right operand zero test");
+    e.op(0x72, "zero operand combination");
+    e.op(0x04, "zero multiplication branch");
+    e.immediate([valueTypes.i64], "i64 branch result type");
+    e.i64(0n);
+    e.op(0x05, "nonzero multiplication branch");
+    e.localGet(0);
+    e.i64(-1n);
+    e.op(0x51, "left negative-one test");
+    e.localGet(1);
+    e.i64(-9223372036854775808n);
+    e.op(0x51, "right minimum test");
+    e.op(0x71, "first division overflow combination");
+    e.localGet(1);
+    e.i64(-1n);
+    e.op(0x51, "right negative-one test");
+    e.localGet(0);
+    e.i64(-9223372036854775808n);
+    e.op(0x51, "left minimum test");
+    e.op(0x71, "second division overflow combination");
+    e.op(0x72, "division overflow combination");
+    e.trapIf("signed i64 multiplication overflow");
+    e.localGet(0);
+    e.localGet(1);
+    e.op(0x7e, "signed i64 multiplication");
+    e.localSet(2);
+    e.localGet(2);
+    e.localGet(1);
+    e.op(0x7f, "signed i64 division overflow check");
+    e.localGet(0);
+    e.op(0x52, "multiplication quotient mismatch");
+    e.trapIf("signed i64 multiplication overflow");
+    e.localGet(2);
+    e.op(0x0b, "end checked multiplication branch");
+    e.end();
+    return e.writer;
+}
+/**
+ * Encodes checked signed i64 negation.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @param {SemanticModule} module - Semantic module.
+ * @returns {BinaryWriter} Encoded helper body.
+ */
+function helperCheckedNegate(index, module) {
+    const e = new SyntheticEmitter(index, module, "$checked_negate");
+    e.localGet(0);
+    e.i64(-9223372036854775808n);
+    e.op(0x51, "minimum i64 negate test");
+    e.trapIf("signed i64 negation overflow");
+    e.i64(0n);
+    e.localGet(0);
+    e.op(0x7d, "signed i64 negation");
+    e.end();
+    return e.writer;
+}
+/** Helper instruction emitter with explicit synthetic provenance. */
+class SyntheticEmitter {
+    /**
+     * Creates a synthetic helper emitter.
+     * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+     * @param {SemanticModule} module - Related semantic module.
+     * @param {string} name - Helper function name.
+     */
+    constructor(index, module, name) {
+        this.writer = new BinaryWriter(index);
+        this.related = { node: module, path: "" };
+        this.name = name;
+    }
+    /**
+     * Writes an instruction opcode.
+     * @param {number} opcode - Wasm opcode.
+     * @param {string} reason - Synthetic provenance reason.
+     * @returns {void}
+     */
+    op(opcode, reason) { this.writer.synthetic([opcode], `${this.name}: ${reason}`, this.related, "instruction"); }
+    /**
+     * Writes encoded instruction immediates.
+     * @param {number[]} bytes - Immediate bytes.
+     * @param {string} reason - Synthetic provenance reason.
+     * @returns {void}
+     */
+    immediate(bytes, reason) { this.writer.synthetic(bytes, `${this.name}: ${reason}`, this.related, "immediate"); }
+    /**
+     * Reads one local.
+     * @param {number} index - Local index.
+     * @returns {void}
+     */
+    localGet(index) { this.op(0x20, "read local"); this.immediate(u32(index), "local index"); }
+    /**
+     * Writes one local.
+     * @param {number} index - Local index.
+     * @returns {void}
+     */
+    localSet(index) { this.op(0x21, "write local"); this.immediate(u32(index), "local index"); }
+    /**
+     * Writes and retains one local value.
+     * @param {number} index - Local index.
+     * @returns {void}
+     */
+    localTee(index) { this.op(0x22, "tee local"); this.immediate(u32(index), "local index"); }
+    /**
+     * Reads one global.
+     * @param {number} index - Global index.
+     * @returns {void}
+     */
+    globalGet(index) { this.op(0x23, "read global"); this.immediate(u32(index), "global index"); }
+    /**
+     * Writes one global.
+     * @param {number} index - Global index.
+     * @returns {void}
+     */
+    globalSet(index) { this.op(0x24, "write global"); this.immediate(u32(index), "global index"); }
+    /**
+     * Writes one i32 constant.
+     * @param {number} value - Constant value.
+     * @returns {void}
+     */
+    i32(value) { this.op(0x41, "i32 constant"); this.immediate(s32(value), "i32 immediate"); }
+    /**
+     * Writes one i64 constant.
+     * @param {bigint} value - Constant value.
+     * @returns {void}
+     */
+    i64(value) { this.op(0x42, "i64 constant"); this.immediate(s64(value), "i64 immediate"); }
+    /**
+     * Loads one unsigned byte.
+     * @returns {void}
+     */
+    load8() { this.op(0x2d, "load unsigned byte"); this.immediate([0x00, 0x00], "byte-load memory arguments"); }
+    /**
+     * Stores one byte.
+     * @returns {void}
+     */
+    store8() { this.op(0x3a, "store byte"); this.immediate([0x00, 0x00], "byte-store memory arguments"); }
+    /**
+     * Traps when the stack's condition is nonzero.
+     * @param {string} reason - Trap provenance reason.
+     * @returns {void}
+     */
+    trapIf(reason) {
+        this.op(0x04, `${reason} branch`);
+        this.immediate([0x40], "empty block type");
+        this.op(0x00, `${reason} trap`);
+        this.op(0x0b, `${reason} branch end`);
+    }
+    /**
+     * Copies one string operand byte by byte.
+     * @param {number} cursor - Loop cursor local.
+     * @param {number} sourcePointer - Source pointer local.
+     * @param {number} sourceLength - Source length local.
+     * @param {number} destination - Allocation start local.
+     * @param {number | undefined} destinationOffset - Optional left-length local.
+     * @returns {void}
+     */
+    copyLoop(cursor, sourcePointer, sourceLength, destination, destinationOffset) {
+        this.op(0x02, "copy exit block");
+        this.immediate([0x40], "empty block type");
+        this.op(0x03, "copy loop");
+        this.immediate([0x40], "empty block type");
+        this.localGet(cursor);
+        this.localGet(sourceLength);
+        this.op(0x4f, "compare copy cursor with length");
+        this.op(0x0d, "exit completed copy");
+        this.immediate(u32(1), "copy block depth");
+        this.localGet(destination);
+        if (destinationOffset !== undefined) {
+            this.localGet(destinationOffset);
+            this.op(0x6a, "add destination offset");
+        }
+        this.localGet(cursor);
+        this.op(0x6a, "add destination cursor");
+        this.localGet(sourcePointer);
+        this.localGet(cursor);
+        this.op(0x6a, "add source cursor");
+        this.load8();
+        this.store8();
+        this.localGet(cursor);
+        this.i32(1);
+        this.op(0x6a, "increment copy cursor");
+        this.localSet(cursor);
+        this.op(0x0c, "continue copy loop");
+        this.immediate(u32(0), "copy loop depth");
+        this.op(0x0b, "end copy loop");
+        this.op(0x0b, "end copy block");
+    }
+    /**
+     * Ends one helper function.
+     * @returns {void}
+     */
+    end() { this.op(0x0b, "function end"); }
+}
+/**
+ * Collects deduplicated literal bytes and their combined semantic origins.
+ * @param {SemanticModule} module - Semantic module.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.
+ * @returns {{boundary: number, byValue: Map<string, {address: number, bytes: Uint8Array}>, entries: {address: number, bytes: Uint8Array, origin: import("../semantic/types.js").SemanticOrigin}[]}} Layout.
+ */
+function collectLiteralLayout(module, index) {
+    /** @type {Map<string, {bytes: Uint8Array, occurrences: ReturnType<typeof index.recordFor>[]}>} */
+    const collected = new Map();
+    for (const { node, path } of semanticEntries(module)) {
+        if (node.kind != "StringLiteral")
+            continue;
+        const existing = collected.get(node.value);
+        if (existing)
+            existing.occurrences.push(index.recordFor(node, path));
+        else
+            collected.set(node.value, { bytes: encoder.encode(node.value), occurrences: [index.recordFor(node, path)] });
+    }
+    let address = 1;
+    /** @type {Map<string, {address: number, bytes: Uint8Array}>} */
+    const byValue = new Map();
+    /** @type {{address: number, bytes: Uint8Array, origin: import("../semantic/types.js").SemanticOrigin}[]} */
+    const entries = [];
+    for (const [value, literal] of collected) {
+        const next = checkedSize(address + literal.bytes.byteLength, module, "immutable literal memory layout");
+        const exactOrigins = literal.occurrences.map((record) => originForRole(index, record, "literal"));
+        const origins = literal.occurrences.flatMap((record, offset) => relatedOrigins(record, exactOrigins[offset]));
+        const origin = literal.occurrences.length == 1 ? exactOrigins[0] : origins.length > 0
+            ? { kind: "derived", origins }
+            : { kind: "synthetic", reason: "Deduplicated immutable UTF-8 literal data without source ranges.", relatedOrigins: [] };
+        entries.push({ address, bytes: literal.bytes, origin: /** @type {import("../semantic/types.js").SemanticOrigin} */ (origin) });
+        byValue.set(value, { address, bytes: literal.bytes });
+        address = next;
+    }
+    return { boundary: address, byValue, entries };
+}
+/**
+ * Performs bounded path-sensitive allocation analysis from run.
+ * @param {SemanticModule} module - Validated module.
+ * @returns {number} Worst reachable allocation bytes.
+ */
+function analyzeScratchUse(module) {
+    const functions = new Map(module.functions.map((declaration) => [declaration.name, declaration]));
+    let steps = 0;
+    const states = block(module.entryPoint.body, [{ allocated: 0, env: new Map() }], 0);
+    return Math.max(0, ...states.map(({ allocated }) => allocated));
+    /**
+     * Analyzes one block from every incoming path state.
+     * @param {import("../semantic/types.js").Block} semanticBlock - Block to analyze.
+     * @param {AnalysisState[]} incoming - Incoming path states.
+     * @param {number} depth - Active semantic call depth.
+     * @returns {AnalysisState[]} Resulting path states.
+     */
+    function block(semanticBlock, incoming, depth) {
+        let states = incoming;
+        for (const statement of semanticBlock.statements) {
+            const next = [];
+            for (const state of states) {
+                if (state.returned) {
+                    next.push(state);
+                    continue;
+                }
+                if (statement.kind == "LocalDeclaration") {
+                    for (const result of expression(statement.initializer, state, depth)) {
+                        const env = new Map(result.state.env);
+                        env.set(statement.name, result.value);
+                        next.push({ ...result.state, env });
+                    }
+                }
+                else if (statement.kind == "AssignmentStatement") {
+                    for (const result of expression(statement.expression, state, depth)) {
+                        const env = new Map(result.state.env);
+                        env.set(statement.target.name, result.value);
+                        next.push({ ...result.state, env });
+                    }
+                }
+                else if (statement.kind == "PrintStatement") {
+                    for (const result of expression(statement.expression, state, depth))
+                        next.push(result.state);
+                }
+                else if (statement.kind == "ReturnStatement") {
+                    if (!statement.expression)
+                        throw new TypeError("Wasm bare return reached abstract execution.");
+                    for (const result of expression(statement.expression, state, depth))
+                        next.push({ ...result.state, returned: result.value });
+                }
+                else if (statement.kind == "ExpressionStatement") {
+                    throw new TypeError("Wasm Task 005 expression statement reached abstract execution.");
+                }
+                else if (statement.kind == "IfStatement") {
+                    for (const condition of expression(statement.condition, state, depth)) {
+                        if (condition.value.knownBoolean !== false) {
+                            next.push(...withoutBranchLocals(block(statement.consequent, [cloneState(condition.state)], depth), condition.state.env));
+                        }
+                        if (condition.value.knownBoolean !== true) {
+                            const alternate = statement.alternate
+                                ? block(statement.alternate, [cloneState(condition.state)], depth)
+                                : [cloneState(condition.state)];
+                            next.push(...withoutBranchLocals(alternate, condition.state.env));
+                        }
+                    }
+                }
+                else {
+                    throw new TypeError("Unsupported Wasm statement reached abstract execution.");
+                }
+            }
+            states = boundedStates(next, statement);
+        }
+        return states;
+    }
+    /**
+     * Evaluates abstract values and allocation demand for one expression.
+     * @param {Expression} value - Expression to analyze.
+     * @param {AnalysisState} state - Incoming path state.
+     * @param {number} depth - Active semantic call depth.
+     * @returns {{state: AnalysisState, value: AbstractValue}[]} Possible outcomes.
+     */
+    function expression(value, state, depth) {
+        steps += 1;
+        if (steps > maximumAnalysisSteps)
+            unsupportedCapability("wasm", "unprovable path-sensitive scratch allocation bound", value.location);
+        if (value.kind == "IdentifierExpression") {
+            const found = state.env.get(value.name);
+            if (!found)
+                throw new Error("Validated Wasm analysis omitted an identifier binding.");
+            return [{ state, value: found }];
+        }
+        if (value.kind == "IntegerLiteral")
+            return [{ state, value: { knownInteger: BigInt(value.value), type: "integer" } }];
+        if (value.kind == "BooleanLiteral")
+            return [{ state, value: { knownBoolean: value.value, type: "boolean" } }];
+        if (value.kind == "StringLiteral") {
+            return [{ state, value: { knownString: value.value, stringLength: encoder.encode(value.value).byteLength, type: "string" } }];
+        }
+        if (value.kind == "CallExpression") {
+            let argumentsList = [{ state, values: /** @type {AbstractValue[]} */ ([]) }];
+            for (const argument of value.arguments) {
+                const next = [];
+                for (const current of argumentsList) {
+                    for (const result of expression(argument, current.state, depth)) {
+                        next.push({ state: result.state, values: [...current.values, result.value] });
+                    }
+                }
+                argumentsList = next;
+            }
+            const declaration = functions.get(value.callee);
+            if (!declaration)
+                throw new Error("Validated Wasm analysis omitted a call declaration.");
+            if (depth >= maximumCallDepth)
+                unsupportedCapability("wasm", `semantic call depth above ${maximumCallDepth}`, value.location);
+            /** @type {{state: AnalysisState, value: AbstractValue}[]} */
+            const outcomes = [];
+            for (const argumentSet of argumentsList) {
+                const env = new Map(declaration.parameters.map((parameter, index) => [parameter.name, argumentSet.values[index]]));
+                const called = block(declaration.body, [{ allocated: 0, env }], depth + 1);
+                for (const returned of called) {
+                    if (!returned.returned)
+                        throw new Error("Validated Wasm function analysis omitted a return value.");
+                    outcomes.push({
+                        state: { ...argumentSet.state, allocated: addAllocation(argumentSet.state.allocated, returned.allocated, value) },
+                        value: returned.returned
+                    });
+                }
+            }
+            return outcomes;
+        }
+        if (value.kind == "UnaryExpression") {
+            return expression(value.operand, state, depth).map((operand) => {
+                if (value.operation == "BooleanNot") {
+                    return { state: operand.state, value: { type: "boolean", ...(operand.value.knownBoolean === undefined ? {} : { knownBoolean: !operand.value.knownBoolean }) } };
+                }
+                const knownInteger = operand.value.knownInteger === undefined ? undefined : checkedI64(-operand.value.knownInteger, value);
+                return { state: operand.state, value: { type: "integer", ...(knownInteger === undefined ? {} : { knownInteger }) } };
+            });
+        }
+        if (value.kind != "BinaryExpression") {
+            return unsupportedCapability("wasm", "collection expression reached scalar analysis", value.location);
+        }
+        if (value.operation == "BooleanAnd" || value.operation == "BooleanOr") {
+            /** @type {{state: AnalysisState, value: AbstractValue}[]} */
+            const outcomes = [];
+            for (const left of expression(value.left, state, depth)) {
+                const shortCircuits = value.operation == "BooleanAnd" ? left.value.knownBoolean === false : left.value.knownBoolean === true;
+                const mustEvaluate = value.operation == "BooleanAnd" ? left.value.knownBoolean === true : left.value.knownBoolean === false;
+                if (shortCircuits || !mustEvaluate)
+                    outcomes.push({ state: left.state, value: { knownBoolean: value.operation == "BooleanOr", type: "boolean" } });
+                if (!shortCircuits)
+                    outcomes.push(...expression(value.right, cloneState(left.state), depth));
+            }
+            return outcomes;
+        }
+        const outcomes = [];
+        for (const left of expression(value.left, state, depth)) {
+            for (const right of expression(value.right, left.state, depth)) {
+                outcomes.push(binary(value, left.value, right.value, right.state));
+            }
+        }
+        return outcomes;
+    }
+    /**
+     * Combines abstract operands for one binary operation.
+     * @param {import("../semantic/types.js").BinaryExpression} expressionNode - Binary expression.
+     * @param {AbstractValue} left - Abstract left operand.
+     * @param {AbstractValue} right - Abstract right operand.
+     * @param {AnalysisState} state - State after evaluating both operands.
+     * @returns {{state: AnalysisState, value: AbstractValue}} Combined outcome.
+     */
+    function binary(expressionNode, left, right, state) {
+        const operation = expressionNode.operation;
+        if (operation == "StringConcat") {
+            if (left.stringLength === undefined || right.stringLength === undefined) {
+                unsupportedCapability("wasm", "unprovable StringConcat byte length", expressionNode.location);
+            }
+            const length = addAllocation(left.stringLength, right.stringLength, expressionNode);
+            const allocated = addAllocation(state.allocated, length, expressionNode);
+            const knownString = left.knownString !== undefined && right.knownString !== undefined ? left.knownString + right.knownString : undefined;
+            return { state: { ...state, allocated }, value: { type: "string", stringLength: length, ...(knownString === undefined ? {} : { knownString }) } };
+        }
+        if (["IntegerAdd", "IntegerSubtract", "IntegerMultiply"].includes(operation)) {
+            let knownInteger;
+            if (left.knownInteger !== undefined && right.knownInteger !== undefined) {
+                knownInteger = operation == "IntegerAdd" ? left.knownInteger + right.knownInteger :
+                    operation == "IntegerSubtract" ? left.knownInteger - right.knownInteger : left.knownInteger * right.knownInteger;
+                knownInteger = checkedI64(knownInteger, expressionNode);
+            }
+            return { state, value: { type: "integer", ...(knownInteger === undefined ? {} : { knownInteger }) } };
+        }
+        if (operation.startsWith("Integer") && operation != "IntegerEqual" && operation != "IntegerNotEqual") {
+            return { state, value: { knownBoolean: compareKnown(operation, left.knownInteger, right.knownInteger), type: "boolean" } };
+        }
+        if (operation == "IntegerEqual" || operation == "IntegerNotEqual") {
+            return { state, value: { knownBoolean: equalKnown(left.knownInteger, right.knownInteger, operation.endsWith("NotEqual")), type: "boolean" } };
+        }
+        if (operation == "BooleanEqual" || operation == "BooleanNotEqual") {
+            return { state, value: { knownBoolean: equalKnown(left.knownBoolean, right.knownBoolean, operation.endsWith("NotEqual")), type: "boolean" } };
+        }
+        return { state, value: { knownBoolean: equalKnown(left.knownString, right.knownString, operation == "StringNotEqual"), type: "boolean" } };
+    }
+    /**
+     * Rejects path-state growth beyond the deterministic analysis bound.
+     * @param {AnalysisState[]} candidates - Candidate states.
+     * @param {{location: import("../semantic/types.js").SourceLocation}} node - Related semantic node.
+     * @returns {AnalysisState[]} Accepted states.
+     */
+    function boundedStates(candidates, node) {
+        if (candidates.length > maximumAnalysisSteps)
+            unsupportedCapability("wasm", "unprovable path-sensitive scratch allocation state count", node.location);
+        return candidates;
+    }
+}
+/**
+ * Compares two known integer operands when available.
+ * @param {string} operation - Semantic comparison operation.
+ * @param {bigint | undefined} left - Known left operand.
+ * @param {bigint | undefined} right - Known right operand.
+ * @returns {boolean | undefined} Known comparison result.
+ */
+function compareKnown(operation, left, right) {
+    if (left === undefined || right === undefined)
+        return undefined;
+    if (operation == "IntegerLessThan")
+        return left < right;
+    if (operation == "IntegerLessThanOrEqual")
+        return left <= right;
+    if (operation == "IntegerGreaterThan")
+        return left > right;
+    return left >= right;
+}
+/**
+ * Compares two known same-type operands when available.
+ * @template T
+ * @param {T | undefined} left - Known left operand.
+ * @param {T | undefined} right - Known right operand.
+ * @param {boolean} invert - Whether to invert equality.
+ * @returns {boolean | undefined} Known equality result.
+ */
+function equalKnown(left, right, invert) {
+    return left === undefined || right === undefined ? undefined : invert ? left !== right : left === right;
+}
+/**
+ * Checks one compile-time integer against signed i64 bounds.
+ * @param {bigint} value - Candidate integer.
+ * @param {{location: import("../semantic/types.js").SourceLocation}} node - Related semantic node.
+ * @returns {bigint} Checked integer.
+ */
+function checkedI64(value, node) {
+    if (value < -9223372036854775808n || value > 9223372036854775807n) {
+        unsupportedCapability("wasm", "compile-time-known signed i64 overflow", node.location);
+    }
+    return value;
+}
+/**
+ * Adds bounded allocation counts without approximation.
+ * @param {number} left - Existing allocation count.
+ * @param {number} right - Additional allocation count.
+ * @param {{location: import("../semantic/types.js").SourceLocation}} node - Related semantic node.
+ * @returns {number} Checked total.
+ */
+function addAllocation(left, right, node) {
+    const total = left + right;
+    if (!Number.isSafeInteger(total) || total < 0)
+        unsupportedCapability("wasm", "scratch allocation arithmetic overflow", node.location);
+    if (total > scratchCapacity)
+        unsupportedCapability("wasm", `scratch allocation above ${scratchCapacity} bytes`, node.location);
+    return total;
+}
+/**
+ * Clones one path state and its lexical environment.
+ * @param {AnalysisState} state - State to clone.
+ * @returns {AnalysisState} Detached state.
+ */
+function cloneState(state) { return { ...state, env: new Map(state.env) }; }
+/**
+ * Removes bindings declared only inside a branch.
+ * @param {AnalysisState[]} states - Branch result states.
+ * @param {Map<string, AbstractValue>} parent - Parent lexical environment.
+ * @returns {AnalysisState[]} States restricted to parent bindings.
+ */
+function withoutBranchLocals(states, parent) {
+    return states.map((state) => {
+        const env = new Map([...state.env].filter(([name]) => parent.has(name)));
+        return { ...state, env };
+    });
+}
+/**
+ * Resolves one expression's semantic scalar type.
+ * @param {Expression} expression - Expression to inspect.
+ * @param {Map<string, LocalBinding>} bindings - Lexical local bindings.
+ * @param {Map<string, import("../semantic/types.js").FunctionDeclaration>} functions - Semantic declarations by name.
+ * @returns {Scalar} Expression type.
+ */
+function expressionType(expression, bindings, functions) {
+    if (expression.kind == "IntegerLiteral")
+        return "integer";
+    if (expression.kind == "BooleanLiteral")
+        return "boolean";
+    if (expression.kind == "StringLiteral")
+        return "string";
+    if (expression.kind == "UnaryExpression" || expression.kind == "BinaryExpression")
+        return expression.type;
+    if (expression.kind == "CallExpression") {
+        const declaration = functions.get(expression.callee);
+        if (!declaration)
+            throw new Error("Validated Wasm expression omitted its call declaration.");
+        return wasmReturnType(declaration);
+    }
+    if (expression.kind != "IdentifierExpression") {
+        return unsupportedCapability("wasm", "collection expression reached scalar type inference", expression.location);
+    }
+    const binding = bindings.get(expression.name);
+    if (!binding)
+        throw new Error("Validated Wasm expression omitted its local binding.");
+    return binding.type;
+}
+/**
+ * Narrows a declaration return after the Wasm Task 005 capability preflight.
+ * @param {import("../semantic/types.js").FunctionDeclaration} declaration - Validated declaration.
+ * @returns {Scalar} Supported Wasm scalar return.
+ */
+function wasmReturnType(declaration) {
+    if (declaration.returnType.kind != "TypeReference" || declaration.returnType.name == "void") {
+        return unsupportedCapability("wasm", "Task 005 void function return", declaration.location);
+    }
+    return declaration.returnType.name;
+}
+/**
+ * Narrows one scalar after Wasm collection capability rejection.
+ * @param {import("../semantic/types.js").SemanticValueType} type - Semantic value type.
+ * @param {import("../semantic/types.js").SourceLocation} location - Owning location.
+ * @returns {Scalar} Scalar type.
+ */
+function wasmScalarType(type, location) {
+    if (type.kind != "TypeReference")
+        return unsupportedCapability("wasm", "Task 006 immutable collection type", location);
+    return type.name;
+}
+/**
+ * Flattens one semantic scalar into Wasm value types.
+ * @param {Scalar} type - Semantic scalar type.
+ * @returns {("i32" | "i64")[]} Wasm value types.
+ */
+function wasmTypes(type) { return type == "integer" ? ["i64"] : type == "boolean" ? ["i32"] : ["i32", "i32"]; }
+/**
+ * Aligns an unsigned size upward.
+ * @param {number} value - Unaligned value.
+ * @param {number} alignment - Required alignment.
+ * @returns {number} Aligned value.
+ */
+function align(value, alignment) { return Math.ceil(value / alignment) * alignment; }
+/**
+ * Checks a computed module size against the portable u32 domain.
+ * @param {number} value - Candidate size.
+ * @param {{location: import("../semantic/types.js").SourceLocation}} node - Related semantic node.
+ * @param {string} capability - Failure capability description.
+ * @returns {number} Checked size.
+ */
+function checkedSize(value, node, capability) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0xffffffff)
+        unsupportedCapability("wasm", capability, node.location);
+    return value;
+}
+/**
+ * Encodes an unsigned u32 LEB128 value.
+ * @param {number} value - Unsigned value.
+ * @returns {number[]} Encoded bytes.
+ */
+function u32(value) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0xffffffff)
+        throw new RangeError("Unsigned WebAssembly integer is outside u32.");
+    const bytes = [];
+    let remaining = value;
+    do {
+        let byte = remaining % 128;
+        remaining = Math.floor(remaining / 128);
+        if (remaining != 0)
+            byte |= 0x80;
+        bytes.push(byte);
+    } while (remaining != 0);
+    return bytes;
+}
+/**
+ * Encodes a signed i32 LEB128 value.
+ * @param {number} value - Signed value.
+ * @returns {number[]} Encoded bytes.
+ */
+function s32(value) { return s64(BigInt(value)); }
+/**
+ * Encodes a signed i64 LEB128 value.
+ * @param {bigint} value - Signed value.
+ * @returns {number[]} Encoded bytes.
+ */
+function s64(value) {
+    const bytes = [];
+    let remaining = value;
+    let done = false;
+    while (!done) {
+        let byte = Number(remaining & 0x7fn);
+        remaining >>= 7n;
+        const signSet = (byte & 0x40) != 0;
+        done = remaining == 0n && !signSet || remaining == -1n && signSet;
+        if (!done)
+            byte |= 0x80;
+        bytes.push(byte);
+    }
+    return bytes;
+}
+/**
+ * Encodes a length-prefixed UTF-8 Wasm name.
+ * @param {string} value - Name value.
+ * @returns {number[]} Encoded bytes.
+ */
+function nameBytes(value) {
+    const bytes = encoder.encode(value);
+    return [...u32(bytes.byteLength), ...bytes];
+}
+/**
+ * Extracts contextual related origins from one semantic record.
+ * @param {SemanticNodeProvenance} record - Semantic provenance record.
+ * @param {import("../semantic/types.js").SemanticOrigin} [origin] - Optional exact semantic origin.
+ * @returns {import("../semantic/types.js").RelatedOrigin[]} Related origins.
+ */
+function relatedOrigins(record, origin = record.origin) {
+    if (origin.kind == "source") {
+        return [{ location: origin.location, nodeId: record.id, role: "related semantic occurrence", sourceId: origin.sourceId,
+                ...(record.symbolId ? { symbolId: record.symbolId } : {}) }];
+    }
+    const origins = origin.kind == "derived" ? origin.origins : origin.relatedOrigins;
+    return origins.map((origin) => ({ ...origin, nodeId: origin.nodeId ?? record.id, role: origin.role ?? "related semantic occurrence",
+        ...(record.symbolId && !origin.symbolId ? { symbolId: record.symbolId } : {}) }));
+}
+/**
+ * Resolves a parser-owned token role to its canonical source identity.
+ * @param {ReturnType<typeof createGenerationIndex>} index - Canonical provenance index.
+ * @param {SemanticNodeProvenance} record - Semantic occurrence record.
+ * @param {string} role - Parser-owned token role.
+ * @returns {import("../semantic/types.js").SemanticOrigin} Exact role origin, or the occurrence origin when unavailable.
+ */
+function originForRole(index, record, role) {
+    const location = record.ranges[role];
+    if (!location)
+        return record.origin;
+    /** @type {string | undefined} */
+    let fallbackSourceId;
+    if (record.origin.kind == "source" && record.origin.location.filename == location.filename)
+        fallbackSourceId = record.origin.sourceId;
+    else if (record.origin.kind == "derived") {
+        fallbackSourceId = record.origin.origins.find((origin) => origin.location.filename == location.filename)?.sourceId;
+    }
+    else if (record.origin.kind == "synthetic") {
+        fallbackSourceId = record.origin.relatedOrigins.find((origin) => origin.location.filename == location.filename)?.sourceId;
+    }
+    const source = index.provenance.sources.find((candidate) => candidate.id == fallbackSourceId) ??
+        index.provenance.sources.find((candidate) => candidate.filename == location.filename);
+    return source ? { kind: "source", location, sourceId: source.id } : record.origin;
+}
+/**
+ * Projects byte provenance to the Wasm Source Map v3 convention.
+ * @param {import("../semantic/types.js").SemantifoldByteMapping} mapping - Authoritative byte mapping.
+ * @param {import("../semantic/types.js").SemanticProvenance} provenance - Source registry.
+ * @returns {import("@jridgewell/gen-mapping").EncodedSourceMap} Source Map v3 projection.
+ */
+function createWasmSourceMap(mapping, provenance) {
+    const generated = new GenMapping({ file: mapping.generated.path });
+    const sourcesById = new Map(provenance.sources.map((source) => [source.id, source]));
+    const symbolsById = new Map(provenance.symbols.map((symbol) => [symbol.id, symbol]));
+    for (const source of provenance.sources)
+        setSourceContent(generated, source.filename, source.content);
+    for (const range of mapping.ranges) {
+        const location = primaryLocation(range.origin);
+        if (!location || range.origin.kind == "synthetic") {
+            maybeAddSegment(generated, 0, range.generated.start);
+            continue;
+        }
+        const sourceId = range.origin.kind == "source" ? range.origin.sourceId : range.origin.origins[0]?.sourceId;
+        const source = sourceId ? sourcesById.get(sourceId) : undefined;
+        if (!source)
+            throw new Error("Validated Wasm byte origin omitted its registered source.");
+        if (range.symbolId === undefined) {
+            addSegment(generated, 0, range.generated.start, source.filename, location.start.line - 1, location.start.column - 1, null, source.content);
+        }
+        else {
+            const symbol = symbolsById.get(range.symbolId);
+            if (!symbol)
+                throw new Error("Validated Wasm byte range omitted its semantic symbol.");
+            addSegment(generated, 0, range.generated.start, source.filename, location.start.line - 1, location.start.column - 1, symbol.name, source.content);
+        }
+    }
+    return toEncodedMap(generated);
+}
+/**
+ * Creates one mapped generated text artifact.
+ * @param {string} content - Complete artifact content.
+ * @param {string} path - Artifact path.
+ * @param {import("../semantic/types.js").GeneratedTextLanguage} language - Generated text syntax.
+ * @param {import("../semantic/types.js").GeneratedArtifactRole} role - Artifact role.
+ * @param {SemanticModule} module - Source semantic module.
+ * @param {{filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[] | undefined} sources - Source overrides.
+ * @param {string} reason - Synthetic mapping reason.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Generated artifact.
+ */
+function textArtifact(content, path, language, role, module, sources, reason) {
+    const writer = new SourceWriter({ filename: path, language, module, sources });
+    writer.synthetic(content, reason, [module], [""]);
+    const mapping = finalizeMapping(writer.finish());
+    return {
+        content,
+        contentKind: "text",
+        mediaType: path.endsWith(".html") ? "text/html" : "text/javascript",
+        ownership: "generated",
+        path,
+        provenance: { kind: "text", mapping, sourceMap: toSourceMapV3(mapping) },
+        role
+    };
+}
+const semantifoldLoader = `const expectedImports = [
+  ["semantifold", "print_i64", ["i64"], []],
+  ["semantifold", "print_bool", ["i32"], []],
+  ["semantifold", "print_string", ["i32", "i32"], []]
+]
+
+export class SemantifoldBrowserError extends Error {
+  constructor(stage, message, cause) {
+    super(message, cause instanceof Error ? {cause} : undefined)
+    this.name = "SemantifoldBrowserError"
+    this.stage = stage
+  }
+}
+
+export async function loadSemantifold(url, {fetch: fetchImplementation = globalThis.fetch, sink, timeoutMs = 10000} = {}) {
+  if (typeof fetchImplementation != "function") throw new TypeError("A fetch implementation is required.")
+  if (typeof sink != "function") throw new TypeError("A text sink function is required.")
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
+    throw new TypeError("timeoutMs must be an integer from 1 through 2147483647.")
+  }
+  const controller = new AbortController()
+  let timedOut = false
+  let timeout
+  const deadline = new Promise((resolve, reject) => {
+    const timeoutCause = new Error("Semantifold browser load timed out.")
+
+    timeout = setTimeout(() => {
+      timedOut = true
+      controller.abort(timeoutCause)
+      reject(new SemantifoldBrowserError("timeout", "Wasm loading timed out.", timeoutCause))
+    }, timeoutMs)
+  })
+  const beforeDeadline = (operation) => Promise.race([operation, deadline])
+  const timeoutFailure = (cause) => new SemantifoldBrowserError("timeout", "Wasm loading timed out.",
+    cause instanceof Error ? cause : controller.signal.reason)
+  const bodyFailure = (cause) => {
+    if (cause instanceof SemantifoldBrowserError) return cause
+    if (timedOut) return timeoutFailure(cause)
+    return new SemantifoldBrowserError("fetch/MIME", "Wasm response body could not be read.", cause)
+  }
+  const instantiationFailure = (cause) => {
+    if (cause instanceof SemantifoldBrowserError) return cause
+    if (timedOut) return timeoutFailure(cause)
+    const stage = cause instanceof WebAssembly.CompileError ? "compile" : "instantiate/import"
+
+    return new SemantifoldBrowserError(stage, \`Wasm \${stage} failed.\`, cause)
+  }
+  const readBody = async (body) => {
+    try {
+      return new Uint8Array(await beforeDeadline(body.arrayBuffer()))
+    } catch (cause) {
+      throw bodyFailure(cause)
+    }
+  }
+  const instantiate = async (operation) => {
+    try {
+      return await beforeDeadline(operation())
+    } catch (cause) {
+      throw instantiationFailure(cause)
+    }
+  }
+  let response
+
+  try {
+    response = await beforeDeadline(Promise.resolve().then(() =>
+      fetchImplementation(url, {credentials: "same-origin", redirect: "error", signal: controller.signal})))
+  } catch (cause) {
+    clearTimeout(timeout)
+    if (cause instanceof SemantifoldBrowserError) throw cause
+    const stage = timedOut ? "timeout" : "fetch/MIME"
+    throw new SemantifoldBrowserError(stage, stage == "timeout" ? "Wasm loading timed out." : "Wasm fetch failed.", cause)
+  }
+  if (!response.ok) {
+    clearTimeout(timeout)
+    throw new SemantifoldBrowserError("fetch/MIME", \`Wasm fetch returned HTTP \${response.status}.\`)
+  }
+  const mediaType = response.headers.get("content-type")?.split(";", 1)[0].trim().toLowerCase()
+
+  if (mediaType != "application/wasm") {
+    clearTimeout(timeout)
+    throw new SemantifoldBrowserError("fetch/MIME", "Wasm response requires application/wasm.")
+  }
+
+  let instance
+  let module
+  const decoder = new TextDecoder("utf-8", {fatal: true, ignoreBOM: true})
+  let memory
+  let abiApproved = false
+  const requireApprovedAbi = () => {
+    if (!abiApproved) throw new SemantifoldBrowserError("instantiate/import", "Wasm host imports are locked until ABI inspection succeeds.")
+  }
+  const append = (text) => sink(\`\${text}\\n\`)
+  const imports = {semantifold: {
+    print_i64(value) {
+      requireApprovedAbi()
+      if (typeof value != "bigint") throw new TypeError("print_i64 requires bigint.")
+      append(value.toString(10))
+    },
+    print_bool(value) {
+      requireApprovedAbi()
+      if (value !== 0 && value !== 1) throw new TypeError("print_bool requires canonical 0 or 1.")
+      append(value === 1 ? "true" : "false")
+    },
+    print_string(pointer, length) {
+      requireApprovedAbi()
+      if (!memory || !Number.isInteger(pointer) || pointer < 0 || !Number.isInteger(length) || length < 0) {
+        const cause = new TypeError("print_string requires a non-negative integer pointer and length.")
+
+        throw new SemantifoldBrowserError("memory bounds/UTF-8", cause.message, cause)
+      }
+      const end = pointer + length
+
+      if (!Number.isSafeInteger(end) || end < pointer || end > memory.buffer.byteLength) {
+        const cause = new RangeError("print_string range is outside exported memory.")
+
+        throw new SemantifoldBrowserError("memory bounds/UTF-8", cause.message, cause)
+      }
+      let text
+
+      try {
+        text = decoder.decode(new Uint8Array(memory.buffer, pointer, length))
+      } catch (cause) {
+        throw new SemantifoldBrowserError("memory bounds/UTF-8", "print_string bytes are not valid UTF-8.", cause)
+      }
+      append(text)
+    }
+  }}
+
+  let result
+
+  try {
+    if (typeof WebAssembly.instantiateStreaming == "function") {
+      let body
+
+      try {
+        body = response.clone()
+      } catch (cause) {
+        throw bodyFailure(cause)
+      }
+      const pending = instantiate(() => WebAssembly.instantiateStreaming(response, imports))
+        .then((value) => ({value}), (error) => ({error}))
+      const bytes = await readBody(body)
+
+      inspectAbi(bytes)
+      abiApproved = true
+      const settled = await pending
+
+      if ("error" in settled) throw settled.error
+      result = settled.value
+    } else {
+      const bytes = await readBody(response)
+
+      inspectAbi(bytes)
+      abiApproved = true
+      result = await instantiate(() => WebAssembly.instantiate(bytes, imports))
+    }
+  } catch (error) {
+    clearTimeout(timeout)
+    throw error
+  }
+  clearTimeout(timeout)
+  instance = result.instance
+  module = result.module
+  validateModuleShape(module, instance)
+  memory = instance.exports.memory
+  let active = false
+  let poisoned = false
+
+  return Object.freeze({
+    memory,
+    run() {
+      if (poisoned) throw new SemantifoldBrowserError("invocation/trap", "Wasm instance is poisoned after a trap.")
+      if (active) throw new SemantifoldBrowserError("invocation/trap", "Reentrant run invocation is forbidden.")
+      active = true
+      try {
+        instance.exports.run()
+      } catch (cause) {
+        poisoned = true
+        if (cause instanceof SemantifoldBrowserError) throw cause
+        throw new SemantifoldBrowserError("invocation/trap", "Wasm run trapped.", cause)
+      } finally {
+        active = false
+      }
+    }
+  })
+}
+
+function validateModuleShape(module, instance) {
+  const imports = WebAssembly.Module.imports(module)
+  const exports = WebAssembly.Module.exports(module)
+
+  if (JSON.stringify(imports.map(({kind, module, name}) => [module, name, kind])) !=
+    JSON.stringify(expectedImports.map(([module, name]) => [module, name, "function"]))) {
+    throw new SemantifoldBrowserError("instantiate/import", "Wasm imports do not match semantifold.browser.v1.")
+  }
+  if (JSON.stringify(exports.map(({kind, name}) => [name, kind])) != JSON.stringify([["memory", "memory"], ["run", "function"]]) ||
+    !(instance.exports.memory instanceof WebAssembly.Memory) || typeof instance.exports.run != "function" || instance.exports.run.length != 0) {
+    throw new SemantifoldBrowserError("instantiate/import", "Wasm exports do not match semantifold.browser.v1.")
+  }
+}
+
+function inspectAbi(bytes) {
+  try {
+    let offset = 8
+    const types = []
+    const importedTypes = []
+    const definedTypes = []
+    const exports = []
+    const memories = []
+
+    if (bytes.length < 8 || bytes[0] != 0 || bytes[1] != 97 || bytes[2] != 115 || bytes[3] != 109 || bytes[4] != 1 ||
+      bytes[5] != 0 || bytes[6] != 0 || bytes[7] != 0) throw new WebAssembly.CompileError("Invalid Wasm header.")
+    while (offset < bytes.length) {
+      const id = bytes[offset++]
+      const sizeValue = readU32(bytes, offset)
+      offset = sizeValue.next
+      const end = offset + sizeValue.value
+
+      if (end > bytes.length) throw new WebAssembly.CompileError("Truncated Wasm section.")
+      if (id == 1) {
+        const count = readU32(bytes, offset); offset = count.next
+        for (let index = 0; index < count.value; index += 1) {
+          if (bytes[offset++] != 0x60) throw new WebAssembly.CompileError("Invalid function type.")
+          const parameters = readTypes(bytes, offset); offset = parameters.next
+          const results = readTypes(bytes, offset); offset = results.next
+          types.push([parameters.values, results.values])
+        }
+      } else if (id == 2) {
+        const count = readU32(bytes, offset); offset = count.next
+        for (let index = 0; index < count.value; index += 1) {
+          const moduleName = readName(bytes, offset); offset = moduleName.next
+          const fieldName = readName(bytes, offset); offset = fieldName.next
+          if (bytes[offset++] != 0) throw new SemantifoldBrowserError("instantiate/import", "Only function imports are allowed.")
+          const type = readU32(bytes, offset); offset = type.next
+          importedTypes.push([moduleName.value, fieldName.value, type.value])
+        }
+      } else if (id == 3) {
+        const count = readU32(bytes, offset); offset = count.next
+        for (let index = 0; index < count.value; index += 1) {
+          const type = readU32(bytes, offset); offset = type.next; definedTypes.push(type.value)
+        }
+      } else if (id == 5) {
+        const count = readU32(bytes, offset); offset = count.next
+        for (let index = 0; index < count.value; index += 1) {
+          const flags = bytes[offset++]
+          const minimum = readU32(bytes, offset); offset = minimum.next
+          let maximum
+          if ((flags & 1) != 0) { maximum = readU32(bytes, offset); offset = maximum.next }
+          memories.push([flags, minimum.value, maximum?.value])
+        }
+      } else if (id == 7) {
+        const count = readU32(bytes, offset); offset = count.next
+        for (let index = 0; index < count.value; index += 1) {
+          const name = readName(bytes, offset); offset = name.next
+          const kind = bytes[offset++]
+          const target = readU32(bytes, offset); offset = target.next
+          exports.push([name.value, kind, target.value])
+        }
+      } else if (id == 8) throw new SemantifoldBrowserError("instantiate/import", "A Wasm start section is forbidden.")
+      offset = end
+    }
+    if (importedTypes.length != expectedImports.length) throw new SemantifoldBrowserError("instantiate/import", "Unexpected Wasm import count.")
+    for (let index = 0; index < expectedImports.length; index += 1) {
+      const expected = expectedImports[index]
+      const actual = importedTypes[index]
+      const type = types[actual?.[2]]
+
+      if (!actual || actual[0] != expected[0] || actual[1] != expected[1] || !type ||
+        JSON.stringify(type) != JSON.stringify([expected[2], expected[3]])) {
+        throw new SemantifoldBrowserError("instantiate/import", "Wasm import signature does not match semantifold.browser.v1.")
+      }
+    }
+    if (memories.length != 1 || memories[0][0] != 1 || memories[0][1] != memories[0][2]) {
+      throw new SemantifoldBrowserError("instantiate/import", "Wasm memory must have equal fixed initial and maximum limits.")
+    }
+    if (exports.length != 2 || exports[0][0] != "memory" || exports[0][1] != 2 || exports[0][2] != 0 ||
+      exports[1][0] != "run" || exports[1][1] != 0) {
+      throw new SemantifoldBrowserError("instantiate/import", "Wasm exports do not match semantifold.browser.v1.")
+    }
+    const runType = types[definedTypes[exports[1][2] - importedTypes.length]]
+
+    if (!runType || runType[0].length != 0 || runType[1].length != 0) {
+      throw new SemantifoldBrowserError("instantiate/import", "Wasm run signature does not match semantifold.browser.v1.")
+    }
+  } catch (cause) {
+    if (cause instanceof SemantifoldBrowserError) throw cause
+    throw new SemantifoldBrowserError("compile", "Wasm binary inspection failed.", cause)
+  }
+}
+
+function readTypes(bytes, offset) {
+  const count = readU32(bytes, offset); offset = count.next; const values = []
+  for (let index = 0; index < count.value; index += 1) {
+    const type = bytes[offset++]
+    if (type == 0x7f) values.push("i32")
+    else if (type == 0x7e) values.push("i64")
+    else if (type == 0x7d) values.push("f32")
+    else if (type == 0x7c) values.push("f64")
+    else if (type == 0x7b) values.push("v128")
+    else if (type == 0x70) values.push("funcref")
+    else if (type == 0x6f) values.push("externref")
+    else throw new WebAssembly.CompileError("Unsupported ABI value type.")
+  }
+  return {next: offset, values}
+}
+
+function readName(bytes, offset) {
+  const length = readU32(bytes, offset); const end = length.next + length.value
+  if (end > bytes.length) throw new WebAssembly.CompileError("Truncated Wasm name.")
+  return {next: end, value: new TextDecoder("utf-8", {fatal: true}).decode(bytes.subarray(length.next, end))}
+}
+
+function readU32(bytes, offset) {
+  let value = 0
+  let shift = 0
+  for (let index = 0; index < 5; index += 1) {
+    if (offset >= bytes.length) throw new WebAssembly.CompileError("Truncated unsigned LEB128.")
+    const byte = bytes[offset++]
+    value += (byte & 0x7f) * 2 ** shift
+    if ((byte & 0x80) == 0) return {next: offset, value}
+    shift += 7
+  }
+  throw new WebAssembly.CompileError("Oversized unsigned LEB128.")
+}
+
+async function runBrowserHarness() {
+  const output = document.querySelector("#output")
+
+  try {
+    const program = await loadSemantifold("./program.wasm", {sink: (line) => { output.textContent += line }})
+    program.run()
+    document.documentElement.dataset.semantifoldOutput = [...new TextEncoder().encode(output.textContent)]
+      .map((byte) => byte.toString(16).padStart(2, "0")).join("")
+    document.documentElement.dataset.semantifold = "pass"
+    console.log("SEMANTIFOLD_BROWSER_OK")
+  } catch (error) {
+    document.documentElement.dataset.semantifold = "fail"
+    output.textContent += \`ERROR[\${error.stage ?? "unknown"}]: \${error.message}\\n\`
+    console.error("SEMANTIFOLD_BROWSER_FAILED", error)
+  }
+}
+
+if (typeof document != "undefined" && document.documentElement.dataset.semantifold == "pending") void runBrowserHarness()
+`;
+const browserHarness = `<!doctype html>
+<html lang="en" data-semantifold="pending">
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'self' 'wasm-unsafe-eval'; connect-src 'self'; base-uri 'none'; form-action 'none'">
+<title>Semantifold Browser Wasm</title>
+<pre id="output"></pre>
+<script type="module" src="./semantifold-loader.mjs"></script>
+</html>
+`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wasm.js","sourceRoot":"","sources":["../../../src/backends/wasm.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {addSegment, GenMapping, maybeAddSegment, setSourceContent, toEncodedMap} from \"@jridgewell/gen-mapping\"\nimport {createByteMapping} from \"../binary-mapping.js\"\nimport {unsupportedCapability} from \"../diagnostic.js\"\nimport {finalizeMapping, toSourceMapV3} from \"../mapping.js\"\nimport {createGenerationIndex, primaryLocation, semanticEntries} from \"../semantic/provenance.js\"\nimport {validateNativeGraph} from \"./native-validation.js\"\nimport {validateBackendModule} from \"./shared.js\"\nimport {SourceWriter} from \"./writer.js\"\n\n/** @typedef {import(\"../semantic/types.js\").SemanticModule} SemanticModule */\n/** @typedef {import(\"../semantic/types.js\").SemanticNode} SemanticNode */\n/** @typedef {import(\"../semantic/types.js\").Expression} Expression */\n/** @typedef {import(\"../semantic/types.js\").SemanticTypeName} Scalar */\n/** @typedef {import(\"../semantic/types.js\").GeneratedByteRange} GeneratedByteRange */\n/** @typedef {import(\"../semantic/types.js\").SemanticNodeProvenance} SemanticNodeProvenance */\n/** @typedef {{type: Scalar, knownBoolean?: boolean, knownInteger?: bigint, knownString?: string, stringLength?: number}} AbstractValue */\n/** @typedef {{allocated: number, env: Map<string, AbstractValue>, returned?: AbstractValue}} AnalysisState */\n/** @typedef {{type: Scalar, indexes: number[]}} LocalBinding */\n\nconst encoder = new TextEncoder()\nconst scratchCapacity = 1_048_576\nconst maximumCallDepth = 64\nconst wasmPageSize = 65_536\nconst maximumAnalysisSteps = 100_000\nconst valueTypes = Object.freeze({i32: 0x7f, i64: 0x7e})\nconst helperNames = Object.freeze([\"$concat\", \"$string_equal\", \"$checked_add\", \"$checked_subtract\", \"$checked_multiply\", \"$checked_negate\"])\nconst helperCount = helperNames.length\nconst importCount = 3\nconst concatFunctionIndex = importCount\nconst stringEqualFunctionIndex = concatFunctionIndex + 1\nconst checkedAddFunctionIndex = stringEqualFunctionIndex + 1\nconst checkedSubtractFunctionIndex = checkedAddFunctionIndex + 1\nconst checkedMultiplyFunctionIndex = checkedSubtractFunctionIndex + 1\nconst checkedNegateFunctionIndex = checkedMultiplyFunctionIndex + 1\nconst cursorGlobalIndex = 0\nconst depthGlobalIndex = 1\nconst activeGlobalIndex = 2\n\n/**\n * Generates the complete deterministic browser Wasm artifact set.\n * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]}} input - Backend request.\n * @returns {{artifacts: import(\"../semantic/types.js\").GeneratedSetArtifact[], metadata: Readonly<Record<string, unknown>>, target: string}} Candidate artifact set.\n */\nexport function generateBrowserWasm({filename, mapDirective, module, sourceMapFilename, sources}) {\n  validateNativeGraph(module, \"wasm\")\n  validateBackendModule(module, \"wasm\")\n  if (filename !== undefined && filename != \"program.wasm\") {\n    unsupportedCapability(\"wasm\", \"artifact filename other than program.wasm\", module.location)\n  }\n  if (mapDirective !== undefined) unsupportedCapability(\"wasm\", \"source-map directive option\", module.location)\n  if (sourceMapFilename !== undefined) unsupportedCapability(\"wasm\", \"alternate source-map filename\", module.location)\n  analyzeScratchUse(module)\n\n  const index = createGenerationIndex(module, sources)\n  const literalLayout = collectLiteralLayout(module, index)\n  const scratchBase = align(literalLayout.boundary, 16)\n  const memoryBytes = checkedSize(scratchBase + scratchCapacity, module, \"linear memory size\")\n  const memoryPages = Math.ceil(memoryBytes / wasmPageSize)\n  const encoded = encodeModule(module, index, literalLayout, scratchBase, memoryPages)\n\n  validateEncodedModule(encoded.bytes, module)\n  const byteMapping = createByteMapping({byteLength: encoded.bytes.byteLength, path: \"program.wasm\", ranges: encoded.ranges})\n  const wasmMap = createWasmSourceMap(byteMapping, index.provenance)\n  const loader = textArtifact(semantifoldLoader, \"semantifold-loader.mjs\", \"javascript\", \"loader\", module, sources,\n    \"Versioned browser Wasm ABI loader and exact scalar bridge.\")\n  const html = textArtifact(browserHarness, \"index.html\", \"html\", \"entry\", module, sources,\n    \"Deterministic local browser acceptance harness.\")\n  const metadata = /** @type {const} */ ({\n    abi: \"semantifold.browser.v1\",\n    exports: [\"memory\", \"run\"],\n    imports: [\n      {module: \"semantifold\", name: \"print_i64\", parameters: [\"i64\"], results: []},\n      {module: \"semantifold\", name: \"print_bool\", parameters: [\"i32\"], results: []},\n      {module: \"semantifold\", name: \"print_string\", parameters: [\"i32\", \"i32\"], results: []}\n    ],\n    maximumCallDepth,\n    memory: {\n      initialPages: memoryPages,\n      literalBoundary: literalLayout.boundary,\n      maximumPages: memoryPages,\n      scratchBase,\n      scratchCapacity\n    },\n    schema: \"SemantifoldBrowserWasmABI\",\n    version: 1\n  })\n\n  return {\n    artifacts: [{\n      content: encoded.bytes,\n      contentKind: \"binary\",\n      mediaType: \"application/wasm\",\n      ownership: \"generated\",\n      path: \"program.wasm\",\n      provenance: {kind: \"bytes\", mapping: byteMapping},\n      role: \"resource\"\n    }, {\n      content: `${JSON.stringify(wasmMap)}\\n`,\n      contentKind: \"text\",\n      mediaType: \"application/json\",\n      ownership: \"generated\",\n      path: \"program.wasm.map\",\n      provenance: {\n        kind: \"synthetic\",\n        reason: \"Source Map v3 projection of program.wasm byte provenance.\",\n        relatedOrigins: relatedOrigins(index.recordFor(module, \"\"))\n      },\n      role: \"mapping\"\n    }, loader, html],\n    metadata,\n    target: \"wasm\"\n  }\n}\n\n/**\n * Independently checks the completed module before any bytes enter an artifact.\n * @param {Uint8Array} bytes - Completed module bytes.\n * @param {SemanticModule} module - Related semantic module.\n * @returns {void}\n */\nfunction validateEncodedModule(bytes, module) {\n  const moduleBytes = new Uint8Array(bytes.byteLength)\n\n  moduleBytes.set(bytes)\n  if (!WebAssembly.validate(moduleBytes)) unsupportedCapability(\"wasm\", \"invalid encoded section, index, stack, or control shape\", module.location)\n\n  /** @type {WebAssembly.Module} */\n  let compiled\n\n  try {\n    compiled = new WebAssembly.Module(moduleBytes)\n  } catch (_error) {\n    unsupportedCapability(\"wasm\", \"invalid completed WebAssembly module\", module.location)\n  }\n  const imports = WebAssembly.Module.imports(compiled).map(({kind, module: namespace, name}) => [namespace, name, kind])\n  const exports = WebAssembly.Module.exports(compiled).map(({kind, name}) => [name, kind])\n\n  if (JSON.stringify(imports) != JSON.stringify([\n    [\"semantifold\", \"print_i64\", \"function\"],\n    [\"semantifold\", \"print_bool\", \"function\"],\n    [\"semantifold\", \"print_string\", \"function\"]\n  ]) || JSON.stringify(exports) != JSON.stringify([[\"memory\", \"memory\"], [\"run\", \"function\"]])) {\n    unsupportedCapability(\"wasm\", \"invalid encoded ABI import or export set\", module.location)\n  }\n}\n\n/**\n * Encodes one validated semantic module directly to portable core WebAssembly.\n * @param {SemanticModule} module - Validated module.\n * @param {ReturnType<typeof createGenerationIndex>} index - Canonical provenance index.\n * @param {ReturnType<typeof collectLiteralLayout>} literals - Static literal layout.\n * @param {number} scratchBase - Aligned scratch arena base.\n * @param {number} memoryPages - Fixed memory page count.\n * @returns {{bytes: Uint8Array, ranges: GeneratedByteRange[]}} Encoded module and rich byte ranges.\n */\nfunction encodeModule(module, index, literals, scratchBase, memoryPages) {\n  const writer = new BinaryWriter(index)\n  const root = {node: module, path: \"\"}\n\n  writer.synthetic([0x00, 0x61, 0x73, 0x6d], \"WebAssembly binary magic\", root, \"module header\")\n  writer.synthetic([0x01, 0x00, 0x00, 0x00], \"Pinned WebAssembly core binary version 1\", root, \"module header\")\n\n  const types = new TypePool()\n  const importTypes = [\n    types.add([\"i64\"], []),\n    types.add([\"i32\"], []),\n    types.add([\"i32\", \"i32\"], [])\n  ]\n  const helperTypes = [\n    types.add([\"i32\", \"i32\", \"i32\", \"i32\"], [\"i32\", \"i32\"]),\n    types.add([\"i32\", \"i32\", \"i32\", \"i32\"], [\"i32\"]),\n    types.add([\"i64\", \"i64\"], [\"i64\"]),\n    types.add([\"i64\", \"i64\"], [\"i64\"]),\n    types.add([\"i64\", \"i64\"], [\"i64\"]),\n    types.add([\"i64\"], [\"i64\"])\n  ]\n  const semanticTypeIndexes = module.functions.map((declaration) => types.add(\n    declaration.parameters.flatMap(({type, location}) => wasmTypes(wasmScalarType(type, location))),\n    wasmTypes(wasmReturnType(declaration))\n  ))\n  const runType = types.add([], [])\n  const functionIndexes = new Map(module.functions.map((declaration, offset) => [declaration.name, importCount + helperCount + offset]))\n  const runFunctionIndex = importCount + helperCount + module.functions.length\n\n  appendSection(writer, 1, \"type\", encodeTypeSection(types, index, root), root)\n  appendSection(writer, 2, \"import\", encodeImportSection(importTypes, index, root), root)\n  appendSection(writer, 3, \"function\", encodeFunctionSection(helperTypes, semanticTypeIndexes, runType, module, index), root)\n  appendSection(writer, 5, \"memory\", encodeMemorySection(memoryPages, index, root), root)\n  appendSection(writer, 6, \"global\", encodeGlobalSection(scratchBase, index, root), root)\n  appendSection(writer, 7, \"export\", encodeExportSection(runFunctionIndex, index, root), root)\n\n  const code = new BinaryWriter(index)\n\n  code.synthetic(u32(helperCount + module.functions.length + 1), \"Defined function count\", root, \"function count\")\n  appendFunctionBody(code, helperConcat(index, module, scratchBase), [\"i32\", \"i32\", \"i32\", \"i32\"], root, \"$concat\")\n  appendFunctionBody(code, helperStringEqual(index, module), [\"i32\"], root, \"$string_equal\")\n  appendFunctionBody(code, helperCheckedAdd(index, module), [\"i64\"], root, \"$checked_add\")\n  appendFunctionBody(code, helperCheckedSubtract(index, module), [\"i64\"], root, \"$checked_subtract\")\n  appendFunctionBody(code, helperCheckedMultiply(index, module), [\"i64\"], root, \"$checked_multiply\")\n  appendFunctionBody(code, helperCheckedNegate(index, module), [], root, \"$checked_negate\")\n\n  for (let functionOffset = 0; functionOffset < module.functions.length; functionOffset += 1) {\n    const declaration = module.functions[functionOffset]\n    const path = `/functions/${functionOffset}`\n    const emitter = new FunctionEmitter({functionIndexes, index, literals: literals.byValue, module, scratchBase})\n\n    emitter.bindParameters(declaration.parameters)\n    emitter.block(declaration.body, `${path}/body`)\n    emitter.syntheticUnreachable(declaration, path)\n    emitter.syntheticEnd(declaration, path)\n    appendFunctionBody(code, emitter.writer, emitter.locals, {node: declaration, path}, declaration.name)\n  }\n\n  const runEmitter = new FunctionEmitter({functionIndexes, index, literals: literals.byValue, module, scratchBase})\n\n  runEmitter.run(module.entryPoint, \"/entryPoint\")\n  appendFunctionBody(code, runEmitter.writer, runEmitter.locals, {node: module.entryPoint, path: \"/entryPoint\"}, \"run\")\n  appendSection(writer, 10, \"code\", code, root)\n  appendSection(writer, 11, \"data\", encodeDataSection(literals.entries, index, root), root)\n  appendCustomSection(writer, \"name\", encodeNamePayload(module, runFunctionIndex, index), root)\n  appendCustomSection(writer, \"sourceMappingURL\", namedPayload(\"program.wasm.map\", index, root), root)\n\n  return {bytes: writer.finish(), ranges: writer.ranges}\n}\n\n/** Direct semantic function and entry-point instruction emitter. */\nclass FunctionEmitter {\n  /**\n   * Creates an instruction emitter.\n   * @param {object} options - Encoding context.\n   * @param {Map<string, number>} options.functionIndexes - Semantic function indexes.\n   * @param {ReturnType<typeof createGenerationIndex>} options.index - Provenance index.\n   * @param {Map<string, {address: number, bytes: Uint8Array}>} options.literals - Literal addresses.\n   * @param {SemanticModule} options.module - Complete module.\n   * @param {number} options.scratchBase - Scratch base.\n   */\n  constructor({functionIndexes, index, literals, module, scratchBase}) {\n    this.functionIndexes = functionIndexes\n    this.functions = new Map(module.functions.map((declaration) => [declaration.name, declaration]))\n    this.index = index\n    this.literals = literals\n    this.module = module\n    this.scratchBase = scratchBase\n    this.writer = new BinaryWriter(index)\n    /** @type {(\"i32\" | \"i64\")[]} */\n    this.locals = []\n    /** @type {Map<string, LocalBinding>} */\n    this.bindings = new Map()\n    this.parameterCount = 0\n  }\n\n  /**\n   * Binds flattened semantic parameters to Wasm parameter indexes.\n   * @param {import(\"../semantic/types.js\").Parameter[]} parameters - Semantic parameters.\n   * @returns {void}\n   */\n  bindParameters(parameters) {\n    let index = 0\n\n    for (const parameter of parameters) {\n      const scalar = wasmScalarType(parameter.type, parameter.location)\n      const types = wasmTypes(scalar)\n      const indexes = types.map(() => index++)\n\n      this.bindings.set(parameter.name, {indexes, type: scalar})\n    }\n    this.parameterCount = index\n  }\n\n  /**\n   * Emits the guarded exported run body.\n   * @param {import(\"../semantic/types.js\").EntryPoint} entryPoint - Semantic entry point.\n   * @param {string} path - Entry-point path.\n   * @returns {void}\n   */\n  run(entryPoint, path) {\n    this.syntheticOp(0x23, entryPoint, path, \"active guard read\")\n    this.syntheticImmediate(u32(activeGlobalIndex), entryPoint, path, \"active guard global index\")\n    this.syntheticOp(0x04, entryPoint, path, \"active guard branch\")\n    this.syntheticImmediate([0x40], entryPoint, path, \"empty block type\")\n    this.syntheticOp(0x00, entryPoint, path, \"reentrant invocation trap\")\n    this.syntheticOp(0x0b, entryPoint, path, \"active guard branch end\")\n    this.syntheticI32(1, entryPoint, path, \"mark run active\")\n    this.syntheticGlobalSet(activeGlobalIndex, entryPoint, path, \"active guard\")\n    this.syntheticI32(this.scratchBase, entryPoint, path, \"reset scratch cursor\")\n    this.syntheticGlobalSet(cursorGlobalIndex, entryPoint, path, \"scratch cursor\")\n    this.syntheticI32(0, entryPoint, path, \"reset semantic call depth\")\n    this.syntheticGlobalSet(depthGlobalIndex, entryPoint, path, \"call depth\")\n    this.block(entryPoint.body, `${path}/body`)\n    this.syntheticI32(0, entryPoint, path, \"clear semantic call depth\")\n    this.syntheticGlobalSet(depthGlobalIndex, entryPoint, path, \"call depth\")\n    this.syntheticI32(0, entryPoint, path, \"mark run inactive\")\n    this.syntheticGlobalSet(activeGlobalIndex, entryPoint, path, \"active guard\")\n    this.syntheticEnd(entryPoint, path)\n  }\n\n  /**\n   * Emits one semantic block.\n   * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n   * @param {string} path - Occurrence path.\n   * @returns {void}\n   */\n  block(block, path) {\n    for (let index = 0; index < block.statements.length; index += 1) {\n      const statement = block.statements[index]\n      const statementPath = `${path}/statements/${index}`\n\n      if (statement.kind == \"LocalDeclaration\") {\n        this.expression(statement.initializer, `${statementPath}/initializer`)\n        const binding = this.allocateBinding(wasmScalarType(statement.type, statement.location))\n\n        this.bindings.set(statement.name, binding)\n        this.setBinding(binding, statement, statementPath, \"name\")\n      } else if (statement.kind == \"AssignmentStatement\") {\n        this.expression(statement.expression, `${statementPath}/expression`)\n        const binding = this.bindings.get(statement.target.name)\n\n        if (!binding) throw new Error(\"Validated Wasm assignment omitted its binding.\")\n        this.setBinding(binding, statement.target, `${statementPath}/target`, \"name\")\n      } else if (statement.kind == \"PrintStatement\") {\n        const type = expressionType(statement.expression, this.bindings, this.functions)\n\n        this.expression(statement.expression, `${statementPath}/expression`)\n        const importIndex = type == \"integer\" ? 0 : type == \"boolean\" ? 1 : 2\n\n        this.mappedOp(0x10, statement, statementPath, \"print instruction\")\n        this.mappedImmediate(u32(importIndex), statement, statementPath, \"print import index\")\n      } else if (statement.kind == \"ReturnStatement\") {\n        if (!statement.expression) throw new TypeError(\"Wasm bare return reached emission.\")\n        this.expression(statement.expression, `${statementPath}/expression`)\n        this.mappedOp(0x0f, statement, statementPath, \"return instruction\")\n      } else if (statement.kind == \"ExpressionStatement\") {\n        throw new TypeError(\"Wasm Task 005 expression statement reached emission.\")\n      } else if (statement.kind == \"IfStatement\") {\n        this.expression(statement.condition, `${statementPath}/condition`)\n        this.mappedOp(0x04, statement.condition, `${statementPath}/condition`, \"conditional instruction\")\n        this.syntheticImmediate([0x40], statement, statementPath, \"empty conditional block type\")\n        this.block(statement.consequent, `${statementPath}/consequent`)\n        if (statement.alternate) {\n          this.mappedOp(0x05, statement, statementPath, \"alternate instruction\")\n          this.block(statement.alternate, `${statementPath}/alternate`)\n        }\n        this.mappedOp(0x0b, statement, statementPath, \"conditional end\")\n      } else {\n        throw new TypeError(\"Unsupported Wasm statement reached emission.\")\n      }\n    }\n  }\n\n  /**\n   * Emits one expression and leaves its flattened result on the operand stack.\n   * @param {Expression} expression - Semantic expression.\n   * @param {string} path - Occurrence path.\n   * @returns {void}\n   */\n  expression(expression, path) {\n    if (expression.kind == \"IdentifierExpression\") {\n      const binding = this.bindings.get(expression.name)\n\n      if (!binding) throw new Error(\"Validated Wasm identifier omitted its binding.\")\n      for (const localIndex of binding.indexes) {\n        this.mappedOp(0x20, expression, path, \"local read\", \"name\")\n        this.mappedImmediate(u32(localIndex), expression, path, \"local index\", \"name\")\n      }\n      return\n    }\n    if (expression.kind == \"IntegerLiteral\") {\n      this.mappedOp(0x42, expression, path, \"i64 constant\", \"literal\")\n      this.mappedImmediate(s64(BigInt(expression.value)), expression, path, \"i64 immediate\", \"literal\")\n      return\n    }\n    if (expression.kind == \"BooleanLiteral\") {\n      this.mappedOp(0x41, expression, path, \"canonical Boolean constant\", \"literal\")\n      this.mappedImmediate(s32(expression.value ? 1 : 0), expression, path, \"i32 immediate\", \"literal\")\n      return\n    }\n    if (expression.kind == \"StringLiteral\") {\n      const literal = this.literals.get(expression.value)\n\n      if (!literal) throw new Error(\"Validated Wasm string literal omitted its static layout.\")\n      this.mappedOp(0x41, expression, path, \"string pointer constant\", \"literal\")\n      this.mappedImmediate(s32(literal.address), expression, path, \"string pointer immediate\", \"literal\")\n      this.mappedOp(0x41, expression, path, \"string length constant\", \"literal\")\n      this.mappedImmediate(s32(literal.bytes.byteLength), expression, path, \"string length immediate\", \"literal\")\n      return\n    }\n    if (expression.kind == \"CallExpression\") {\n      for (let index = 0; index < expression.arguments.length; index += 1) {\n        this.expression(expression.arguments[index], `${path}/arguments/${index}`)\n      }\n      this.semanticCall(expression, path)\n      return\n    }\n    if (expression.kind == \"UnaryExpression\") {\n      this.expression(expression.operand, `${path}/operand`)\n      if (expression.operation == \"BooleanNot\") this.mappedOp(0x45, expression, path, \"Boolean not instruction\", \"operator\")\n      else {\n        this.mappedOp(0x10, expression, path, \"checked integer negate instruction\", \"operator\")\n        this.mappedImmediate(u32(checkedNegateFunctionIndex), expression, path, \"checked helper index\", \"operator\")\n      }\n      return\n    }\n    if (expression.kind != \"BinaryExpression\") {\n      return unsupportedCapability(\"wasm\", \"collection expression reached scalar emission\", expression.location)\n    }\n    if (expression.operation == \"BooleanAnd\" || expression.operation == \"BooleanOr\") {\n      this.expression(expression.left, `${path}/left`)\n      this.mappedOp(0x04, expression, path, \"short-circuit conditional\", \"operator\")\n      this.syntheticImmediate([valueTypes.i32], expression, path, \"Boolean conditional result type\")\n      if (expression.operation == \"BooleanAnd\") {\n        this.expression(expression.right, `${path}/right`)\n        this.mappedOp(0x05, expression, path, \"short-circuit alternate\", \"operator\")\n        this.syntheticI32(0, expression, path, \"canonical false result\")\n      } else {\n        this.syntheticI32(1, expression, path, \"canonical true result\")\n        this.mappedOp(0x05, expression, path, \"short-circuit alternate\", \"operator\")\n        this.expression(expression.right, `${path}/right`)\n      }\n      this.mappedOp(0x0b, expression, path, \"short-circuit end\", \"operator\")\n      return\n    }\n\n    this.expression(expression.left, `${path}/left`)\n    this.expression(expression.right, `${path}/right`)\n    const directOpcode = new Map([\n      [\"IntegerEqual\", 0x51], [\"IntegerNotEqual\", 0x52], [\"IntegerLessThan\", 0x53],\n      [\"IntegerGreaterThan\", 0x55], [\"IntegerLessThanOrEqual\", 0x57], [\"IntegerGreaterThanOrEqual\", 0x59],\n      [\"BooleanEqual\", 0x46], [\"BooleanNotEqual\", 0x47]\n    ]).get(expression.operation)\n\n    if (directOpcode !== undefined) this.mappedOp(directOpcode, expression, path, `${expression.operation} instruction`, \"operator\")\n    else {\n      const helperIndex = expression.operation == \"StringConcat\" ? concatFunctionIndex :\n        expression.operation == \"StringEqual\" || expression.operation == \"StringNotEqual\" ? stringEqualFunctionIndex :\n          expression.operation == \"IntegerAdd\" ? checkedAddFunctionIndex :\n            expression.operation == \"IntegerSubtract\" ? checkedSubtractFunctionIndex : checkedMultiplyFunctionIndex\n\n      this.mappedOp(0x10, expression, path, `${expression.operation} helper call`, \"operator\")\n      this.mappedImmediate(u32(helperIndex), expression, path, \"helper function index\", \"operator\")\n      if (expression.operation == \"StringNotEqual\") this.mappedOp(0x45, expression, path, \"String inequality inversion\", \"operator\")\n    }\n  }\n\n  /**\n   * Emits checked semantic-call depth accounting without changing argument order.\n   * @param {import(\"../semantic/types.js\").CallExpression} expression - Call expression.\n   * @param {string} path - Call occurrence path.\n   * @returns {void}\n   */\n  semanticCall(expression, path) {\n    const declaration = this.functions.get(expression.callee)\n    const functionIndex = this.functionIndexes.get(expression.callee)\n\n    if (!declaration || functionIndex === undefined) throw new Error(\"Validated Wasm call omitted its declaration.\")\n    this.syntheticOp(0x23, expression, path, \"read semantic call depth\")\n    this.syntheticImmediate(u32(depthGlobalIndex), expression, path, \"call-depth global index\")\n    this.syntheticI32(maximumCallDepth, expression, path, \"maximum semantic call depth\")\n    this.syntheticOp(0x4f, expression, path, \"semantic call-depth limit comparison\")\n    this.syntheticOp(0x04, expression, path, \"semantic call-depth guard\")\n    this.syntheticImmediate([0x40], expression, path, \"empty call-depth guard block type\")\n    this.syntheticOp(0x00, expression, path, \"semantic call-depth trap\")\n    this.syntheticOp(0x0b, expression, path, \"semantic call-depth guard end\")\n    this.syntheticOp(0x23, expression, path, \"read semantic call depth\")\n    this.syntheticImmediate(u32(depthGlobalIndex), expression, path, \"call-depth global index\")\n    this.syntheticI32(1, expression, path, \"semantic call-depth increment\")\n    this.syntheticOp(0x6a, expression, path, \"increment semantic call depth\")\n    this.syntheticGlobalSet(depthGlobalIndex, expression, path, \"call depth\")\n    this.mappedOp(0x10, expression, path, \"semantic call instruction\", \"callee\")\n    this.mappedImmediate(u32(functionIndex), expression, path, \"semantic callee index\", \"callee\")\n\n    const result = this.allocateBinding(wasmReturnType(declaration))\n\n    this.setBinding(result, expression, path)\n    this.syntheticOp(0x23, expression, path, \"read semantic call depth\")\n    this.syntheticImmediate(u32(depthGlobalIndex), expression, path, \"call-depth global index\")\n    this.syntheticI32(1, expression, path, \"semantic call-depth decrement\")\n    this.syntheticOp(0x6b, expression, path, \"decrement semantic call depth\")\n    this.syntheticGlobalSet(depthGlobalIndex, expression, path, \"call depth\")\n    for (const localIndex of result.indexes) {\n      this.syntheticOp(0x20, expression, path, \"restore semantic call result\")\n      this.syntheticImmediate(u32(localIndex), expression, path, \"result temporary local index\")\n    }\n  }\n\n  /**\n   * Allocates flattened Wasm locals for one semantic value.\n   * @param {Scalar} type - Semantic type.\n   * @returns {LocalBinding} Local binding.\n   */\n  allocateBinding(type) {\n    const indexes = wasmTypes(type).map((wasmType) => {\n      const index = this.parameterCount + this.locals.length\n\n      this.locals.push(wasmType)\n\n      return index\n    })\n\n    return {indexes, type}\n  }\n\n  /**\n   * Pops a flattened value into its locals.\n   * @param {LocalBinding} binding - Destination.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Occurrence path.\n   * @param {string} [sourceRole] - Exact parser-owned token role, when this is a semantic binding.\n   * @returns {void}\n   */\n  setBinding(binding, node, path, sourceRole) {\n    for (let index = binding.indexes.length - 1; index >= 0; index -= 1) {\n      if (sourceRole) {\n        this.mappedOp(0x21, node, path, \"local write\", sourceRole)\n        this.mappedImmediate(u32(binding.indexes[index]), node, path, \"local index\", sourceRole)\n      } else {\n        this.syntheticOp(0x21, node, path, \"store semantic call result\")\n        this.syntheticImmediate(u32(binding.indexes[index]), node, path, \"result temporary local index\")\n      }\n    }\n  }\n\n  /**\n   * Writes a source-mapped instruction opcode.\n   * @param {number} opcode - Wasm opcode.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Node occurrence path.\n   * @param {string} role - Mapping role.\n   * @param {string} [sourceRole] - Exact parser-owned token role.\n   * @returns {void}\n   */\n  mappedOp(opcode, node, path, role, sourceRole) { this.writer.mapped([opcode], node, path, role, sourceRole) }\n\n  /**\n   * Writes a source-mapped instruction immediate.\n   * @param {number[]} bytes - Encoded immediate bytes.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Node occurrence path.\n   * @param {string} role - Mapping role.\n   * @param {string} [sourceRole] - Exact parser-owned token role.\n   * @returns {void}\n   */\n  mappedImmediate(bytes, node, path, role, sourceRole) { this.writer.mapped(bytes, node, path, role, sourceRole) }\n\n  /**\n   * Writes a synthetic instruction opcode with semantic context.\n   * @param {number} opcode - Wasm opcode.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Node occurrence path.\n   * @param {string} reason - Synthetic provenance reason.\n   * @returns {void}\n   */\n  syntheticOp(opcode, node, path, reason) { this.writer.synthetic([opcode], reason, {node, path}, \"instruction\") }\n\n  /**\n   * Writes a synthetic immediate with semantic context.\n   * @param {number[]} bytes - Encoded immediate bytes.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Node occurrence path.\n   * @param {string} reason - Synthetic provenance reason.\n   * @returns {void}\n   */\n  syntheticImmediate(bytes, node, path, reason) { this.writer.synthetic(bytes, reason, {node, path}, \"immediate\") }\n\n  /**\n   * Writes a synthetic i32 constant instruction.\n   * @param {number} value - Constant value.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Node occurrence path.\n   * @param {string} reason - Synthetic provenance reason.\n   * @returns {void}\n   */\n  syntheticI32(value, node, path, reason) {\n    this.syntheticOp(0x41, node, path, reason)\n    this.syntheticImmediate(s32(value), node, path, `${reason} immediate`)\n  }\n\n  /**\n   * Writes a synthetic global assignment.\n   * @param {number} index - Global index.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Node occurrence path.\n   * @param {string} reason - Synthetic provenance reason.\n   * @returns {void}\n   */\n  syntheticGlobalSet(index, node, path, reason) {\n    this.syntheticOp(0x24, node, path, `set ${reason}`)\n    this.syntheticImmediate(u32(index), node, path, `${reason} global index`)\n  }\n\n  /**\n   * Writes a synthetic function-end instruction.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Node occurrence path.\n   * @returns {void}\n   */\n  syntheticEnd(node, path) { this.syntheticOp(0x0b, node, path, \"function end\") }\n\n  /**\n   * Writes a synthetic unreachable instruction.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Node occurrence path.\n   * @returns {void}\n   */\n  syntheticUnreachable(node, path) { this.syntheticOp(0x00, node, path, \"validated non-void fallthrough trap\") }\n}\n\n/** Byte writer that preserves one non-overlapping provenance annotation per write. */\nclass BinaryWriter {\n  /**\n   * Creates an annotated binary writer.\n   * @param {ReturnType<typeof createGenerationIndex>} index - Canonical provenance index.\n   */\n  constructor(index) {\n    this.index = index\n    /** @type {number[]} */\n    this.bytes = []\n    /** @type {GeneratedByteRange[]} */\n    this.ranges = []\n  }\n\n  /**\n   * Writes source-backed bytes.\n   * @param {number[] | Uint8Array} bytes - Exact bytes.\n   * @param {SemanticNode} node - Semantic node.\n   * @param {string} path - Occurrence path.\n   * @param {string} role - Binary role.\n   * @param {string} [sourceRole] - Exact parser-owned token role.\n   * @returns {void}\n   */\n  mapped(bytes, node, path, role, sourceRole) {\n    const record = this.index.recordFor(node, path)\n    const origin = sourceRole ? originForRole(this.index, record, sourceRole) : record.origin\n\n    this.write(bytes, {nodeId: record.id, origin, role, symbolId: record.symbolId})\n  }\n\n  /**\n   * Writes explicit backend scaffolding bytes.\n   * @param {number[] | Uint8Array} bytes - Exact bytes.\n   * @param {string} reason - Synthetic reason.\n   * @param {{node: SemanticNode, path: string}} related - Related occurrence.\n   * @param {string} role - Binary role.\n   * @returns {void}\n   */\n  synthetic(bytes, reason, related, role) {\n    const record = this.index.recordFor(related.node, related.path)\n\n    this.write(bytes, {\n      origin: {kind: \"synthetic\", reason, relatedOrigins: relatedOrigins(record)},\n      role\n    })\n  }\n\n  /**\n   * Appends another annotated writer.\n   * @param {BinaryWriter} child - Child bytes.\n   * @returns {void}\n   */\n  append(child) {\n    const offset = this.bytes.length\n\n    for (const byte of child.bytes) this.bytes.push(byte)\n    for (const range of child.ranges) {\n      this.ranges.push({...range, generated: {start: range.generated.start + offset, end: range.generated.end + offset}})\n    }\n  }\n\n  /**\n   * Returns detached encoded bytes.\n   * @returns {Uint8Array} Detached bytes.\n   */\n  finish() { return Uint8Array.from(this.bytes) }\n\n  /**\n   * Writes one non-empty annotated range.\n   * @param {number[] | Uint8Array} bytes - Exact bytes.\n   * @param {Omit<GeneratedByteRange, \"generated\">} annotation - Provenance.\n   * @returns {void}\n   */\n  write(bytes, annotation) {\n    if (bytes.length == 0) return\n    const start = this.bytes.length\n\n    for (const byte of bytes) {\n      if (!Number.isInteger(byte) || byte < 0 || byte > 255) throw new RangeError(\"Invalid WebAssembly byte.\")\n      this.bytes.push(byte)\n    }\n    this.ranges.push({...annotation, generated: {start, end: this.bytes.length}})\n  }\n}\n\n/** Deterministic function-type interner. */\nclass TypePool {\n  constructor() {\n    /** @type {{parameters: (\"i32\" | \"i64\")[], results: (\"i32\" | \"i64\")[]}[]} */\n    this.entries = []\n    /** @type {Map<string, number>} */\n    this.indexes = new Map()\n  }\n\n  /**\n   * Interns one function type.\n   * @param {(\"i32\" | \"i64\")[]} parameters - Parameters.\n   * @param {(\"i32\" | \"i64\")[]} results - Results.\n   * @returns {number} Type index.\n   */\n  add(parameters, results) {\n    const key = `${parameters.join(\",\")}->${results.join(\",\")}`\n    const prior = this.indexes.get(key)\n\n    if (prior !== undefined) return prior\n    const index = this.entries.length\n\n    this.entries.push({parameters, results})\n    this.indexes.set(key, index)\n\n    return index\n  }\n}\n\n/**\n * Encodes the function-type section payload.\n * @param {TypePool} types - Interned function types.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {{node: SemanticNode, path: string}} root - Related module occurrence.\n * @returns {BinaryWriter} Encoded payload.\n */\nfunction encodeTypeSection(types, index, root) {\n  const writer = new BinaryWriter(index)\n\n  writer.synthetic(u32(types.entries.length), \"Function type count\", root, \"type count\")\n  for (const type of types.entries) {\n    writer.synthetic([0x60], \"Function type form\", root, \"type form\")\n    writer.synthetic(u32(type.parameters.length), \"Function parameter count\", root, \"type parameter count\")\n    for (const parameter of type.parameters) writer.synthetic([valueTypes[parameter]], \"Function parameter value type\", root, \"value type\")\n    writer.synthetic(u32(type.results.length), \"Function result count\", root, \"type result count\")\n    for (const result of type.results) writer.synthetic([valueTypes[result]], \"Function result value type\", root, \"value type\")\n  }\n\n  return writer\n}\n\n/**\n * Encodes the fixed ABI import section payload.\n * @param {number[]} typeIndexes - Import function type indexes.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {{node: SemanticNode, path: string}} root - Related module occurrence.\n * @returns {BinaryWriter} Encoded payload.\n */\nfunction encodeImportSection(typeIndexes, index, root) {\n  const writer = new BinaryWriter(index)\n  const names = [\"print_i64\", \"print_bool\", \"print_string\"]\n\n  writer.synthetic(u32(names.length), \"ABI import count\", root, \"import count\")\n  for (let offset = 0; offset < names.length; offset += 1) {\n    writer.synthetic(nameBytes(\"semantifold\"), \"ABI import module name\", root, \"import module\")\n    writer.synthetic(nameBytes(names[offset]), \"ABI import function name\", root, \"import name\")\n    writer.synthetic([0x00], \"Function import kind\", root, \"import kind\")\n    writer.synthetic(u32(typeIndexes[offset]), \"ABI import type index\", root, \"type index\")\n  }\n\n  return writer\n}\n\n/**\n * Encodes defined-function type indexes.\n * @param {number[]} helperTypes - Private helper type indexes.\n * @param {number[]} semanticTypes - Semantic function type indexes.\n * @param {number} runType - Exported run function type index.\n * @param {SemanticModule} module - Semantic module.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @returns {BinaryWriter} Encoded payload.\n */\nfunction encodeFunctionSection(helperTypes, semanticTypes, runType, module, index) {\n  const writer = new BinaryWriter(index)\n  const root = {node: module, path: \"\"}\n\n  writer.synthetic(u32(helperTypes.length + semanticTypes.length + 1), \"Defined function count\", root, \"function count\")\n  for (const typeIndex of helperTypes) writer.synthetic(u32(typeIndex), \"Private ABI helper type index\", root, \"type index\")\n  for (let offset = 0; offset < semanticTypes.length; offset += 1) {\n    const declaration = module.functions[offset]\n\n    writer.synthetic(u32(semanticTypes[offset]), \"Semantic function type index\", {node: declaration, path: `/functions/${offset}`}, \"type index\")\n  }\n  writer.synthetic(u32(runType), \"Exported run type index\", {node: module.entryPoint, path: \"/entryPoint\"}, \"type index\")\n\n  return writer\n}\n\n/**\n * Encodes one fixed-memory declaration.\n * @param {number} pages - Equal initial and maximum page count.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {{node: SemanticNode, path: string}} root - Related module occurrence.\n * @returns {BinaryWriter} Encoded payload.\n */\nfunction encodeMemorySection(pages, index, root) {\n  const writer = new BinaryWriter(index)\n\n  writer.synthetic(u32(1), \"Single fixed linear memory\", root, \"memory count\")\n  writer.synthetic([0x01], \"Memory limits include equal maximum\", root, \"memory limits flags\")\n  writer.synthetic(u32(pages), \"Initial memory page count\", root, \"memory initial pages\")\n  writer.synthetic(u32(pages), \"Maximum memory page count\", root, \"memory maximum pages\")\n\n  return writer\n}\n\n/**\n * Encodes private mutable ABI globals.\n * @param {number} scratchBase - Initial scratch cursor.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {{node: SemanticNode, path: string}} root - Related module occurrence.\n * @returns {BinaryWriter} Encoded payload.\n */\nfunction encodeGlobalSection(scratchBase, index, root) {\n  const writer = new BinaryWriter(index)\n  const globals = [\n    {initial: scratchBase, reason: \"Private scratch cursor\"},\n    {initial: 0, reason: \"Private semantic call depth\"},\n    {initial: 0, reason: \"Private run active guard\"}\n  ]\n\n  writer.synthetic(u32(globals.length), \"Private mutable global count\", root, \"global count\")\n  for (const global of globals) {\n    writer.synthetic([valueTypes.i32, 0x01], `${global.reason} type and mutability`, root, \"global type\")\n    writer.synthetic([0x41], `${global.reason} initializer instruction`, root, \"instruction\")\n    writer.synthetic(s32(global.initial), `${global.reason} initializer immediate`, root, \"immediate\")\n    writer.synthetic([0x0b], `${global.reason} initializer end`, root, \"instruction\")\n  }\n\n  return writer\n}\n\n/**\n * Encodes exactly the public memory and run exports.\n * @param {number} runIndex - Exported run function index.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {{node: SemanticNode, path: string}} root - Related module occurrence.\n * @returns {BinaryWriter} Encoded payload.\n */\nfunction encodeExportSection(runIndex, index, root) {\n  const writer = new BinaryWriter(index)\n\n  writer.synthetic(u32(2), \"Exact ABI export count\", root, \"export count\")\n  writer.synthetic(nameBytes(\"memory\"), \"Exported memory name\", root, \"export name\")\n  writer.synthetic([0x02], \"Memory export kind\", root, \"export kind\")\n  writer.synthetic(u32(0), \"Exported memory index\", root, \"memory index\")\n  writer.synthetic(nameBytes(\"run\"), \"Exported run name\", root, \"export name\")\n  writer.synthetic([0x00], \"Function export kind\", root, \"export kind\")\n  writer.synthetic(u32(runIndex), \"Exported run function index\", root, \"function index\")\n\n  return writer\n}\n\n/**\n * Encodes immutable UTF-8 literal data segments.\n * @param {ReturnType<typeof collectLiteralLayout>[\"entries\"]} entries - Ordered literal entries.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {{node: SemanticNode, path: string}} root - Related module occurrence.\n * @returns {BinaryWriter} Encoded payload.\n */\nfunction encodeDataSection(entries, index, root) {\n  const writer = new BinaryWriter(index)\n  const nonempty = entries.filter(({bytes}) => bytes.byteLength > 0)\n\n  writer.synthetic(u32(nonempty.length), \"Immutable literal data segment count\", root, \"data segment count\")\n  for (const entry of nonempty) {\n    writer.synthetic([0x00, 0x41], \"Active literal data segment and offset instruction\", root, \"data segment header\")\n    writer.synthetic(s32(entry.address), \"Literal data address\", root, \"data segment offset\")\n    writer.synthetic([0x0b], \"Literal offset expression end\", root, \"instruction\")\n    writer.synthetic(u32(entry.bytes.byteLength), \"Literal data byte length\", root, \"data segment length\")\n    writer.write(entry.bytes, {\n      origin: entry.origin,\n      role: \"immutable UTF-8 literal data\"\n    })\n  }\n\n  return writer\n}\n\n/**\n * Encodes deterministic internal and semantic function names.\n * @param {SemanticModule} module - Semantic module.\n * @param {number} runIndex - Exported run function index.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @returns {BinaryWriter} Encoded custom-section payload.\n */\nfunction encodeNamePayload(module, runIndex, index) {\n  const writer = new BinaryWriter(index)\n  const root = {node: module, path: \"\"}\n  const subsection = new BinaryWriter(index)\n  /** @type {{declaration?: import(\"../semantic/types.js\").FunctionDeclaration, index: number, name: string, path?: string}[]} */\n  const names = [\n    ...helperNames.map((name, offset) => ({index: importCount + offset, name})),\n    ...module.functions.map((declaration, offset) => ({declaration, index: importCount + helperCount + offset, name: declaration.name, path: `/functions/${offset}`})),\n    {index: runIndex, name: \"run\"}\n  ]\n\n  subsection.synthetic(u32(names.length), \"Named function count\", root, \"name count\")\n  for (const name of names) {\n    subsection.synthetic(u32(name.index), \"Named function index\", root, \"function index\")\n    if (name.declaration) {\n      const bytes = encoder.encode(name.name)\n      const related = {node: name.declaration, path: /** @type {string} */ (name.path)}\n\n      subsection.synthetic(u32(bytes.byteLength), \"Semantic function name byte length\", related, \"function name length\")\n      subsection.mapped(bytes, name.declaration, related.path, \"semantic function name\", \"name\")\n    } else subsection.synthetic(nameBytes(name.name), \"Private ABI function name\", root, \"function name\")\n  }\n  writer.synthetic([0x01], \"Function names subsection ID\", root, \"custom subsection id\")\n  writer.synthetic(u32(subsection.bytes.length), \"Function names subsection size\", root, \"custom subsection size\")\n  writer.append(subsection)\n\n  return writer\n}\n\n/**\n * Encodes one source-map URL custom-section payload.\n * @param {string} content - Relative map URL.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {{node: SemanticNode, path: string}} root - Related module occurrence.\n * @returns {BinaryWriter} Encoded payload.\n */\nfunction namedPayload(content, index, root) {\n  const writer = new BinaryWriter(index)\n\n  writer.synthetic(encoder.encode(content), \"Relative external Wasm source-map URL\", root, \"custom section payload\")\n\n  return writer\n}\n\n/**\n * Appends one sized module section.\n * @param {BinaryWriter} moduleWriter - Complete module writer.\n * @param {number} id - Core section ID.\n * @param {string} name - Diagnostic section name.\n * @param {BinaryWriter} payload - Encoded section payload.\n * @param {{node: SemanticNode, path: string}} root - Related module occurrence.\n * @returns {void}\n */\nfunction appendSection(moduleWriter, id, name, payload, root) {\n  moduleWriter.synthetic([id], `${name} section ID`, root, `${name} section`)\n  moduleWriter.synthetic(u32(payload.bytes.length), `${name} section byte length`, root, `${name} section length`)\n  moduleWriter.append(payload)\n}\n\n/**\n * Appends one named custom section.\n * @param {BinaryWriter} writer - Complete module writer.\n * @param {string} name - Custom-section name.\n * @param {BinaryWriter} payload - Custom-section payload.\n * @param {{node: SemanticNode, path: string}} root - Related module occurrence.\n * @returns {void}\n */\nfunction appendCustomSection(writer, name, payload, root) {\n  const complete = new BinaryWriter(writer.index)\n\n  complete.synthetic(nameBytes(name), `Custom section name '${name}'`, root, \"custom section name\")\n  complete.append(payload)\n  appendSection(writer, 0, `custom ${name}`, complete, root)\n}\n\n/**\n * Appends one sized function body and its flattened locals.\n * @param {BinaryWriter} code - Code-section payload writer.\n * @param {BinaryWriter} instructions - Function instructions.\n * @param {(\"i32\" | \"i64\")[]} locals - Flattened local types.\n * @param {{node: SemanticNode, path: string}} related - Related semantic occurrence.\n * @param {string} name - Function name for provenance.\n * @returns {void}\n */\nfunction appendFunctionBody(code, instructions, locals, related, name) {\n  const body = new BinaryWriter(code.index)\n\n  body.synthetic(u32(locals.length), `Local declaration group count for ${name}`, related, \"function locals\")\n  for (const local of locals) {\n    body.synthetic(u32(1), `Local count for ${name}`, related, \"local count\")\n    body.synthetic([valueTypes[local]], `Local value type for ${name}`, related, \"local type\")\n  }\n  body.append(instructions)\n  code.synthetic(u32(body.bytes.length), `Function body byte length for ${name}`, related, \"function body length\")\n  code.append(body)\n}\n\n/**\n * Encodes checked scratch allocation and string concatenation.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {SemanticModule} module - Semantic module.\n * @param {number} scratchBase - Arena start address.\n * @returns {BinaryWriter} Encoded helper body.\n */\nfunction helperConcat(index, module, scratchBase) {\n  const e = new SyntheticEmitter(index, module, \"$concat\")\n  const total = 4\n  const start = 5\n  const end = 6\n  const cursor = 7\n\n  e.localGet(1); e.localGet(3); e.op(0x6a, \"add string lengths\"); e.localTee(total)\n  e.localGet(1); e.op(0x49, \"detect unsigned string-length overflow\"); e.trapIf(\"string-length overflow\")\n  e.globalGet(cursorGlobalIndex); e.localTee(start)\n  e.localGet(total); e.op(0x6a, \"add scratch cursor and allocation length\"); e.localTee(end)\n  e.localGet(start); e.op(0x49, \"detect unsigned scratch-cursor overflow\"); e.trapIf(\"scratch cursor overflow\")\n  e.localGet(end); e.i32(scratchBase + scratchCapacity); e.op(0x4b, \"compare allocation end with arena end\"); e.trapIf(\"scratch capacity exceeded\")\n  e.i32(0); e.localSet(cursor)\n  e.copyLoop(cursor, 0, 1, start, undefined)\n  e.i32(0); e.localSet(cursor)\n  e.copyLoop(cursor, 2, 3, start, 1)\n  e.localGet(end); e.globalSet(cursorGlobalIndex)\n  e.localGet(start); e.localGet(total); e.end()\n\n  return e.writer\n}\n\n/**\n * Encodes byte-exact string equality.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {SemanticModule} module - Semantic module.\n * @returns {BinaryWriter} Encoded helper body.\n */\nfunction helperStringEqual(index, module) {\n  const e = new SyntheticEmitter(index, module, \"$string_equal\")\n  const cursor = 4\n\n  e.localGet(1); e.localGet(3); e.op(0x47, \"compare string lengths\")\n  e.op(0x04, \"branch for unequal string lengths\"); e.immediate([0x40], \"empty block type\")\n  e.i32(0); e.op(0x0f, \"return false for unequal lengths\"); e.op(0x0b, \"end length branch\")\n  e.i32(0); e.localSet(cursor)\n  e.op(0x02, \"string comparison exit block\"); e.immediate([0x40], \"empty block type\")\n  e.op(0x03, \"string comparison loop\"); e.immediate([0x40], \"empty block type\")\n  e.localGet(cursor); e.localGet(1); e.op(0x4f, \"compare cursor with string length\")\n  e.op(0x0d, \"exit completed comparison\"); e.immediate(u32(1), \"comparison block depth\")\n  e.localGet(0); e.localGet(cursor); e.op(0x6a, \"left byte address\"); e.load8()\n  e.localGet(2); e.localGet(cursor); e.op(0x6a, \"right byte address\"); e.load8()\n  e.op(0x47, \"compare UTF-8 bytes\")\n  e.op(0x04, \"branch for unequal UTF-8 bytes\"); e.immediate([0x40], \"empty block type\")\n  e.i32(0); e.op(0x0f, \"return false for unequal bytes\"); e.op(0x0b, \"end byte branch\")\n  e.localGet(cursor); e.i32(1); e.op(0x6a, \"increment comparison cursor\"); e.localSet(cursor)\n  e.op(0x0c, \"continue string comparison\"); e.immediate(u32(0), \"comparison loop depth\")\n  e.op(0x0b, \"end comparison loop\"); e.op(0x0b, \"end comparison block\")\n  e.i32(1); e.end()\n\n  return e.writer\n}\n\n/**\n * Encodes checked signed i64 addition.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {SemanticModule} module - Semantic module.\n * @returns {BinaryWriter} Encoded helper body.\n */\nfunction helperCheckedAdd(index, module) {\n  const e = new SyntheticEmitter(index, module, \"$checked_add\")\n\n  e.localGet(0); e.localGet(1); e.op(0x7c, \"signed i64 addition\"); e.localSet(2)\n  e.localGet(0); e.localGet(2); e.op(0x85, \"addition overflow xor\")\n  e.localGet(1); e.localGet(2); e.op(0x85, \"addition overflow xor\")\n  e.op(0x83, \"addition overflow mask\"); e.i64(0n); e.op(0x53, \"addition overflow sign test\"); e.trapIf(\"signed i64 addition overflow\")\n  e.localGet(2); e.end()\n\n  return e.writer\n}\n\n/**\n * Encodes checked signed i64 subtraction.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {SemanticModule} module - Semantic module.\n * @returns {BinaryWriter} Encoded helper body.\n */\nfunction helperCheckedSubtract(index, module) {\n  const e = new SyntheticEmitter(index, module, \"$checked_subtract\")\n\n  e.localGet(0); e.localGet(1); e.op(0x7d, \"signed i64 subtraction\"); e.localSet(2)\n  e.localGet(0); e.localGet(1); e.op(0x85, \"subtraction overflow xor\")\n  e.localGet(0); e.localGet(2); e.op(0x85, \"subtraction overflow xor\")\n  e.op(0x83, \"subtraction overflow mask\"); e.i64(0n); e.op(0x53, \"subtraction overflow sign test\"); e.trapIf(\"signed i64 subtraction overflow\")\n  e.localGet(2); e.end()\n\n  return e.writer\n}\n\n/**\n * Encodes checked signed i64 multiplication.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {SemanticModule} module - Semantic module.\n * @returns {BinaryWriter} Encoded helper body.\n */\nfunction helperCheckedMultiply(index, module) {\n  const e = new SyntheticEmitter(index, module, \"$checked_multiply\")\n\n  e.localGet(0); e.op(0x50, \"left operand zero test\")\n  e.localGet(1); e.op(0x50, \"right operand zero test\"); e.op(0x72, \"zero operand combination\")\n  e.op(0x04, \"zero multiplication branch\"); e.immediate([valueTypes.i64], \"i64 branch result type\")\n  e.i64(0n)\n  e.op(0x05, \"nonzero multiplication branch\")\n  e.localGet(0); e.i64(-1n); e.op(0x51, \"left negative-one test\")\n  e.localGet(1); e.i64(-9223372036854775808n); e.op(0x51, \"right minimum test\"); e.op(0x71, \"first division overflow combination\")\n  e.localGet(1); e.i64(-1n); e.op(0x51, \"right negative-one test\")\n  e.localGet(0); e.i64(-9223372036854775808n); e.op(0x51, \"left minimum test\"); e.op(0x71, \"second division overflow combination\")\n  e.op(0x72, \"division overflow combination\"); e.trapIf(\"signed i64 multiplication overflow\")\n  e.localGet(0); e.localGet(1); e.op(0x7e, \"signed i64 multiplication\"); e.localSet(2)\n  e.localGet(2); e.localGet(1); e.op(0x7f, \"signed i64 division overflow check\"); e.localGet(0); e.op(0x52, \"multiplication quotient mismatch\")\n  e.trapIf(\"signed i64 multiplication overflow\")\n  e.localGet(2); e.op(0x0b, \"end checked multiplication branch\"); e.end()\n\n  return e.writer\n}\n\n/**\n * Encodes checked signed i64 negation.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @param {SemanticModule} module - Semantic module.\n * @returns {BinaryWriter} Encoded helper body.\n */\nfunction helperCheckedNegate(index, module) {\n  const e = new SyntheticEmitter(index, module, \"$checked_negate\")\n\n  e.localGet(0); e.i64(-9223372036854775808n); e.op(0x51, \"minimum i64 negate test\"); e.trapIf(\"signed i64 negation overflow\")\n  e.i64(0n); e.localGet(0); e.op(0x7d, \"signed i64 negation\"); e.end()\n\n  return e.writer\n}\n\n/** Helper instruction emitter with explicit synthetic provenance. */\nclass SyntheticEmitter {\n  /**\n   * Creates a synthetic helper emitter.\n   * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n   * @param {SemanticModule} module - Related semantic module.\n   * @param {string} name - Helper function name.\n   */\n  constructor(index, module, name) {\n    this.writer = new BinaryWriter(index)\n    this.related = {node: module, path: \"\"}\n    this.name = name\n  }\n\n  /**\n   * Writes an instruction opcode.\n   * @param {number} opcode - Wasm opcode.\n   * @param {string} reason - Synthetic provenance reason.\n   * @returns {void}\n   */\n  op(opcode, reason) { this.writer.synthetic([opcode], `${this.name}: ${reason}`, this.related, \"instruction\") }\n\n  /**\n   * Writes encoded instruction immediates.\n   * @param {number[]} bytes - Immediate bytes.\n   * @param {string} reason - Synthetic provenance reason.\n   * @returns {void}\n   */\n  immediate(bytes, reason) { this.writer.synthetic(bytes, `${this.name}: ${reason}`, this.related, \"immediate\") }\n\n  /**\n   * Reads one local.\n   * @param {number} index - Local index.\n   * @returns {void}\n   */\n  localGet(index) { this.op(0x20, \"read local\"); this.immediate(u32(index), \"local index\") }\n\n  /**\n   * Writes one local.\n   * @param {number} index - Local index.\n   * @returns {void}\n   */\n  localSet(index) { this.op(0x21, \"write local\"); this.immediate(u32(index), \"local index\") }\n\n  /**\n   * Writes and retains one local value.\n   * @param {number} index - Local index.\n   * @returns {void}\n   */\n  localTee(index) { this.op(0x22, \"tee local\"); this.immediate(u32(index), \"local index\") }\n\n  /**\n   * Reads one global.\n   * @param {number} index - Global index.\n   * @returns {void}\n   */\n  globalGet(index) { this.op(0x23, \"read global\"); this.immediate(u32(index), \"global index\") }\n\n  /**\n   * Writes one global.\n   * @param {number} index - Global index.\n   * @returns {void}\n   */\n  globalSet(index) { this.op(0x24, \"write global\"); this.immediate(u32(index), \"global index\") }\n\n  /**\n   * Writes one i32 constant.\n   * @param {number} value - Constant value.\n   * @returns {void}\n   */\n  i32(value) { this.op(0x41, \"i32 constant\"); this.immediate(s32(value), \"i32 immediate\") }\n\n  /**\n   * Writes one i64 constant.\n   * @param {bigint} value - Constant value.\n   * @returns {void}\n   */\n  i64(value) { this.op(0x42, \"i64 constant\"); this.immediate(s64(value), \"i64 immediate\") }\n\n  /**\n   * Loads one unsigned byte.\n   * @returns {void}\n   */\n  load8() { this.op(0x2d, \"load unsigned byte\"); this.immediate([0x00, 0x00], \"byte-load memory arguments\") }\n\n  /**\n   * Stores one byte.\n   * @returns {void}\n   */\n  store8() { this.op(0x3a, \"store byte\"); this.immediate([0x00, 0x00], \"byte-store memory arguments\") }\n\n  /**\n   * Traps when the stack's condition is nonzero.\n   * @param {string} reason - Trap provenance reason.\n   * @returns {void}\n   */\n  trapIf(reason) {\n    this.op(0x04, `${reason} branch`); this.immediate([0x40], \"empty block type\")\n    this.op(0x00, `${reason} trap`); this.op(0x0b, `${reason} branch end`)\n  }\n  /**\n   * Copies one string operand byte by byte.\n   * @param {number} cursor - Loop cursor local.\n   * @param {number} sourcePointer - Source pointer local.\n   * @param {number} sourceLength - Source length local.\n   * @param {number} destination - Allocation start local.\n   * @param {number | undefined} destinationOffset - Optional left-length local.\n   * @returns {void}\n   */\n  copyLoop(cursor, sourcePointer, sourceLength, destination, destinationOffset) {\n    this.op(0x02, \"copy exit block\"); this.immediate([0x40], \"empty block type\")\n    this.op(0x03, \"copy loop\"); this.immediate([0x40], \"empty block type\")\n    this.localGet(cursor); this.localGet(sourceLength); this.op(0x4f, \"compare copy cursor with length\")\n    this.op(0x0d, \"exit completed copy\"); this.immediate(u32(1), \"copy block depth\")\n    this.localGet(destination)\n    if (destinationOffset !== undefined) { this.localGet(destinationOffset); this.op(0x6a, \"add destination offset\") }\n    this.localGet(cursor); this.op(0x6a, \"add destination cursor\")\n    this.localGet(sourcePointer); this.localGet(cursor); this.op(0x6a, \"add source cursor\"); this.load8(); this.store8()\n    this.localGet(cursor); this.i32(1); this.op(0x6a, \"increment copy cursor\"); this.localSet(cursor)\n    this.op(0x0c, \"continue copy loop\"); this.immediate(u32(0), \"copy loop depth\")\n    this.op(0x0b, \"end copy loop\"); this.op(0x0b, \"end copy block\")\n  }\n  /**\n   * Ends one helper function.\n   * @returns {void}\n   */\n  end() { this.op(0x0b, \"function end\") }\n}\n\n/**\n * Collects deduplicated literal bytes and their combined semantic origins.\n * @param {SemanticModule} module - Semantic module.\n * @param {ReturnType<typeof createGenerationIndex>} index - Provenance index.\n * @returns {{boundary: number, byValue: Map<string, {address: number, bytes: Uint8Array}>, entries: {address: number, bytes: Uint8Array, origin: import(\"../semantic/types.js\").SemanticOrigin}[]}} Layout.\n */\nfunction collectLiteralLayout(module, index) {\n  /** @type {Map<string, {bytes: Uint8Array, occurrences: ReturnType<typeof index.recordFor>[]}>} */\n  const collected = new Map()\n\n  for (const {node, path} of semanticEntries(module)) {\n    if (node.kind != \"StringLiteral\") continue\n    const existing = collected.get(node.value)\n\n    if (existing) existing.occurrences.push(index.recordFor(node, path))\n    else collected.set(node.value, {bytes: encoder.encode(node.value), occurrences: [index.recordFor(node, path)]})\n  }\n\n  let address = 1\n  /** @type {Map<string, {address: number, bytes: Uint8Array}>} */\n  const byValue = new Map()\n  /** @type {{address: number, bytes: Uint8Array, origin: import(\"../semantic/types.js\").SemanticOrigin}[]} */\n  const entries = []\n\n  for (const [value, literal] of collected) {\n    const next = checkedSize(address + literal.bytes.byteLength, module, \"immutable literal memory layout\")\n    const exactOrigins = literal.occurrences.map((record) => originForRole(index, record, \"literal\"))\n    const origins = literal.occurrences.flatMap((record, offset) => relatedOrigins(record, exactOrigins[offset]))\n    const origin = literal.occurrences.length == 1 ? exactOrigins[0] : origins.length > 0\n      ? {kind: \"derived\", origins}\n      : {kind: \"synthetic\", reason: \"Deduplicated immutable UTF-8 literal data without source ranges.\", relatedOrigins: []}\n\n    entries.push({address, bytes: literal.bytes, origin: /** @type {import(\"../semantic/types.js\").SemanticOrigin} */ (origin)})\n    byValue.set(value, {address, bytes: literal.bytes})\n    address = next\n  }\n\n  return {boundary: address, byValue, entries}\n}\n\n/**\n * Performs bounded path-sensitive allocation analysis from run.\n * @param {SemanticModule} module - Validated module.\n * @returns {number} Worst reachable allocation bytes.\n */\nfunction analyzeScratchUse(module) {\n  const functions = new Map(module.functions.map((declaration) => [declaration.name, declaration]))\n  let steps = 0\n\n  const states = block(module.entryPoint.body, [{allocated: 0, env: new Map()}], 0)\n\n  return Math.max(0, ...states.map(({allocated}) => allocated))\n\n  /**\n   * Analyzes one block from every incoming path state.\n   * @param {import(\"../semantic/types.js\").Block} semanticBlock - Block to analyze.\n   * @param {AnalysisState[]} incoming - Incoming path states.\n   * @param {number} depth - Active semantic call depth.\n   * @returns {AnalysisState[]} Resulting path states.\n   */\n  function block(semanticBlock, incoming, depth) {\n    let states = incoming\n\n    for (const statement of semanticBlock.statements) {\n      const next = []\n\n      for (const state of states) {\n        if (state.returned) { next.push(state); continue }\n        if (statement.kind == \"LocalDeclaration\") {\n          for (const result of expression(statement.initializer, state, depth)) {\n            const env = new Map(result.state.env)\n\n            env.set(statement.name, result.value)\n            next.push({...result.state, env})\n          }\n        } else if (statement.kind == \"AssignmentStatement\") {\n          for (const result of expression(statement.expression, state, depth)) {\n            const env = new Map(result.state.env)\n\n            env.set(statement.target.name, result.value)\n            next.push({...result.state, env})\n          }\n        } else if (statement.kind == \"PrintStatement\") {\n          for (const result of expression(statement.expression, state, depth)) next.push(result.state)\n        } else if (statement.kind == \"ReturnStatement\") {\n          if (!statement.expression) throw new TypeError(\"Wasm bare return reached abstract execution.\")\n          for (const result of expression(statement.expression, state, depth)) next.push({...result.state, returned: result.value})\n        } else if (statement.kind == \"ExpressionStatement\") {\n          throw new TypeError(\"Wasm Task 005 expression statement reached abstract execution.\")\n        } else if (statement.kind == \"IfStatement\") {\n          for (const condition of expression(statement.condition, state, depth)) {\n            if (condition.value.knownBoolean !== false) {\n              next.push(...withoutBranchLocals(block(statement.consequent, [cloneState(condition.state)], depth), condition.state.env))\n            }\n            if (condition.value.knownBoolean !== true) {\n              const alternate = statement.alternate\n                ? block(statement.alternate, [cloneState(condition.state)], depth)\n                : [cloneState(condition.state)]\n\n              next.push(...withoutBranchLocals(alternate, condition.state.env))\n            }\n          }\n        } else {\n          throw new TypeError(\"Unsupported Wasm statement reached abstract execution.\")\n        }\n      }\n      states = boundedStates(next, statement)\n    }\n\n    return states\n  }\n\n  /**\n   * Evaluates abstract values and allocation demand for one expression.\n   * @param {Expression} value - Expression to analyze.\n   * @param {AnalysisState} state - Incoming path state.\n   * @param {number} depth - Active semantic call depth.\n   * @returns {{state: AnalysisState, value: AbstractValue}[]} Possible outcomes.\n   */\n  function expression(value, state, depth) {\n    steps += 1\n    if (steps > maximumAnalysisSteps) unsupportedCapability(\"wasm\", \"unprovable path-sensitive scratch allocation bound\", value.location)\n\n    if (value.kind == \"IdentifierExpression\") {\n      const found = state.env.get(value.name)\n\n      if (!found) throw new Error(\"Validated Wasm analysis omitted an identifier binding.\")\n\n      return [{state, value: found}]\n    }\n    if (value.kind == \"IntegerLiteral\") return [{state, value: {knownInteger: BigInt(value.value), type: \"integer\"}}]\n    if (value.kind == \"BooleanLiteral\") return [{state, value: {knownBoolean: value.value, type: \"boolean\"}}]\n    if (value.kind == \"StringLiteral\") {\n      return [{state, value: {knownString: value.value, stringLength: encoder.encode(value.value).byteLength, type: \"string\"}}]\n    }\n    if (value.kind == \"CallExpression\") {\n      let argumentsList = [{state, values: /** @type {AbstractValue[]} */ ([])}]\n\n      for (const argument of value.arguments) {\n        const next = []\n\n        for (const current of argumentsList) {\n          for (const result of expression(argument, current.state, depth)) {\n            next.push({state: result.state, values: [...current.values, result.value]})\n          }\n        }\n        argumentsList = next\n      }\n      const declaration = functions.get(value.callee)\n\n      if (!declaration) throw new Error(\"Validated Wasm analysis omitted a call declaration.\")\n      if (depth >= maximumCallDepth) unsupportedCapability(\"wasm\", `semantic call depth above ${maximumCallDepth}`, value.location)\n      /** @type {{state: AnalysisState, value: AbstractValue}[]} */\n      const outcomes = []\n\n      for (const argumentSet of argumentsList) {\n        const env = new Map(declaration.parameters.map((parameter, index) => [parameter.name, argumentSet.values[index]]))\n        const called = block(declaration.body, [{allocated: 0, env}], depth + 1)\n\n        for (const returned of called) {\n          if (!returned.returned) throw new Error(\"Validated Wasm function analysis omitted a return value.\")\n          outcomes.push({\n            state: {...argumentSet.state, allocated: addAllocation(argumentSet.state.allocated, returned.allocated, value)},\n            value: returned.returned\n          })\n        }\n      }\n\n      return outcomes\n    }\n    if (value.kind == \"UnaryExpression\") {\n      return expression(value.operand, state, depth).map((operand) => {\n        if (value.operation == \"BooleanNot\") {\n          return {state: operand.state, value: {type: \"boolean\", ...(operand.value.knownBoolean === undefined ? {} : {knownBoolean: !operand.value.knownBoolean})}}\n        }\n        const knownInteger = operand.value.knownInteger === undefined ? undefined : checkedI64(-operand.value.knownInteger, value)\n\n        return {state: operand.state, value: {type: \"integer\", ...(knownInteger === undefined ? {} : {knownInteger})}}\n      })\n    }\n    if (value.kind != \"BinaryExpression\") {\n      return unsupportedCapability(\"wasm\", \"collection expression reached scalar analysis\", value.location)\n    }\n    if (value.operation == \"BooleanAnd\" || value.operation == \"BooleanOr\") {\n      /** @type {{state: AnalysisState, value: AbstractValue}[]} */\n      const outcomes = []\n\n      for (const left of expression(value.left, state, depth)) {\n        const shortCircuits = value.operation == \"BooleanAnd\" ? left.value.knownBoolean === false : left.value.knownBoolean === true\n        const mustEvaluate = value.operation == \"BooleanAnd\" ? left.value.knownBoolean === true : left.value.knownBoolean === false\n\n        if (shortCircuits || !mustEvaluate) outcomes.push({state: left.state, value: {knownBoolean: value.operation == \"BooleanOr\", type: \"boolean\"}})\n        if (!shortCircuits) outcomes.push(...expression(value.right, cloneState(left.state), depth))\n      }\n\n      return outcomes\n    }\n\n    const outcomes = []\n\n    for (const left of expression(value.left, state, depth)) {\n      for (const right of expression(value.right, left.state, depth)) {\n        outcomes.push(binary(value, left.value, right.value, right.state))\n      }\n    }\n\n    return outcomes\n  }\n\n  /**\n   * Combines abstract operands for one binary operation.\n   * @param {import(\"../semantic/types.js\").BinaryExpression} expressionNode - Binary expression.\n   * @param {AbstractValue} left - Abstract left operand.\n   * @param {AbstractValue} right - Abstract right operand.\n   * @param {AnalysisState} state - State after evaluating both operands.\n   * @returns {{state: AnalysisState, value: AbstractValue}} Combined outcome.\n   */\n  function binary(expressionNode, left, right, state) {\n    const operation = expressionNode.operation\n\n    if (operation == \"StringConcat\") {\n      if (left.stringLength === undefined || right.stringLength === undefined) {\n        unsupportedCapability(\"wasm\", \"unprovable StringConcat byte length\", expressionNode.location)\n      }\n      const length = addAllocation(left.stringLength, right.stringLength, expressionNode)\n      const allocated = addAllocation(state.allocated, length, expressionNode)\n      const knownString = left.knownString !== undefined && right.knownString !== undefined ? left.knownString + right.knownString : undefined\n\n      return {state: {...state, allocated}, value: {type: \"string\", stringLength: length, ...(knownString === undefined ? {} : {knownString})}}\n    }\n    if ([\"IntegerAdd\", \"IntegerSubtract\", \"IntegerMultiply\"].includes(operation)) {\n      let knownInteger\n\n      if (left.knownInteger !== undefined && right.knownInteger !== undefined) {\n        knownInteger = operation == \"IntegerAdd\" ? left.knownInteger + right.knownInteger :\n          operation == \"IntegerSubtract\" ? left.knownInteger - right.knownInteger : left.knownInteger * right.knownInteger\n        knownInteger = checkedI64(knownInteger, expressionNode)\n      }\n\n      return {state, value: {type: \"integer\", ...(knownInteger === undefined ? {} : {knownInteger})}}\n    }\n    if (operation.startsWith(\"Integer\") && operation != \"IntegerEqual\" && operation != \"IntegerNotEqual\") {\n      return {state, value: {knownBoolean: compareKnown(operation, left.knownInteger, right.knownInteger), type: \"boolean\"}}\n    }\n    if (operation == \"IntegerEqual\" || operation == \"IntegerNotEqual\") {\n      return {state, value: {knownBoolean: equalKnown(left.knownInteger, right.knownInteger, operation.endsWith(\"NotEqual\")), type: \"boolean\"}}\n    }\n    if (operation == \"BooleanEqual\" || operation == \"BooleanNotEqual\") {\n      return {state, value: {knownBoolean: equalKnown(left.knownBoolean, right.knownBoolean, operation.endsWith(\"NotEqual\")), type: \"boolean\"}}\n    }\n\n    return {state, value: {knownBoolean: equalKnown(left.knownString, right.knownString, operation == \"StringNotEqual\"), type: \"boolean\"}}\n  }\n\n  /**\n   * Rejects path-state growth beyond the deterministic analysis bound.\n   * @param {AnalysisState[]} candidates - Candidate states.\n   * @param {{location: import(\"../semantic/types.js\").SourceLocation}} node - Related semantic node.\n   * @returns {AnalysisState[]} Accepted states.\n   */\n  function boundedStates(candidates, node) {\n    if (candidates.length > maximumAnalysisSteps) unsupportedCapability(\"wasm\", \"unprovable path-sensitive scratch allocation state count\", node.location)\n\n    return candidates\n  }\n}\n\n/**\n * Compares two known integer operands when available.\n * @param {string} operation - Semantic comparison operation.\n * @param {bigint | undefined} left - Known left operand.\n * @param {bigint | undefined} right - Known right operand.\n * @returns {boolean | undefined} Known comparison result.\n */\nfunction compareKnown(operation, left, right) {\n  if (left === undefined || right === undefined) return undefined\n  if (operation == \"IntegerLessThan\") return left < right\n  if (operation == \"IntegerLessThanOrEqual\") return left <= right\n  if (operation == \"IntegerGreaterThan\") return left > right\n\n  return left >= right\n}\n\n/**\n * Compares two known same-type operands when available.\n * @template T\n * @param {T | undefined} left - Known left operand.\n * @param {T | undefined} right - Known right operand.\n * @param {boolean} invert - Whether to invert equality.\n * @returns {boolean | undefined} Known equality result.\n */\nfunction equalKnown(left, right, invert) {\n  return left === undefined || right === undefined ? undefined : invert ? left !== right : left === right\n}\n\n/**\n * Checks one compile-time integer against signed i64 bounds.\n * @param {bigint} value - Candidate integer.\n * @param {{location: import(\"../semantic/types.js\").SourceLocation}} node - Related semantic node.\n * @returns {bigint} Checked integer.\n */\nfunction checkedI64(value, node) {\n  if (value < -9223372036854775808n || value > 9223372036854775807n) {\n    unsupportedCapability(\"wasm\", \"compile-time-known signed i64 overflow\", node.location)\n  }\n\n  return value\n}\n\n/**\n * Adds bounded allocation counts without approximation.\n * @param {number} left - Existing allocation count.\n * @param {number} right - Additional allocation count.\n * @param {{location: import(\"../semantic/types.js\").SourceLocation}} node - Related semantic node.\n * @returns {number} Checked total.\n */\nfunction addAllocation(left, right, node) {\n  const total = left + right\n\n  if (!Number.isSafeInteger(total) || total < 0) unsupportedCapability(\"wasm\", \"scratch allocation arithmetic overflow\", node.location)\n  if (total > scratchCapacity) unsupportedCapability(\"wasm\", `scratch allocation above ${scratchCapacity} bytes`, node.location)\n\n  return total\n}\n\n/**\n * Clones one path state and its lexical environment.\n * @param {AnalysisState} state - State to clone.\n * @returns {AnalysisState} Detached state.\n */\nfunction cloneState(state) { return {...state, env: new Map(state.env)} }\n\n/**\n * Removes bindings declared only inside a branch.\n * @param {AnalysisState[]} states - Branch result states.\n * @param {Map<string, AbstractValue>} parent - Parent lexical environment.\n * @returns {AnalysisState[]} States restricted to parent bindings.\n */\nfunction withoutBranchLocals(states, parent) {\n  return states.map((state) => {\n    const env = new Map([...state.env].filter(([name]) => parent.has(name)))\n\n    return {...state, env}\n  })\n}\n\n/**\n * Resolves one expression's semantic scalar type.\n * @param {Expression} expression - Expression to inspect.\n * @param {Map<string, LocalBinding>} bindings - Lexical local bindings.\n * @param {Map<string, import(\"../semantic/types.js\").FunctionDeclaration>} functions - Semantic declarations by name.\n * @returns {Scalar} Expression type.\n */\nfunction expressionType(expression, bindings, functions) {\n  if (expression.kind == \"IntegerLiteral\") return \"integer\"\n  if (expression.kind == \"BooleanLiteral\") return \"boolean\"\n  if (expression.kind == \"StringLiteral\") return \"string\"\n  if (expression.kind == \"UnaryExpression\" || expression.kind == \"BinaryExpression\") return expression.type\n  if (expression.kind == \"CallExpression\") {\n    const declaration = functions.get(expression.callee)\n\n    if (!declaration) throw new Error(\"Validated Wasm expression omitted its call declaration.\")\n\n    return wasmReturnType(declaration)\n  }\n  if (expression.kind != \"IdentifierExpression\") {\n    return unsupportedCapability(\"wasm\", \"collection expression reached scalar type inference\", expression.location)\n  }\n  const binding = bindings.get(expression.name)\n\n  if (!binding) throw new Error(\"Validated Wasm expression omitted its local binding.\")\n\n  return binding.type\n}\n\n/**\n * Narrows a declaration return after the Wasm Task 005 capability preflight.\n * @param {import(\"../semantic/types.js\").FunctionDeclaration} declaration - Validated declaration.\n * @returns {Scalar} Supported Wasm scalar return.\n */\nfunction wasmReturnType(declaration) {\n  if (declaration.returnType.kind != \"TypeReference\" || declaration.returnType.name == \"void\") {\n    return unsupportedCapability(\"wasm\", \"Task 005 void function return\", declaration.location)\n  }\n\n  return declaration.returnType.name\n}\n\n/**\n * Narrows one scalar after Wasm collection capability rejection.\n * @param {import(\"../semantic/types.js\").SemanticValueType} type - Semantic value type.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Owning location.\n * @returns {Scalar} Scalar type.\n */\nfunction wasmScalarType(type, location) {\n  if (type.kind != \"TypeReference\") return unsupportedCapability(\"wasm\", \"Task 006 immutable collection type\", location)\n\n  return type.name\n}\n\n/**\n * Flattens one semantic scalar into Wasm value types.\n * @param {Scalar} type - Semantic scalar type.\n * @returns {(\"i32\" | \"i64\")[]} Wasm value types.\n */\nfunction wasmTypes(type) { return type == \"integer\" ? [\"i64\"] : type == \"boolean\" ? [\"i32\"] : [\"i32\", \"i32\"] }\n\n/**\n * Aligns an unsigned size upward.\n * @param {number} value - Unaligned value.\n * @param {number} alignment - Required alignment.\n * @returns {number} Aligned value.\n */\nfunction align(value, alignment) { return Math.ceil(value / alignment) * alignment }\n\n/**\n * Checks a computed module size against the portable u32 domain.\n * @param {number} value - Candidate size.\n * @param {{location: import(\"../semantic/types.js\").SourceLocation}} node - Related semantic node.\n * @param {string} capability - Failure capability description.\n * @returns {number} Checked size.\n */\nfunction checkedSize(value, node, capability) {\n  if (!Number.isSafeInteger(value) || value < 0 || value > 0xffffffff) unsupportedCapability(\"wasm\", capability, node.location)\n\n  return value\n}\n\n/**\n * Encodes an unsigned u32 LEB128 value.\n * @param {number} value - Unsigned value.\n * @returns {number[]} Encoded bytes.\n */\nfunction u32(value) {\n  if (!Number.isSafeInteger(value) || value < 0 || value > 0xffffffff) throw new RangeError(\"Unsigned WebAssembly integer is outside u32.\")\n  const bytes = []\n  let remaining = value\n\n  do {\n    let byte = remaining % 128\n\n    remaining = Math.floor(remaining / 128)\n    if (remaining != 0) byte |= 0x80\n    bytes.push(byte)\n  } while (remaining != 0)\n\n  return bytes\n}\n\n/**\n * Encodes a signed i32 LEB128 value.\n * @param {number} value - Signed value.\n * @returns {number[]} Encoded bytes.\n */\nfunction s32(value) { return s64(BigInt(value)) }\n\n/**\n * Encodes a signed i64 LEB128 value.\n * @param {bigint} value - Signed value.\n * @returns {number[]} Encoded bytes.\n */\nfunction s64(value) {\n  const bytes = []\n  let remaining = value\n  let done = false\n\n  while (!done) {\n    let byte = Number(remaining & 0x7fn)\n\n    remaining >>= 7n\n    const signSet = (byte & 0x40) != 0\n\n    done = remaining == 0n && !signSet || remaining == -1n && signSet\n    if (!done) byte |= 0x80\n    bytes.push(byte)\n  }\n\n  return bytes\n}\n\n/**\n * Encodes a length-prefixed UTF-8 Wasm name.\n * @param {string} value - Name value.\n * @returns {number[]} Encoded bytes.\n */\nfunction nameBytes(value) {\n  const bytes = encoder.encode(value)\n\n  return [...u32(bytes.byteLength), ...bytes]\n}\n\n/**\n * Extracts contextual related origins from one semantic record.\n * @param {SemanticNodeProvenance} record - Semantic provenance record.\n * @param {import(\"../semantic/types.js\").SemanticOrigin} [origin] - Optional exact semantic origin.\n * @returns {import(\"../semantic/types.js\").RelatedOrigin[]} Related origins.\n */\nfunction relatedOrigins(record, origin = record.origin) {\n  if (origin.kind == \"source\") {\n    return [{location: origin.location, nodeId: record.id, role: \"related semantic occurrence\", sourceId: origin.sourceId,\n      ...(record.symbolId ? {symbolId: record.symbolId} : {})}]\n  }\n  const origins = origin.kind == \"derived\" ? origin.origins : origin.relatedOrigins\n\n  return origins.map((origin) => ({...origin, nodeId: origin.nodeId ?? record.id, role: origin.role ?? \"related semantic occurrence\",\n    ...(record.symbolId && !origin.symbolId ? {symbolId: record.symbolId} : {})}))\n}\n\n/**\n * Resolves a parser-owned token role to its canonical source identity.\n * @param {ReturnType<typeof createGenerationIndex>} index - Canonical provenance index.\n * @param {SemanticNodeProvenance} record - Semantic occurrence record.\n * @param {string} role - Parser-owned token role.\n * @returns {import(\"../semantic/types.js\").SemanticOrigin} Exact role origin, or the occurrence origin when unavailable.\n */\nfunction originForRole(index, record, role) {\n  const location = record.ranges[role]\n\n  if (!location) return record.origin\n  /** @type {string | undefined} */\n  let fallbackSourceId\n\n  if (record.origin.kind == \"source\" && record.origin.location.filename == location.filename) fallbackSourceId = record.origin.sourceId\n  else if (record.origin.kind == \"derived\") {\n    fallbackSourceId = record.origin.origins.find((origin) => origin.location.filename == location.filename)?.sourceId\n  } else if (record.origin.kind == \"synthetic\") {\n    fallbackSourceId = record.origin.relatedOrigins.find((origin) => origin.location.filename == location.filename)?.sourceId\n  }\n  const source = index.provenance.sources.find((candidate) => candidate.id == fallbackSourceId) ??\n    index.provenance.sources.find((candidate) => candidate.filename == location.filename)\n\n  return source ? {kind: \"source\", location, sourceId: source.id} : record.origin\n}\n\n/**\n * Projects byte provenance to the Wasm Source Map v3 convention.\n * @param {import(\"../semantic/types.js\").SemantifoldByteMapping} mapping - Authoritative byte mapping.\n * @param {import(\"../semantic/types.js\").SemanticProvenance} provenance - Source registry.\n * @returns {import(\"@jridgewell/gen-mapping\").EncodedSourceMap} Source Map v3 projection.\n */\nfunction createWasmSourceMap(mapping, provenance) {\n  const generated = new GenMapping({file: mapping.generated.path})\n  const sourcesById = new Map(provenance.sources.map((source) => [source.id, source]))\n  const symbolsById = new Map(provenance.symbols.map((symbol) => [symbol.id, symbol]))\n\n  for (const source of provenance.sources) setSourceContent(generated, source.filename, source.content)\n  for (const range of mapping.ranges) {\n    const location = primaryLocation(range.origin)\n\n    if (!location || range.origin.kind == \"synthetic\") {\n      maybeAddSegment(generated, 0, range.generated.start)\n      continue\n    }\n    const sourceId = range.origin.kind == \"source\" ? range.origin.sourceId : range.origin.origins[0]?.sourceId\n    const source = sourceId ? sourcesById.get(sourceId) : undefined\n\n    if (!source) throw new Error(\"Validated Wasm byte origin omitted its registered source.\")\n    if (range.symbolId === undefined) {\n      addSegment(generated, 0, range.generated.start, source.filename, location.start.line - 1, location.start.column - 1,\n        null, source.content)\n    } else {\n      const symbol = symbolsById.get(range.symbolId)\n\n      if (!symbol) throw new Error(\"Validated Wasm byte range omitted its semantic symbol.\")\n      addSegment(generated, 0, range.generated.start, source.filename, location.start.line - 1, location.start.column - 1,\n        symbol.name, source.content)\n    }\n  }\n\n  return toEncodedMap(generated)\n}\n\n/**\n * Creates one mapped generated text artifact.\n * @param {string} content - Complete artifact content.\n * @param {string} path - Artifact path.\n * @param {import(\"../semantic/types.js\").GeneratedTextLanguage} language - Generated text syntax.\n * @param {import(\"../semantic/types.js\").GeneratedArtifactRole} role - Artifact role.\n * @param {SemanticModule} module - Source semantic module.\n * @param {{filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[] | undefined} sources - Source overrides.\n * @param {string} reason - Synthetic mapping reason.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Generated artifact.\n */\nfunction textArtifact(content, path, language, role, module, sources, reason) {\n  const writer = new SourceWriter({filename: path, language, module, sources})\n\n  writer.synthetic(content, reason, [module], [\"\"])\n  const mapping = finalizeMapping(writer.finish())\n\n  return {\n    content,\n    contentKind: \"text\",\n    mediaType: path.endsWith(\".html\") ? \"text/html\" : \"text/javascript\",\n    ownership: \"generated\",\n    path,\n    provenance: {kind: \"text\", mapping, sourceMap: toSourceMapV3(mapping)},\n    role\n  }\n}\n\nconst semantifoldLoader = `const expectedImports = [\n  [\"semantifold\", \"print_i64\", [\"i64\"], []],\n  [\"semantifold\", \"print_bool\", [\"i32\"], []],\n  [\"semantifold\", \"print_string\", [\"i32\", \"i32\"], []]\n]\n\nexport class SemantifoldBrowserError extends Error {\n  constructor(stage, message, cause) {\n    super(message, cause instanceof Error ? {cause} : undefined)\n    this.name = \"SemantifoldBrowserError\"\n    this.stage = stage\n  }\n}\n\nexport async function loadSemantifold(url, {fetch: fetchImplementation = globalThis.fetch, sink, timeoutMs = 10000} = {}) {\n  if (typeof fetchImplementation != \"function\") throw new TypeError(\"A fetch implementation is required.\")\n  if (typeof sink != \"function\") throw new TypeError(\"A text sink function is required.\")\n  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {\n    throw new TypeError(\"timeoutMs must be an integer from 1 through 2147483647.\")\n  }\n  const controller = new AbortController()\n  let timedOut = false\n  let timeout\n  const deadline = new Promise((resolve, reject) => {\n    const timeoutCause = new Error(\"Semantifold browser load timed out.\")\n\n    timeout = setTimeout(() => {\n      timedOut = true\n      controller.abort(timeoutCause)\n      reject(new SemantifoldBrowserError(\"timeout\", \"Wasm loading timed out.\", timeoutCause))\n    }, timeoutMs)\n  })\n  const beforeDeadline = (operation) => Promise.race([operation, deadline])\n  const timeoutFailure = (cause) => new SemantifoldBrowserError(\"timeout\", \"Wasm loading timed out.\",\n    cause instanceof Error ? cause : controller.signal.reason)\n  const bodyFailure = (cause) => {\n    if (cause instanceof SemantifoldBrowserError) return cause\n    if (timedOut) return timeoutFailure(cause)\n    return new SemantifoldBrowserError(\"fetch/MIME\", \"Wasm response body could not be read.\", cause)\n  }\n  const instantiationFailure = (cause) => {\n    if (cause instanceof SemantifoldBrowserError) return cause\n    if (timedOut) return timeoutFailure(cause)\n    const stage = cause instanceof WebAssembly.CompileError ? \"compile\" : \"instantiate/import\"\n\n    return new SemantifoldBrowserError(stage, \\`Wasm \\${stage} failed.\\`, cause)\n  }\n  const readBody = async (body) => {\n    try {\n      return new Uint8Array(await beforeDeadline(body.arrayBuffer()))\n    } catch (cause) {\n      throw bodyFailure(cause)\n    }\n  }\n  const instantiate = async (operation) => {\n    try {\n      return await beforeDeadline(operation())\n    } catch (cause) {\n      throw instantiationFailure(cause)\n    }\n  }\n  let response\n\n  try {\n    response = await beforeDeadline(Promise.resolve().then(() =>\n      fetchImplementation(url, {credentials: \"same-origin\", redirect: \"error\", signal: controller.signal})))\n  } catch (cause) {\n    clearTimeout(timeout)\n    if (cause instanceof SemantifoldBrowserError) throw cause\n    const stage = timedOut ? \"timeout\" : \"fetch/MIME\"\n    throw new SemantifoldBrowserError(stage, stage == \"timeout\" ? \"Wasm loading timed out.\" : \"Wasm fetch failed.\", cause)\n  }\n  if (!response.ok) {\n    clearTimeout(timeout)\n    throw new SemantifoldBrowserError(\"fetch/MIME\", \\`Wasm fetch returned HTTP \\${response.status}.\\`)\n  }\n  const mediaType = response.headers.get(\"content-type\")?.split(\";\", 1)[0].trim().toLowerCase()\n\n  if (mediaType != \"application/wasm\") {\n    clearTimeout(timeout)\n    throw new SemantifoldBrowserError(\"fetch/MIME\", \"Wasm response requires application/wasm.\")\n  }\n\n  let instance\n  let module\n  const decoder = new TextDecoder(\"utf-8\", {fatal: true, ignoreBOM: true})\n  let memory\n  let abiApproved = false\n  const requireApprovedAbi = () => {\n    if (!abiApproved) throw new SemantifoldBrowserError(\"instantiate/import\", \"Wasm host imports are locked until ABI inspection succeeds.\")\n  }\n  const append = (text) => sink(\\`\\${text}\\\\n\\`)\n  const imports = {semantifold: {\n    print_i64(value) {\n      requireApprovedAbi()\n      if (typeof value != \"bigint\") throw new TypeError(\"print_i64 requires bigint.\")\n      append(value.toString(10))\n    },\n    print_bool(value) {\n      requireApprovedAbi()\n      if (value !== 0 && value !== 1) throw new TypeError(\"print_bool requires canonical 0 or 1.\")\n      append(value === 1 ? \"true\" : \"false\")\n    },\n    print_string(pointer, length) {\n      requireApprovedAbi()\n      if (!memory || !Number.isInteger(pointer) || pointer < 0 || !Number.isInteger(length) || length < 0) {\n        const cause = new TypeError(\"print_string requires a non-negative integer pointer and length.\")\n\n        throw new SemantifoldBrowserError(\"memory bounds/UTF-8\", cause.message, cause)\n      }\n      const end = pointer + length\n\n      if (!Number.isSafeInteger(end) || end < pointer || end > memory.buffer.byteLength) {\n        const cause = new RangeError(\"print_string range is outside exported memory.\")\n\n        throw new SemantifoldBrowserError(\"memory bounds/UTF-8\", cause.message, cause)\n      }\n      let text\n\n      try {\n        text = decoder.decode(new Uint8Array(memory.buffer, pointer, length))\n      } catch (cause) {\n        throw new SemantifoldBrowserError(\"memory bounds/UTF-8\", \"print_string bytes are not valid UTF-8.\", cause)\n      }\n      append(text)\n    }\n  }}\n\n  let result\n\n  try {\n    if (typeof WebAssembly.instantiateStreaming == \"function\") {\n      let body\n\n      try {\n        body = response.clone()\n      } catch (cause) {\n        throw bodyFailure(cause)\n      }\n      const pending = instantiate(() => WebAssembly.instantiateStreaming(response, imports))\n        .then((value) => ({value}), (error) => ({error}))\n      const bytes = await readBody(body)\n\n      inspectAbi(bytes)\n      abiApproved = true\n      const settled = await pending\n\n      if (\"error\" in settled) throw settled.error\n      result = settled.value\n    } else {\n      const bytes = await readBody(response)\n\n      inspectAbi(bytes)\n      abiApproved = true\n      result = await instantiate(() => WebAssembly.instantiate(bytes, imports))\n    }\n  } catch (error) {\n    clearTimeout(timeout)\n    throw error\n  }\n  clearTimeout(timeout)\n  instance = result.instance\n  module = result.module\n  validateModuleShape(module, instance)\n  memory = instance.exports.memory\n  let active = false\n  let poisoned = false\n\n  return Object.freeze({\n    memory,\n    run() {\n      if (poisoned) throw new SemantifoldBrowserError(\"invocation/trap\", \"Wasm instance is poisoned after a trap.\")\n      if (active) throw new SemantifoldBrowserError(\"invocation/trap\", \"Reentrant run invocation is forbidden.\")\n      active = true\n      try {\n        instance.exports.run()\n      } catch (cause) {\n        poisoned = true\n        if (cause instanceof SemantifoldBrowserError) throw cause\n        throw new SemantifoldBrowserError(\"invocation/trap\", \"Wasm run trapped.\", cause)\n      } finally {\n        active = false\n      }\n    }\n  })\n}\n\nfunction validateModuleShape(module, instance) {\n  const imports = WebAssembly.Module.imports(module)\n  const exports = WebAssembly.Module.exports(module)\n\n  if (JSON.stringify(imports.map(({kind, module, name}) => [module, name, kind])) !=\n    JSON.stringify(expectedImports.map(([module, name]) => [module, name, \"function\"]))) {\n    throw new SemantifoldBrowserError(\"instantiate/import\", \"Wasm imports do not match semantifold.browser.v1.\")\n  }\n  if (JSON.stringify(exports.map(({kind, name}) => [name, kind])) != JSON.stringify([[\"memory\", \"memory\"], [\"run\", \"function\"]]) ||\n    !(instance.exports.memory instanceof WebAssembly.Memory) || typeof instance.exports.run != \"function\" || instance.exports.run.length != 0) {\n    throw new SemantifoldBrowserError(\"instantiate/import\", \"Wasm exports do not match semantifold.browser.v1.\")\n  }\n}\n\nfunction inspectAbi(bytes) {\n  try {\n    let offset = 8\n    const types = []\n    const importedTypes = []\n    const definedTypes = []\n    const exports = []\n    const memories = []\n\n    if (bytes.length < 8 || bytes[0] != 0 || bytes[1] != 97 || bytes[2] != 115 || bytes[3] != 109 || bytes[4] != 1 ||\n      bytes[5] != 0 || bytes[6] != 0 || bytes[7] != 0) throw new WebAssembly.CompileError(\"Invalid Wasm header.\")\n    while (offset < bytes.length) {\n      const id = bytes[offset++]\n      const sizeValue = readU32(bytes, offset)\n      offset = sizeValue.next\n      const end = offset + sizeValue.value\n\n      if (end > bytes.length) throw new WebAssembly.CompileError(\"Truncated Wasm section.\")\n      if (id == 1) {\n        const count = readU32(bytes, offset); offset = count.next\n        for (let index = 0; index < count.value; index += 1) {\n          if (bytes[offset++] != 0x60) throw new WebAssembly.CompileError(\"Invalid function type.\")\n          const parameters = readTypes(bytes, offset); offset = parameters.next\n          const results = readTypes(bytes, offset); offset = results.next\n          types.push([parameters.values, results.values])\n        }\n      } else if (id == 2) {\n        const count = readU32(bytes, offset); offset = count.next\n        for (let index = 0; index < count.value; index += 1) {\n          const moduleName = readName(bytes, offset); offset = moduleName.next\n          const fieldName = readName(bytes, offset); offset = fieldName.next\n          if (bytes[offset++] != 0) throw new SemantifoldBrowserError(\"instantiate/import\", \"Only function imports are allowed.\")\n          const type = readU32(bytes, offset); offset = type.next\n          importedTypes.push([moduleName.value, fieldName.value, type.value])\n        }\n      } else if (id == 3) {\n        const count = readU32(bytes, offset); offset = count.next\n        for (let index = 0; index < count.value; index += 1) {\n          const type = readU32(bytes, offset); offset = type.next; definedTypes.push(type.value)\n        }\n      } else if (id == 5) {\n        const count = readU32(bytes, offset); offset = count.next\n        for (let index = 0; index < count.value; index += 1) {\n          const flags = bytes[offset++]\n          const minimum = readU32(bytes, offset); offset = minimum.next\n          let maximum\n          if ((flags & 1) != 0) { maximum = readU32(bytes, offset); offset = maximum.next }\n          memories.push([flags, minimum.value, maximum?.value])\n        }\n      } else if (id == 7) {\n        const count = readU32(bytes, offset); offset = count.next\n        for (let index = 0; index < count.value; index += 1) {\n          const name = readName(bytes, offset); offset = name.next\n          const kind = bytes[offset++]\n          const target = readU32(bytes, offset); offset = target.next\n          exports.push([name.value, kind, target.value])\n        }\n      } else if (id == 8) throw new SemantifoldBrowserError(\"instantiate/import\", \"A Wasm start section is forbidden.\")\n      offset = end\n    }\n    if (importedTypes.length != expectedImports.length) throw new SemantifoldBrowserError(\"instantiate/import\", \"Unexpected Wasm import count.\")\n    for (let index = 0; index < expectedImports.length; index += 1) {\n      const expected = expectedImports[index]\n      const actual = importedTypes[index]\n      const type = types[actual?.[2]]\n\n      if (!actual || actual[0] != expected[0] || actual[1] != expected[1] || !type ||\n        JSON.stringify(type) != JSON.stringify([expected[2], expected[3]])) {\n        throw new SemantifoldBrowserError(\"instantiate/import\", \"Wasm import signature does not match semantifold.browser.v1.\")\n      }\n    }\n    if (memories.length != 1 || memories[0][0] != 1 || memories[0][1] != memories[0][2]) {\n      throw new SemantifoldBrowserError(\"instantiate/import\", \"Wasm memory must have equal fixed initial and maximum limits.\")\n    }\n    if (exports.length != 2 || exports[0][0] != \"memory\" || exports[0][1] != 2 || exports[0][2] != 0 ||\n      exports[1][0] != \"run\" || exports[1][1] != 0) {\n      throw new SemantifoldBrowserError(\"instantiate/import\", \"Wasm exports do not match semantifold.browser.v1.\")\n    }\n    const runType = types[definedTypes[exports[1][2] - importedTypes.length]]\n\n    if (!runType || runType[0].length != 0 || runType[1].length != 0) {\n      throw new SemantifoldBrowserError(\"instantiate/import\", \"Wasm run signature does not match semantifold.browser.v1.\")\n    }\n  } catch (cause) {\n    if (cause instanceof SemantifoldBrowserError) throw cause\n    throw new SemantifoldBrowserError(\"compile\", \"Wasm binary inspection failed.\", cause)\n  }\n}\n\nfunction readTypes(bytes, offset) {\n  const count = readU32(bytes, offset); offset = count.next; const values = []\n  for (let index = 0; index < count.value; index += 1) {\n    const type = bytes[offset++]\n    if (type == 0x7f) values.push(\"i32\")\n    else if (type == 0x7e) values.push(\"i64\")\n    else if (type == 0x7d) values.push(\"f32\")\n    else if (type == 0x7c) values.push(\"f64\")\n    else if (type == 0x7b) values.push(\"v128\")\n    else if (type == 0x70) values.push(\"funcref\")\n    else if (type == 0x6f) values.push(\"externref\")\n    else throw new WebAssembly.CompileError(\"Unsupported ABI value type.\")\n  }\n  return {next: offset, values}\n}\n\nfunction readName(bytes, offset) {\n  const length = readU32(bytes, offset); const end = length.next + length.value\n  if (end > bytes.length) throw new WebAssembly.CompileError(\"Truncated Wasm name.\")\n  return {next: end, value: new TextDecoder(\"utf-8\", {fatal: true}).decode(bytes.subarray(length.next, end))}\n}\n\nfunction readU32(bytes, offset) {\n  let value = 0\n  let shift = 0\n  for (let index = 0; index < 5; index += 1) {\n    if (offset >= bytes.length) throw new WebAssembly.CompileError(\"Truncated unsigned LEB128.\")\n    const byte = bytes[offset++]\n    value += (byte & 0x7f) * 2 ** shift\n    if ((byte & 0x80) == 0) return {next: offset, value}\n    shift += 7\n  }\n  throw new WebAssembly.CompileError(\"Oversized unsigned LEB128.\")\n}\n\nasync function runBrowserHarness() {\n  const output = document.querySelector(\"#output\")\n\n  try {\n    const program = await loadSemantifold(\"./program.wasm\", {sink: (line) => { output.textContent += line }})\n    program.run()\n    document.documentElement.dataset.semantifoldOutput = [...new TextEncoder().encode(output.textContent)]\n      .map((byte) => byte.toString(16).padStart(2, \"0\")).join(\"\")\n    document.documentElement.dataset.semantifold = \"pass\"\n    console.log(\"SEMANTIFOLD_BROWSER_OK\")\n  } catch (error) {\n    document.documentElement.dataset.semantifold = \"fail\"\n    output.textContent += \\`ERROR[\\${error.stage ?? \"unknown\"}]: \\${error.message}\\\\n\\`\n    console.error(\"SEMANTIFOLD_BROWSER_FAILED\", error)\n  }\n}\n\nif (typeof document != \"undefined\" && document.documentElement.dataset.semantifold == \"pending\") void runBrowserHarness()\n`\n\nconst browserHarness = `<!doctype html>\n<html lang=\"en\" data-semantifold=\"pending\">\n<meta charset=\"utf-8\">\n<meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; script-src 'self' 'wasm-unsafe-eval'; connect-src 'self'; base-uri 'none'; form-action 'none'\">\n<title>Semantifold Browser Wasm</title>\n<pre id=\"output\"></pre>\n<script type=\"module\" src=\"./semantifold-loader.mjs\"></script>\n</html>\n`\n"]}