semantifold 0.1.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 Kasper Nielsen
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# Semantifold
+
+Semantifold is an early language-neutral semantic code toolkit. This first release candidate proves a deliberately small end-to-end slice: parse equivalent PHP, Ruby, JavaScript with JSDoc, TypeScript, and Java programs into one typed semantic representation, then generate and genuinely execute equivalent programs in every target language.
+
+## Current API
+
+```js
+import {generate, parse} from "semantifold"
+
+const module = parse({
+  filename: "label.ts",
+  language: "typescript",
+  source: `
+    function label(flag: boolean, fallback: string): string {
+      if (flag) return "yes"
+      else return fallback
+    }
+    console.log(label(true, "no"))
+  `
+})
+
+const javaSource = generate({language: "java", module})
+```
+
+`parse` returns parser-independent discriminated semantic nodes with normalized types, source locations, a versioned source registry, and deterministic node/symbol provenance. `generate` accepts that shared module and returns an independently executable source program with its historical bytes unchanged. `generateArtifact` adds an output filename, an authoritative range-based `SemantifoldMapping` v1, and a Source Map v3 sidecar for every target:
+
+```js
+import {generateArtifact, originalPositionFor} from "semantifold"
+
+const artifact = generateArtifact({language: "java", module})
+const original = originalPositionFor(artifact.mapping, {offset: artifact.code.indexOf("label")})
+```
+
+Generated output always uses LF. Exact original content, including LF, CRLF, lone CR, and astral UTF-16 coordinates, remains in the source registry and `sourcesContent`. Optional inline/external `sourceMappingURL` directives apply only to JavaScript and TypeScript; PHP, Ruby, and Java use the same rich/v3 sidecars without foreign comments. See [source provenance and mappings](docs/source-maps.md) for schemas, lookups, composition, diagnostics, directives, and compatibility.
+
+`supportedLanguages` lists the five exact language identifiers, and `SemantifoldDiagnostic` exposes stable error codes for unsupported syntax, missing types, parse failures, binding/type failures, and backend capabilities.
+
+This is not general-purpose support for any of the five languages. The implemented subset is a two-parameter function using explicit integer, boolean, or string types; explicitly typed, initialized scalar locals; plain assignment to mutable locals; ordered lexical blocks; strictly boolean, nested `if` statements with optional `else`; explicit scalar returns; typed scalar operations; a two-argument function call; and sequenced printing. Operations cover integer add/subtract/multiply/negate and ordering, Boolean not/short-circuit and/or, same-type scalar value equality/inequality, and string concatenation. Non-void functions must return on every reachable path, and statements after an unconditional return are rejected. See [language support](docs/language-support.md) before using it on other code.
+
+Semantic integers must be JavaScript-safe mathematical integers and have one unsigned zero. Generated JavaScript and TypeScript canonically render scalar output for modules containing negation or multiplication so IEEE-754 `-0` is observed as `0` without folding or rewriting the semantic operation tree. Java generation narrows literals and compile-time-known arithmetic trees further to signed 32-bit `int`; general runtime-overflow equivalence remains outside the portable contract. Strings are parser-decoded Unicode scalar values and are re-escaped for each target without preserving source quotes or escapes. Equality never coerces and never applies to objects or collections. Division, remainder, exponentiation, bitwise/shift/update/compound operations, ternary/nullish forms, casts/assertions, truthiness, implicit returns, loops, switches, exceptions, and constant folding are unsupported. JavaScript and TypeScript functions must be synchronous and non-generator; Ruby annotations must be immediately associated comment blocks; and PHP accepts only an optional exact `declare(strict_types=1)`. Ruby and PHP local carriers default to mutable and use the exact `@semantifold-immutable` profile tag for immutable locals. Frontends reject syntax instead of dropping receivers, arguments, parameters, declarations, or statements. Before emission, each backend recursively validates blocks, flow, scalar types, typed operations, modeled bindings, mutability, target identifiers, and literal representability.
+
+## Development
+
+Use Node.js 24 and install with `npm ci`. Specs use `@velocious/testing@0.0.0` and the standalone `velocious-test` runner. Run a focused spec with `npx velocious-test spec/repository-contract.spec.js`; run the framework-native `spec` directory discovery with `npm test`.
+
+The complete local gate is:
+
+```sh
+npm test
+npm run lint
+npm run typecheck
+npm run build
+npm audit --audit-level=high
+npm ls --omit=dev --all
+npm pack --dry-run --json
+```
+
+The execution specs require PHP CLI, Ruby, TypeScript, and a Java JDK in addition to Node; missing tools are failures. The canonical container provides them: `docker compose up --build --detach`, followed by `docker compose exec dev npm ci` and the commands above.
+
+## Documentation
+
+- [Goals](docs/goals.md)
+- [Architecture](docs/architecture.md)
+- [Coding standards](docs/coding-standards.md)
+- [Language support](docs/language-support.md)
+- [Testing](docs/testing.md)
+- [Source provenance and mappings](docs/source-maps.md)
+- [Language feature roadmap](https://github.com/kaspernj/semantifold/blob/master/todo/README.md)
+- [Initial toolchain plan](docs/plans/2026-09-02-initial-toolchain.md)
+
+Semantifold is ISC licensed.

package/build/index.d.ts

@@ -0,0 +1,54 @@
+export { SemantifoldDiagnostic } from "./src/diagnostic.js";
+export { getNodeProvenance, getSymbolProvenance } from "./src/semantic/provenance.js";
+export { primaryLocation } from "./src/semantic/provenance.js";
+export { composeMappings, composeSourceMaps, generatedPositionFor, mappingFromSourceMap, originalPositionFor, parseMapping, remapDiagnostic, remapLocation, spansForNode, spansForSymbol, stringifyMapping, toSourceMapV3 } from "./src/mapping.js";
+/** @type {readonly import("./src/semantic/types.js").SemanticLanguage[]} */
+export declare const supportedLanguages: readonly import("./src/semantic/types.js").SemanticLanguage[];
+/**
+ * Parses source into Semantifold's shared semantic representation.
+ * @param {object} input - Parse request.
+ * @param {string} input.filename - Source filename used in diagnostics.
+ * @param {import("./src/semantic/types.js").SemanticLanguage} input.language - Source language.
+ * @param {string} input.source - Source text.
+ * @returns {import("./src/semantic/types.js").SemanticModule} Semantic module.
+ */
+export declare function parse(input: {
+    filename: string;
+    language: import("./src/semantic/types.js").SemanticLanguage;
+    source: string;
+}): import("./src/semantic/types.js").SemanticModule;
+/**
+ * Generates target-language source from a shared semantic module.
+ * @param {object} input - Generation request.
+ * @param {import("./src/semantic/types.js").SemanticLanguage} input.language - Target language.
+ * @param {import("./src/semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @returns {string} Generated source.
+ */
+export declare function generate(input: {
+    language: import("./src/semantic/types.js").SemanticLanguage;
+    module: import("./src/semantic/types.js").SemanticModule;
+}): string;
+/**
+ * Generates a reusable output artifact with rich and Source Map v3 mappings.
+ * @param {object} input - Generation request.
+ * @param {import("./src/semantic/types.js").SemanticLanguage} input.language - Target language.
+ * @param {import("./src/semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @param {string} [input.filename] - Output filename.
+ * @param {"none" | "external" | "inline"} [input.mapDirective] - JavaScript-family map directive.
+ * @param {string} [input.sourceMapFilename] - External map filename.
+ * @param {{filename: string, content: string, language?: import("./src/semantic/types.js").SemanticLanguage}[]} [input.sources] - Sources for caller-authored modules.
+ * @returns {import("./src/semantic/types.js").GeneratedArtifact} Generated artifact.
+ */
+export declare function generateArtifact(input: {
+    language: import("./src/semantic/types.js").SemanticLanguage;
+    module: import("./src/semantic/types.js").SemanticModule;
+    filename?: string;
+    mapDirective?: "none" | "external" | "inline";
+    sourceMapFilename?: string;
+    sources?: {
+        filename: string;
+        content: string;
+        language?: import("./src/semantic/types.js").SemanticLanguage;
+    }[];
+}): import("./src/semantic/types.js").GeneratedArtifact;
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"AAKA,OAAO,EAAC,qBAAqB,EAAC,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAA;AACnF,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACd,MAAM,kBAAkB,CAAA;AAEzB,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,EADpB,SAAS,OAAO,yBAAyB,EAAE,gBAAgB,EAC8B,CAAA;AAEpG;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EALxB;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAsB,MAAM,EAApB,MAAM,CACd;CAEwB,GAFd,OAAO,yBAAyB,EAAE,cAAc,CAI5D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAJ3B;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;CAE2B,GAFjB,MAAM,CAIlB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EARnC;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAA+C,YAAY,AAA3D,CACA,EADQ,MAAM,GAAG,UAAU,GAAG,QAAQ,CACtC;IAAuB,iBAAiB,AAAxC,CACA,EADQ,MAAM,CACd;IAAqH,OAAO,AAA5H,CACA,EADQ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAC5G;CAEmC,GAFzB,OAAO,yBAAyB,EAAE,iBAAiB,CAI/D"}

package/build/index.js

@@ -0,0 +1,45 @@
+// @ts-check
+import { parseSource } from "./src/frontends/index.js";
+import { generateArtifactSource, generateSource } from "./src/backends/index.js";
+export { SemantifoldDiagnostic } from "./src/diagnostic.js";
+export { getNodeProvenance, getSymbolProvenance } from "./src/semantic/provenance.js";
+export { primaryLocation } from "./src/semantic/provenance.js";
+export { composeMappings, composeSourceMaps, generatedPositionFor, mappingFromSourceMap, originalPositionFor, parseMapping, remapDiagnostic, remapLocation, spansForNode, spansForSymbol, stringifyMapping, toSourceMapV3 } from "./src/mapping.js";
+/** @type {readonly import("./src/semantic/types.js").SemanticLanguage[]} */
+export const supportedLanguages = Object.freeze(["php", "ruby", "javascript", "typescript", "java"]);
+/**
+ * Parses source into Semantifold's shared semantic representation.
+ * @param {object} input - Parse request.
+ * @param {string} input.filename - Source filename used in diagnostics.
+ * @param {import("./src/semantic/types.js").SemanticLanguage} input.language - Source language.
+ * @param {string} input.source - Source text.
+ * @returns {import("./src/semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parse(input) {
+    return parseSource(input);
+}
+/**
+ * Generates target-language source from a shared semantic module.
+ * @param {object} input - Generation request.
+ * @param {import("./src/semantic/types.js").SemanticLanguage} input.language - Target language.
+ * @param {import("./src/semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @returns {string} Generated source.
+ */
+export function generate(input) {
+    return generateSource(input);
+}
+/**
+ * Generates a reusable output artifact with rich and Source Map v3 mappings.
+ * @param {object} input - Generation request.
+ * @param {import("./src/semantic/types.js").SemanticLanguage} input.language - Target language.
+ * @param {import("./src/semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @param {string} [input.filename] - Output filename.
+ * @param {"none" | "external" | "inline"} [input.mapDirective] - JavaScript-family map directive.
+ * @param {string} [input.sourceMapFilename] - External map filename.
+ * @param {{filename: string, content: string, language?: import("./src/semantic/types.js").SemanticLanguage}[]} [input.sources] - Sources for caller-authored modules.
+ * @returns {import("./src/semantic/types.js").GeneratedArtifact} Generated artifact.
+ */
+export function generateArtifact(input) {
+    return generateArtifactSource(input);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+/**
+ * Validates an identifier against the target backend's deliberately narrow lexical contract.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {unknown} name - Candidate semantic identifier.
+ * @param {string} role - Identifier role for diagnostics.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} location - Originating location.
+ * @returns {void}
+ */
+export declare function validateTargetIdentifier(language: import("../semantic/types.js").SemanticLanguage, name: unknown, role: string, location: import("../semantic/types.js").SourceLocation | undefined): void;
+/**
+ * Validates a binding identifier against target restrictions beyond general identifier syntax.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {unknown} name - Candidate semantic identifier.
+ * @param {string} role - Binding role for diagnostics.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} location - Originating location.
+ * @returns {void}
+ */
+export declare function validateTargetBindingIdentifier(language: import("../semantic/types.js").SemanticLanguage, name: unknown, role: string, location: import("../semantic/types.js").SourceLocation | undefined): void;
+//# sourceMappingURL=identifiers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../../../src/backends/identifiers.js"],"names":[],"mappings":"AA8DA;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EANtC,OAAO,sBAAsB,EAAE,gBAMO,EAAE,IAAI,EAL5C,OAK4C,EAAE,IAAI,EAJlD,MAIkD,EAAE,QAAQ,EAH5D,OAAO,sBAAsB,EAAE,cAAc,GAAG,SAGY,GAF1D,IAAI,CAUhB;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAN7C,OAAO,sBAAsB,EAAE,gBAMc,EAAE,IAAI,EALnD,OAKmD,EAAE,IAAI,EAJzD,MAIyD,EAAE,QAAQ,EAHnE,OAAO,sBAAsB,EAAE,cAAc,GAAG,SAGmB,GAFjE,IAAI,CAchB"}

package/build/src/backends/identifiers.js

@@ -0,0 +1,93 @@
+// @ts-check
+import { unsupportedCapability } from "../diagnostic.js";
+/** @type {Record<import("../semantic/types.js").SemanticLanguage, RegExp>} */
+const identifierPatterns = {
+    java: /^[A-Za-z_$][A-Za-z0-9_$]*$/u,
+    javascript: /^[A-Za-z_$][A-Za-z0-9_$]*$/u,
+    php: /^[A-Za-z_][A-Za-z0-9_]*$/u,
+    ruby: /^[a-z_][A-Za-z0-9_]*$/u,
+    typescript: /^[A-Za-z_$][A-Za-z0-9_$]*$/u
+};
+/** @type {Record<import("../semantic/types.js").SemanticLanguage, Set<string>>} */
+const reservedWords = {
+    java: new Set([
+        "_", "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue",
+        "default", "do", "double", "else", "enum", "exports", "extends", "false", "final", "finally", "float", "for",
+        "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "module", "native", "new",
+        "non-sealed", "null", "open", "opens", "package", "permits", "private", "protected", "provides", "public",
+        "record", "requires", "return", "sealed", "short", "static", "strictfp", "super", "switch", "synchronized",
+        "this", "throw", "throws", "to", "transient", "transitive", "true", "try", "uses", "var", "void", "volatile",
+        "when", "while", "with", "yield"
+    ]),
+    javascript: new Set([
+        "await", "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else",
+        "enum", "export", "extends", "false", "finally", "for", "function", "if", "implements", "import", "in",
+        "instanceof", "interface", "let", "new", "null", "package", "private", "protected", "public", "return", "static",
+        "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "yield"
+    ]),
+    php: new Set([
+        "__halt_compiler", "abstract", "and", "array", "as", "break", "callable", "case", "catch", "class", "clone",
+        "const", "continue", "declare", "default", "die", "do", "echo", "else", "elseif", "empty", "enddeclare",
+        "endfor", "endforeach", "endif", "endswitch", "endwhile", "enum", "eval", "exit", "extends", "false", "final",
+        "finally", "fn", "for", "foreach", "from", "function", "global", "goto", "if", "implements", "include",
+        "include_once", "instanceof", "insteadof", "interface", "isset", "iterable", "list", "match", "mixed", "namespace",
+        "never", "new", "null", "object", "or", "parent", "print", "private", "protected", "public", "readonly", "require",
+        "require_once", "return", "self", "static", "switch", "throw", "trait", "true", "try", "unset", "use", "var",
+        "void", "while", "xor", "yield"
+    ]),
+    ruby: new Set([
+        "BEGIN", "END", "__ENCODING__", "__END__", "__FILE__", "__LINE__", "alias", "and", "begin", "break", "case",
+        "class", "def", "defined?", "do", "else", "elsif", "end", "ensure", "false", "for", "if", "in", "module",
+        "next", "nil", "not", "or", "redo", "rescue", "retry", "return", "self", "super", "then", "true", "undef",
+        "unless", "until", "when", "while", "yield"
+    ]),
+    typescript: new Set([
+        "abstract", "any", "as", "asserts", "async", "await", "boolean", "break", "case", "catch", "class", "const",
+        "constructor", "continue", "debugger", "declare", "default", "delete", "do", "else", "enum", "export", "extends",
+        "false", "finally", "for", "from", "function", "get", "if", "implements", "import", "in", "infer", "instanceof",
+        "interface", "is", "keyof", "let", "module", "namespace", "never", "new", "null", "number", "object", "of",
+        "override", "package", "private", "protected", "public", "readonly", "require", "return", "satisfies", "set",
+        "static", "string", "super", "switch", "symbol", "this", "throw", "true", "try", "type", "typeof", "undefined",
+        "unique", "unknown", "using", "var", "void", "while", "with", "yield"
+    ])
+};
+const phpInvalidParameterBindings = new Set([
+    "GLOBALS", "_COOKIE", "_ENV", "_FILES", "_GET", "_POST", "_REQUEST", "_SERVER", "_SESSION", "this"
+]);
+const phpInvalidAssignedBindings = new Set(["GLOBALS", "this"]);
+/**
+ * Validates an identifier against the target backend's deliberately narrow lexical contract.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {unknown} name - Candidate semantic identifier.
+ * @param {string} role - Identifier role for diagnostics.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} location - Originating location.
+ * @returns {void}
+ */
+export function validateTargetIdentifier(language, name, role, location) {
+    if (typeof name != "string")
+        unsupportedCapability(language, `${role} identifier`, location);
+    const reservedName = language == "php" ? name.toLowerCase() : name;
+    if (!identifierPatterns[language].test(name) || reservedWords[language].has(reservedName)) {
+        unsupportedCapability(language, `${role} identifier '${name}'`, location);
+    }
+}
+/**
+ * Validates a binding identifier against target restrictions beyond general identifier syntax.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {unknown} name - Candidate semantic identifier.
+ * @param {string} role - Binding role for diagnostics.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} location - Originating location.
+ * @returns {void}
+ */
+export function validateTargetBindingIdentifier(language, name, role, location) {
+    validateTargetIdentifier(language, name, role, location);
+    const invalidTypeScriptBinding = language == "typescript" && (name == "arguments" || name == "eval");
+    const invalidPhpVariable = language == "php" && typeof name == "string" &&
+        ((role == "parameter" && phpInvalidParameterBindings.has(name)) ||
+            ((role == "local" || role == "assignment target") && phpInvalidAssignedBindings.has(name)));
+    const invalidRubyBinding = language == "ruby" && typeof name == "string" && /^_[1-9]$/u.test(name);
+    if (invalidTypeScriptBinding || invalidPhpVariable || invalidRubyBinding) {
+        unsupportedCapability(language, `${role} identifier '${name}'`, location);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identifiers.js","sourceRoot":"","sources":["../../../src/backends/identifiers.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {unsupportedCapability} from \"../diagnostic.js\"\n\n/** @type {Record<import(\"../semantic/types.js\").SemanticLanguage, RegExp>} */\nconst identifierPatterns = {\n  java: /^[A-Za-z_$][A-Za-z0-9_$]*$/u,\n  javascript: /^[A-Za-z_$][A-Za-z0-9_$]*$/u,\n  php: /^[A-Za-z_][A-Za-z0-9_]*$/u,\n  ruby: /^[a-z_][A-Za-z0-9_]*$/u,\n  typescript: /^[A-Za-z_$][A-Za-z0-9_$]*$/u\n}\n\n/** @type {Record<import(\"../semantic/types.js\").SemanticLanguage, Set<string>>} */\nconst reservedWords = {\n  java: new Set([\n    \"_\", \"abstract\", \"assert\", \"boolean\", \"break\", \"byte\", \"case\", \"catch\", \"char\", \"class\", \"const\", \"continue\",\n    \"default\", \"do\", \"double\", \"else\", \"enum\", \"exports\", \"extends\", \"false\", \"final\", \"finally\", \"float\", \"for\",\n    \"goto\", \"if\", \"implements\", \"import\", \"instanceof\", \"int\", \"interface\", \"long\", \"module\", \"native\", \"new\",\n    \"non-sealed\", \"null\", \"open\", \"opens\", \"package\", \"permits\", \"private\", \"protected\", \"provides\", \"public\",\n    \"record\", \"requires\", \"return\", \"sealed\", \"short\", \"static\", \"strictfp\", \"super\", \"switch\", \"synchronized\",\n    \"this\", \"throw\", \"throws\", \"to\", \"transient\", \"transitive\", \"true\", \"try\", \"uses\", \"var\", \"void\", \"volatile\",\n    \"when\", \"while\", \"with\", \"yield\"\n  ]),\n  javascript: new Set([\n    \"await\", \"break\", \"case\", \"catch\", \"class\", \"const\", \"continue\", \"debugger\", \"default\", \"delete\", \"do\", \"else\",\n    \"enum\", \"export\", \"extends\", \"false\", \"finally\", \"for\", \"function\", \"if\", \"implements\", \"import\", \"in\",\n    \"instanceof\", \"interface\", \"let\", \"new\", \"null\", \"package\", \"private\", \"protected\", \"public\", \"return\", \"static\",\n    \"super\", \"switch\", \"this\", \"throw\", \"true\", \"try\", \"typeof\", \"var\", \"void\", \"while\", \"with\", \"yield\"\n  ]),\n  php: new Set([\n    \"__halt_compiler\", \"abstract\", \"and\", \"array\", \"as\", \"break\", \"callable\", \"case\", \"catch\", \"class\", \"clone\",\n    \"const\", \"continue\", \"declare\", \"default\", \"die\", \"do\", \"echo\", \"else\", \"elseif\", \"empty\", \"enddeclare\",\n    \"endfor\", \"endforeach\", \"endif\", \"endswitch\", \"endwhile\", \"enum\", \"eval\", \"exit\", \"extends\", \"false\", \"final\",\n    \"finally\", \"fn\", \"for\", \"foreach\", \"from\", \"function\", \"global\", \"goto\", \"if\", \"implements\", \"include\",\n    \"include_once\", \"instanceof\", \"insteadof\", \"interface\", \"isset\", \"iterable\", \"list\", \"match\", \"mixed\", \"namespace\",\n    \"never\", \"new\", \"null\", \"object\", \"or\", \"parent\", \"print\", \"private\", \"protected\", \"public\", \"readonly\", \"require\",\n    \"require_once\", \"return\", \"self\", \"static\", \"switch\", \"throw\", \"trait\", \"true\", \"try\", \"unset\", \"use\", \"var\",\n    \"void\", \"while\", \"xor\", \"yield\"\n  ]),\n  ruby: new Set([\n    \"BEGIN\", \"END\", \"__ENCODING__\", \"__END__\", \"__FILE__\", \"__LINE__\", \"alias\", \"and\", \"begin\", \"break\", \"case\",\n    \"class\", \"def\", \"defined?\", \"do\", \"else\", \"elsif\", \"end\", \"ensure\", \"false\", \"for\", \"if\", \"in\", \"module\",\n    \"next\", \"nil\", \"not\", \"or\", \"redo\", \"rescue\", \"retry\", \"return\", \"self\", \"super\", \"then\", \"true\", \"undef\",\n    \"unless\", \"until\", \"when\", \"while\", \"yield\"\n  ]),\n  typescript: new Set([\n    \"abstract\", \"any\", \"as\", \"asserts\", \"async\", \"await\", \"boolean\", \"break\", \"case\", \"catch\", \"class\", \"const\",\n    \"constructor\", \"continue\", \"debugger\", \"declare\", \"default\", \"delete\", \"do\", \"else\", \"enum\", \"export\", \"extends\",\n    \"false\", \"finally\", \"for\", \"from\", \"function\", \"get\", \"if\", \"implements\", \"import\", \"in\", \"infer\", \"instanceof\",\n    \"interface\", \"is\", \"keyof\", \"let\", \"module\", \"namespace\", \"never\", \"new\", \"null\", \"number\", \"object\", \"of\",\n    \"override\", \"package\", \"private\", \"protected\", \"public\", \"readonly\", \"require\", \"return\", \"satisfies\", \"set\",\n    \"static\", \"string\", \"super\", \"switch\", \"symbol\", \"this\", \"throw\", \"true\", \"try\", \"type\", \"typeof\", \"undefined\",\n    \"unique\", \"unknown\", \"using\", \"var\", \"void\", \"while\", \"with\", \"yield\"\n  ])\n}\n\nconst phpInvalidParameterBindings = new Set([\n  \"GLOBALS\", \"_COOKIE\", \"_ENV\", \"_FILES\", \"_GET\", \"_POST\", \"_REQUEST\", \"_SERVER\", \"_SESSION\", \"this\"\n])\nconst phpInvalidAssignedBindings = new Set([\"GLOBALS\", \"this\"])\n\n/**\n * Validates an identifier against the target backend's deliberately narrow lexical contract.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {unknown} name - Candidate semantic identifier.\n * @param {string} role - Identifier role for diagnostics.\n * @param {import(\"../semantic/types.js\").SourceLocation | undefined} location - Originating location.\n * @returns {void}\n */\nexport function validateTargetIdentifier(language, name, role, location) {\n  if (typeof name != \"string\") unsupportedCapability(language, `${role} identifier`, location)\n\n  const reservedName = language == \"php\" ? name.toLowerCase() : name\n\n  if (!identifierPatterns[language].test(name) || reservedWords[language].has(reservedName)) {\n    unsupportedCapability(language, `${role} identifier '${name}'`, location)\n  }\n}\n\n/**\n * Validates a binding identifier against target restrictions beyond general identifier syntax.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {unknown} name - Candidate semantic identifier.\n * @param {string} role - Binding role for diagnostics.\n * @param {import(\"../semantic/types.js\").SourceLocation | undefined} location - Originating location.\n * @returns {void}\n */\nexport function validateTargetBindingIdentifier(language, name, role, location) {\n  validateTargetIdentifier(language, name, role, location)\n\n  const invalidTypeScriptBinding = language == \"typescript\" && (name == \"arguments\" || name == \"eval\")\n  const invalidPhpVariable = language == \"php\" && typeof name == \"string\" &&\n    ((role == \"parameter\" && phpInvalidParameterBindings.has(name)) ||\n      ((role == \"local\" || role == \"assignment target\") && phpInvalidAssignedBindings.has(name)))\n  const invalidRubyBinding = language == \"ruby\" && typeof name == \"string\" && /^_[1-9]$/u.test(name)\n\n  if (invalidTypeScriptBinding || invalidPhpVariable || invalidRubyBinding) {\n    unsupportedCapability(language, `${role} identifier '${name}'`, location)\n  }\n}\n"]}

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

@@ -0,0 +1,35 @@
+/**
+ * Generates target source from a semantic module.
+ * @param {object} input - Generation request.
+ * @param {import("../semantic/types.js").SemanticLanguage} input.language - Target language.
+ * @param {import("../semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @returns {string} Generated source.
+ */
+export declare function generateSource({ language, module }: {
+    language: import("../semantic/types.js").SemanticLanguage;
+    module: import("../semantic/types.js").SemanticModule;
+}): string;
+/**
+ * Generates source together with authoritative rich and Source Map v3 mappings.
+ * @param {object} input - Generation request.
+ * @param {import("../semantic/types.js").SemanticLanguage} input.language - Target language.
+ * @param {import("../semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @param {string} [input.filename] - Output filename.
+ * @param {"none" | "external" | "inline"} [input.mapDirective] - JavaScript-family source map directive.
+ * @param {string} [input.sourceMapFilename] - External source map filename.
+ * @param {{filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]} [input.sources] - Source content for legacy or assembled modules.
+ * @returns {import("../semantic/types.js").GeneratedArtifact} Generated artifact.
+ */
+export declare function generateArtifactSource({ language, filename, mapDirective, module, sourceMapFilename, sources }: {
+    language: import("../semantic/types.js").SemanticLanguage;
+    module: import("../semantic/types.js").SemanticModule;
+    filename?: string;
+    mapDirective?: "none" | "external" | "inline";
+    sourceMapFilename?: string;
+    sources?: {
+        filename: string;
+        content: string;
+        language?: import("../semantic/types.js").SemanticLanguage;
+    }[];
+}): import("../semantic/types.js").GeneratedArtifact;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backends/index.js"],"names":[],"mappings":"AAuBA;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAC,QAAQ,EAAE,MAAM,EAAC,EAJ9C;IAA+D,QAAQ,EAA/D,OAAO,sBAAsB,EAAE,gBAAgB,CACvD;IAA6D,MAAM,EAA3D,OAAO,sBAAsB,EAAE,cAAc,CACrD;CAE8C,GAFpC,MAAM,CAIlB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,EAAC,QAAQ,EAAE,QAAqC,EAAE,YAAqB,EAAE,MAAM,EAAE,iBAAqC,EAAE,OAAO,EAAC,EARpK;IAA+D,QAAQ,EAA/D,OAAO,sBAAsB,EAAE,gBAAgB,CACvD;IAA6D,MAAM,EAA3D,OAAO,sBAAsB,EAAE,cAAc,CACrD;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAA+C,YAAY,AAA3D,CACA,EADQ,MAAM,GAAG,UAAU,GAAG,QAAQ,CACtC;IAAuB,iBAAiB,AAAxC,CACA,EADQ,MAAM,CACd;IAAkH,OAAO,AAAzH,CACA,EADQ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CACzG;CAEoK,GAF1J,OAAO,sBAAsB,EAAE,iBAAiB,CAyD5D"}

package/build/src/backends/index.js

@@ -0,0 +1,149 @@
+// @ts-check
+import { SemantifoldDiagnostic, unsupportedCapability } from "../diagnostic.js";
+import { generateJava } from "./java.js";
+import { generateJavaScript } from "./javascript.js";
+import { generatePhp } from "./php.js";
+import { generateRuby } from "./ruby.js";
+import { validateBackendModule } from "./shared.js";
+import { generateTypeScript } from "./typescript.js";
+import { SourceWriter } from "./writer.js";
+import { finalizeMapping, toSourceMapV3 } from "../mapping.js";
+/** @type {Readonly<Record<import("../semantic/types.js").SemanticLanguage, string>>} */
+const defaultFilenames = Object.freeze({
+    java: "Main.java",
+    javascript: "program.js",
+    php: "program.php",
+    ruby: "program.rb",
+    typescript: "program.ts"
+});
+const lineTerminatorPattern = /[\n\r\u2028\u2029]/u;
+const syntheticArtifactBase = Object.freeze(["__semantifold_artifacts__"]);
+/**
+ * Generates target source from a semantic module.
+ * @param {object} input - Generation request.
+ * @param {import("../semantic/types.js").SemanticLanguage} input.language - Target language.
+ * @param {import("../semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @returns {string} Generated source.
+ */
+export function generateSource({ language, module }) {
+    return generateArtifactSource({ language, module }).code;
+}
+/**
+ * Generates source together with authoritative rich and Source Map v3 mappings.
+ * @param {object} input - Generation request.
+ * @param {import("../semantic/types.js").SemanticLanguage} input.language - Target language.
+ * @param {import("../semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @param {string} [input.filename] - Output filename.
+ * @param {"none" | "external" | "inline"} [input.mapDirective] - JavaScript-family source map directive.
+ * @param {string} [input.sourceMapFilename] - External source map filename.
+ * @param {{filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]} [input.sources] - Source content for legacy or assembled modules.
+ * @returns {import("../semantic/types.js").GeneratedArtifact} Generated artifact.
+ */
+export function generateArtifactSource({ language, filename = defaultFilenames[language], mapDirective = "none", module, sourceMapFilename = `${filename}.map`, sources }) {
+    validateBackendModule(module, language);
+    if (typeof filename != "string" || filename.length == 0 || lineTerminatorPattern.test(filename)) {
+        throw new TypeError("Generated filename must be a non-empty single-line string.");
+    }
+    if (typeof sourceMapFilename != "string" || sourceMapFilename.length == 0 || lineTerminatorPattern.test(sourceMapFilename)) {
+        throw new TypeError("Source map filename must be a non-empty single-line string.");
+    }
+    if (language == "java" && filename.split(/[\\/]/u).at(-1) != "Main.java") {
+        unsupportedCapability(language, "artifact filename basename other than Main.java", module.location);
+    }
+    if (!["none", "external", "inline"].includes(mapDirective))
+        throw new TypeError(`Unsupported map directive: ${mapDirective}`);
+    if (mapDirective != "none" && language != "javascript" && language != "typescript") {
+        throw new TypeError("Source map directives are supported only for JavaScript and TypeScript outputs.");
+    }
+    const writer = new SourceWriter({ filename, language, module, sources });
+    if (language == "php")
+        generatePhp(module, writer);
+    else if (language == "ruby")
+        generateRuby(module, writer);
+    else if (language == "javascript")
+        generateJavaScript(module, writer);
+    else if (language == "typescript")
+        generateTypeScript(module, writer);
+    else if (language == "java")
+        generateJava(module, writer);
+    else {
+        throw new SemantifoldDiagnostic({
+            code: "UNSUPPORTED_LANGUAGE",
+            language,
+            location: module.location,
+            message: "No source backend is registered for this language."
+        });
+    }
+    const sourceMap = toSourceMapV3(writer.finish());
+    if (mapDirective == "external") {
+        const sourceMapUrl = encodeArtifactPath(relativeArtifactPath(filename, sourceMapFilename));
+        writer.synthetic(`//# sourceMappingURL=${sourceMapUrl}\n`, "external source map directive", [module]);
+    }
+    else if (mapDirective == "inline") {
+        const encoded = base64Utf8(JSON.stringify(sourceMap));
+        writer.synthetic(`//# sourceMappingURL=data:application/json;charset=utf-8;base64,${encoded}\n`, "inline source map directive", [module]);
+    }
+    const mapping = finalizeMapping(writer.finish());
+    return {
+        code: mapping.generated.content,
+        filename,
+        language,
+        mapping,
+        sourceMap,
+        sourceMapFilename
+    };
+}
+/**
+ * Resolves one logical artifact filename relative to another artifact's directory.
+ * @param {string} generatedFilename - Generated code artifact filename.
+ * @param {string} relatedFilename - Related artifact filename.
+ * @returns {string} Portable forward-slash relative path.
+ */
+function relativeArtifactPath(generatedFilename, relatedFilename) {
+    const generatedDirectory = resolvedArtifactPathParts(generatedFilename);
+    const related = resolvedArtifactPathParts(relatedFilename);
+    generatedDirectory.pop();
+    let common = 0;
+    while (common < generatedDirectory.length && common < related.length && generatedDirectory[common] == related[common])
+        common++;
+    return [...generatedDirectory.slice(common).map(() => ".."), ...related.slice(common)].join("/") || ".";
+}
+/**
+ * Resolves separators and dot segments against the shared synthetic artifact base.
+ * @param {string} filename - Logical artifact filename.
+ * @returns {string[]} Resolved path parts.
+ */
+function resolvedArtifactPathParts(filename) {
+    const parts = [...syntheticArtifactBase];
+    for (const part of filename.replaceAll("\\", "/").split("/")) {
+        if (part == "" || part == ".")
+            continue;
+        if (part == "..") {
+            if (parts.length > syntheticArtifactBase.length)
+                parts.pop();
+        }
+        else
+            parts.push(part);
+    }
+    return parts;
+}
+/**
+ * Encodes literal filesystem path segments without encoding structural slashes.
+ * @param {string} path - Relative artifact path.
+ * @returns {string} URL-safe relative artifact path.
+ */
+function encodeArtifactPath(path) {
+    return path.split("/").map((part) => encodeURIComponent(part)).join("/");
+}
+/**
+ * Encodes Unicode JSON without relying on a Node-only artifact contract.
+ * @param {string} value - Unicode string.
+ * @returns {string} Base64 UTF-8.
+ */
+function base64Utf8(value) {
+    let binary = "";
+    for (const byte of new TextEncoder().encode(value))
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/backends/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {SemantifoldDiagnostic, unsupportedCapability} from \"../diagnostic.js\"\nimport {generateJava} from \"./java.js\"\nimport {generateJavaScript} from \"./javascript.js\"\nimport {generatePhp} from \"./php.js\"\nimport {generateRuby} from \"./ruby.js\"\nimport {validateBackendModule} from \"./shared.js\"\nimport {generateTypeScript} from \"./typescript.js\"\nimport {SourceWriter} from \"./writer.js\"\nimport {finalizeMapping, toSourceMapV3} from \"../mapping.js\"\n\n/** @type {Readonly<Record<import(\"../semantic/types.js\").SemanticLanguage, string>>} */\nconst defaultFilenames = Object.freeze({\n  java: \"Main.java\",\n  javascript: \"program.js\",\n  php: \"program.php\",\n  ruby: \"program.rb\",\n  typescript: \"program.ts\"\n})\nconst lineTerminatorPattern = /[\\n\\r\\u2028\\u2029]/u\nconst syntheticArtifactBase = Object.freeze([\"__semantifold_artifacts__\"])\n\n/**\n * Generates target source from a semantic module.\n * @param {object} input - Generation request.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} input.language - Target language.\n * @param {import(\"../semantic/types.js\").SemanticModule} input.module - Semantic module.\n * @returns {string} Generated source.\n */\nexport function generateSource({language, module}) {\n  return generateArtifactSource({language, module}).code\n}\n\n/**\n * Generates source together with authoritative rich and Source Map v3 mappings.\n * @param {object} input - Generation request.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} input.language - Target language.\n * @param {import(\"../semantic/types.js\").SemanticModule} input.module - Semantic module.\n * @param {string} [input.filename] - Output filename.\n * @param {\"none\" | \"external\" | \"inline\"} [input.mapDirective] - JavaScript-family source map directive.\n * @param {string} [input.sourceMapFilename] - External source map filename.\n * @param {{filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]} [input.sources] - Source content for legacy or assembled modules.\n * @returns {import(\"../semantic/types.js\").GeneratedArtifact} Generated artifact.\n */\nexport function generateArtifactSource({language, filename = defaultFilenames[language], mapDirective = \"none\", module, sourceMapFilename = `${filename}.map`, sources}) {\n  validateBackendModule(module, language)\n\n  if (typeof filename != \"string\" || filename.length == 0 || lineTerminatorPattern.test(filename)) {\n    throw new TypeError(\"Generated filename must be a non-empty single-line string.\")\n  }\n  if (typeof sourceMapFilename != \"string\" || sourceMapFilename.length == 0 || lineTerminatorPattern.test(sourceMapFilename)) {\n    throw new TypeError(\"Source map filename must be a non-empty single-line string.\")\n  }\n  if (language == \"java\" && filename.split(/[\\\\/]/u).at(-1) != \"Main.java\") {\n    unsupportedCapability(language, \"artifact filename basename other than Main.java\", module.location)\n  }\n  if (![\"none\", \"external\", \"inline\"].includes(mapDirective)) throw new TypeError(`Unsupported map directive: ${mapDirective}`)\n  if (mapDirective != \"none\" && language != \"javascript\" && language != \"typescript\") {\n    throw new TypeError(\"Source map directives are supported only for JavaScript and TypeScript outputs.\")\n  }\n\n  const writer = new SourceWriter({filename, language, module, sources})\n\n  if (language == \"php\") generatePhp(module, writer)\n  else if (language == \"ruby\") generateRuby(module, writer)\n  else if (language == \"javascript\") generateJavaScript(module, writer)\n  else if (language == \"typescript\") generateTypeScript(module, writer)\n  else if (language == \"java\") generateJava(module, writer)\n  else {\n    throw new SemantifoldDiagnostic({\n      code: \"UNSUPPORTED_LANGUAGE\",\n      language,\n      location: module.location,\n      message: \"No source backend is registered for this language.\"\n    })\n  }\n\n  const sourceMap = toSourceMapV3(writer.finish())\n\n  if (mapDirective == \"external\") {\n    const sourceMapUrl = encodeArtifactPath(relativeArtifactPath(filename, sourceMapFilename))\n\n    writer.synthetic(`//# sourceMappingURL=${sourceMapUrl}\\n`, \"external source map directive\", [module])\n  } else if (mapDirective == \"inline\") {\n    const encoded = base64Utf8(JSON.stringify(sourceMap))\n\n    writer.synthetic(`//# sourceMappingURL=data:application/json;charset=utf-8;base64,${encoded}\\n`, \"inline source map directive\", [module])\n  }\n\n  const mapping = finalizeMapping(writer.finish())\n\n  return {\n    code: mapping.generated.content,\n    filename,\n    language,\n    mapping,\n    sourceMap,\n    sourceMapFilename\n  }\n}\n\n/**\n * Resolves one logical artifact filename relative to another artifact's directory.\n * @param {string} generatedFilename - Generated code artifact filename.\n * @param {string} relatedFilename - Related artifact filename.\n * @returns {string} Portable forward-slash relative path.\n */\nfunction relativeArtifactPath(generatedFilename, relatedFilename) {\n  const generatedDirectory = resolvedArtifactPathParts(generatedFilename)\n  const related = resolvedArtifactPathParts(relatedFilename)\n\n  generatedDirectory.pop()\n  let common = 0\n\n  while (common < generatedDirectory.length && common < related.length && generatedDirectory[common] == related[common]) common++\n\n  return [...generatedDirectory.slice(common).map(() => \"..\"), ...related.slice(common)].join(\"/\") || \".\"\n}\n\n/**\n * Resolves separators and dot segments against the shared synthetic artifact base.\n * @param {string} filename - Logical artifact filename.\n * @returns {string[]} Resolved path parts.\n */\nfunction resolvedArtifactPathParts(filename) {\n  const parts = [...syntheticArtifactBase]\n\n  for (const part of filename.replaceAll(\"\\\\\", \"/\").split(\"/\")) {\n    if (part == \"\" || part == \".\") continue\n    if (part == \"..\") {\n      if (parts.length > syntheticArtifactBase.length) parts.pop()\n    } else parts.push(part)\n  }\n\n  return parts\n}\n\n/**\n * Encodes literal filesystem path segments without encoding structural slashes.\n * @param {string} path - Relative artifact path.\n * @returns {string} URL-safe relative artifact path.\n */\nfunction encodeArtifactPath(path) {\n  return path.split(\"/\").map((part) => encodeURIComponent(part)).join(\"/\")\n}\n\n/**\n * Encodes Unicode JSON without relying on a Node-only artifact contract.\n * @param {string} value - Unicode string.\n * @returns {string} Base64 UTF-8.\n */\nfunction base64Utf8(value) {\n  let binary = \"\"\n\n  for (const byte of new TextEncoder().encode(value)) binary += String.fromCharCode(byte)\n\n  return btoa(binary)\n}\n"]}

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

@@ -0,0 +1,8 @@
+/**
+ * Emits an independently executable Java `Main` program through the source-aware writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+export declare function generateJava(module: import("../semantic/types.js").SemanticModule, writer: import("./writer.js").SourceWriter): void;
+//# sourceMappingURL=java.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../../src/backends/java.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAJxB,OAAO,sBAAsB,EAAE,cAIP,EAAE,MAAM,EAHhC,OAAO,aAAa,EAAE,YAGU,GAF9B,IAAI,CAyDhB"}