semantifold 0.4.0 → 0.6.0

package/build/src/backends/zig.js

@@ -0,0 +1,584 @@
+// @ts-check
+import { createHash } from "node:crypto";
+import { unsupportedCapability } from "../diagnostic.js";
+import { finalizeMapping, toSourceMapV3 } from "../mapping.js";
+import { parseZigCst } from "../frontends/zig-parser.js";
+import { validateNativeGraph } from "./native-validation.js";
+import { emitScalarType } from "./scalars.js";
+import { validateBackendModule } from "./shared.js";
+import { SourceWriter } from "./writer.js";
+import { zigBuild, zigRuntime } from "./zig-runtime.js";
+import { maximumZigSourceLength, validateZigValues } from "./zig-validation.js";
+import { collectZigBindingUsage } from "../zig-bindings.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").Statement} Statement */
+/** @typedef {import("../semantic/types.js").FunctionReturnTypeName} Scalar */
+/** @typedef {{expression: Expression, path: string, type: Scalar, name?: string}} ZigPlannedValue */
+/** @typedef {{result: ZigPlannedValue, operands: ZigPlannedValue[], rightSteps?: ZigPlannedStep[]}} ZigPlannedStep */
+/** @typedef {{id: string, steps: ZigPlannedStep[], terminal?: ZigPlannedStep, value?: ZigPlannedValue}} ZigStatementPlan */
+const operators = new Map([
+    ["IntegerAdd", "semantifold_integer_add"], ["IntegerSubtract", "semantifold_integer_subtract"],
+    ["IntegerMultiply", "semantifold_integer_multiply"], ["IntegerEqual", "=="], ["IntegerNotEqual", "!="],
+    ["IntegerLessThan", "<"], ["IntegerLessThanOrEqual", "<="], ["IntegerGreaterThan", ">"], ["IntegerGreaterThanOrEqual", ">="],
+    ["BooleanEqual", "=="], ["BooleanNotEqual", "!="], ["BooleanAnd", "and"], ["BooleanOr", "or"],
+    ["StringConcat", "semantifold_string_concat"], ["StringEqual", "semantifold_string_equal"],
+    ["StringNotEqual", "semantifold_string_not_equal"]
+]);
+/** Plans scalar operations by occurrence without rewriting caller-owned semantic values. */
+class ZigExpressionPlanner {
+    /**
+     * Creates a planner for one validated scalar module.
+     * @param {SemanticModule} module - Validated module.
+     */
+    constructor(module) {
+        this.functions = new Map(module.functions.map(declaration => [declaration.name, zigType(declaration.returnType, declaration.location)]));
+        this.nextTemporary = 1;
+    }
+    /**
+     * Resolves one already-validated expression type.
+     * @param {Expression} expression - Expression occurrence.
+     * @param {Map<string, Scalar>} bindings - Visible scalar bindings.
+     * @returns {Scalar} Exact result type.
+     */
+    type(expression, bindings) {
+        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" && expression.kind != "IdentifierExpression") {
+            return unsupportedCapability("zig", "collection expression reached scalar planning", expression.location);
+        }
+        const type = expression.kind == "CallExpression" ? this.functions.get(expression.callee) : bindings.get(expression.name);
+        if (!type)
+            return unsupportedCapability("zig", "unresolved expression type", expression.location);
+        return type;
+    }
+    /**
+     * Plans one value expression in semantic left-to-right order.
+     * @param {Expression} expression - Expression occurrence.
+     * @param {string} path - Canonical occurrence path.
+     * @param {Map<string, Scalar>} bindings - Visible scalar bindings.
+     * @param {ZigPlannedStep[]} steps - Ordered enclosing prelude.
+     * @returns {ZigPlannedValue} Pure final value.
+     */
+    plan(expression, path, bindings, steps) {
+        const result = { expression, path, type: this.type(expression, bindings) };
+        if (!["CallExpression", "UnaryExpression", "BinaryExpression"].includes(expression.kind))
+            return result;
+        const operands = [];
+        /** @type {ZigPlannedStep[] | undefined} */
+        let rightSteps;
+        if (expression.kind == "CallExpression") {
+            for (const [index, argument] of expression.arguments.entries())
+                operands.push(this.plan(argument, `${path}/arguments/${index}`, bindings, steps));
+        }
+        else if (expression.kind == "UnaryExpression")
+            operands.push(this.plan(expression.operand, `${path}/operand`, bindings, steps));
+        else if (expression.kind == "BinaryExpression") {
+            operands.push(this.plan(expression.left, `${path}/left`, bindings, steps));
+            if (expression.operation == "BooleanAnd" || expression.operation == "BooleanOr") {
+                const planned = { ...result, name: this.allocate(expression) };
+                rightSteps = [];
+                operands.push(this.plan(expression.right, `${path}/right`, bindings, rightSteps));
+                steps.push({ operands, result: planned, rightSteps });
+                return planned;
+            }
+            operands.push(this.plan(expression.right, `${path}/right`, bindings, steps));
+        }
+        if (result.type == "void")
+            throw new Error("Void Zig call reached value planning.");
+        const planned = { ...result, name: this.allocate(expression) };
+        steps.push({ operands, result: planned });
+        return planned;
+    }
+    /**
+     * Plans the arguments of one terminal void call without inventing a void temporary.
+     * @param {Expression} expression - Terminal expression occurrence.
+     * @param {string} path - Canonical occurrence path.
+     * @param {Map<string, Scalar>} bindings - Visible scalar bindings.
+     * @param {ZigPlannedStep[]} steps - Ordered enclosing prelude.
+     * @returns {ZigPlannedStep} Terminal direct-call step.
+     */
+    terminal(expression, path, bindings, steps) {
+        if (expression.kind != "CallExpression" || this.type(expression, bindings) != "void") {
+            throw new Error("Non-void expression reached Zig terminal-call planning.");
+        }
+        const result = { expression, path, type: /** @type {const} */ ("void") };
+        const operands = expression.arguments.map((argument, index) => this.plan(argument, `${path}/arguments/${index}`, bindings, steps));
+        return { operands, result };
+    }
+    /**
+     * Allocates one bounded deterministic occurrence name.
+     * @param {Expression} expression - Related semantic occurrence.
+     * @returns {string} Reserved occurrence name.
+     */
+    allocate(expression) {
+        if (this.nextTemporary > 999999)
+            return unsupportedCapability("zig", "ordered-expression occurrence limit", expression.location);
+        return `semantifold_ordered_${String(this.nextTemporary++).padStart(6, "0")}`;
+    }
+}
+/**
+ * Plans every Zig statement before writer construction or artifact exposure.
+ * @param {SemanticModule} module - Validated module.
+ * @returns {Map<string, ZigStatementPlan>} Plans by semantic occurrence path.
+ */
+function planZigModule(module) {
+    const planner = new ZigExpressionPlanner(module);
+    /** @type {Map<string, ZigStatementPlan>} */
+    const plans = new Map();
+    /**
+     * Plans one lexical block with independent branch environments.
+     * @param {import("../semantic/types.js").Block} block - Block to plan.
+     * @param {string} path - Canonical block path.
+     * @param {Map<string, Scalar>} inherited - Visible scalar bindings.
+     */
+    const visit = (block, path, inherited) => {
+        const bindings = new Map(inherited);
+        block.statements.forEach((statement, index) => {
+            const statementPath = `${path}/statements/${index}`;
+            const field = statement.kind == "IfStatement" ? "condition" : statement.kind == "LocalDeclaration" ? "initializer" : "expression";
+            const expression = statement.kind == "IfStatement" ? statement.condition : statement.kind == "LocalDeclaration" ? statement.initializer :
+                statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement" ? statement.expression :
+                    statement.kind == "ReturnStatement" ? statement.expression : undefined;
+            /** @type {ZigPlannedStep[]} */
+            const steps = [];
+            /** @type {ZigStatementPlan} */
+            const plan = { id: String(plans.size + 1).padStart(6, "0"), steps };
+            if (statement.kind == "ExpressionStatement")
+                plan.terminal = planner.terminal(statement.expression, `${statementPath}/${field}`, bindings, steps);
+            else if (expression)
+                plan.value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps);
+            plans.set(statementPath, plan);
+            if (statement.kind == "LocalDeclaration")
+                bindings.set(statement.name, zigType(statement.type, statement.location));
+            if (statement.kind == "IfStatement") {
+                visit(statement.consequent, `${statementPath}/consequent`, bindings);
+                if (statement.alternate)
+                    visit(statement.alternate, `${statementPath}/alternate`, bindings);
+            }
+        });
+    };
+    module.functions.forEach((declaration, index) => visit(declaration.body, `/functions/${index}/body`, new Map(declaration.parameters.map(parameter => [parameter.name, zigType(parameter.type, parameter.location)]))));
+    visit(module.entryPoint.body, "/entryPoint/body", new Map());
+    return plans;
+}
+/**
+ * Binds an ordered region to its exact semantic consumer and expression.
+ * @param {Statement} statement - Semantic statement occurrence.
+ * @returns {string} Stable scaffold signature.
+ */
+function zigStatementSignature(statement) {
+    const consumer = statement.kind == "LocalDeclaration" ? [statement.kind, statement.name,
+        zigType(statement.type, statement.location), statement.mutable] :
+        statement.kind == "AssignmentStatement" ? [statement.kind, statement.target.name] : [statement.kind];
+    const expression = statement.kind == "IfStatement" ? statement.condition : statement.kind == "LocalDeclaration" ? statement.initializer :
+        statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement" ? statement.expression :
+            statement.kind == "ReturnStatement" ? statement.expression : undefined;
+    return createHash("sha256").update(JSON.stringify([consumer, expression ? zigExpressionSignature(expression) : null])).digest("hex");
+}
+/**
+ * Serializes only the closed semantic expression fields.
+ * @param {Expression} expression - Closed scalar expression.
+ * @returns {unknown[]} Stable signature data.
+ */
+function zigExpressionSignature(expression) {
+    if (expression.kind == "IdentifierExpression")
+        return [expression.kind, expression.name];
+    if (expression.kind == "IntegerLiteral" || expression.kind == "BooleanLiteral" || expression.kind == "StringLiteral") {
+        return [expression.kind, expression.value];
+    }
+    if (expression.kind == "CallExpression")
+        return [expression.kind, expression.callee, ...expression.arguments.map(zigExpressionSignature)];
+    if (expression.kind == "UnaryExpression")
+        return [expression.kind, expression.operation, expression.type, zigExpressionSignature(expression.operand)];
+    if (expression.kind == "BinaryExpression") {
+        return [expression.kind, expression.operation, expression.type, zigExpressionSignature(expression.left), zigExpressionSignature(expression.right)];
+    }
+    return [expression.kind];
+}
+/**
+ * Produces a deterministic dependency-free Zig 0.15.2 native project after complete preflight.
+ * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Artifact request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Candidate project.
+ */
+export function generateZigProject({ filename, mapDirective, module, sourceMapFilename, sources }) {
+    validateNativeGraph(module, "zig");
+    validateBackendModule(module, "zig");
+    validateZigValues(module);
+    if (filename !== undefined && filename != "src/main.zig")
+        unsupportedCapability("zig", "artifact filename other than src/main.zig", module.location);
+    if (mapDirective !== undefined || sourceMapFilename !== undefined)
+        unsupportedCapability("zig", "source-map filename or directive option", module.location);
+    new ZigEmitter(module).program(module);
+    const writer = new SourceWriter({ filename: "src/main.zig", language: "zig", module, sources });
+    new ZigEmitter(module, writer).program(module);
+    const mapping = finalizeMapping(writer.finish());
+    validateGeneratedZig(mapping.generated.content, module.location);
+    const root = mapping.nodes.find(node => node.path == "");
+    if (!root)
+        throw new Error("Validated Zig module omitted root provenance.");
+    const origin = root.origin;
+    const relatedOrigins = origin.kind == "source" ? [{ location: origin.location, nodeId: root.id, role: "module", sourceId: origin.sourceId }] :
+        (origin.kind == "derived" ? origin.origins : origin.relatedOrigins).map(item => ({ ...item, nodeId: item.nodeId ?? root.id, role: item.role ?? "module" }));
+    return { target: "zig", artifacts: [{
+                path: "build.zig", role: "manifest", ownership: "generated", contentKind: "text", mediaType: "text/x-zig", content: zigBuild,
+                provenance: { kind: "synthetic", reason: "Fixed dependency-free Zig 0.15.2 native-host project with caller-selected Debug, ReleaseSafe, or ReleaseFast optimization.", relatedOrigins }
+            }, {
+                path: "src/main.zig", role: "entry", ownership: "generated", contentKind: "text", mediaType: "text/x-zig", content: mapping.generated.content,
+                provenance: { kind: "text", mapping, sourceMap: toSourceMapV3(mapping) }
+            }] };
+}
+/** Emits exact Zig support and Tasks 001-005 semantic occurrences. */
+class ZigEmitter {
+    /**
+     * Creates a validation-only or writing emitter for one module.
+     * @param {SemanticModule} module - Validated semantic module.
+     * @param {SourceWriter} [writer] - Optional provenance-aware output writer.
+     */
+    constructor(module, writer) {
+        this.writer = writer;
+        this.plans = planZigModule(module);
+        this.length = 0;
+        this.location = module.location;
+        this.usage = { reads: new Set(), writes: new Set() };
+    }
+    /**
+     * Accounts for generated size before any text becomes observable.
+     * @param {string} text - Text about to be emitted.
+     * @param {SemanticNode} node - Owning semantic occurrence.
+     */
+    checkSize(text, node) {
+        this.length += text.length;
+        if (this.length > maximumZigSourceLength)
+            unsupportedCapability("zig", "generated source exceeds the 1000000 UTF-16 input limit", "location" in node ? node.location : this.location);
+    }
+    /**
+     * Emits synthetic Zig syntax when a writer is present.
+     * @param {string} text - Text to emit.
+     * @param {SemanticNode} node - Related semantic node.
+     * @param {string} path - Canonical semantic path.
+     * @param {string} [reason] - Synthetic provenance reason.
+     */
+    synthetic(text, node, path, reason = "Zig declaration and expression syntax") {
+        this.checkSize(text, node);
+        this.writer?.synthetic(text, reason, [node], [path]);
+    }
+    /**
+     * Emits an exact or anchored semantic occurrence when a writer is present.
+     * @param {string} text - Text to emit.
+     * @param {SemanticNode} node - Owning semantic node.
+     * @param {string} path - Canonical semantic path.
+     * @param {string} [role] - Exact parser-token role when available.
+     */
+    mapped(text, node, path, role) {
+        this.checkSize(text, node);
+        this.writer?.mapped(text, { mappingKind: role ? "exact" : "anchor", node, path, ...(role ? { role } : {}) });
+    }
+    /**
+     * Validates or emits the complete deterministic entry source.
+     * @param {SemanticModule} module - Semantic module to process.
+     */
+    program(module) {
+        this.synthetic(zigRuntime, module, "", "Exact Zig arena, UTF-8, output, comparison, and checked-arithmetic support");
+        this.synthetic("// semantifold:program:zig:v1\n", module, "", "Exact generated Zig ordered-expression profile marker");
+        module.functions.forEach((declaration, index) => {
+            const path = `/functions/${index}`;
+            this.synthetic("\n", declaration, path);
+            this.mapped("fn", declaration, path);
+            this.synthetic(" ", declaration, path);
+            this.mapped(declaration.name, declaration, path, "name");
+            this.synthetic("(", declaration, path);
+            declaration.parameters.forEach((parameter, parameterIndex) => {
+                const parameterPath = `${path}/parameters/${parameterIndex}`;
+                if (parameterIndex)
+                    this.synthetic(", ", parameter, parameterPath);
+                this.mapped(parameter.name, parameter, parameterPath, "name");
+                this.synthetic(": ", parameter, parameterPath);
+                this.mapped(emitScalarType("zig", parameter.type), parameter.type, `${parameterPath}/type`, "type");
+            });
+            this.synthetic(") ", declaration, path);
+            this.mapped(emitScalarType("zig", declaration.returnType), declaration.returnType, `${path}/returnType`, "type");
+            this.synthetic(" {\n", declaration, path);
+            this.usage = collectZigBindingUsage(declaration.body);
+            declaration.parameters.forEach((parameter, parameterIndex) => {
+                const parameterPath = `${path}/parameters/${parameterIndex}`;
+                if (!this.usage.reads.has(parameter.name)) {
+                    this.synthetic("    _ = ", parameter, parameterPath, "Zig explicit unused-parameter scaffold");
+                    this.mapped(parameter.name, parameter, parameterPath, "name");
+                    this.synthetic(";\n", parameter, parameterPath, "Zig explicit unused-parameter scaffold");
+                }
+            });
+            this.block(declaration.body, `${path}/body`, "    ");
+            this.synthetic("}\n", declaration, path);
+        });
+        this.usage = collectZigBindingUsage(module.entryPoint.body);
+        this.synthetic("\npub fn main() void {\n    defer semantifold_arena.deinit();\n", module.entryPoint, "/entryPoint", "Zig generated entry and arena lifetime shell");
+        this.block(module.entryPoint.body, "/entryPoint/body", "    ");
+        this.synthetic("}\n", module.entryPoint, "/entryPoint", "Zig generated entry shell");
+    }
+    /**
+     * Emits one lexical block and compiler-required binding scaffolds.
+     * @param {import("../semantic/types.js").Block} block - Semantic block.
+     * @param {string} path - Canonical block path.
+     * @param {string} indent - Current output indentation.
+     */
+    block(block, path, indent) {
+        block.statements.forEach((statement, index) => {
+            this.statement(statement, `${path}/statements/${index}`, indent);
+        });
+    }
+    /**
+     * Emits one complete paired ordered region and its pure final consumer.
+     * @param {import("../semantic/types.js").Statement} statement - Statement to emit.
+     * @param {string} path - Canonical statement path.
+     * @param {string} indent - Current output indentation.
+     */
+    statement(statement, path, indent) {
+        const plan = this.plans.get(path);
+        if (!plan)
+            throw new Error("Missing validated Zig statement plan.");
+        const marker = "semantifold:ordered-expression:zig:v1";
+        const signature = zigStatementSignature(statement);
+        this.synthetic(`${indent}// ${marker} begin ${plan.id} ${signature}\n`, statement, path, "Zig ordered-expression region marker");
+        this.steps(plan.steps, indent);
+        this.synthetic(indent, statement, path, "indentation");
+        if (statement.kind == "LocalDeclaration") {
+            this.mapped(statement.mutable ? "var" : "const", statement, path);
+            this.synthetic(" ", statement, path);
+            this.mapped(statement.name, statement, path, "name");
+            this.synthetic(": ", statement, path);
+            this.mapped(emitScalarType("zig", statement.type), statement.type, `${path}/type`, "type");
+            this.synthetic(" ", statement, path);
+            this.mapped("=", statement, path, "operator");
+            this.synthetic(" ", statement, path);
+            this.value(requiredPlanValue(plan, statement));
+        }
+        else if (statement.kind == "AssignmentStatement") {
+            this.mapped(statement.target.name, statement.target, `${path}/target`, "name");
+            this.synthetic(" ", statement, path);
+            this.mapped("=", statement, path, "operator");
+            this.synthetic(" ", statement, path);
+            this.value(requiredPlanValue(plan, statement));
+        }
+        else if (statement.kind == "ReturnStatement") {
+            this.mapped("return", statement, path);
+            if (statement.expression) {
+                this.synthetic(" ", statement, path);
+                this.value(requiredPlanValue(plan, statement));
+            }
+        }
+        else if (statement.kind == "PrintStatement") {
+            const value = requiredPlanValue(plan, statement);
+            this.mapped(`semantifold_print_${value.type}`, statement, path);
+            this.synthetic("(", statement, path);
+            this.value(value);
+            this.synthetic(")", statement, path);
+        }
+        else if (statement.kind == "ExpressionStatement") {
+            if (!plan.terminal)
+                throw new Error("Missing validated Zig terminal call.");
+            this.operation(plan.terminal);
+        }
+        else if (statement.kind == "IfStatement") {
+            this.mapped("if", statement, path);
+            this.synthetic(" (", statement, path);
+            this.value(requiredPlanValue(plan, statement));
+            this.synthetic(") {\n", statement, path);
+            this.block(statement.consequent, `${path}/consequent`, indent + "    ");
+            this.synthetic(indent + "}", statement, path);
+            if (statement.alternate) {
+                this.mapped(" else", statement, path);
+                this.synthetic(" {\n", statement, path);
+                this.block(statement.alternate, `${path}/alternate`, indent + "    ");
+                this.synthetic(indent + "}", statement, path);
+            }
+            this.synthetic("\n", statement, path);
+        }
+        else
+            throw new TypeError("Unsupported Zig statement reached emission after preflight.");
+        if (statement.kind != "IfStatement")
+            this.synthetic(";\n", statement, path);
+        if (statement.kind == "LocalDeclaration") {
+            const unmutated = statement.mutable && !this.usage.writes.has(statement.name);
+            const unread = !statement.mutable && !this.usage.reads.has(statement.name);
+            if (unmutated || unread) {
+                this.synthetic(indent + "_ = ", statement, path, "Zig explicit local binding scaffold");
+                if (unmutated)
+                    this.synthetic("&", statement, path, "Zig explicit unmutated-var scaffold");
+                this.mapped(statement.name, statement, path, "name");
+                this.synthetic(";\n", statement, path, "Zig explicit local binding scaffold");
+            }
+        }
+        this.synthetic(`${indent}// ${marker} end ${plan.id} ${signature}\n`, statement, path, "Zig ordered-expression region marker");
+    }
+    /**
+     * Emits eager steps in semantic order and keeps a Boolean RHS conditional.
+     * @param {ZigPlannedStep[]} steps - Ordered private steps.
+     * @param {string} indent - Current indentation.
+     */
+    steps(steps, indent) {
+        for (const step of steps) {
+            const { expression, path, name, type } = step.result;
+            if (!name || type == "void")
+                throw new Error("Invalid Zig ordered value step.");
+            this.synthetic(`${indent}${step.rightSteps ? "var" : "const"} ${name}: ${emitScalarType("zig", { kind: "TypeReference", name: type })} = `, expression, path, "Zig typed ordered-expression temporary");
+            if (step.rightSteps) {
+                this.value(step.operands[0]);
+                this.synthetic(`;\n${indent}if (`, expression, path, "Zig conditional ordered-expression RHS");
+                if (expression.kind != "BinaryExpression")
+                    throw new Error("Invalid Zig conditional ordered plan.");
+                this.synthetic(`${expression.operation == "BooleanOr" ? "!" : ""}${name}) {\n`, expression, path, "Zig conditional ordered-expression RHS");
+                this.steps(step.rightSteps, indent + "    ");
+                this.synthetic(`${indent}    ${name} = ${name} `, expression, path, "Zig conditional ordered-expression result");
+                this.mapped(expression.operation == "BooleanOr" ? "or" : "and", expression, path, "operator");
+                this.synthetic(" ", expression, path);
+                this.value(step.operands[1]);
+                this.synthetic(`;\n${indent}}\n`, expression, path, "Zig conditional ordered-expression RHS");
+            }
+            else {
+                this.operation(step);
+                this.synthetic(";\n", expression, path);
+            }
+        }
+    }
+    /**
+     * Emits one operation whose operands are already pure.
+     * @param {ZigPlannedStep} step - Planned operation.
+     */
+    operation({ result: { expression, path }, operands }) {
+        if (expression.kind == "CallExpression") {
+            this.mapped(expression.callee, expression, path, "callee");
+            this.synthetic("(", expression, path);
+            operands.forEach((operand, index) => {
+                if (index)
+                    this.synthetic(", ", expression, path);
+                this.value(operand);
+            });
+            this.synthetic(")", expression, path);
+        }
+        else if (expression.kind == "UnaryExpression") {
+            this.mapped(expression.operation == "IntegerNegate" ? "semantifold_integer_negate" : "!", expression, path, "operator");
+            this.synthetic("(", expression, path);
+            this.value(operands[0]);
+            this.synthetic(")", expression, path);
+        }
+        else if (expression.kind == "BinaryExpression") {
+            const token = operators.get(expression.operation);
+            if (!token)
+                throw new Error("Unsupported operation passed Zig validation.");
+            const helper = token.startsWith("semantifold_");
+            if (helper)
+                this.mapped(token, expression, path, "operator");
+            this.synthetic("(", expression, path);
+            this.value(operands[0]);
+            if (helper)
+                this.synthetic(", ", expression, path);
+            else {
+                this.synthetic(" ", expression, path);
+                this.mapped(token, expression, path, "operator");
+                this.synthetic(" ", expression, path);
+            }
+            this.value(operands[1]);
+            this.synthetic(")", expression, path);
+        }
+        else
+            throw new Error("Pure value reached Zig operation emission.");
+    }
+    /**
+     * Emits one pure literal, binding, or ordered temporary use.
+     * @param {ZigPlannedValue} value - Planned pure value.
+     * @returns {void} Text is emitted through the configured writer.
+     */
+    value({ expression, path, name }) {
+        if (name)
+            return this.synthetic(name, expression, path, "Zig ordered-expression temporary use");
+        if (expression.kind == "IdentifierExpression")
+            return this.mapped(expression.name, expression, path, "name");
+        if (expression.kind == "BooleanLiteral")
+            return this.mapped(String(expression.value), expression, path, "literal");
+        if (expression.kind == "IntegerLiteral")
+            return this.mapped(String(expression.value), expression, path, "literal");
+        if (expression.kind == "StringLiteral")
+            return this.mapped(zigString(expression.value), expression, path, "literal");
+        throw new Error("Unsequenced expression passed Zig emission.");
+    }
+}
+/**
+ * Requires the final pure value owned by a non-void statement plan.
+ * @param {ZigStatementPlan} plan - Statement plan.
+ * @param {Statement} statement - Owning semantic statement.
+ * @returns {ZigPlannedValue} Required planned value.
+ */
+function requiredPlanValue(plan, statement) {
+    if (!plan.value)
+        throw new Error(`Missing validated Zig value for ${statement.kind}.`);
+    return plan.value;
+}
+/**
+ * Narrows an already validated semantic type to the Zig scalar cohort.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @param {import("../semantic/types.js").SourceLocation} location - Diagnostic location.
+ * @returns {Scalar} Scalar type name.
+ */
+function zigType(type, location) {
+    if (type.kind != "TypeReference")
+        return unsupportedCapability("zig", "collection type reached scalar emission", location);
+    return type.name;
+}
+/**
+ * Encodes a Unicode scalar string as a canonical Zig literal.
+ * @param {string} value - Semantic string value.
+ * @returns {string} Zig literal spelling.
+ */
+function zigString(value) {
+    let literal = '"';
+    for (const character of value) {
+        const scalar = /** @type {number} */ (character.codePointAt(0));
+        if (character == '"')
+            literal += '\\"';
+        else if (character == "\\")
+            literal += "\\\\";
+        else if (scalar < 32 || scalar == 127)
+            literal += `\\x${scalar.toString(16).padStart(2, "0")}`;
+        else if (scalar == 0x2028 || scalar == 0x2029)
+            literal += `\\u{${scalar.toString(16)}}`;
+        else
+            literal += character;
+    }
+    return literal + '"';
+}
+/**
+ * Reparses the complete generated source and rejects recovery or excessive depth.
+ * @param {string} source - Generated Zig source.
+ * @param {import("../semantic/types.js").SourceLocation} location - Module diagnostic location.
+ * @returns {void} Returns only after the complete CST is accepted.
+ */
+function validateGeneratedZig(source, location) {
+    let snapshot;
+    try {
+        snapshot = parseZigCst(source);
+    }
+    catch (error) {
+        return unsupportedCapability("zig", `generated source could not be reparsed: ${error instanceof Error ? error.message : error}`, location);
+    }
+    /**
+     * Validates one generated CST subtree.
+     * @param {import("../frontends/zig-parser.js").CstNode} node - Current parser node.
+     * @param {number} depth - Current nesting depth.
+     */
+    const visit = (node, depth) => {
+        if (depth > 512 || node.error || node.missing || node.hasError)
+            unsupportedCapability("zig", "generated source contains parser recovery or exceeds the CST depth limit", location);
+        for (const { node: child } of node.children)
+            visit(child, depth + 1);
+    };
+    visit(snapshot.root, 0);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zig.js","sourceRoot":"","sources":["../../../src/backends/zig.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createHash} from \"node:crypto\"\nimport {unsupportedCapability} from \"../diagnostic.js\"\nimport {finalizeMapping, toSourceMapV3} from \"../mapping.js\"\nimport {parseZigCst} from \"../frontends/zig-parser.js\"\nimport {validateNativeGraph} from \"./native-validation.js\"\nimport {emitScalarType} from \"./scalars.js\"\nimport {validateBackendModule} from \"./shared.js\"\nimport {SourceWriter} from \"./writer.js\"\nimport {zigBuild, zigRuntime} from \"./zig-runtime.js\"\nimport {maximumZigSourceLength, validateZigValues} from \"./zig-validation.js\"\nimport {collectZigBindingUsage} from \"../zig-bindings.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\").Statement} Statement */\n/** @typedef {import(\"../semantic/types.js\").FunctionReturnTypeName} Scalar */\n/** @typedef {{expression: Expression, path: string, type: Scalar, name?: string}} ZigPlannedValue */\n/** @typedef {{result: ZigPlannedValue, operands: ZigPlannedValue[], rightSteps?: ZigPlannedStep[]}} ZigPlannedStep */\n/** @typedef {{id: string, steps: ZigPlannedStep[], terminal?: ZigPlannedStep, value?: ZigPlannedValue}} ZigStatementPlan */\n\nconst operators = new Map([\n  [\"IntegerAdd\", \"semantifold_integer_add\"], [\"IntegerSubtract\", \"semantifold_integer_subtract\"],\n  [\"IntegerMultiply\", \"semantifold_integer_multiply\"], [\"IntegerEqual\", \"==\"], [\"IntegerNotEqual\", \"!=\"],\n  [\"IntegerLessThan\", \"<\"], [\"IntegerLessThanOrEqual\", \"<=\"], [\"IntegerGreaterThan\", \">\"], [\"IntegerGreaterThanOrEqual\", \">=\"],\n  [\"BooleanEqual\", \"==\"], [\"BooleanNotEqual\", \"!=\"], [\"BooleanAnd\", \"and\"], [\"BooleanOr\", \"or\"],\n  [\"StringConcat\", \"semantifold_string_concat\"], [\"StringEqual\", \"semantifold_string_equal\"],\n  [\"StringNotEqual\", \"semantifold_string_not_equal\"]\n])\n\n/** Plans scalar operations by occurrence without rewriting caller-owned semantic values. */\nclass ZigExpressionPlanner {\n  /**\n   * Creates a planner for one validated scalar module.\n   * @param {SemanticModule} module - Validated module.\n   */\n  constructor(module) {\n    this.functions = new Map(module.functions.map(declaration => [declaration.name, zigType(declaration.returnType, declaration.location)]))\n    this.nextTemporary = 1\n  }\n\n  /**\n   * Resolves one already-validated expression type.\n   * @param {Expression} expression - Expression occurrence.\n   * @param {Map<string, Scalar>} bindings - Visible scalar bindings.\n   * @returns {Scalar} Exact result type.\n   */\n  type(expression, bindings) {\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\" && expression.kind != \"IdentifierExpression\") {\n      return unsupportedCapability(\"zig\", \"collection expression reached scalar planning\", expression.location)\n    }\n    const type = expression.kind == \"CallExpression\" ? this.functions.get(expression.callee) : bindings.get(expression.name)\n\n    if (!type) return unsupportedCapability(\"zig\", \"unresolved expression type\", expression.location)\n    return type\n  }\n\n  /**\n   * Plans one value expression in semantic left-to-right order.\n   * @param {Expression} expression - Expression occurrence.\n   * @param {string} path - Canonical occurrence path.\n   * @param {Map<string, Scalar>} bindings - Visible scalar bindings.\n   * @param {ZigPlannedStep[]} steps - Ordered enclosing prelude.\n   * @returns {ZigPlannedValue} Pure final value.\n   */\n  plan(expression, path, bindings, steps) {\n    const result = {expression, path, type: this.type(expression, bindings)}\n\n    if (![\"CallExpression\", \"UnaryExpression\", \"BinaryExpression\"].includes(expression.kind)) return result\n    const operands = []\n    /** @type {ZigPlannedStep[] | undefined} */\n    let rightSteps\n\n    if (expression.kind == \"CallExpression\") {\n      for (const [index, argument] of expression.arguments.entries()) operands.push(this.plan(argument, `${path}/arguments/${index}`, bindings, steps))\n    } else if (expression.kind == \"UnaryExpression\") operands.push(this.plan(expression.operand, `${path}/operand`, bindings, steps))\n    else if (expression.kind == \"BinaryExpression\") {\n      operands.push(this.plan(expression.left, `${path}/left`, bindings, steps))\n      if (expression.operation == \"BooleanAnd\" || expression.operation == \"BooleanOr\") {\n        const planned = {...result, name: this.allocate(expression)}\n\n        rightSteps = []\n        operands.push(this.plan(expression.right, `${path}/right`, bindings, rightSteps))\n        steps.push({operands, result: planned, rightSteps})\n        return planned\n      }\n      operands.push(this.plan(expression.right, `${path}/right`, bindings, steps))\n    }\n    if (result.type == \"void\") throw new Error(\"Void Zig call reached value planning.\")\n    const planned = {...result, name: this.allocate(expression)}\n\n    steps.push({operands, result: planned})\n    return planned\n  }\n\n  /**\n   * Plans the arguments of one terminal void call without inventing a void temporary.\n   * @param {Expression} expression - Terminal expression occurrence.\n   * @param {string} path - Canonical occurrence path.\n   * @param {Map<string, Scalar>} bindings - Visible scalar bindings.\n   * @param {ZigPlannedStep[]} steps - Ordered enclosing prelude.\n   * @returns {ZigPlannedStep} Terminal direct-call step.\n   */\n  terminal(expression, path, bindings, steps) {\n    if (expression.kind != \"CallExpression\" || this.type(expression, bindings) != \"void\") {\n      throw new Error(\"Non-void expression reached Zig terminal-call planning.\")\n    }\n    const result = {expression, path, type: /** @type {const} */ (\"void\")}\n    const operands = expression.arguments.map((argument, index) => this.plan(argument, `${path}/arguments/${index}`, bindings, steps))\n\n    return {operands, result}\n  }\n\n  /**\n   * Allocates one bounded deterministic occurrence name.\n   * @param {Expression} expression - Related semantic occurrence.\n   * @returns {string} Reserved occurrence name.\n   */\n  allocate(expression) {\n    if (this.nextTemporary > 999999) return unsupportedCapability(\"zig\", \"ordered-expression occurrence limit\", expression.location)\n    return `semantifold_ordered_${String(this.nextTemporary++).padStart(6, \"0\")}`\n  }\n}\n\n/**\n * Plans every Zig statement before writer construction or artifact exposure.\n * @param {SemanticModule} module - Validated module.\n * @returns {Map<string, ZigStatementPlan>} Plans by semantic occurrence path.\n */\nfunction planZigModule(module) {\n  const planner = new ZigExpressionPlanner(module)\n  /** @type {Map<string, ZigStatementPlan>} */\n  const plans = new Map()\n  /**\n   * Plans one lexical block with independent branch environments.\n   * @param {import(\"../semantic/types.js\").Block} block - Block to plan.\n   * @param {string} path - Canonical block path.\n   * @param {Map<string, Scalar>} inherited - Visible scalar bindings.\n   */\n  const visit = (block, path, inherited) => {\n    const bindings = new Map(inherited)\n\n    block.statements.forEach((statement, index) => {\n      const statementPath = `${path}/statements/${index}`\n      const field = statement.kind == \"IfStatement\" ? \"condition\" : statement.kind == \"LocalDeclaration\" ? \"initializer\" : \"expression\"\n      const expression = statement.kind == \"IfStatement\" ? statement.condition : statement.kind == \"LocalDeclaration\" ? statement.initializer :\n        statement.kind == \"AssignmentStatement\" || statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\" ? statement.expression :\n          statement.kind == \"ReturnStatement\" ? statement.expression : undefined\n      /** @type {ZigPlannedStep[]} */\n      const steps = []\n      /** @type {ZigStatementPlan} */\n      const plan = {id: String(plans.size + 1).padStart(6, \"0\"), steps}\n\n      if (statement.kind == \"ExpressionStatement\") plan.terminal = planner.terminal(statement.expression, `${statementPath}/${field}`, bindings, steps)\n      else if (expression) plan.value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps)\n      plans.set(statementPath, plan)\n      if (statement.kind == \"LocalDeclaration\") bindings.set(statement.name, zigType(statement.type, statement.location))\n      if (statement.kind == \"IfStatement\") {\n        visit(statement.consequent, `${statementPath}/consequent`, bindings)\n        if (statement.alternate) visit(statement.alternate, `${statementPath}/alternate`, bindings)\n      }\n    })\n  }\n\n  module.functions.forEach((declaration, index) => visit(declaration.body, `/functions/${index}/body`,\n    new Map(declaration.parameters.map(parameter => [parameter.name, zigType(parameter.type, parameter.location)]))))\n  visit(module.entryPoint.body, \"/entryPoint/body\", new Map())\n  return plans\n}\n\n/**\n * Binds an ordered region to its exact semantic consumer and expression.\n * @param {Statement} statement - Semantic statement occurrence.\n * @returns {string} Stable scaffold signature.\n */\nfunction zigStatementSignature(statement) {\n  const consumer = statement.kind == \"LocalDeclaration\" ? [statement.kind, statement.name,\n    zigType(statement.type, statement.location), statement.mutable] :\n    statement.kind == \"AssignmentStatement\" ? [statement.kind, statement.target.name] : [statement.kind]\n  const expression = statement.kind == \"IfStatement\" ? statement.condition : statement.kind == \"LocalDeclaration\" ? statement.initializer :\n    statement.kind == \"AssignmentStatement\" || statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\" ? statement.expression :\n      statement.kind == \"ReturnStatement\" ? statement.expression : undefined\n\n  return createHash(\"sha256\").update(JSON.stringify([consumer, expression ? zigExpressionSignature(expression) : null])).digest(\"hex\")\n}\n\n/**\n * Serializes only the closed semantic expression fields.\n * @param {Expression} expression - Closed scalar expression.\n * @returns {unknown[]} Stable signature data.\n */\nfunction zigExpressionSignature(expression) {\n  if (expression.kind == \"IdentifierExpression\") return [expression.kind, expression.name]\n  if (expression.kind == \"IntegerLiteral\" || expression.kind == \"BooleanLiteral\" || expression.kind == \"StringLiteral\") {\n    return [expression.kind, expression.value]\n  }\n  if (expression.kind == \"CallExpression\") return [expression.kind, expression.callee, ...expression.arguments.map(zigExpressionSignature)]\n  if (expression.kind == \"UnaryExpression\") return [expression.kind, expression.operation, expression.type, zigExpressionSignature(expression.operand)]\n  if (expression.kind == \"BinaryExpression\") {\n    return [expression.kind, expression.operation, expression.type, zigExpressionSignature(expression.left), zigExpressionSignature(expression.right)]\n  }\n  return [expression.kind]\n}\n\n/**\n * Produces a deterministic dependency-free Zig 0.15.2 native project after complete preflight.\n * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]}} input - Artifact request.\n * @returns {{artifacts: import(\"../semantic/types.js\").GeneratedSetArtifact[], target: string}} Candidate project.\n */\nexport function generateZigProject({filename, mapDirective, module, sourceMapFilename, sources}) {\n  validateNativeGraph(module, \"zig\")\n  validateBackendModule(module, \"zig\")\n  validateZigValues(module)\n  if (filename !== undefined && filename != \"src/main.zig\") unsupportedCapability(\"zig\", \"artifact filename other than src/main.zig\", module.location)\n  if (mapDirective !== undefined || sourceMapFilename !== undefined) unsupportedCapability(\"zig\", \"source-map filename or directive option\", module.location)\n  new ZigEmitter(module).program(module)\n  const writer = new SourceWriter({filename: \"src/main.zig\", language: \"zig\", module, sources})\n\n  new ZigEmitter(module, writer).program(module)\n  const mapping = finalizeMapping(writer.finish())\n  validateGeneratedZig(mapping.generated.content, module.location)\n  const root = mapping.nodes.find(node => node.path == \"\")\n\n  if (!root) throw new Error(\"Validated Zig module omitted root provenance.\")\n  const origin = root.origin\n  const relatedOrigins = origin.kind == \"source\" ? [{location: origin.location, nodeId: root.id, role: \"module\", sourceId: origin.sourceId}] :\n    (origin.kind == \"derived\" ? origin.origins : origin.relatedOrigins).map(item => ({...item, nodeId: item.nodeId ?? root.id, role: item.role ?? \"module\"}))\n\n  return {target: \"zig\", artifacts: [{\n    path: \"build.zig\", role: \"manifest\", ownership: \"generated\", contentKind: \"text\", mediaType: \"text/x-zig\", content: zigBuild,\n    provenance: {kind: \"synthetic\", reason: \"Fixed dependency-free Zig 0.15.2 native-host project with caller-selected Debug, ReleaseSafe, or ReleaseFast optimization.\", relatedOrigins}\n  }, {\n    path: \"src/main.zig\", role: \"entry\", ownership: \"generated\", contentKind: \"text\", mediaType: \"text/x-zig\", content: mapping.generated.content,\n    provenance: {kind: \"text\", mapping, sourceMap: toSourceMapV3(mapping)}\n  }]}\n}\n\n/** Emits exact Zig support and Tasks 001-005 semantic occurrences. */\nclass ZigEmitter {\n  /**\n   * Creates a validation-only or writing emitter for one module.\n   * @param {SemanticModule} module - Validated semantic module.\n   * @param {SourceWriter} [writer] - Optional provenance-aware output writer.\n   */\n  constructor(module, writer) {\n    this.writer = writer\n    this.plans = planZigModule(module)\n    this.length = 0\n    this.location = module.location\n    this.usage = {reads: new Set(), writes: new Set()}\n  }\n\n  /**\n   * Accounts for generated size before any text becomes observable.\n   * @param {string} text - Text about to be emitted.\n   * @param {SemanticNode} node - Owning semantic occurrence.\n   */\n  checkSize(text, node) {\n    this.length += text.length\n    if (this.length > maximumZigSourceLength) unsupportedCapability(\"zig\", \"generated source exceeds the 1000000 UTF-16 input limit\", \"location\" in node ? node.location : this.location)\n  }\n\n  /**\n   * Emits synthetic Zig syntax when a writer is present.\n   * @param {string} text - Text to emit.\n   * @param {SemanticNode} node - Related semantic node.\n   * @param {string} path - Canonical semantic path.\n   * @param {string} [reason] - Synthetic provenance reason.\n   */\n  synthetic(text, node, path, reason = \"Zig declaration and expression syntax\") {\n    this.checkSize(text, node)\n    this.writer?.synthetic(text, reason, [node], [path])\n  }\n\n  /**\n   * Emits an exact or anchored semantic occurrence when a writer is present.\n   * @param {string} text - Text to emit.\n   * @param {SemanticNode} node - Owning semantic node.\n   * @param {string} path - Canonical semantic path.\n   * @param {string} [role] - Exact parser-token role when available.\n   */\n  mapped(text, node, path, role) {\n    this.checkSize(text, node)\n    this.writer?.mapped(text, {mappingKind: role ? \"exact\" : \"anchor\", node, path, ...(role ? {role} : {})})\n  }\n\n  /**\n   * Validates or emits the complete deterministic entry source.\n   * @param {SemanticModule} module - Semantic module to process.\n   */\n  program(module) {\n    this.synthetic(zigRuntime, module, \"\", \"Exact Zig arena, UTF-8, output, comparison, and checked-arithmetic support\")\n    this.synthetic(\"// semantifold:program:zig:v1\\n\", module, \"\", \"Exact generated Zig ordered-expression profile marker\")\n    module.functions.forEach((declaration, index) => {\n      const path = `/functions/${index}`\n\n      this.synthetic(\"\\n\", declaration, path)\n      this.mapped(\"fn\", declaration, path)\n      this.synthetic(\" \", declaration, path)\n      this.mapped(declaration.name, declaration, path, \"name\")\n      this.synthetic(\"(\", declaration, path)\n      declaration.parameters.forEach((parameter, parameterIndex) => {\n        const parameterPath = `${path}/parameters/${parameterIndex}`\n\n        if (parameterIndex) this.synthetic(\", \", parameter, parameterPath)\n        this.mapped(parameter.name, parameter, parameterPath, \"name\")\n        this.synthetic(\": \", parameter, parameterPath)\n        this.mapped(emitScalarType(\"zig\", parameter.type), parameter.type, `${parameterPath}/type`, \"type\")\n      })\n      this.synthetic(\") \", declaration, path)\n      this.mapped(emitScalarType(\"zig\", declaration.returnType), declaration.returnType, `${path}/returnType`, \"type\")\n      this.synthetic(\" {\\n\", declaration, path)\n      this.usage = collectZigBindingUsage(declaration.body)\n      declaration.parameters.forEach((parameter, parameterIndex) => {\n        const parameterPath = `${path}/parameters/${parameterIndex}`\n\n        if (!this.usage.reads.has(parameter.name)) {\n          this.synthetic(\"    _ = \", parameter, parameterPath, \"Zig explicit unused-parameter scaffold\")\n          this.mapped(parameter.name, parameter, parameterPath, \"name\")\n          this.synthetic(\";\\n\", parameter, parameterPath, \"Zig explicit unused-parameter scaffold\")\n        }\n      })\n      this.block(declaration.body, `${path}/body`, \"    \")\n      this.synthetic(\"}\\n\", declaration, path)\n    })\n    this.usage = collectZigBindingUsage(module.entryPoint.body)\n    this.synthetic(\"\\npub fn main() void {\\n    defer semantifold_arena.deinit();\\n\", module.entryPoint, \"/entryPoint\", \"Zig generated entry and arena lifetime shell\")\n    this.block(module.entryPoint.body, \"/entryPoint/body\", \"    \")\n    this.synthetic(\"}\\n\", module.entryPoint, \"/entryPoint\", \"Zig generated entry shell\")\n  }\n\n  /**\n   * Emits one lexical block and compiler-required binding scaffolds.\n   * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n   * @param {string} path - Canonical block path.\n   * @param {string} indent - Current output indentation.\n   */\n  block(block, path, indent) {\n    block.statements.forEach((statement, index) => {\n      this.statement(statement, `${path}/statements/${index}`, indent)\n    })\n  }\n\n  /**\n   * Emits one complete paired ordered region and its pure final consumer.\n   * @param {import(\"../semantic/types.js\").Statement} statement - Statement to emit.\n   * @param {string} path - Canonical statement path.\n   * @param {string} indent - Current output indentation.\n   */\n  statement(statement, path, indent) {\n    const plan = this.plans.get(path)\n\n    if (!plan) throw new Error(\"Missing validated Zig statement plan.\")\n    const marker = \"semantifold:ordered-expression:zig:v1\"\n    const signature = zigStatementSignature(statement)\n\n    this.synthetic(`${indent}// ${marker} begin ${plan.id} ${signature}\\n`, statement, path, \"Zig ordered-expression region marker\")\n    this.steps(plan.steps, indent)\n    this.synthetic(indent, statement, path, \"indentation\")\n    if (statement.kind == \"LocalDeclaration\") {\n      this.mapped(statement.mutable ? \"var\" : \"const\", statement, path)\n      this.synthetic(\" \", statement, path)\n      this.mapped(statement.name, statement, path, \"name\")\n      this.synthetic(\": \", statement, path)\n      this.mapped(emitScalarType(\"zig\", statement.type), statement.type, `${path}/type`, \"type\")\n      this.synthetic(\" \", statement, path)\n      this.mapped(\"=\", statement, path, \"operator\")\n      this.synthetic(\" \", statement, path)\n      this.value(requiredPlanValue(plan, statement))\n    } else if (statement.kind == \"AssignmentStatement\") {\n      this.mapped(statement.target.name, statement.target, `${path}/target`, \"name\")\n      this.synthetic(\" \", statement, path)\n      this.mapped(\"=\", statement, path, \"operator\")\n      this.synthetic(\" \", statement, path)\n      this.value(requiredPlanValue(plan, statement))\n    } else if (statement.kind == \"ReturnStatement\") {\n      this.mapped(\"return\", statement, path)\n      if (statement.expression) {\n        this.synthetic(\" \", statement, path)\n        this.value(requiredPlanValue(plan, statement))\n      }\n    } else if (statement.kind == \"PrintStatement\") {\n      const value = requiredPlanValue(plan, statement)\n\n      this.mapped(`semantifold_print_${value.type}`, statement, path)\n      this.synthetic(\"(\", statement, path)\n      this.value(value)\n      this.synthetic(\")\", statement, path)\n    } else if (statement.kind == \"ExpressionStatement\") {\n      if (!plan.terminal) throw new Error(\"Missing validated Zig terminal call.\")\n      this.operation(plan.terminal)\n    } else if (statement.kind == \"IfStatement\") {\n      this.mapped(\"if\", statement, path)\n      this.synthetic(\" (\", statement, path)\n      this.value(requiredPlanValue(plan, statement))\n      this.synthetic(\") {\\n\", statement, path)\n      this.block(statement.consequent, `${path}/consequent`, indent + \"    \")\n      this.synthetic(indent + \"}\", statement, path)\n      if (statement.alternate) {\n        this.mapped(\" else\", statement, path)\n        this.synthetic(\" {\\n\", statement, path)\n        this.block(statement.alternate, `${path}/alternate`, indent + \"    \")\n        this.synthetic(indent + \"}\", statement, path)\n      }\n      this.synthetic(\"\\n\", statement, path)\n    } else throw new TypeError(\"Unsupported Zig statement reached emission after preflight.\")\n    if (statement.kind != \"IfStatement\") this.synthetic(\";\\n\", statement, path)\n    if (statement.kind == \"LocalDeclaration\") {\n      const unmutated = statement.mutable && !this.usage.writes.has(statement.name)\n      const unread = !statement.mutable && !this.usage.reads.has(statement.name)\n\n      if (unmutated || unread) {\n        this.synthetic(indent + \"_ = \", statement, path, \"Zig explicit local binding scaffold\")\n        if (unmutated) this.synthetic(\"&\", statement, path, \"Zig explicit unmutated-var scaffold\")\n        this.mapped(statement.name, statement, path, \"name\")\n        this.synthetic(\";\\n\", statement, path, \"Zig explicit local binding scaffold\")\n      }\n    }\n    this.synthetic(`${indent}// ${marker} end ${plan.id} ${signature}\\n`, statement, path, \"Zig ordered-expression region marker\")\n  }\n\n  /**\n   * Emits eager steps in semantic order and keeps a Boolean RHS conditional.\n   * @param {ZigPlannedStep[]} steps - Ordered private steps.\n   * @param {string} indent - Current indentation.\n   */\n  steps(steps, indent) {\n    for (const step of steps) {\n      const {expression, path, name, type} = step.result\n\n      if (!name || type == \"void\") throw new Error(\"Invalid Zig ordered value step.\")\n      this.synthetic(`${indent}${step.rightSteps ? \"var\" : \"const\"} ${name}: ${emitScalarType(\"zig\", {kind: \"TypeReference\", name: type})} = `,\n        expression, path, \"Zig typed ordered-expression temporary\")\n      if (step.rightSteps) {\n        this.value(step.operands[0])\n        this.synthetic(`;\\n${indent}if (`, expression, path, \"Zig conditional ordered-expression RHS\")\n        if (expression.kind != \"BinaryExpression\") throw new Error(\"Invalid Zig conditional ordered plan.\")\n        this.synthetic(`${expression.operation == \"BooleanOr\" ? \"!\" : \"\"}${name}) {\\n`, expression, path,\n          \"Zig conditional ordered-expression RHS\")\n        this.steps(step.rightSteps, indent + \"    \")\n        this.synthetic(`${indent}    ${name} = ${name} `, expression, path, \"Zig conditional ordered-expression result\")\n        this.mapped(expression.operation == \"BooleanOr\" ? \"or\" : \"and\", expression, path, \"operator\")\n        this.synthetic(\" \", expression, path)\n        this.value(step.operands[1])\n        this.synthetic(`;\\n${indent}}\\n`, expression, path, \"Zig conditional ordered-expression RHS\")\n      } else {\n        this.operation(step)\n        this.synthetic(\";\\n\", expression, path)\n      }\n    }\n  }\n\n  /**\n   * Emits one operation whose operands are already pure.\n   * @param {ZigPlannedStep} step - Planned operation.\n   */\n  operation({result: {expression, path}, operands}) {\n    if (expression.kind == \"CallExpression\") {\n      this.mapped(expression.callee, expression, path, \"callee\")\n      this.synthetic(\"(\", expression, path)\n      operands.forEach((operand, index) => {\n        if (index) this.synthetic(\", \", expression, path)\n        this.value(operand)\n      })\n      this.synthetic(\")\", expression, path)\n    } else if (expression.kind == \"UnaryExpression\") {\n      this.mapped(expression.operation == \"IntegerNegate\" ? \"semantifold_integer_negate\" : \"!\", expression, path, \"operator\")\n      this.synthetic(\"(\", expression, path)\n      this.value(operands[0])\n      this.synthetic(\")\", expression, path)\n    } else if (expression.kind == \"BinaryExpression\") {\n      const token = operators.get(expression.operation)\n\n      if (!token) throw new Error(\"Unsupported operation passed Zig validation.\")\n      const helper = token.startsWith(\"semantifold_\")\n\n      if (helper) this.mapped(token, expression, path, \"operator\")\n      this.synthetic(\"(\", expression, path)\n      this.value(operands[0])\n      if (helper) this.synthetic(\", \", expression, path)\n      else {\n        this.synthetic(\" \", expression, path)\n        this.mapped(token, expression, path, \"operator\")\n        this.synthetic(\" \", expression, path)\n      }\n      this.value(operands[1])\n      this.synthetic(\")\", expression, path)\n    } else throw new Error(\"Pure value reached Zig operation emission.\")\n  }\n\n  /**\n   * Emits one pure literal, binding, or ordered temporary use.\n   * @param {ZigPlannedValue} value - Planned pure value.\n   * @returns {void} Text is emitted through the configured writer.\n   */\n  value({expression, path, name}) {\n    if (name) return this.synthetic(name, expression, path, \"Zig ordered-expression temporary use\")\n    if (expression.kind == \"IdentifierExpression\") return this.mapped(expression.name, expression, path, \"name\")\n    if (expression.kind == \"BooleanLiteral\") return this.mapped(String(expression.value), expression, path, \"literal\")\n    if (expression.kind == \"IntegerLiteral\") return this.mapped(String(expression.value), expression, path, \"literal\")\n    if (expression.kind == \"StringLiteral\") return this.mapped(zigString(expression.value), expression, path, \"literal\")\n    throw new Error(\"Unsequenced expression passed Zig emission.\")\n  }\n}\n\n/**\n * Requires the final pure value owned by a non-void statement plan.\n * @param {ZigStatementPlan} plan - Statement plan.\n * @param {Statement} statement - Owning semantic statement.\n * @returns {ZigPlannedValue} Required planned value.\n */\nfunction requiredPlanValue(plan, statement) {\n  if (!plan.value) throw new Error(`Missing validated Zig value for ${statement.kind}.`)\n  return plan.value\n}\n\n/**\n * Narrows an already validated semantic type to the Zig scalar cohort.\n * @param {import(\"../semantic/types.js\").SemanticFunctionReturnType} type - Semantic type.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Diagnostic location.\n * @returns {Scalar} Scalar type name.\n */\nfunction zigType(type, location) {\n  if (type.kind != \"TypeReference\") return unsupportedCapability(\"zig\", \"collection type reached scalar emission\", location)\n  return type.name\n}\n\n/**\n * Encodes a Unicode scalar string as a canonical Zig literal.\n * @param {string} value - Semantic string value.\n * @returns {string} Zig literal spelling.\n */\nfunction zigString(value) {\n  let literal = '\"'\n\n  for (const character of value) {\n    const scalar = /** @type {number} */ (character.codePointAt(0))\n\n    if (character == '\"') literal += '\\\\\"'\n    else if (character == \"\\\\\") literal += \"\\\\\\\\\"\n    else if (scalar < 32 || scalar == 127) literal += `\\\\x${scalar.toString(16).padStart(2, \"0\")}`\n    else if (scalar == 0x2028 || scalar == 0x2029) literal += `\\\\u{${scalar.toString(16)}}`\n    else literal += character\n  }\n  return literal + '\"'\n}\n\n/**\n * Reparses the complete generated source and rejects recovery or excessive depth.\n * @param {string} source - Generated Zig source.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Module diagnostic location.\n * @returns {void} Returns only after the complete CST is accepted.\n */\nfunction validateGeneratedZig(source, location) {\n  let snapshot\n\n  try {\n    snapshot = parseZigCst(source)\n  } catch (error) {\n    return unsupportedCapability(\"zig\", `generated source could not be reparsed: ${error instanceof Error ? error.message : error}`, location)\n  }\n  /**\n   * Validates one generated CST subtree.\n   * @param {import(\"../frontends/zig-parser.js\").CstNode} node - Current parser node.\n   * @param {number} depth - Current nesting depth.\n   */\n  const visit = (node, depth) => {\n    if (depth > 512 || node.error || node.missing || node.hasError) unsupportedCapability(\"zig\", \"generated source contains parser recovery or exceeds the CST depth limit\", location)\n    for (const {node: child} of node.children) visit(child, depth + 1)\n  }\n\n  visit(snapshot.root, 0)\n}\n"]}