semantifold 0.1.0

package/src/backends/identifiers.js

@@ -0,0 +1,101 @@
+// @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)
+  }
+}

package/src/backends/index.js

@@ -0,0 +1,159 @@
+// @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)
+}

package/src/backends/java.js

@@ -0,0 +1,182 @@
+// @ts-check
+
+import {emitExpression} from "./shared.js"
+import {emitScalarType} from "./scalars.js"
+
+/**
+ * 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 function generateJava(module, writer) {
+  writer.synthetic("public final class Main {\n", "Java class scaffolding", [module])
+
+  module.functions.forEach((declaration, functionIndex) => {
+    if (functionIndex > 0) writer.synthetic("\n\n", "declaration separator", [declaration])
+
+    writer.synthetic("  ", "indentation", [declaration])
+    writer.mapped("private static", {mappingKind: "anchor", node: declaration})
+    writer.synthetic(" ", "method spacing", [declaration])
+    writer.mapped(emitScalarType("java", declaration.returnType), {
+      mappingKind: "exact",
+      node: declaration.returnType,
+      path: `/functions/${functionIndex}/returnType`,
+      role: "type"
+    })
+    writer.synthetic(" ", "method spacing", [declaration])
+    writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, role: "name"})
+    writer.mapped("(", {mappingKind: "anchor", node: declaration})
+    declaration.parameters.forEach((parameter, index) => {
+      const parameterPath = `/functions/${functionIndex}/parameters/${index}`
+
+      if (index > 0) writer.synthetic(", ", "parameter separator", [declaration])
+      writer.mapped(emitScalarType("java", parameter.type), {
+        mappingKind: "exact",
+        node: parameter.type,
+        path: `${parameterPath}/type`,
+        role: "type"
+      })
+      writer.synthetic(" ", "parameter spacing", [parameter], [parameterPath])
+      writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: parameterPath, role: "name"})
+    })
+    writer.mapped(")", {mappingKind: "anchor", node: declaration})
+    writer.synthetic(" ", "method spacing", [declaration])
+    writer.mapped("{", {mappingKind: "anchor", node: declaration})
+    writer.synthetic("\n", "line break", [declaration])
+
+    emitBlock(writer, declaration.body, "    ", `/functions/${functionIndex}/body`)
+    writer.synthetic("  ", "indentation", [declaration])
+    writer.mapped("}", {mappingKind: "anchor", node: declaration})
+  })
+
+  writer.synthetic("\n\n", "entry-point separator", [module.entryPoint])
+  writer.synthetic("  ", "indentation", [module.entryPoint])
+  writer.mapped("public static void main", {mappingKind: "anchor", node: module.entryPoint})
+  writer.mapped("(", {mappingKind: "anchor", node: module.entryPoint})
+  writer.synthetic("String[] args", "Java entry-point signature", [module.entryPoint])
+  writer.mapped(")", {mappingKind: "anchor", node: module.entryPoint})
+  writer.synthetic(" ", "method spacing", [module.entryPoint])
+  writer.mapped("{", {mappingKind: "anchor", node: module.entryPoint})
+  writer.synthetic("\n", "line break", [module.entryPoint])
+
+  emitBlock(writer, module.entryPoint.body, "    ", "/entryPoint/body")
+  writer.synthetic("  ", "indentation", [module.entryPoint])
+  writer.mapped("}", {mappingKind: "anchor", node: module.entryPoint})
+  writer.synthetic("\n}\n", "Java class scaffolding", [module])
+}
+
+/**
+ * Emits one ordered Java block body.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {string} indent - Indentation.
+ * @param {string} path - Exact block path.
+ * @returns {void}
+ */
+function emitBlock(writer, block, indent, path) {
+  block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`))
+}
+
+/**
+ * Emits one Java statement.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Statement} statement - Semantic statement.
+ * @param {string} indent - Indentation.
+ * @param {string} path - Exact statement path.
+ * @returns {void}
+ */
+function emitStatement(writer, statement, indent, path) {
+  if (statement.kind == "LocalDeclaration" || statement.kind == "AssignmentStatement") return emitLocal(writer, statement, indent, path)
+  writer.synthetic(indent, "indentation", [statement], [path])
+  if (statement.kind == "ReturnStatement") {
+    writer.mapped("return", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "return spacing", [statement], [path])
+    emitExpression(writer, statement.expression, `${path}/expression`, "java", identity)
+    writer.mapped(";", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "PrintStatement") {
+    writer.mapped("System.out.println", {mappingKind: "anchor", node: statement, path})
+    writer.mapped("(", {mappingKind: "anchor", node: statement, path})
+    emitExpression(writer, statement.expression, `${path}/expression`, "java", identity)
+    writer.mapped(")", {mappingKind: "anchor", node: statement, path})
+    writer.mapped(";", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  writer.mapped("if", {mappingKind: "anchor", node: statement, path})
+  writer.synthetic(" ", "conditional spacing", [statement], [path])
+  writer.mapped("(", {mappingKind: "anchor", node: statement, path})
+  emitExpression(writer, statement.condition, `${path}/condition`, "java", identity)
+  writer.mapped(")", {mappingKind: "anchor", node: statement, path})
+  writer.synthetic(" ", "conditional spacing", [statement], [path])
+  writer.mapped("{", {mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent`})
+  writer.synthetic("\n", "line break", [statement], [path])
+  emitBlock(writer, statement.consequent, `${indent}  `, `${path}/consequent`)
+  writer.synthetic(indent, "indentation", [statement], [path])
+  writer.mapped("}", {mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent`})
+  if (statement.alternate) {
+    writer.synthetic(" ", "conditional spacing", [statement], [path])
+    writer.mapped("else", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "conditional spacing", [statement], [path])
+    writer.mapped("{", {mappingKind: "anchor", node: statement.alternate, path: `${path}/alternate`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.alternate, `${indent}  `, `${path}/alternate`)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("}", {mappingKind: "anchor", node: statement.alternate, path: `${path}/alternate`})
+  }
+  writer.synthetic("\n", "line break", [statement], [path])
+}
+
+/**
+ * Emits one Java local statement.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").LocalStatement} statement - Local statement.
+ * @param {string} indent - Leading indentation.
+ * @param {string} statementPath - Exact JSON Pointer for this statement occurrence.
+ * @returns {void}
+ */
+function emitLocal(writer, statement, indent, statementPath) {
+  writer.synthetic(indent, "indentation", [statement], [statementPath])
+
+  if (statement.kind == "AssignmentStatement") {
+    writer.mapped(statement.target.name, {mappingKind: "exact", node: statement.target, path: `${statementPath}/target`, role: "name"})
+    writer.synthetic(" ", "assignment spacing", [statement], [statementPath])
+    writer.mapped("=", {mappingKind: "exact", node: statement, path: statementPath, role: "operator"})
+    writer.synthetic(" ", "assignment spacing", [statement], [statementPath])
+    emitExpression(writer, statement.expression, `${statementPath}/expression`, "java", identity)
+    writer.mapped(";", {mappingKind: "anchor", node: statement, path: statementPath})
+    writer.synthetic("\n", "line break", [statement], [statementPath])
+    return
+  }
+
+  if (!statement.mutable) {
+    writer.mapped("final", {mappingKind: "anchor", node: statement, path: statementPath})
+    writer.synthetic(" ", "modifier spacing", [statement], [statementPath])
+  }
+  writer.mapped(emitScalarType("java", statement.type), {
+    mappingKind: "exact",
+    node: statement.type,
+    path: `${statementPath}/type`,
+    role: "type"
+  })
+  writer.synthetic(" ", "declaration spacing", [statement], [statementPath])
+  writer.mapped(statement.name, {mappingKind: "exact", node: statement, path: statementPath, role: "name"})
+  writer.synthetic(" ", "assignment spacing", [statement], [statementPath])
+  writer.mapped("=", {mappingKind: "exact", node: statement, path: statementPath, role: "operator"})
+  writer.synthetic(" ", "assignment spacing", [statement], [statementPath])
+  emitExpression(writer, statement.initializer, `${statementPath}/initializer`, "java", identity)
+  writer.mapped(";", {mappingKind: "anchor", node: statement, path: statementPath})
+  writer.synthetic("\n", "line break", [statement], [statementPath])
+}
+
+/**
+ * Returns an unchanged Java identifier.
+ * @param {string} name - Identifier.
+ * @returns {string} Identifier.
+ */
+function identity(name) {
+  return name
+}

package/src/backends/javascript.js

@@ -0,0 +1,184 @@
+// @ts-check
+
+import {emitExpression, requiresCanonicalZeroRendering} from "./shared.js"
+import {emitScalarType} from "./scalars.js"
+
+/**
+ * Emits an independently executable JavaScript program with JSDoc types.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+export function generateJavaScript(module, writer) {
+  const canonicalizeZero = requiresCanonicalZeroRendering(module)
+
+  module.functions.forEach((declaration, functionIndex) => {
+    if (functionIndex > 0) writer.synthetic("\n\n", "declaration separator", [declaration])
+
+    writer.synthetic("/**\n * Generated semantic function.\n", "JavaScript type scaffolding", [declaration])
+    for (const [parameterIndex, parameter] of declaration.parameters.entries()) {
+      const parameterPath = `/functions/${functionIndex}/parameters/${parameterIndex}`
+
+      writer.synthetic(" * @param {", "JavaScript type scaffolding", [parameter], [parameterPath])
+      writer.mapped(emitScalarType("javascript", parameter.type), {
+        mappingKind: "exact",
+        node: parameter.type,
+        path: `${parameterPath}/type`,
+        role: "type"
+      })
+      writer.synthetic("} ", "JavaScript type scaffolding", [parameter], [parameterPath])
+      writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: parameterPath, role: "name"})
+      writer.synthetic(" - Semantic parameter.\n", "JavaScript type scaffolding", [parameter], [parameterPath])
+    }
+    writer.synthetic(" * @returns {", "JavaScript type scaffolding", [declaration])
+    writer.mapped(emitScalarType("javascript", declaration.returnType), {
+      mappingKind: "exact",
+      node: declaration.returnType,
+      path: `/functions/${functionIndex}/returnType`,
+      role: "type"
+    })
+    writer.synthetic("} Semantic result.\n */\n", "JavaScript type scaffolding", [declaration])
+    writer.mapped("function", {mappingKind: "anchor", node: declaration})
+    writer.synthetic(" ", "function spacing", [declaration])
+    writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, role: "name"})
+    writer.mapped("(", {mappingKind: "anchor", node: declaration})
+    declaration.parameters.forEach((parameter, index) => {
+      if (index > 0) writer.synthetic(", ", "parameter separator", [declaration])
+      writer.mapped(parameter.name, {
+        mappingKind: "exact",
+        node: parameter,
+        path: `/functions/${functionIndex}/parameters/${index}`,
+        role: "name"
+      })
+    })
+    writer.mapped(")", {mappingKind: "anchor", node: declaration})
+    writer.synthetic(" ", "function spacing", [declaration])
+    writer.mapped("{", {mappingKind: "anchor", node: declaration})
+    writer.synthetic("\n", "line break", [declaration])
+
+    emitBlock(writer, declaration.body, "  ", `/functions/${functionIndex}/body`, canonicalizeZero)
+    writer.mapped("}", {mappingKind: "anchor", node: declaration})
+  })
+
+  writer.synthetic("\n\n", "entry-point separator", [module.entryPoint])
+  emitBlock(writer, module.entryPoint.body, "", "/entryPoint/body", canonicalizeZero)
+}
+
+/**
+ * Emits one ordered JavaScript block body.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {string} indent - Indentation.
+ * @param {string} blockPath - Exact JSON Pointer for the block.
+ * @param {boolean} canonicalizeZero - Whether printed integer zero must be canonicalized.
+ * @returns {void}
+ */
+function emitBlock(writer, block, indent, blockPath, canonicalizeZero) {
+  block.statements.forEach((statement, index) => emitStatement(
+    writer, statement, indent, `${blockPath}/statements/${index}`, canonicalizeZero
+  ))
+}
+
+/**
+ * Emits one JavaScript statement.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Statement} statement - Semantic statement.
+ * @param {string} indent - Indentation.
+ * @param {string} path - Exact statement path.
+ * @param {boolean} canonicalizeZero - Whether printed integer zero must be canonicalized.
+ * @returns {void}
+ */
+function emitStatement(writer, statement, indent, path, canonicalizeZero) {
+  if (statement.kind == "LocalDeclaration" || statement.kind == "AssignmentStatement") return emitLocal(writer, statement, indent, path)
+
+  writer.synthetic(indent, "indentation", [statement], [path])
+  if (statement.kind == "ReturnStatement") {
+    writer.mapped("return", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "return spacing", [statement], [path])
+    emitExpression(writer, statement.expression, `${path}/expression`, "javascript", identity)
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "PrintStatement") {
+    writer.mapped("console.log", {mappingKind: "anchor", node: statement, path})
+    writer.mapped("(", {mappingKind: "anchor", node: statement, path})
+    if (canonicalizeZero) writer.synthetic("(", "canonical integer output", [statement], [path])
+    emitExpression(writer, statement.expression, `${path}/expression`, "javascript", identity)
+    if (canonicalizeZero) writer.synthetic(").toString()", "canonical integer output", [statement], [path])
+    writer.mapped(")", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+
+  writer.mapped("if", {mappingKind: "anchor", node: statement, path})
+  writer.synthetic(" ", "conditional spacing", [statement], [path])
+  writer.mapped("(", {mappingKind: "anchor", node: statement, path})
+  emitExpression(writer, statement.condition, `${path}/condition`, "javascript", identity)
+  writer.mapped(")", {mappingKind: "anchor", node: statement, path})
+  writer.synthetic(" ", "conditional spacing", [statement], [path])
+  writer.mapped("{", {mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent`})
+  writer.synthetic("\n", "line break", [statement], [path])
+  emitBlock(writer, statement.consequent, `${indent}  `, `${path}/consequent`, canonicalizeZero)
+  writer.synthetic(indent, "indentation", [statement], [path])
+  writer.mapped("}", {mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent`})
+  if (statement.alternate) {
+    writer.synthetic(" ", "conditional spacing", [statement], [path])
+    writer.mapped("else", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "conditional spacing", [statement], [path])
+    writer.mapped("{", {mappingKind: "anchor", node: statement.alternate, path: `${path}/alternate`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.alternate, `${indent}  `, `${path}/alternate`, canonicalizeZero)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("}", {mappingKind: "anchor", node: statement.alternate, path: `${path}/alternate`})
+  }
+  writer.synthetic("\n", "line break", [statement], [path])
+}
+
+/**
+ * Emits one JavaScript local statement and its JSDoc type carrier.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").LocalStatement} statement - Local statement.
+ * @param {string} indent - Leading indentation.
+ * @param {string} statementPath - Exact JSON Pointer for this statement occurrence.
+ * @returns {void}
+ */
+function emitLocal(writer, statement, indent, statementPath) {
+  writer.synthetic(indent, "indentation", [statement], [statementPath])
+
+  if (statement.kind == "AssignmentStatement") {
+    writer.mapped(statement.target.name, {mappingKind: "exact", node: statement.target, path: `${statementPath}/target`, role: "name"})
+    writer.synthetic(" ", "assignment spacing", [statement], [statementPath])
+    writer.mapped("=", {mappingKind: "exact", node: statement, path: statementPath, role: "operator"})
+    writer.synthetic(" ", "assignment spacing", [statement], [statementPath])
+    emitExpression(writer, statement.expression, `${statementPath}/expression`, "javascript", identity)
+    writer.synthetic("\n", "line break", [statement], [statementPath])
+    return
+  }
+
+  writer.synthetic("/** @type {", "JavaScript local type scaffolding", [statement], [statementPath])
+  writer.mapped(emitScalarType("javascript", statement.type), {
+    mappingKind: "exact",
+    node: statement.type,
+    path: `${statementPath}/type`,
+    role: "type"
+  })
+  writer.synthetic("} */\n", "JavaScript local type scaffolding", [statement], [statementPath])
+  writer.synthetic(indent, "indentation", [statement], [statementPath])
+  writer.mapped(statement.mutable ? "let" : "const", {mappingKind: "anchor", node: statement, path: statementPath})
+  writer.synthetic(" ", "declaration spacing", [statement], [statementPath])
+  writer.mapped(statement.name, {mappingKind: "exact", node: statement, path: statementPath, role: "name"})
+  writer.synthetic(" ", "assignment spacing", [statement], [statementPath])
+  writer.mapped("=", {mappingKind: "exact", node: statement, path: statementPath, role: "operator"})
+  writer.synthetic(" ", "assignment spacing", [statement], [statementPath])
+  emitExpression(writer, statement.initializer, `${statementPath}/initializer`, "javascript", identity)
+  writer.synthetic("\n", "line break", [statement], [statementPath])
+}
+
+/**
+ * Returns an unchanged JavaScript identifier.
+ * @param {string} name - Identifier.
+ * @returns {string} Identifier.
+ */
+function identity(name) {
+  return name
+}