semantifold 0.1.1 → 0.3.0

package/build/src/backends/cpp.d.ts

@@ -0,0 +1,16 @@
+import { SourceWriter } from "./writer.js";
+export type SemanticModule = import("../semantic/types.js").SemanticModule;
+export type SemanticNode = import("../semantic/types.js").SemanticNode;
+export type Statement = import("../semantic/types.js").Statement;
+export type Block = import("../semantic/types.js").Block;
+export type PlannedValue = import("./ordered-expressions.js").PlannedValue;
+export type PlannedStep = import("./ordered-expressions.js").PlannedStep;
+export type StatementPlan = import("./ordered-expressions.js").StatementPlan;
+/**
+ * Emits the one fully validated C++20 translation unit with owned by-value strings.
+ * @param {SemanticModule} module - Shared validated semantics.
+ * @param {SourceWriter} [writer] - Optional caller-owned provenance writer.
+ * @returns {string} Deterministic source for public generation or same-language CST validation.
+ */
+export declare function generateCpp(module: SemanticModule, writer?: SourceWriter): string;
+//# sourceMappingURL=cpp.d.ts.map

package/build/src/backends/cpp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpp.d.ts","sourceRoot":"","sources":["../../../src/backends/cpp.js"],"names":[],"mappings":"AAOA,OAAO,EAAC,YAAY,EAAC,MAAM,aAAa,CAAA;AAEpC,YAAyD,cAAc,GAA7D,OAAO,sBAAsB,EAAE,cAAc,CAAgB;AACvE,YAAuD,YAAY,GAAzD,OAAO,sBAAsB,EAAE,YAAY,CAAc;AACnE,YAAoD,SAAS,GAAnD,OAAO,sBAAsB,EAAE,SAAS,CAAW;AAC7D,YAAgD,KAAK,GAA3C,OAAO,sBAAsB,EAAE,KAAK,CAAO;AACrD,YAA2D,YAAY,GAA7D,OAAO,0BAA0B,EAAE,YAAY,CAAc;AACvE,YAA0D,WAAW,GAA3D,OAAO,0BAA0B,EAAE,WAAW,CAAa;AACrE,YAA4D,aAAa,GAA/D,OAAO,0BAA0B,EAAE,aAAa,CAAe;AAW7E;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAJvB,cAIuB,EAAE,MAAM,AAHvC,CACA,EADQ,YAG+B,GAF7B,MAAM,CAWlB"}

package/build/src/backends/cpp.js

@@ -0,0 +1,285 @@
+// @ts-check
+import { unsupportedCapability } from "../diagnostic.js";
+import { statementSignature, planNativeModule } from "./ordered-expressions.js";
+import { cppRuntime } from "./cpp-runtime.js";
+import { maximumCppSourceLength, validateCppValues } from "./cpp-validation.js";
+import { emitScalarType } from "./scalars.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").Statement} Statement */
+/** @typedef {import("../semantic/types.js").Block} Block */
+/** @typedef {import("./ordered-expressions.js").PlannedValue} PlannedValue */
+/** @typedef {import("./ordered-expressions.js").PlannedStep} PlannedStep */
+/** @typedef {import("./ordered-expressions.js").StatementPlan} StatementPlan */
+const binaryTokens = new Map([
+    ["IntegerAdd", "semantifold_integer_add"], ["IntegerSubtract", "semantifold_integer_subtract"],
+    ["IntegerMultiply", "semantifold_integer_multiply"], ["StringConcat", "semantifold_string_concat"],
+    ["StringEqual", "semantifold_string_equal"], ["StringNotEqual", "semantifold_string_not_equal"],
+    ["IntegerEqual", "=="], ["IntegerNotEqual", "!="], ["BooleanEqual", "=="], ["BooleanNotEqual", "!="],
+    ["IntegerLessThan", "<"], ["IntegerLessThanOrEqual", "<="],
+    ["IntegerGreaterThan", ">"], ["IntegerGreaterThanOrEqual", ">="]
+]);
+/**
+ * Emits the one fully validated C++20 translation unit with owned by-value strings.
+ * @param {SemanticModule} module - Shared validated semantics.
+ * @param {SourceWriter} [writer] - Optional caller-owned provenance writer.
+ * @returns {string} Deterministic source for public generation or same-language CST validation.
+ */
+export function generateCpp(module, writer) {
+    validateCppValues(module);
+    const plans = planNativeModule(module, "cpp");
+    new CppEmitter(undefined, plans, module.location).program(module);
+    const output = writer ?? new SourceWriter({ filename: "program.cpp", language: "cpp", module });
+    new CppEmitter(output, plans, module.location).program(module);
+    return output.finish().generated.content;
+}
+/** Writes only target syntax from validated semantic occurrences and private plans. */
+class CppEmitter {
+    /**
+     * Binds the writer and complete plan.
+     * @param {SourceWriter | undefined} writer - Provenance writer; omitted for exact size preflight.
+     * @param {Map<string, StatementPlan>} plans - Validated occurrence plans.
+     * @param {import("../semantic/types.js").SourceLocation} location - Root diagnostic location.
+     */
+    constructor(writer, plans, location) {
+        this.writer = writer;
+        this.plans = plans;
+        this.location = location;
+        this.length = 0;
+    }
+    /**
+     * Writes generated scaffold with a related semantic origin.
+     * @param {string} text - C++ syntax.
+     * @param {SemanticNode} node - Related node.
+     * @param {string} path - Occurrence path.
+     * @returns {void}
+     */
+    synthetic(text, node, path) {
+        this.checkSize(text, node);
+        this.writer?.synthetic(text, "C++20 ordered-expression and lifetime scaffold", [node], [path]);
+    }
+    /**
+     * Writes an original semantic token or anchor.
+     * @param {string} text - Target token.
+     * @param {SemanticNode} node - Original node.
+     * @param {string} path - Occurrence path.
+     * @param {string} [role] - Parser token role.
+     * @returns {void}
+     */
+    mapped(text, node, path, role) {
+        this.checkSize(text, node);
+        this.writer?.mapped(text, { mappingKind: role ? "exact" : "anchor", node, path, ...(role ? { role } : {}) });
+    }
+    /**
+     * Bounds private emission before any artifact can escape the parser's proven input profile.
+     * @param {string} text - Next exact output chunk.
+     * @param {SemanticNode} node - Related semantic occurrence.
+     * @returns {void}
+     */
+    checkSize(text, node) {
+        this.length += text.length;
+        if (this.length > maximumCppSourceLength)
+            unsupportedCapability("cpp", "generated program exceeds the frozen CPP parser's 32767 UTF-16 input limit", "location" in node ? node.location : this.location);
+    }
+    /**
+     * Emits canonical prototypes, definitions, and the parameterless main.
+     * @param {SemanticModule} module - Semantic module.
+     * @returns {void}
+     */
+    program(module) {
+        this.synthetic("/* semantifold:program:cpp:v1 */\n" + cppRuntime + "\n", module, "");
+        module.functions.forEach((declaration, index) => {
+            const parameters = declaration.parameters.map((parameter) => `${emitScalarType("cpp", parameter.type)} ${parameter.name}`).join(", ");
+            this.synthetic(`${emitScalarType("cpp", declaration.returnType)} ${declaration.name}(${parameters});\n`, declaration, `/functions/${index}`);
+        });
+        module.functions.forEach((declaration, index) => {
+            const path = `/functions/${index}`;
+            this.synthetic("\n", declaration, path);
+            this.mapped(emitScalarType("cpp", declaration.returnType), declaration.returnType, `${path}/returnType`, "type");
+            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(emitScalarType("cpp", parameter.type), parameter.type, `${parameterPath}/type`, "type");
+                this.synthetic(" ", parameter, parameterPath);
+                this.mapped(parameter.name, parameter, parameterPath, "name");
+            });
+            this.synthetic(") {\n", declaration, path);
+            declaration.parameters.forEach((parameter, parameterIndex) => this.synthetic(`    (void)${parameter.name};\n`, parameter, `${path}/parameters/${parameterIndex}`));
+            this.block(declaration.body, `${path}/body`, "    ");
+            this.synthetic("}\n", declaration, path);
+        });
+        this.synthetic("\nint main() {\n", module.entryPoint, "/entryPoint");
+        this.block(module.entryPoint.body, "/entryPoint/body", "    ");
+        this.synthetic("    return 0;\n}\n", module.entryPoint, "/entryPoint");
+    }
+    /**
+     * Emits statements in semantic source order.
+     * @param {Block} block - Semantic block.
+     * @param {string} path - Occurrence path.
+     * @param {string} indent - Current indentation.
+     * @returns {void}
+     */
+    block(block, path, indent) {
+        block.statements.forEach((statement, index) => this.statement(statement, `${path}/statements/${index}`, indent));
+    }
+    /**
+     * Emits one paired region with a pure final consumer.
+     * @param {Statement} statement - Original statement.
+     * @param {string} path - Occurrence path.
+     * @param {string} indent - Current indentation.
+     * @returns {void}
+     */
+    statement(statement, path, indent) {
+        const plan = this.plans.get(path);
+        if (!plan)
+            throw new Error("Missing validated C++ statement plan.");
+        const marker = `semantifold:ordered-expression:cpp:v1`;
+        const signature = statementSignature(statement);
+        this.synthetic(`${indent}/* ${marker} begin ${plan.id} ${signature} */\n`, statement, path);
+        this.steps(plan.steps, indent);
+        this.synthetic(indent, statement, path);
+        if (statement.kind == "LocalDeclaration") {
+            if (!statement.mutable)
+                this.synthetic("const ", statement, path);
+            this.mapped(emitScalarType("cpp", statement.type), statement.type, `${path}/type`, "type");
+            this.synthetic(" ", statement, path);
+            this.mapped(statement.name, statement, path, "name");
+            this.synthetic(" ", statement, path);
+            this.mapped("=", statement, path, "operator");
+            this.synthetic(" ", statement, path);
+        }
+        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);
+        }
+        else if (statement.kind == "ReturnStatement")
+            this.mapped("return ", statement, path);
+        else if (statement.kind == "PrintStatement")
+            this.mapped(`semantifold_print_${plan.value.type}(`, statement, path);
+        else
+            this.mapped("if (", statement, path);
+        this.value(plan.value);
+        if (statement.kind == "IfStatement") {
+            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 {
+            this.synthetic(`${statement.kind == "PrintStatement" ? ")" : ""};\n`, statement, path);
+            if (statement.kind == "LocalDeclaration")
+                this.synthetic(`${indent}(void)${statement.name};\n`, statement, path);
+        }
+        this.synthetic(`${indent}/* ${marker} end ${plan.id} ${signature} */\n`, statement, path);
+    }
+    /**
+     * Emits each eager step or conditional RHS at its planned location.
+     * @param {PlannedStep[]} steps - Ordered private steps.
+     * @param {string} indent - Current indentation.
+     * @returns {void}
+     */
+    steps(steps, indent) {
+        for (const step of steps) {
+            const { result, operands, rightSteps } = step;
+            const { expression, path, name } = result;
+            const type = emitScalarType("cpp", { kind: "TypeReference", name: result.type });
+            this.synthetic(`${indent}${type} ${name} = `, expression, path);
+            if (rightSteps) {
+                this.value(operands[0]);
+                this.synthetic(`;\n${indent}if (`, expression, path);
+                if (expression.kind != "BinaryExpression")
+                    throw new Error("Invalid conditional C++ plan.");
+                this.synthetic(`${expression.operation == "BooleanOr" ? "!" : ""}${name}) {\n`, expression, path);
+                this.steps(rightSteps, `${indent}    `);
+                this.synthetic(`${indent}    ${name} = (${name} `, expression, path);
+                this.mapped(expression.operation == "BooleanOr" ? "||" : "&&", expression, path, "operator");
+                this.synthetic(" ", expression, path);
+                this.value(operands[1]);
+                this.synthetic(`);\n${indent}}\n`, expression, path);
+            }
+            else {
+                this.operation(step);
+                this.synthetic(";\n", expression, path);
+            }
+        }
+    }
+    /**
+     * Emits one nontrivial operation with pure operands.
+     * @param {PlannedStep} step - Eager step.
+     * @returns {void}
+     */
+    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 = binaryTokens.get(expression.operation);
+            if (!token)
+                throw new Error("Unsupported operation passed C++ planning.");
+            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 expression was scheduled as a CPP operation.");
+    }
+    /**
+     * Emits a pure operand with original token provenance or a synthetic temporary use.
+     * @param {PlannedValue} value - Planned pure operand.
+     * @returns {void}
+     */
+    value({ expression, path, name }) {
+        if (name)
+            return this.synthetic(name, expression, path);
+        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(`std::int64_t(${expression.value})`, expression, path, "literal");
+        if (expression.kind == "StringLiteral") {
+            const bytes = new TextEncoder().encode(expression.value);
+            const literal = Array.from(bytes, (byte) => `\\${byte.toString(8).padStart(3, "0")}`).join("");
+            return this.mapped(`std::string("${literal}", ${bytes.length})`, expression, path, "literal");
+        }
+        throw new Error("Unsequenced expression passed C++ planning.");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cpp.js","sourceRoot":"","sources":["../../../src/backends/cpp.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {unsupportedCapability} from \"../diagnostic.js\"\nimport {statementSignature, planNativeModule} from \"./ordered-expressions.js\"\nimport {cppRuntime} from \"./cpp-runtime.js\"\nimport {maximumCppSourceLength, validateCppValues} from \"./cpp-validation.js\"\nimport {emitScalarType} from \"./scalars.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\").Statement} Statement */\n/** @typedef {import(\"../semantic/types.js\").Block} Block */\n/** @typedef {import(\"./ordered-expressions.js\").PlannedValue} PlannedValue */\n/** @typedef {import(\"./ordered-expressions.js\").PlannedStep} PlannedStep */\n/** @typedef {import(\"./ordered-expressions.js\").StatementPlan} StatementPlan */\n\nconst binaryTokens = new Map([\n  [\"IntegerAdd\", \"semantifold_integer_add\"], [\"IntegerSubtract\", \"semantifold_integer_subtract\"],\n  [\"IntegerMultiply\", \"semantifold_integer_multiply\"], [\"StringConcat\", \"semantifold_string_concat\"],\n  [\"StringEqual\", \"semantifold_string_equal\"], [\"StringNotEqual\", \"semantifold_string_not_equal\"],\n  [\"IntegerEqual\", \"==\"], [\"IntegerNotEqual\", \"!=\"], [\"BooleanEqual\", \"==\"], [\"BooleanNotEqual\", \"!=\"],\n  [\"IntegerLessThan\", \"<\"], [\"IntegerLessThanOrEqual\", \"<=\"],\n  [\"IntegerGreaterThan\", \">\"], [\"IntegerGreaterThanOrEqual\", \">=\"]\n])\n\n/**\n * Emits the one fully validated C++20 translation unit with owned by-value strings.\n * @param {SemanticModule} module - Shared validated semantics.\n * @param {SourceWriter} [writer] - Optional caller-owned provenance writer.\n * @returns {string} Deterministic source for public generation or same-language CST validation.\n */\nexport function generateCpp(module, writer) {\n  validateCppValues(module)\n  const plans = planNativeModule(module, \"cpp\")\n\n  new CppEmitter(undefined, plans, module.location).program(module)\n  const output = writer ?? new SourceWriter({filename: \"program.cpp\", language: \"cpp\", module})\n\n  new CppEmitter(output, plans, module.location).program(module)\n  return output.finish().generated.content\n}\n\n/** Writes only target syntax from validated semantic occurrences and private plans. */\nclass CppEmitter {\n  /**\n   * Binds the writer and complete plan.\n   * @param {SourceWriter | undefined} writer - Provenance writer; omitted for exact size preflight.\n   * @param {Map<string, StatementPlan>} plans - Validated occurrence plans.\n   * @param {import(\"../semantic/types.js\").SourceLocation} location - Root diagnostic location.\n   */\n  constructor(writer, plans, location) {\n    this.writer = writer\n    this.plans = plans\n    this.location = location\n    this.length = 0\n  }\n\n  /**\n   * Writes generated scaffold with a related semantic origin.\n   * @param {string} text - C++ syntax.\n   * @param {SemanticNode} node - Related node.\n   * @param {string} path - Occurrence path.\n   * @returns {void}\n   */\n  synthetic(text, node, path) {\n    this.checkSize(text, node)\n    this.writer?.synthetic(text, \"C++20 ordered-expression and lifetime scaffold\", [node], [path])\n  }\n\n  /**\n   * Writes an original semantic token or anchor.\n   * @param {string} text - Target token.\n   * @param {SemanticNode} node - Original node.\n   * @param {string} path - Occurrence path.\n   * @param {string} [role] - Parser token role.\n   * @returns {void}\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   * Bounds private emission before any artifact can escape the parser's proven input profile.\n   * @param {string} text - Next exact output chunk.\n   * @param {SemanticNode} node - Related semantic occurrence.\n   * @returns {void}\n   */\n  checkSize(text, node) {\n    this.length += text.length\n    if (this.length > maximumCppSourceLength) unsupportedCapability(\"cpp\", \"generated program exceeds the frozen CPP parser's 32767 UTF-16 input limit\",\n      \"location\" in node ? node.location : this.location)\n  }\n\n  /**\n   * Emits canonical prototypes, definitions, and the parameterless main.\n   * @param {SemanticModule} module - Semantic module.\n   * @returns {void}\n   */\n  program(module) {\n    this.synthetic(\"/* semantifold:program:cpp:v1 */\\n\" + cppRuntime + \"\\n\", module, \"\")\n    module.functions.forEach((declaration, index) => {\n      const parameters = declaration.parameters.map((parameter) => `${emitScalarType(\"cpp\", parameter.type)} ${parameter.name}`).join(\", \")\n\n      this.synthetic(`${emitScalarType(\"cpp\", declaration.returnType)} ${declaration.name}(${parameters});\\n`, declaration, `/functions/${index}`)\n    })\n    module.functions.forEach((declaration, index) => {\n      const path = `/functions/${index}`\n\n      this.synthetic(\"\\n\", declaration, path)\n      this.mapped(emitScalarType(\"cpp\", declaration.returnType), declaration.returnType, `${path}/returnType`, \"type\")\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(emitScalarType(\"cpp\", parameter.type), parameter.type, `${parameterPath}/type`, \"type\")\n        this.synthetic(\" \", parameter, parameterPath)\n        this.mapped(parameter.name, parameter, parameterPath, \"name\")\n      })\n      this.synthetic(\") {\\n\", declaration, path)\n      declaration.parameters.forEach((parameter, parameterIndex) => this.synthetic(`    (void)${parameter.name};\\n`, parameter, `${path}/parameters/${parameterIndex}`))\n      this.block(declaration.body, `${path}/body`, \"    \")\n      this.synthetic(\"}\\n\", declaration, path)\n    })\n    this.synthetic(\"\\nint main() {\\n\", module.entryPoint, \"/entryPoint\")\n    this.block(module.entryPoint.body, \"/entryPoint/body\", \"    \")\n    this.synthetic(\"    return 0;\\n}\\n\", module.entryPoint, \"/entryPoint\")\n  }\n\n  /**\n   * Emits statements in semantic source order.\n   * @param {Block} block - Semantic block.\n   * @param {string} path - Occurrence path.\n   * @param {string} indent - Current indentation.\n   * @returns {void}\n   */\n  block(block, path, indent) {\n    block.statements.forEach((statement, index) => this.statement(statement, `${path}/statements/${index}`, indent))\n  }\n\n  /**\n   * Emits one paired region with a pure final consumer.\n   * @param {Statement} statement - Original statement.\n   * @param {string} path - Occurrence path.\n   * @param {string} indent - Current indentation.\n   * @returns {void}\n   */\n  statement(statement, path, indent) {\n    const plan = this.plans.get(path)\n\n    if (!plan) throw new Error(\"Missing validated C++ statement plan.\")\n    const marker = `semantifold:ordered-expression:cpp:v1`\n    const signature = statementSignature(statement)\n\n    this.synthetic(`${indent}/* ${marker} begin ${plan.id} ${signature} */\\n`, statement, path)\n    this.steps(plan.steps, indent)\n    this.synthetic(indent, statement, path)\n    if (statement.kind == \"LocalDeclaration\") {\n      if (!statement.mutable) this.synthetic(\"const \", statement, path)\n      this.mapped(emitScalarType(\"cpp\", statement.type), statement.type, `${path}/type`, \"type\")\n      this.synthetic(\" \", statement, path)\n      this.mapped(statement.name, statement, path, \"name\")\n      this.synthetic(\" \", statement, path)\n      this.mapped(\"=\", statement, path, \"operator\")\n      this.synthetic(\" \", statement, path)\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    } else if (statement.kind == \"ReturnStatement\") this.mapped(\"return \", statement, path)\n    else if (statement.kind == \"PrintStatement\") this.mapped(`semantifold_print_${plan.value.type}(`, statement, path)\n    else this.mapped(\"if (\", statement, path)\n    this.value(plan.value)\n    if (statement.kind == \"IfStatement\") {\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 {\n      this.synthetic(`${statement.kind == \"PrintStatement\" ? \")\" : \"\"};\\n`, statement, path)\n      if (statement.kind == \"LocalDeclaration\") this.synthetic(`${indent}(void)${statement.name};\\n`, statement, path)\n    }\n    this.synthetic(`${indent}/* ${marker} end ${plan.id} ${signature} */\\n`, statement, path)\n  }\n\n  /**\n   * Emits each eager step or conditional RHS at its planned location.\n   * @param {PlannedStep[]} steps - Ordered private steps.\n   * @param {string} indent - Current indentation.\n   * @returns {void}\n   */\n  steps(steps, indent) {\n    for (const step of steps) {\n      const {result, operands, rightSteps} = step\n      const {expression, path, name} = result\n      const type = emitScalarType(\"cpp\", {kind: \"TypeReference\", name: result.type})\n\n      this.synthetic(`${indent}${type} ${name} = `, expression, path)\n      if (rightSteps) {\n        this.value(operands[0])\n        this.synthetic(`;\\n${indent}if (`, expression, path)\n        if (expression.kind != \"BinaryExpression\") throw new Error(\"Invalid conditional C++ plan.\")\n        this.synthetic(`${expression.operation == \"BooleanOr\" ? \"!\" : \"\"}${name}) {\\n`, expression, path)\n        this.steps(rightSteps, `${indent}    `)\n        this.synthetic(`${indent}    ${name} = (${name} `, expression, path)\n        this.mapped(expression.operation == \"BooleanOr\" ? \"||\" : \"&&\", expression, path, \"operator\")\n        this.synthetic(\" \", expression, path)\n        this.value(operands[1])\n        this.synthetic(`);\\n${indent}}\\n`, expression, path)\n      } else {\n        this.operation(step)\n        this.synthetic(\";\\n\", expression, path)\n      }\n    }\n  }\n\n  /**\n   * Emits one nontrivial operation with pure operands.\n   * @param {PlannedStep} step - Eager step.\n   * @returns {void}\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 = binaryTokens.get(expression.operation)\n\n      if (!token) throw new Error(\"Unsupported operation passed C++ planning.\")\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 expression was scheduled as a CPP operation.\")\n  }\n\n  /**\n   * Emits a pure operand with original token provenance or a synthetic temporary use.\n   * @param {PlannedValue} value - Planned pure operand.\n   * @returns {void}\n   */\n  value({expression, path, name}) {\n    if (name) return this.synthetic(name, expression, path)\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(`std::int64_t(${expression.value})`, expression, path, \"literal\")\n    if (expression.kind == \"StringLiteral\") {\n      const bytes = new TextEncoder().encode(expression.value)\n      const literal = Array.from(bytes, (byte) => `\\\\${byte.toString(8).padStart(3, \"0\")}`).join(\"\")\n\n      return this.mapped(`std::string(\"${literal}\", ${bytes.length})`, expression, path, \"literal\")\n    }\n    throw new Error(\"Unsequenced expression passed C++ planning.\")\n  }\n}\n"]}

package/build/src/backends/csharp.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Emits one deterministic two-file C# project candidate.
+ * @param {{filename?: string, mapDirective?: unknown, module: import("../semantic/types.js").SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Backend request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Candidate artifact set.
+ */
+export declare function generateCSharpProject({ filename, mapDirective, module, sourceMapFilename, sources }: {
+    filename?: string;
+    mapDirective?: unknown;
+    module: import("../semantic/types.js").SemanticModule;
+    sourceMapFilename?: unknown;
+    sources?: {
+        filename: string;
+        content: string;
+        language?: import("../semantic/types.js").SemanticLanguage;
+    }[];
+}): {
+    artifacts: import("../semantic/types.js").GeneratedSetArtifact[];
+    target: string;
+};
+//# sourceMappingURL=csharp.d.ts.map

package/build/src/backends/csharp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csharp.d.ts","sourceRoot":"","sources":["../../../src/backends/csharp.js"],"names":[],"mappings":"AAsCA;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,EAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAC,EAHvF;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,cAAc,CAAC;IAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAAA;CAGpJ,GAFrF;IAAC,SAAS,EAAE,OAAO,sBAAsB,EAAE,oBAAoB,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAsC9F"}