semantifold 0.3.0 → 0.5.0

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

@@ -1,15 +1,23 @@
 /**
- * Emits one target-language scalar type spelling.
- * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
- * @param {import("../semantic/types.js").TypeReference} type - Semantic scalar type.
+ * Emits one target-language scalar or function-return type spelling.
+ * @param {import("../semantic/types.js").TextBackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
  * @returns {string} Target type spelling.
  */
-export declare function emitScalarType(language: import("../semantic/types.js").SemanticLanguage, type: import("../semantic/types.js").TypeReference): string;
+export declare function emitScalarType(language: import("../semantic/types.js").TextBackendLanguage, type: import("../semantic/types.js").SemanticFunctionReturnType): string;
+/**
+ * Emits one recursively parameterized semantic type for the Task 006 cohort.
+ * @param {import("../semantic/types.js").TextBackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @param {boolean} [javaBoxed] - Whether Java scalar arguments require boxed spellings.
+ * @returns {string} Exact target spelling.
+ */
+export declare function emitSemanticType(language: import("../semantic/types.js").TextBackendLanguage, type: import("../semantic/types.js").SemanticFunctionReturnType, javaBoxed?: boolean): string;
 /**
  * Emits a safely escaped target-language string literal.
- * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {import("../semantic/types.js").TextBackendLanguage} language - Target language.
  * @param {string} value - Valid Unicode scalar string.
  * @returns {string} Target string literal.
  */
-export declare function emitStringLiteral(language: import("../semantic/types.js").SemanticLanguage, value: string): string;
+export declare function emitStringLiteral(language: import("../semantic/types.js").TextBackendLanguage, value: string): string;
 //# sourceMappingURL=scalars.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/backends/scalars.js"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAJ5B,OAAO,sBAAsB,EAAE,mBAIH,EAAE,IAAI,EAHlC,OAAO,sBAAsB,EAAE,0BAGG,GAFhC,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAL9B,OAAO,sBAAsB,EAAE,mBAKD,EAAE,IAAI,EAJpC,OAAO,sBAAsB,EAAE,0BAIK,EAAE,SAAS,AAHvD,CACA,EADQ,OAGuD,GAFrD,MAAM,CAmClB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAJ/B,OAAO,sBAAsB,EAAE,mBAIA,EAAE,KAAK,EAHtC,MAGsC,GAFpC,MAAM,CAiBlB"}

package/build/src/backends/scalars.js

@@ -1,45 +1,165 @@
 // @ts-check
-/** @type {Readonly<Record<import("../semantic/types.js").SemanticLanguage, Readonly<Record<import("../semantic/types.js").SemanticTypeName, string>>>>} */
+/** @type {Readonly<Record<import("../semantic/types.js").TextBackendLanguage, Readonly<Record<import("../semantic/types.js").FunctionReturnTypeName, 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" }),
-    python: Object.freeze({ boolean: "bool", integer: "int", string: "str" }),
-    ruby: Object.freeze({ boolean: "bool", integer: "Integer", string: "String" }),
-    typescript: Object.freeze({ boolean: "boolean", integer: "number", string: "string" })
+    dart: Object.freeze({ boolean: "bool", integer: "int", string: "String", void: "void" }),
+    swift: Object.freeze({ boolean: "Bool", integer: "Int64", string: "String", void: "Void" }),
+    rust: Object.freeze({ boolean: "bool", integer: "i64", string: "String", void: "()" }),
+    cpp: Object.freeze({ boolean: "bool", integer: "std::int64_t", string: "std::string", void: "void" }),
+    c: Object.freeze({ boolean: "bool", integer: "int64_t", string: "SemantifoldString", void: "void" }),
+    csharp: Object.freeze({ boolean: "bool", integer: "long", string: "string", void: "void" }),
+    go: Object.freeze({ boolean: "bool", integer: "int64", string: "string", void: "void" }),
+    java: Object.freeze({ boolean: "boolean", integer: "int", string: "String", void: "void" }),
+    kotlin: Object.freeze({ boolean: "Boolean", integer: "Long", string: "String", void: "Unit" }),
+    javascript: Object.freeze({ boolean: "boolean", integer: "number", string: "string", void: "void" }),
+    php: Object.freeze({ boolean: "bool", integer: "int", string: "string", void: "void" }),
+    python: Object.freeze({ boolean: "bool", integer: "int", string: "str", void: "None" }),
+    ruby: Object.freeze({ boolean: "bool", integer: "Integer", string: "String", void: "void" }),
+    typescript: Object.freeze({ boolean: "boolean", integer: "number", string: "string", void: "void" })
 });
 /**
- * Emits one target-language scalar type spelling.
- * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
- * @param {import("../semantic/types.js").TypeReference} type - Semantic scalar type.
+ * Emits one target-language scalar or function-return type spelling.
+ * @param {import("../semantic/types.js").TextBackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
  * @returns {string} Target type spelling.
  */
 export function emitScalarType(language, type) {
-    return targetScalarTypes[language][type.name];
+    return type.kind == "TypeReference" ? targetScalarTypes[language][type.name] : "";
+}
+/**
+ * Emits one recursively parameterized semantic type for the Task 006 cohort.
+ * @param {import("../semantic/types.js").TextBackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @param {boolean} [javaBoxed] - Whether Java scalar arguments require boxed spellings.
+ * @returns {string} Exact target spelling.
+ */
+export function emitSemanticType(language, type, javaBoxed = false) {
+    if (type.kind == "RecordType" || type.kind == "ReferenceType") {
+        throw new TypeError("Nominal type emission requires declaration context.");
+    }
+    if (type.kind == "OwnedResourceType" || type.kind == "OwnedReferenceType") {
+        throw new TypeError("Owned type emission requires declaration context.");
+    }
+    if (type.kind == "TypeVariableReference")
+        throw new TypeError("Type-variable emission requires declaration context.");
+    if (type.kind == "OptionalType")
+        throw new TypeError("Optional type emission requires target-specific context.");
+    if (type.kind == "TypeReference") {
+        if (language == "java" && javaBoxed) {
+            return type.name == "integer" ? "Integer" : type.name == "boolean" ? "Boolean" : type.name == "string" ? "String" : "void";
+        }
+        return emitScalarType(language, type);
+    }
+    const element = type.kind == "ListType" ? type.elementType : type.valueType;
+    const nested = emitSemanticType(language, element, language == "java");
+    if (type.kind == "ListType") {
+        if (language == "ruby")
+            return `Array[${nested}]`;
+        if (language == "php")
+            return `list<${nested}>`;
+        if (language == "javascript" || language == "typescript")
+            return `ReadonlyArray<${nested}>`;
+        if (language == "java")
+            return `java.util.List<${nested}>`;
+    }
+    else {
+        if (language == "ruby")
+            return `Hash[String,${nested}]`;
+        if (language == "php")
+            return `array<string,${nested}>`;
+        if (language == "javascript" || language == "typescript")
+            return `ReadonlyMap<string, ${nested}>`;
+        if (language == "java")
+            return `java.util.Map<String,${nested}>`;
+    }
+    return "";
 }
 /**
  * Emits a safely escaped target-language string literal.
- * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {import("../semantic/types.js").TextBackendLanguage} language - Target language.
  * @param {string} value - Valid Unicode scalar string.
  * @returns {string} Target string literal.
  */
 export function emitStringLiteral(language, value) {
+    if (language == "dart")
+        return emitDartString(value);
+    if (language == "swift")
+        return emitSwiftString(value);
     if (language == "php")
         return emitPhpString(value);
     if (language == "ruby")
         return emitRubyString(value);
     if (language == "java")
         return emitJavaString(value);
+    if (language == "kotlin")
+        return emitKotlinString(value);
     const literal = JSON.stringify(value);
     if (typeof literal != "string")
         throw new TypeError("A validated semantic string did not serialize.");
     const escapedLineSeparators = literal.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
     return language == "csharp" ? escapedLineSeparators.replaceAll("\u0085", "\\u0085") : escapedLineSeparators;
 }
+/**
+ * Emits an ordinary noninterpolated Dart string.
+ * @param {string} value Valid Unicode scalar string.
+ * @returns {string} Dart string literal.
+ */
+function emitDartString(value) {
+    let emitted = "\"";
+    for (const character of value) {
+        const codePoint = /** @type {number} */ (character.codePointAt(0));
+        if (character == "\"")
+            emitted += "\\\"";
+        else if (character == "\\")
+            emitted += "\\\\";
+        else if (character == "$")
+            emitted += "\\$";
+        else if (character == "\n")
+            emitted += "\\n";
+        else if (character == "\r")
+            emitted += "\\r";
+        else if (character == "\t")
+            emitted += "\\t";
+        else if (character == "\b")
+            emitted += "\\b";
+        else if (character == "\f")
+            emitted += "\\f";
+        else if (character == "\v")
+            emitted += "\\v";
+        else if (codePoint < 32 || codePoint == 127 || codePoint == 0x85 || codePoint == 0x2028 || codePoint == 0x2029) {
+            emitted += `\\u{${codePoint.toString(16)}}`;
+        }
+        else
+            emitted += character;
+    }
+    return `${emitted}"`;
+}
+/**
+ * Emits one noninterpolated Swift string over Unicode scalar values.
+ * @param {string} value - Valid Unicode scalar string.
+ * @returns {string} Swift string literal.
+ */
+function emitSwiftString(value) {
+    let emitted = "\"";
+    for (const character of value) {
+        const codePoint = /** @type {number} */ (character.codePointAt(0));
+        if (character == "\"")
+            emitted += "\\\"";
+        else if (character == "\\")
+            emitted += "\\\\";
+        else if (character == "\n")
+            emitted += "\\n";
+        else if (character == "\r")
+            emitted += "\\r";
+        else if (character == "\t")
+            emitted += "\\t";
+        else if (codePoint < 32 || codePoint == 127 || codePoint == 0x85 || codePoint == 0x2028 || codePoint == 0x2029) {
+            emitted += `\\u{${codePoint.toString(16)}}`;
+        }
+        else
+            emitted += character;
+    }
+    return `${emitted}"`;
+}
 /**
  * Emits a PHP double-quoted string while preventing interpolation.
  * @param {string} value - Valid Unicode scalar string.
@@ -141,4 +261,34 @@ 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  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"]}
+/**
+ * Emits an ordinary noninterpolated Kotlin string over Unicode scalar values.
+ * @param {string} value - Valid Unicode scalar string.
+ * @returns {string} Kotlin string literal.
+ */
+function emitKotlinString(value) {
+    let emitted = "\"";
+    for (const character of value) {
+        const codePoint = /** @type {number} */ (character.codePointAt(0));
+        if (character == "\"")
+            emitted += "\\\"";
+        else if (character == "\\")
+            emitted += "\\\\";
+        else if (character == "$")
+            emitted += "\\$";
+        else if (character == "\b")
+            emitted += "\\b";
+        else if (character == "\t")
+            emitted += "\\t";
+        else if (character == "\n")
+            emitted += "\\n";
+        else if (character == "\r")
+            emitted += "\\r";
+        else if (codePoint < 32 || codePoint == 127)
+            emitted += `\\u${codePoint.toString(16).padStart(4, "0")}`;
+        else
+            emitted += character;
+    }
+    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\").TextBackendLanguage, Readonly<Record<import(\"../semantic/types.js\").FunctionReturnTypeName, string>>>>} */\nconst targetScalarTypes = Object.freeze({\n  dart: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"String\", void: \"void\"}),\n  swift: Object.freeze({boolean: \"Bool\", integer: \"Int64\", string: \"String\", void: \"Void\"}),\n  rust: Object.freeze({boolean: \"bool\", integer: \"i64\", string: \"String\", void: \"()\"}),\n  cpp: Object.freeze({boolean: \"bool\", integer: \"std::int64_t\", string: \"std::string\", void: \"void\"}),\n  c: Object.freeze({boolean: \"bool\", integer: \"int64_t\", string: \"SemantifoldString\", void: \"void\"}),\n  csharp: Object.freeze({boolean: \"bool\", integer: \"long\", string: \"string\", void: \"void\"}),\n  go: Object.freeze({boolean: \"bool\", integer: \"int64\", string: \"string\", void: \"void\"}),\n  java: Object.freeze({boolean: \"boolean\", integer: \"int\", string: \"String\", void: \"void\"}),\n  kotlin: Object.freeze({boolean: \"Boolean\", integer: \"Long\", string: \"String\", void: \"Unit\"}),\n  javascript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\", void: \"void\"}),\n  php: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"string\", void: \"void\"}),\n  python: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"str\", void: \"None\"}),\n  ruby: Object.freeze({boolean: \"bool\", integer: \"Integer\", string: \"String\", void: \"void\"}),\n  typescript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\", void: \"void\"})\n})\n\n/**\n * Emits one target-language scalar or function-return type spelling.\n * @param {import(\"../semantic/types.js\").TextBackendLanguage} language - Target language.\n * @param {import(\"../semantic/types.js\").SemanticFunctionReturnType} type - Semantic type.\n * @returns {string} Target type spelling.\n */\nexport function emitScalarType(language, type) {\n  return type.kind == \"TypeReference\" ? targetScalarTypes[language][type.name] : \"\"\n}\n\n/**\n * Emits one recursively parameterized semantic type for the Task 006 cohort.\n * @param {import(\"../semantic/types.js\").TextBackendLanguage} language - Target language.\n * @param {import(\"../semantic/types.js\").SemanticFunctionReturnType} type - Semantic type.\n * @param {boolean} [javaBoxed] - Whether Java scalar arguments require boxed spellings.\n * @returns {string} Exact target spelling.\n */\nexport function emitSemanticType(language, type, javaBoxed = false) {\n  if (type.kind == \"RecordType\" || type.kind == \"ReferenceType\") {\n    throw new TypeError(\"Nominal type emission requires declaration context.\")\n  }\n  if (type.kind == \"OwnedResourceType\" || type.kind == \"OwnedReferenceType\") {\n    throw new TypeError(\"Owned type emission requires declaration context.\")\n  }\n  if (type.kind == \"TypeVariableReference\") throw new TypeError(\"Type-variable emission requires declaration context.\")\n  if (type.kind == \"OptionalType\") throw new TypeError(\"Optional type emission requires target-specific context.\")\n  if (type.kind == \"TypeReference\") {\n    if (language == \"java\" && javaBoxed) {\n      return type.name == \"integer\" ? \"Integer\" : type.name == \"boolean\" ? \"Boolean\" : type.name == \"string\" ? \"String\" : \"void\"\n    }\n\n    return emitScalarType(language, type)\n  }\n\n  const element = type.kind == \"ListType\" ? type.elementType : type.valueType\n  const nested = emitSemanticType(language, element, language == \"java\")\n\n  if (type.kind == \"ListType\") {\n    if (language == \"ruby\") return `Array[${nested}]`\n    if (language == \"php\") return `list<${nested}>`\n    if (language == \"javascript\" || language == \"typescript\") return `ReadonlyArray<${nested}>`\n    if (language == \"java\") return `java.util.List<${nested}>`\n  } else {\n    if (language == \"ruby\") return `Hash[String,${nested}]`\n    if (language == \"php\") return `array<string,${nested}>`\n    if (language == \"javascript\" || language == \"typescript\") return `ReadonlyMap<string, ${nested}>`\n    if (language == \"java\") return `java.util.Map<String,${nested}>`\n  }\n\n  return \"\"\n}\n\n/**\n * Emits a safely escaped target-language string literal.\n * @param {import(\"../semantic/types.js\").TextBackendLanguage} 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 == \"dart\") return emitDartString(value)\n  if (language == \"swift\") return emitSwiftString(value)\n  if (language == \"php\") return emitPhpString(value)\n  if (language == \"ruby\") return emitRubyString(value)\n  if (language == \"java\") return emitJavaString(value)\n  if (language == \"kotlin\") return emitKotlinString(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 an ordinary noninterpolated Dart string.\n * @param {string} value Valid Unicode scalar string.\n * @returns {string} Dart string literal.\n */\nfunction emitDartString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = /** @type {number} */ (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 == \"\\b\") emitted += \"\\\\b\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\v\") emitted += \"\\\\v\"\n    else if (codePoint < 32 || codePoint == 127 || codePoint == 0x85 || codePoint == 0x2028 || codePoint == 0x2029) {\n      emitted += `\\\\u{${codePoint.toString(16)}}`\n    } else emitted += character\n  }\n  return `${emitted}\"`\n}\n\n/**\n * Emits one noninterpolated Swift string over Unicode scalar values.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Swift string literal.\n */\nfunction emitSwiftString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = /** @type {number} */ (character.codePointAt(0))\n\n    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 (codePoint < 32 || codePoint == 127 || codePoint == 0x85 || codePoint == 0x2028 || codePoint == 0x2029) {\n      emitted += `\\\\u{${codePoint.toString(16)}}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\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\n/**\n * Emits an ordinary noninterpolated Kotlin string over Unicode scalar values.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Kotlin string literal.\n */\nfunction emitKotlinString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = /** @type {number} */ (character.codePointAt(0))\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else 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 == \"\\r\") emitted += \"\\\\r\"\n    else if (codePoint < 32 || codePoint == 127) emitted += `\\\\u${codePoint.toString(16).padStart(4, \"0\")}`\n    else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n"]}

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

@@ -1,20 +1,39 @@
 /**
  * Checks the intentionally narrow backend contract.
  * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
- * @param {import("../semantic/types.js").SemanticLanguage} language - Backend language.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Backend language or binary target.
+ * @param {{externalDeclarationIds?: Set<string>, program?: boolean, visibleFunctions?: Map<string, import("../semantic/types.js").FunctionDeclaration>, visibleRecords?: Map<string, import("../semantic/types.js").RecordDeclaration>, visibleClasses?: Map<string, import("../semantic/types.js").ClassDeclaration>, visibleErrors?: Map<string, import("../semantic/types.js").ErrorDeclaration>, visibleCallEffects?: Map<string, Set<string>>}} [options] - Resolved program validation context.
  * @returns {void}
  */
-export declare function validateBackendModule(module: import("../semantic/types.js").SemanticModule, language: import("../semantic/types.js").SemanticLanguage): void;
+export declare function validateBackendModule(module: import("../semantic/types.js").SemanticModule, language: import("../semantic/types.js").BackendLanguage, options?: {
+    externalDeclarationIds?: Set<string>;
+    program?: boolean;
+    visibleFunctions?: Map<string, import("../semantic/types.js").FunctionDeclaration>;
+    visibleRecords?: Map<string, import("../semantic/types.js").RecordDeclaration>;
+    visibleClasses?: Map<string, import("../semantic/types.js").ClassDeclaration>;
+    visibleErrors?: Map<string, import("../semantic/types.js").ErrorDeclaration>;
+    visibleCallEffects?: Map<string, Set<string>>;
+}): void;
+/**
+ * Emits one recursive semantic type while mapping every constituent identity.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @param {string} path - Exact type occurrence path.
+ * @param {import("../semantic/types.js").TextBackendLanguage} language - Target language.
+ * @param {boolean} [javaBoxed] - Whether a Java scalar is a generic argument.
+ * @returns {void}
+ */
+export declare function emitType(writer: import("./writer.js").SourceWriter, type: import("../semantic/types.js").SemanticFunctionReturnType, path: string, language: import("../semantic/types.js").TextBackendLanguage, javaBoxed?: boolean): void;
 /**
  * Emits a supported expression.
  * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
  * @param {import("../semantic/types.js").Expression} expression - Semantic expression.
  * @param {string} path - Exact JSON Pointer for this expression occurrence.
- * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {import("../semantic/types.js").TextBackendLanguage} language - Target language.
  * @param {(name: string) => string} emitIdentifier - Identifier formatter.
  * @returns {void}
  */
-export declare function emitExpression(writer: import("./writer.js").SourceWriter, expression: import("../semantic/types.js").Expression, path: string, language: import("../semantic/types.js").SemanticLanguage, emitIdentifier: (name: string) => string): void;
+export declare function emitExpression(writer: import("./writer.js").SourceWriter, expression: import("../semantic/types.js").Expression, path: string, language: import("../semantic/types.js").TextBackendLanguage, emitIdentifier: (name: string) => string): void;
 /**
  * Reports whether JavaScript-family execution can create IEEE-754 signed zero.
  * Semantifold integers have one mathematical zero, so those targets canonicalize

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,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"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/backends/shared.js"],"names":[],"mappings":"AAqDA;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EALjC,OAAO,sBAAsB,EAAE,cAKE,EAAE,QAAQ,EAJ3C,OAAO,sBAAsB,EAAE,eAIY,EAAE,OAAO,AAH5D,CACA,EADQ;IAAC,sBAAsB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,mBAAmB,CAAC,CAAC;IAAC,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,iBAAiB,CAAC,CAAC;IAAC,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAC,CAAC;IAAC,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAC,CAAC;IAAC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;CAG/W,GAFvD,IAAI,CA4GhB;AAiyDD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAPpB,OAAO,aAAa,EAAE,YAOF,EAAE,IAAI,EAN1B,OAAO,sBAAsB,EAAE,0BAML,EAAE,IAAI,EALhC,MAKgC,EAAE,QAAQ,EAJ1C,OAAO,sBAAsB,EAAE,mBAIW,EAAE,SAAS,AAH7D,CACA,EADQ,OAG6D,GAF3D,IAAI,CA4EhB;AAED;;;;;;;;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,mBAIuB,EAAE,cAAc,EAHtE,CAAC,IAAI,EAAE,MAAM,KAAK,MAGoD,GAFpE,IAAI,CAqZhB;AA8GD;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAH1C,OAAO,sBAAsB,EAAE,cAGW,GAFxC,OAAO,CAKnB"}