semantifold 0.1.0 → 0.2.0

package/src/artifacts.js

@@ -0,0 +1,420 @@
+// @ts-check
+
+import {decodedMappings, encodedMappings, presortedDecodedMap, TraceMap} from "@jridgewell/trace-mapping"
+import {isDenseArray} from "./array.js"
+import {isSafeArtifactPath, isValidFilenameMetadata} from "./artifact-path.js"
+import {finalizeByteMapping} from "./binary-mapping.js"
+import {SemantifoldDiagnostic} from "./diagnostic.js"
+import {finalizeMapping, toSourceMapV3} from "./mapping.js"
+import {isSourceRangeOrdered} from "./semantic/location.js"
+import {hasOnlyUnicodeScalars} from "./semantic/scalars.js"
+
+const artifactRoles = new Set(["entry", "source", "manifest", "support", "mapping", "resource", "loader"])
+const mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+(?:;[\u0020-\u007e]+)?$/u
+
+/**
+ * Transactionally validates and constructs one deterministic generated artifact set.
+ * @param {unknown} candidate - Artifact-set fields.
+ * @returns {import("./semantic/types.js").GeneratedArtifactSet} Detached immutable set.
+ */
+export function createGeneratedArtifactSet(candidate) {
+  try {
+    if (!isPlainObject(candidate) || typeof candidate.target != "string" || candidate.target.length == 0 ||
+      !/^[a-z][a-z0-9-]*$/u.test(candidate.target)) {
+      invalidArtifactSet("Artifact set requires a stable lowercase target ID.", targetOf(candidate))
+    }
+    if (!isDenseArray(candidate.artifacts) || candidate.artifacts.length == 0) {
+      invalidArtifactSet("Artifact set requires a non-empty ordered artifact array.", candidate.target)
+    }
+    const target = candidate.target
+
+    const paths = new Set()
+    const directoryPaths = new Set()
+    /** @type {string[]} */
+    const entryPaths = []
+    /** @type {import("./semantic/types.js").GeneratedSetArtifact[]} */
+    const artifacts = []
+
+    for (let index = 0; index < candidate.artifacts.length; index += 1) {
+      const artifact = candidate.artifacts[index]
+
+      if (!isPlainObject(artifact)) invalidArtifactSet(`Artifact ${index} must be a plain object.`, target)
+      const artifactPath = artifact.path
+      const mediaType = artifact.mediaType
+      const role = artifact.role
+      const contentKind = artifact.contentKind
+
+      if (!isSafeArtifactPath(artifactPath)) invalidArtifactSet(`Artifact ${index} has an unsafe path.`, target)
+      if (paths.has(artifactPath)) invalidArtifactSet(`Duplicate artifact path '${artifactPath}'.`, target)
+      if (directoryPaths.has(artifactPath)) {
+        invalidArtifactSet(`Artifact path '${artifactPath}' collides with a required directory.`, target)
+      }
+      const parentPaths = artifactDirectoryPaths(artifactPath)
+
+      for (const parentPath of parentPaths) {
+        if (paths.has(parentPath)) {
+          invalidArtifactSet(`Artifact path '${artifactPath}' descends from artifact file '${parentPath}'.`, target)
+        }
+      }
+      paths.add(artifactPath)
+      for (const parentPath of parentPaths) directoryPaths.add(parentPath)
+      if (typeof mediaType != "string" || !mediaTypePattern.test(mediaType) || /[\r\n]/u.test(mediaType)) {
+        invalidArtifactSet(`Artifact '${artifactPath}' has an invalid media type.`, target)
+      }
+      if (typeof role != "string" || !artifactRoles.has(role)) invalidArtifactSet(`Artifact '${artifactPath}' has an invalid role.`, target)
+      if (artifact.ownership != "generated") invalidArtifactSet(`Artifact '${artifactPath}' must have generated ownership.`, target)
+      if (role == "entry") {
+        if (entryPaths.length > 0) invalidArtifactSet("Artifact set must declare exactly one entry artifact.", target)
+        entryPaths.push(artifactPath)
+      }
+
+      const contentValue = artifact.content
+      /** @type {string | Uint8Array} */
+      let content
+
+      if (contentKind == "text") {
+        if (typeof contentValue != "string" || contentValue.length == 0 || !hasOnlyUnicodeScalars(contentValue)) {
+          invalidArtifactSet(`Text artifact '${artifactPath}' requires non-empty string content.`, target)
+        }
+        content = contentValue
+      } else if (contentKind == "binary") {
+        if (!(contentValue instanceof Uint8Array) || contentValue.byteLength == 0) {
+          invalidArtifactSet(`Binary artifact '${artifactPath}' requires non-empty bytes.`, target)
+        }
+        content = new Uint8Array(contentValue)
+      } else invalidArtifactSet(`Artifact '${artifactPath}' has an invalid content kind.`, target)
+
+      const provenance = validateArtifactProvenance(artifact.provenance, contentKind, artifactPath, content, target)
+
+      artifacts.push(/** @type {import("./semantic/types.js").GeneratedSetArtifact} */ (freezeArtifact({
+        content,
+        contentKind,
+        mediaType,
+        ownership: /** @type {const} */ ("generated"),
+        path: artifactPath,
+        provenance,
+        role
+      })))
+    }
+
+    if (entryPaths.length != 1) invalidArtifactSet("Artifact set must declare exactly one entry artifact.", candidate.target)
+
+    return Object.freeze({
+      artifacts: Object.freeze(artifacts),
+      entry: entryPaths[0],
+      schema: /** @type {const} */ ("GeneratedArtifactSet"),
+      target,
+      version: /** @type {const} */ (1)
+    })
+  } catch (error) {
+    if (error instanceof SemantifoldDiagnostic && error.code == "INVALID_ARTIFACT_SET") throw error
+
+    return invalidArtifactSet("Artifact-set validation failed.", targetOf(candidate), error)
+  }
+}
+
+/**
+ * Validates artifact-level text, byte, or synthetic provenance.
+ * @param {unknown} value - Provenance candidate.
+ * @param {unknown} contentKind - Validated artifact content kind.
+ * @param {string} artifactPath - Validated artifact path.
+ * @param {string | Uint8Array} content - Detached artifact content.
+ * @param {string} target - Artifact target.
+ * @returns {import("./semantic/types.js").ArtifactProvenance} Validated provenance.
+ */
+function validateArtifactProvenance(value, contentKind, artifactPath, content, target) {
+  if (!isPlainObject(value)) invalidArtifactSet(`Artifact '${artifactPath}' requires provenance.`, target)
+
+  if (value.kind == "synthetic") {
+    if (typeof value.reason != "string" || value.reason.length == 0 || !isDenseArray(value.relatedOrigins)) {
+      invalidArtifactSet(`Synthetic artifact '${artifactPath}' requires an explicit reason and related origins.`, target)
+    }
+    if (contentKind == "binary") {
+      invalidArtifactSet(`Binary artifact '${artifactPath}' requires byte-range provenance.`, target)
+    }
+    /** @type {import("./semantic/types.js").RelatedOrigin[]} */
+    const relatedOrigins = []
+
+    for (let index = 0; index < value.relatedOrigins.length; index += 1) {
+      relatedOrigins.push(validateRelatedOrigin(value.relatedOrigins[index], artifactPath, index, target))
+    }
+
+    return Object.freeze({kind: /** @type {const} */ ("synthetic"), reason: value.reason, relatedOrigins: Object.freeze(relatedOrigins)})
+  }
+
+  if (value.kind == "text") {
+    const mappingCandidate = value.mapping
+
+    if (contentKind != "text" || !isPlainObject(mappingCandidate) || mappingCandidate.schema != "SemantifoldMapping" ||
+      !isPlainObject(mappingCandidate.generated) || mappingCandidate.generated.filename != artifactPath ||
+      mappingCandidate.generated.content != content || !isPlainObject(value.sourceMap)) {
+      invalidArtifactSet(`Text artifact '${artifactPath}' has mismatched rich or Source Map provenance.`, target)
+    }
+    if (value.sourceMapFilename !== undefined && !isValidFilenameMetadata(value.sourceMapFilename)) {
+      invalidArtifactSet(`Text artifact '${artifactPath}' has invalid Source Map filename metadata.`, target)
+    }
+    const mapping = finalizeMapping(mappingCandidate)
+    const sourceMap = validateSourceMap(value.sourceMap, artifactPath, target)
+    const projectedSourceMap = toSourceMapV3(mapping)
+
+    if (!sameJsonValue(sourceMap, projectedSourceMap)) {
+      invalidArtifactSet(`Text artifact '${artifactPath}' has Source Map provenance that contradicts its rich mapping.`, target)
+    }
+
+    return Object.freeze({
+      kind: /** @type {const} */ ("text"),
+      mapping,
+      sourceMap,
+      sourceMapFilename: value.sourceMapFilename
+    })
+  }
+
+  if (value.kind == "bytes") {
+    if (contentKind != "binary") invalidArtifactSet(`Byte provenance requires binary content for '${artifactPath}'.`, target)
+    const mapping = finalizeByteMapping(value.mapping)
+
+    if (mapping.generated.path != artifactPath || mapping.generated.byteLength != /** @type {Uint8Array} */ (content).byteLength) {
+      invalidArtifactSet(`Byte provenance does not match artifact '${artifactPath}'.`, target)
+    }
+
+    return Object.freeze({kind: /** @type {const} */ ("bytes"), mapping})
+  }
+
+  return invalidArtifactSet(`Artifact '${artifactPath}' has an unknown provenance kind.`, target)
+}
+
+/**
+ * Freezes one validated artifact record.
+ * @param {Record<string, unknown>} artifact - Validated fields.
+ * @returns {Readonly<Record<string, unknown>>} Frozen record.
+ */
+function freezeArtifact(artifact) {
+  if (artifact.contentKind == "binary" && artifact.content instanceof Uint8Array) {
+    const content = artifact.content
+
+    Object.defineProperty(artifact, "content", {
+      configurable: false,
+      enumerable: true,
+      get() {
+        return new Uint8Array(content)
+      }
+    })
+  }
+
+  return Object.freeze(artifact)
+}
+
+/**
+ * Lists every directory a safe relative POSIX artifact path requires.
+ * @param {string} artifactPath - Validated artifact path.
+ * @returns {string[]} Ordered parent directory paths.
+ */
+function artifactDirectoryPaths(artifactPath) {
+  const parts = artifactPath.split("/")
+  /** @type {string[]} */
+  const directories = []
+
+  for (let index = 1; index < parts.length; index += 1) directories.push(parts.slice(0, index).join("/"))
+
+  return directories
+}
+
+/**
+ * Throws a normalized artifact-set diagnostic.
+ * @param {string} message - Failure detail.
+ * @param {string} target - Artifact target.
+ * @param {unknown} [error] - Preserved validation cause.
+ * @returns {never} Always throws.
+ */
+function invalidArtifactSet(message, target, error) {
+  throw new SemantifoldDiagnostic({
+    cause: error instanceof Error ? error : undefined,
+    code: "INVALID_ARTIFACT_SET",
+    language: target,
+    message
+  })
+}
+
+/**
+ * Derives a safe diagnostic identity from an unknown request.
+ * @param {unknown} value - Candidate set.
+ * @returns {string} Diagnostic identity.
+ */
+function targetOf(value) {
+  return isPlainObject(value) && typeof value.target == "string" && value.target.length > 0 ? value.target : "artifact"
+}
+
+/**
+ * Checks for an ordinary string-keyed object.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain object.
+ */
+function isPlainObject(value) {
+  return typeof value == "object" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype
+}
+
+/**
+ * Validates an artifact-level related origin without interpreting source offsets as generated bytes.
+ * @param {unknown} value - Related-origin candidate.
+ * @param {string} artifactPath - Owning artifact path.
+ * @param {number} index - Origin index.
+ * @param {string} target - Artifact target.
+ * @returns {import("./semantic/types.js").RelatedOrigin} Detached related origin.
+ */
+function validateRelatedOrigin(value, artifactPath, index, target) {
+  if (!isPlainObject(value) || typeof value.sourceId != "string" || value.sourceId.length == 0 ||
+    !isPlainObject(value.location) || typeof value.location.filename != "string" || value.location.filename.length == 0 ||
+    !validSourcePoint(value.location.start) || !validSourcePoint(value.location.end) ||
+    value.location.end.offset < value.location.start.offset || !isSourceRangeOrdered(value.location.start, value.location.end)) {
+    invalidArtifactSet(`Artifact '${artifactPath}' has malformed related origin ${index}.`, target)
+  }
+
+  return deepFreeze({
+    location: {
+      end: {...value.location.end},
+      filename: value.location.filename,
+      start: {...value.location.start}
+    },
+    sourceId: value.sourceId,
+    ...(optionalString(value.nodeId, "nodeId", artifactPath, index, target)),
+    ...(optionalString(value.symbolId, "symbolId", artifactPath, index, target)),
+    ...(optionalString(value.role, "role", artifactPath, index, target))
+  })
+}
+
+/**
+ * Validates one optional related-origin string field.
+ * @param {unknown} value - Candidate value.
+ * @param {string} property - Property name.
+ * @param {string} artifactPath - Owning artifact path.
+ * @param {number} index - Origin index.
+ * @param {string} target - Artifact target.
+ * @returns {Record<string, string>} Present validated property or an empty record.
+ */
+function optionalString(value, property, artifactPath, index, target) {
+  if (value === undefined) return {}
+  if (typeof value != "string" || value.length == 0) {
+    invalidArtifactSet(`Artifact '${artifactPath}' has invalid ${property} in related origin ${index}.`, target)
+  }
+
+  return {[property]: value}
+}
+
+/**
+ * Checks one UTF-16 source point.
+ * @param {unknown} value - Candidate point.
+ * @returns {value is import("./semantic/types.js").SourcePoint} Whether the point is structurally valid.
+ */
+function validSourcePoint(value) {
+  return isPlainObject(value) && typeof value.line == "number" && Number.isSafeInteger(value.line) && value.line > 0 &&
+    typeof value.column == "number" && Number.isSafeInteger(value.column) && value.column > 0 &&
+    typeof value.offset == "number" && Number.isSafeInteger(value.offset) && value.offset >= 0
+}
+
+/**
+ * Validates and detaches the Source Map v3 projection carried by a text artifact.
+ * @param {unknown} value - Source Map candidate.
+ * @param {string} artifactPath - Owning artifact path.
+ * @param {string} target - Artifact target.
+ * @returns {import("@jridgewell/gen-mapping").EncodedSourceMap} Detached Source Map.
+ */
+function validateSourceMap(value, artifactPath, target) {
+  if (!isPlainObject(value) || value.version != 3 || value.file != artifactPath || typeof value.mappings != "string" ||
+    !isDenseArray(value.names) || !value.names.every((name) => typeof name == "string") ||
+    !isDenseArray(value.sources) || !value.sources.every((source) => typeof source == "string") ||
+    (value.sourcesContent !== undefined && (!isDenseArray(value.sourcesContent) ||
+      !value.sourcesContent.every((source) => source == null || typeof source == "string")))) {
+    invalidArtifactSet(`Text artifact '${artifactPath}' has malformed Source Map v3 provenance.`, target)
+  }
+  validateEncodedSourceMapMappings(
+    /** @type {import("@jridgewell/trace-mapping").EncodedSourceMap} */ (/** @type {unknown} */ (value)),
+    artifactPath,
+    target
+  )
+
+  const detached = /** @type {unknown} */ (structuredClone(value))
+
+  return deepFreeze(/** @type {import("@jridgewell/gen-mapping").EncodedSourceMap} */ (detached))
+}
+
+/**
+ * Decodes and validates the Source Map payload with the installed mapping implementation.
+ * @param {import("@jridgewell/trace-mapping").EncodedSourceMap} sourceMap - Structurally validated map.
+ * @param {string} artifactPath - Owning artifact path.
+ * @param {string} target - Artifact target.
+ * @returns {void}
+ */
+function validateEncodedSourceMapMappings(sourceMap, artifactPath, target) {
+  /** @type {Readonly<import("@jridgewell/trace-mapping").SourceMapSegment[][]>} */
+  let decoded
+  let canonicalMappings
+
+  try {
+    decoded = decodedMappings(new TraceMap(sourceMap))
+    const decodedMap = /** @type {import("@jridgewell/trace-mapping").DecodedSourceMap} */ ({
+      ...sourceMap,
+      mappings: structuredClone(decoded)
+    })
+
+    canonicalMappings = encodedMappings(presortedDecodedMap(decodedMap))
+  } catch (error) {
+    invalidArtifactSet(`Text artifact '${artifactPath}' has invalid encoded Source Map mappings.`, target, error)
+  }
+
+  if (canonicalMappings != sourceMap.mappings ||
+    !validDecodedSourceMapMappings(decoded, sourceMap.sources.length, sourceMap.names.length)) {
+    invalidArtifactSet(`Text artifact '${artifactPath}' has invalid encoded Source Map mappings.`, target)
+  }
+}
+
+/**
+ * Validates decoded Source Map segment shape and referenced indices.
+ * @param {Readonly<import("@jridgewell/trace-mapping").SourceMapSegment[][]>} lines - Decoded mapping lines.
+ * @param {number} sourceCount - Declared source count.
+ * @param {number} nameCount - Declared name count.
+ * @returns {boolean} Whether every segment is semantically valid.
+ */
+function validDecodedSourceMapMappings(lines, sourceCount, nameCount) {
+  return lines.every((line) => line.every((segment) => {
+    if (segment.length != 1 && segment.length != 4 && segment.length != 5) return false
+    if (!segment.every((field) => Number.isSafeInteger(field) && field >= 0)) return false
+    if (segment.length == 1) return true
+    if (segment[1] >= sourceCount) return false
+
+    return segment.length == 4 || segment[4] < nameCount
+  }))
+}
+
+/**
+ * Compares detached JSON values without depending on caller object-key order.
+ * @param {unknown} left - First JSON value.
+ * @param {unknown} right - Second JSON value.
+ * @returns {boolean} Whether both values are structurally identical.
+ */
+function sameJsonValue(left, right) {
+  if (left === right) return true
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length == right.length &&
+      left.every((entry, index) => sameJsonValue(entry, right[index]))
+  }
+  if (!isPlainObject(left) || !isPlainObject(right)) return false
+  const leftKeys = Object.keys(left)
+  const rightKeys = Object.keys(right)
+
+  return leftKeys.length == rightKeys.length &&
+    leftKeys.every((key) => Object.hasOwn(right, key) && sameJsonValue(left[key], right[key]))
+}
+
+/**
+ * Deeply freezes a detached JSON value.
+ * @template T
+ * @param {T} value - Detached value.
+ * @returns {T} Frozen value.
+ */
+function deepFreeze(value) {
+  if (!value || typeof value != "object" || Object.isFrozen(value)) return value
+
+  for (const nested of Object.values(value)) deepFreeze(nested)
+
+  return Object.freeze(value)
+}

package/src/backends/identifiers.js

@@ -7,6 +7,7 @@ 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,
+  python: /^(?:_|\p{XID_Start})(?:_|\p{XID_Continue})*$/u,
   ruby: /^[a-z_][A-Za-z0-9_]*$/u,
   typescript: /^[A-Za-z_$][A-Za-z0-9_$]*$/u
 }
@@ -38,6 +39,12 @@ const reservedWords = {
     "require_once", "return", "self", "static", "switch", "throw", "trait", "true", "try", "unset", "use", "var",
     "void", "while", "xor", "yield"
   ]),
+  python: new Set([
+    "False", "None", "True", "and", "as", "assert", "async", "await", "bool", "break", "case", "class",
+    "continue", "def", "del", "elif", "else", "except", "exec", "finally", "for", "from", "global", "if",
+    "import", "in", "int", "is", "lambda", "match", "nonlocal", "not", "or", "pass", "print",
+    "raise", "return", "str", "try", "type", "while", "with", "yield", "_", "__debug__"
+  ]),
   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",
@@ -73,7 +80,8 @@ export function validateTargetIdentifier(language, name, role, location) {
 
   const reservedName = language == "php" ? name.toLowerCase() : name
 
-  if (!identifierPatterns[language].test(name) || reservedWords[language].has(reservedName)) {
+  if (!identifierPatterns[language].test(name) || reservedWords[language].has(reservedName) ||
+    language == "python" && name.normalize("NFKC") != name) {
     unsupportedCapability(language, `${role} identifier '${name}'`, location)
   }
 }

package/src/backends/index.js

@@ -1,24 +1,11 @@
 // @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 {unsupportedCapability, unsupportedRole} from "../diagnostic.js"
+import {isValidFilenameMetadata} from "../artifact-path.js"
+import {languageRegistry} from "../language-registry.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__"])
 
 /**
@@ -43,18 +30,27 @@ export function generateSource({language, module}) {
  * @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}) {
+export function generateArtifactSource({language, filename, mapDirective = "none", module, sourceMapFilename, sources}) {
+  const backend = languageRegistry.resolve(language, "textBackend", module?.location)
+  const record = languageRegistry.record(language)
+
+  if (record.artifactMultiplicity != "single") unsupportedRole(language, "single-text backend", module?.location)
+  if (filename === undefined) filename = record.defaultFilename
+  if (sourceMapFilename === undefined) sourceMapFilename = `${filename}.map`
   validateBackendModule(module, language)
 
-  if (typeof filename != "string" || filename.length == 0 || lineTerminatorPattern.test(filename)) {
+  if (!isValidFilenameMetadata(filename)) {
     throw new TypeError("Generated filename must be a non-empty single-line string.")
   }
-  if (typeof sourceMapFilename != "string" || sourceMapFilename.length == 0 || lineTerminatorPattern.test(sourceMapFilename)) {
+  if (!isValidFilenameMetadata(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 (language == "python" && filename.split(/[\\/]/u).at(-1) != "program.py") {
+    unsupportedCapability(language, "artifact filename basename other than program.py", 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.")
@@ -62,19 +58,7 @@ export function generateArtifactSource({language, filename = defaultFilenames[la
 
   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."
-    })
-  }
+  backend(module, writer)
 
   const sourceMap = toSourceMapV3(writer.finish())