semantifold 0.2.0 → 0.3.0

package/build/src/backends/ordered-expressions.js

@@ -0,0 +1,159 @@
+// @ts-check
+import { createHash } from "node:crypto";
+import { unsupportedCapability } from "../diagnostic.js";
+/** @typedef {import("../semantic/types.js").Expression} Expression */
+/** @typedef {import("../semantic/types.js").SemanticTypeName} Scalar */
+/** @typedef {{expression: Expression, path: string, type: Scalar, name?: string}} PlannedValue */
+/** @typedef {{result: PlannedValue, operands: PlannedValue[], rightSteps?: PlannedStep[]}} PlannedStep */
+/** @typedef {Array<string | number | boolean | Signature>} Signature */
+/** Private occurrence-based native expression sequencer; it never rewrites the IR. */
+export class OrderedExpressionPlanner {
+    /**
+     * Indexes already validated callable return types.
+     * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
+     * @param {"c" | "cpp"} [language] - Owning backend diagnostic language.
+     */
+    constructor(module, language = "c") {
+        this.language = language;
+        this.functions = new Map(module.functions.map((declaration) => [declaration.name, declaration.returnType.name]));
+        this.nextTemporary = 1;
+    }
+    /**
+     * Resolves an expression type from the validated lexical environment.
+     * @param {Expression} expression - Semantic expression.
+     * @param {Map<string, Scalar>} bindings - Lexical scalar types.
+     * @returns {Scalar} Exact semantic 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;
+        const type = expression.kind == "CallExpression" ? this.functions.get(expression.callee) : bindings.get(expression.name);
+        if (!type)
+            return unsupportedCapability(this.language, "unresolved expression type", expression.location);
+        return type;
+    }
+    /**
+     * Plans one expression in semantic order, keeping the short-circuit RHS conditional.
+     * @param {Expression} expression - Original occurrence.
+     * @param {string} path - Occurrence path.
+     * @param {Map<string, Scalar>} bindings - Lexical types.
+     * @param {PlannedStep[]} steps - Enclosing ordered prelude.
+     * @returns {PlannedValue} 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 {PlannedStep[] | 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));
+        }
+        const planned = { ...result, name: this.allocate(expression) };
+        steps.push({ operands, result: planned });
+        return planned;
+    }
+    /**
+     * Allocates one bounded deterministic occurrence name.
+     * @param {Expression} expression - Related expression.
+     * @returns {string} Reserved temporary name.
+     */
+    allocate(expression) {
+        if (this.nextTemporary > 999999)
+            return unsupportedCapability(this.language, "ordered-expression occurrence limit", expression.location);
+        return `semantifold_ordered_${String(this.nextTemporary++).padStart(6, "0")}`;
+    }
+}
+/**
+ * Binds a region marker to its semantic consumer and expression, independently of locations.
+ * The digest detects edits; structural CST validation remains mandatory and authoritative.
+ * @param {import("../semantic/types.js").Statement} statement - Reconstructed or original statement.
+ * @returns {string} Stable SHA-256 profile signature.
+ */
+export function statementSignature(statement) {
+    const consumer = statement.kind == "LocalDeclaration" ? [statement.kind, statement.name, statement.type.name, 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.expression;
+    return createHash("sha256").update(JSON.stringify([consumer, expressionSignature(expression)])).digest("hex");
+}
+/**
+ * Serializes only the closed semantic expression fields.
+ * @param {Expression} expression - Expression occurrence.
+ * @returns {Signature} Signature data.
+ */
+function expressionSignature(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(expressionSignature)];
+    if (expression.kind == "UnaryExpression")
+        return [expression.kind, expression.operation, expression.type, expressionSignature(expression.operand)];
+    return [expression.kind, expression.operation, expression.type, expressionSignature(expression.left), expressionSignature(expression.right)];
+}
+/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */
+/**
+ * Plans every occurrence before constructing a writer or exposing either artifact.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
+ * @param {"c" | "cpp"} [language] - Native diagnostic owner.
+ * @returns {Map<string, StatementPlan>} Plans indexed by semantic occurrence path.
+ */
+export function planNativeModule(module, language = "c") {
+    const planner = new OrderedExpressionPlanner(module, language);
+    /** @type {Map<string, StatementPlan>} */
+    const plans = new Map();
+    /**
+     * Plans one lexical block with independent branch environments.
+     * @param {import("../semantic/types.js").Block} block - Semantic block.
+     * @param {string} path - Occurrence path.
+     * @param {Map<string, import("../semantic/types.js").SemanticTypeName>} inherited - Visible types.
+     * @returns {void}
+     */
+    function 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.expression;
+            /** @type {PlannedStep[]} */
+            const steps = [];
+            const value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps);
+            if (plans.size >= 999999)
+                unsupportedCapability(language, "ordered statement limit", statement.location);
+            plans.set(statementPath, { id: String(plans.size + 1).padStart(6, "0"), steps, value });
+            if (statement.kind == "LocalDeclaration")
+                bindings.set(statement.name, statement.type.name);
+            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, parameter.type.name]))));
+    visit(module.entryPoint.body, "/entryPoint/body", new Map());
+    return plans;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ordered-expressions.js","sourceRoot":"","sources":["../../../src/backends/ordered-expressions.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createHash} from \"node:crypto\"\nimport {unsupportedCapability} from \"../diagnostic.js\"\n\n/** @typedef {import(\"../semantic/types.js\").Expression} Expression */\n/** @typedef {import(\"../semantic/types.js\").SemanticTypeName} Scalar */\n/** @typedef {{expression: Expression, path: string, type: Scalar, name?: string}} PlannedValue */\n/** @typedef {{result: PlannedValue, operands: PlannedValue[], rightSteps?: PlannedStep[]}} PlannedStep */\n/** @typedef {Array<string | number | boolean | Signature>} Signature */\n\n/** Private occurrence-based native expression sequencer; it never rewrites the IR. */\nexport class OrderedExpressionPlanner {\n  /**\n   * Indexes already validated callable return types.\n   * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated module.\n   * @param {\"c\" | \"cpp\"} [language] - Owning backend diagnostic language.\n   */\n  constructor(module, language = \"c\") {\n    this.language = language\n    this.functions = new Map(module.functions.map((declaration) => [declaration.name, declaration.returnType.name]))\n    this.nextTemporary = 1\n  }\n\n  /**\n   * Resolves an expression type from the validated lexical environment.\n   * @param {Expression} expression - Semantic expression.\n   * @param {Map<string, Scalar>} bindings - Lexical scalar types.\n   * @returns {Scalar} Exact semantic 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    const type = expression.kind == \"CallExpression\" ? this.functions.get(expression.callee) : bindings.get(expression.name)\n\n    if (!type) return unsupportedCapability(this.language, \"unresolved expression type\", expression.location)\n    return type\n  }\n\n  /**\n   * Plans one expression in semantic order, keeping the short-circuit RHS conditional.\n   * @param {Expression} expression - Original occurrence.\n   * @param {string} path - Occurrence path.\n   * @param {Map<string, Scalar>} bindings - Lexical types.\n   * @param {PlannedStep[]} steps - Enclosing ordered prelude.\n   * @returns {PlannedValue} 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 {PlannedStep[] | 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    const planned = {...result, name: this.allocate(expression)}\n\n    steps.push({operands, result: planned})\n    return planned\n  }\n\n  /**\n   * Allocates one bounded deterministic occurrence name.\n   * @param {Expression} expression - Related expression.\n   * @returns {string} Reserved temporary name.\n   */\n  allocate(expression) {\n    if (this.nextTemporary > 999999) return unsupportedCapability(this.language, \"ordered-expression occurrence limit\", expression.location)\n    return `semantifold_ordered_${String(this.nextTemporary++).padStart(6, \"0\")}`\n  }\n}\n\n/**\n * Binds a region marker to its semantic consumer and expression, independently of locations.\n * The digest detects edits; structural CST validation remains mandatory and authoritative.\n * @param {import(\"../semantic/types.js\").Statement} statement - Reconstructed or original statement.\n * @returns {string} Stable SHA-256 profile signature.\n */\nexport function statementSignature(statement) {\n  const consumer = statement.kind == \"LocalDeclaration\" ? [statement.kind, statement.name, statement.type.name, 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 : statement.expression\n\n  return createHash(\"sha256\").update(JSON.stringify([consumer, expressionSignature(expression)])).digest(\"hex\")\n}\n\n/**\n * Serializes only the closed semantic expression fields.\n * @param {Expression} expression - Expression occurrence.\n * @returns {Signature} Signature data.\n */\nfunction expressionSignature(expression) {\n  if (expression.kind == \"IdentifierExpression\") return [expression.kind, expression.name]\n  if (expression.kind == \"IntegerLiteral\" || expression.kind == \"BooleanLiteral\" || expression.kind == \"StringLiteral\") return [expression.kind, expression.value]\n  if (expression.kind == \"CallExpression\") return [expression.kind, expression.callee, ...expression.arguments.map(expressionSignature)]\n  if (expression.kind == \"UnaryExpression\") return [expression.kind, expression.operation, expression.type, expressionSignature(expression.operand)]\n  return [expression.kind, expression.operation, expression.type, expressionSignature(expression.left), expressionSignature(expression.right)]\n}\n\n/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */\n/**\n * Plans every occurrence before constructing a writer or exposing either artifact.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated module.\n * @param {\"c\" | \"cpp\"} [language] - Native diagnostic owner.\n * @returns {Map<string, StatementPlan>} Plans indexed by semantic occurrence path.\n */\nexport function planNativeModule(module, language = \"c\") {\n  const planner = new OrderedExpressionPlanner(module, language)\n  /** @type {Map<string, StatementPlan>} */\n  const plans = new Map()\n\n  /**\n   * Plans one lexical block with independent branch environments.\n   * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n   * @param {string} path - Occurrence path.\n   * @param {Map<string, import(\"../semantic/types.js\").SemanticTypeName>} inherited - Visible types.\n   * @returns {void}\n   */\n  function 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 : statement.expression\n      /** @type {PlannedStep[]} */\n      const steps = []\n      const value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps)\n\n      if (plans.size >= 999999) unsupportedCapability(language, \"ordered statement limit\", statement.location)\n      plans.set(statementPath, {id: String(plans.size + 1).padStart(6, \"0\"), steps, value})\n      if (statement.kind == \"LocalDeclaration\") bindings.set(statement.name, statement.type.name)\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, parameter.type.name]))))\n  visit(module.entryPoint.body, \"/entryPoint/body\", new Map())\n  return plans\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/backends/scalars.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAJ5B,OAAO,sBAAsB,EAAE,gBAIH,EAAE,IAAI,EAHlC,OAAO,sBAAsB,EAAE,aAGG,GAFhC,MAAM,CAIlB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAJ/B,OAAO,sBAAsB,EAAE,gBAIA,EAAE,KAAK,EAHtC,MAGsC,GAFpC,MAAM,CAYlB"}
+{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/backends/scalars.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAJ5B,OAAO,sBAAsB,EAAE,gBAIH,EAAE,IAAI,EAHlC,OAAO,sBAAsB,EAAE,aAGG,GAFhC,MAAM,CAIlB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAJ/B,OAAO,sBAAsB,EAAE,gBAIA,EAAE,KAAK,EAHtC,MAGsC,GAFpC,MAAM,CAclB"}

package/build/src/backends/scalars.js

@@ -1,6 +1,10 @@
 // @ts-check
 /** @type {Readonly<Record<import("../semantic/types.js").SemanticLanguage, Readonly<Record<import("../semantic/types.js").SemanticTypeName, string>>>>} */
 const targetScalarTypes = Object.freeze({
+    cpp: Object.freeze({ boolean: "bool", integer: "std::int64_t", string: "std::string" }),
+    c: Object.freeze({ boolean: "bool", integer: "int64_t", string: "SemantifoldString" }),
+    csharp: Object.freeze({ boolean: "bool", integer: "long", string: "string" }),
+    go: Object.freeze({ boolean: "bool", integer: "int64", string: "string" }),
     java: Object.freeze({ boolean: "boolean", integer: "int", string: "String" }),
     javascript: Object.freeze({ boolean: "boolean", integer: "number", string: "string" }),
     php: Object.freeze({ boolean: "bool", integer: "int", string: "string" }),
@@ -33,7 +37,8 @@ export function emitStringLiteral(language, value) {
     const literal = JSON.stringify(value);
     if (typeof literal != "string")
         throw new TypeError("A validated semantic string did not serialize.");
-    return literal.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+    const escapedLineSeparators = literal.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+    return language == "csharp" ? escapedLineSeparators.replaceAll("\u0085", "\\u0085") : escapedLineSeparators;
 }
 /**
  * Emits a PHP double-quoted string while preventing interpolation.
@@ -136,4 +141,4 @@ function emitJavaString(value) {
     }
     return `${emitted}"`;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scalars.js","sourceRoot":"","sources":["../../../src/backends/scalars.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/** @type {Readonly<Record<import(\"../semantic/types.js\").SemanticLanguage, Readonly<Record<import(\"../semantic/types.js\").SemanticTypeName, string>>>>} */\nconst targetScalarTypes = Object.freeze({\n  java: Object.freeze({boolean: \"boolean\", integer: \"int\", string: \"String\"}),\n  javascript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\"}),\n  php: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"string\"}),\n  python: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"str\"}),\n  ruby: Object.freeze({boolean: \"bool\", integer: \"Integer\", string: \"String\"}),\n  typescript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\"})\n})\n\n/**\n * Emits one target-language scalar type spelling.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {import(\"../semantic/types.js\").TypeReference} type - Semantic scalar type.\n * @returns {string} Target type spelling.\n */\nexport function emitScalarType(language, type) {\n  return targetScalarTypes[language][type.name]\n}\n\n/**\n * Emits a safely escaped target-language string literal.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Target string literal.\n */\nexport function emitStringLiteral(language, value) {\n  if (language == \"php\") return emitPhpString(value)\n  if (language == \"ruby\") return emitRubyString(value)\n  if (language == \"java\") return emitJavaString(value)\n\n  const literal = JSON.stringify(value)\n\n  if (typeof literal != \"string\") throw new TypeError(\"A validated semantic string did not serialize.\")\n\n  return literal.replaceAll(\"\\u2028\", \"\\\\u2028\").replaceAll(\"\\u2029\", \"\\\\u2029\")\n}\n\n/**\n * Emits a PHP double-quoted string while preventing interpolation.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} PHP string literal.\n */\nfunction emitPhpString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"$\") emitted += \"\\\\$\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\v\") emitted += \"\\\\v\"\n    else if (codePoint == 27) emitted += \"\\\\e\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\x${codePoint.toString(16).padStart(2, \"0\")}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n\n/**\n * Emits a Ruby double-quoted string while preventing interpolation.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Ruby string literal.\n */\nfunction emitRubyString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"#\") emitted += \"\\\\#\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\v\") emitted += \"\\\\v\"\n    else if (codePoint == 27) emitted += \"\\\\e\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\u{${codePoint.toString(16)}}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n\n/**\n * Emits a Java string using standard or fixed-width octal control escapes.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Java string literal.\n */\nfunction emitJavaString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"\\b\") emitted += \"\\\\b\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\${codePoint.toString(8).padStart(3, \"0\")}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scalars.js","sourceRoot":"","sources":["../../../src/backends/scalars.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/** @type {Readonly<Record<import(\"../semantic/types.js\").SemanticLanguage, Readonly<Record<import(\"../semantic/types.js\").SemanticTypeName, string>>>>} */\nconst targetScalarTypes = Object.freeze({\n  cpp: Object.freeze({boolean: \"bool\", integer: \"std::int64_t\", string: \"std::string\"}),\n  c: Object.freeze({boolean: \"bool\", integer: \"int64_t\", string: \"SemantifoldString\"}),\n  csharp: Object.freeze({boolean: \"bool\", integer: \"long\", string: \"string\"}),\n  go: Object.freeze({boolean: \"bool\", integer: \"int64\", string: \"string\"}),\n  java: Object.freeze({boolean: \"boolean\", integer: \"int\", string: \"String\"}),\n  javascript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\"}),\n  php: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"string\"}),\n  python: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"str\"}),\n  ruby: Object.freeze({boolean: \"bool\", integer: \"Integer\", string: \"String\"}),\n  typescript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\"})\n})\n\n/**\n * Emits one target-language scalar type spelling.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {import(\"../semantic/types.js\").TypeReference} type - Semantic scalar type.\n * @returns {string} Target type spelling.\n */\nexport function emitScalarType(language, type) {\n  return targetScalarTypes[language][type.name]\n}\n\n/**\n * Emits a safely escaped target-language string literal.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Target string literal.\n */\nexport function emitStringLiteral(language, value) {\n  if (language == \"php\") return emitPhpString(value)\n  if (language == \"ruby\") return emitRubyString(value)\n  if (language == \"java\") return emitJavaString(value)\n\n  const literal = JSON.stringify(value)\n\n  if (typeof literal != \"string\") throw new TypeError(\"A validated semantic string did not serialize.\")\n\n  const escapedLineSeparators = literal.replaceAll(\"\\u2028\", \"\\\\u2028\").replaceAll(\"\\u2029\", \"\\\\u2029\")\n\n  return language == \"csharp\" ? escapedLineSeparators.replaceAll(\"\\u0085\", \"\\\\u0085\") : escapedLineSeparators\n}\n\n/**\n * Emits a PHP double-quoted string while preventing interpolation.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} PHP string literal.\n */\nfunction emitPhpString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"$\") emitted += \"\\\\$\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\v\") emitted += \"\\\\v\"\n    else if (codePoint == 27) emitted += \"\\\\e\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\x${codePoint.toString(16).padStart(2, \"0\")}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n\n/**\n * Emits a Ruby double-quoted string while preventing interpolation.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Ruby string literal.\n */\nfunction emitRubyString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"#\") emitted += \"\\\\#\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\v\") emitted += \"\\\\v\"\n    else if (codePoint == 27) emitted += \"\\\\e\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\u{${codePoint.toString(16)}}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n\n/**\n * Emits a Java string using standard or fixed-width octal control escapes.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Java string literal.\n */\nfunction emitJavaString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"\\b\") emitted += \"\\\\b\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\${codePoint.toString(8).padStart(3, \"0\")}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/backends/shared.js"],"names":[],"mappings":"AA6BA;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAJjC,OAAO,sBAAsB,EAAE,cAIE,EAAE,QAAQ,EAH3C,OAAO,sBAAsB,EAAE,gBAGY,GAFzC,IAAI,CAuBhB;AA4PD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAP1B,OAAO,aAAa,EAAE,YAOI,EAAE,UAAU,EANtC,OAAO,sBAAsB,EAAE,UAMO,EAAE,IAAI,EAL5C,MAK4C,EAAE,QAAQ,EAJtD,OAAO,sBAAsB,EAAE,gBAIuB,EAAE,cAAc,EAHtE,CAAC,IAAI,EAAE,MAAM,KAAK,MAGoD,GAFpE,IAAI,CA0EhB;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAH1C,OAAO,sBAAsB,EAAE,cAGW,GAFxC,OAAO,CAKnB"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/backends/shared.js"],"names":[],"mappings":"AA6BA;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAJjC,OAAO,sBAAsB,EAAE,cAIE,EAAE,QAAQ,EAH3C,OAAO,sBAAsB,EAAE,gBAGY,GAFzC,IAAI,CAiChB;AAwQD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAP1B,OAAO,aAAa,EAAE,YAOI,EAAE,UAAU,EANtC,OAAO,sBAAsB,EAAE,UAMO,EAAE,IAAI,EAL5C,MAK4C,EAAE,QAAQ,EAJtD,OAAO,sBAAsB,EAAE,gBAIuB,EAAE,cAAc,EAHtE,CAAC,IAAI,EAAE,MAAM,KAAK,MAGoD,GAFpE,IAAI,CAgGhB;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAH1C,OAAO,sBAAsB,EAAE,cAGW,GAFxC,OAAO,CAKnB"}