semantifold 0.3.0 → 0.4.0

package/src/language-registry.js

@@ -3,16 +3,26 @@
 import {isDenseArray} from "./array.js"
 import {SemantifoldDiagnostic, unsupportedRole} from "./diagnostic.js"
 import {generateJava} from "./backends/java.js"
+import {generateKotlin} from "./backends/kotlin.js"
 import {generateCSharpProject} from "./backends/csharp.js"
 import {generateGoModule} from "./backends/go.js"
+import {generateRustProject} from "./backends/rust.js"
+import {generateSwift} from "./backends/swift.js"
+import {generateDartPackage} from "./backends/dart.js"
 import {generateJavaScript} from "./backends/javascript.js"
 import {generatePhp} from "./backends/php.js"
 import {generatePython} from "./backends/python.js"
 import {generateRuby} from "./backends/ruby.js"
 import {generateTypeScript} from "./backends/typescript.js"
+import {generateBrowserWasm} from "./backends/wasm.js"
+import {generateIosApplication} from "./backends/ios.js"
 import {parseJava} from "./frontends/java.js"
+import {parseKotlin} from "./frontends/kotlin.js"
 import {parseCSharp} from "./frontends/csharp.js"
 import {parseGo} from "./frontends/go.js"
+import {parseRust} from "./frontends/rust.js"
+import {parseSwift} from "./frontends/swift.js"
+import {parseDart} from "./frontends/dart.js"
 import {parseCpp} from "./frontends/cpp.js"
 import {generateCpp} from "./backends/cpp.js"
 import {parseC} from "./frontends/c.js"
@@ -27,22 +37,37 @@ const acceptanceStageOrder = ["parse", "generate", "restore", "compile", "link",
 const acceptanceStages = new Map(acceptanceStageOrder.map((stage, index) => [stage, index]))
 const registryKeys = new Set([
   "acceptance", "applicationBackend", "artifactMultiplicity", "binaryBackend", "defaultFilename", "frontend", "id",
-  "interoperability", "mapping", "mediaType", "roundTrip", "textBackend"
+  "features", "interoperability", "mapping", "mediaType", "provider", "roundTrip", "textBackend"
 ])
 
 /** @typedef {"frontend" | "textBackend" | "binaryBackend" | "applicationBackend" | "interoperability"} RegistryRole */
-/** @typedef {(input: {filename: string, source: string}) => import("./semantic/types.js").SemanticModule} Frontend */
 /** @typedef {(...values: unknown[]) => unknown} RegistryImplementation */
 
+/**
+ * @typedef FrontendInput
+ * @property {readonly import("./semantic/types.js").EffectCapabilityDeclaration[]} [capabilities] - Compiler-authorized declarations.
+ * @property {string} filename - Source filename.
+ * @property {string} source - Source text.
+ * @property {{isEntry: boolean, functions: Map<string, import("./semantic/types.js").FunctionDeclaration>, records: Map<string, import("./semantic/types.js").RecordDeclaration>, errors?: Map<string, import("./semantic/types.js").ErrorDeclaration>, valueRecords?: Map<string, import("./semantic/types.js").RecordDeclaration>}} [program] - Program conversion context.
+ */
+
+/**
+ * @callback Frontend
+ * @param {FrontendInput} input - Frontend request.
+ * @returns {import("./semantic/types.js").SemanticModule} Semantic module.
+ */
+
 /**
  * @typedef LanguageRegistryRecord
  * @property {string} id - Stable identity.
  * @property {{stages: import("./semantic/types.js").AcceptanceStage[], toolchains: string[]}} acceptance - Acceptance declaration.
  * @property {"single" | "multiple"} artifactMultiplicity - Artifact multiplicity.
+ * @property {import("./semantic/types.js").LanguageFeatureCapabilities} features - Semantic feature capabilities.
  * @property {import("./semantic/types.js").LanguageMappingCapabilities} mapping - Mapping capabilities.
  * @property {boolean} roundTrip - Round-trip declaration.
  * @property {string} [defaultFilename] - Default backend filename.
  * @property {string} [mediaType] - Default backend media type.
+ * @property {boolean} [provider] - Target host stdlib provider/native-binding role.
  * @property {RegistryImplementation} [frontend] - Frontend adapter.
  * @property {RegistryImplementation} [textBackend] - Text backend.
  * @property {RegistryImplementation} [binaryBackend] - Binary backend.
@@ -82,6 +107,9 @@ export function createLanguageRegistry(candidateRecords) {
     }
     if (recordsById.has(id)) invalidRegistry(`Duplicate registry ID '${id}'.`, id)
     if (Object.keys(candidate).some((key) => !registryKeys.has(key))) invalidRegistry(`Registry record '${id}' has unknown fields.`, id)
+    if (candidate.provider !== undefined && typeof candidate.provider != "boolean") {
+      invalidRegistry(`Registry record '${id}' declares an invalid provider role.`, id)
+    }
 
     for (const role of registryRoles) {
       if (candidate[role] !== undefined && typeof candidate[role] != "function") {
@@ -94,6 +122,48 @@ export function createLanguageRegistry(candidateRecords) {
       invalidRegistry(`Registry record '${id}' has an invalid artifact multiplicity.`, id)
     }
     if (typeof candidate.roundTrip != "boolean") invalidRegistry(`Registry record '${id}' requires a Boolean round-trip declaration.`, id)
+    const featuresCandidate = candidate.features ?? {
+      closedRecords: false,
+      conditionControlledLoops: false,
+      effectfulCapabilitiesAndResources: false,
+      generalFunctionsAndCalls: false,
+      immutableCollections: false,
+      optionalValues: false,
+      orderedListIteration: false,
+      orderedMapIteration: false,
+      referenceClasses: false,
+      typedErrors: false,
+      typeParametersAndGenerics: false
+    }
+
+    if (!isPlainObject(featuresCandidate) ||
+      Object.keys(featuresCandidate).sort().join(",") != "closedRecords,conditionControlledLoops,effectfulCapabilitiesAndResources,generalFunctionsAndCalls,immutableCollections,optionalValues,orderedListIteration,orderedMapIteration,referenceClasses,typeParametersAndGenerics,typedErrors" ||
+      typeof featuresCandidate.closedRecords != "boolean" ||
+      typeof featuresCandidate.conditionControlledLoops != "boolean" ||
+      typeof featuresCandidate.effectfulCapabilitiesAndResources != "boolean" ||
+      typeof featuresCandidate.generalFunctionsAndCalls != "boolean" ||
+      typeof featuresCandidate.immutableCollections != "boolean" ||
+      typeof featuresCandidate.optionalValues != "boolean" ||
+      typeof featuresCandidate.orderedListIteration != "boolean" ||
+      typeof featuresCandidate.orderedMapIteration != "boolean" ||
+      typeof featuresCandidate.referenceClasses != "boolean" ||
+      typeof featuresCandidate.typedErrors != "boolean" ||
+      typeof featuresCandidate.typeParametersAndGenerics != "boolean") {
+      invalidRegistry(`Registry record '${id}' has an invalid feature declaration.`, id)
+    }
+    const features = deepFreeze(/** @type {import("./semantic/types.js").LanguageFeatureCapabilities} */ ({
+      closedRecords: featuresCandidate.closedRecords,
+      conditionControlledLoops: featuresCandidate.conditionControlledLoops,
+      effectfulCapabilitiesAndResources: featuresCandidate.effectfulCapabilitiesAndResources,
+      generalFunctionsAndCalls: featuresCandidate.generalFunctionsAndCalls,
+      immutableCollections: featuresCandidate.immutableCollections,
+      optionalValues: featuresCandidate.optionalValues,
+      orderedListIteration: featuresCandidate.orderedListIteration,
+      orderedMapIteration: featuresCandidate.orderedMapIteration,
+      referenceClasses: featuresCandidate.referenceClasses,
+      typedErrors: featuresCandidate.typedErrors,
+      typeParametersAndGenerics: featuresCandidate.typeParametersAndGenerics
+    }))
     const mappingCandidate = candidate.mapping
 
     if (!isPlainObject(mappingCandidate)) invalidRegistry(`Registry record '${id}' has an invalid mapping declaration.`, id)
@@ -151,7 +221,7 @@ export function createLanguageRegistry(candidateRecords) {
     const hasApplicationBackend = typeof candidate.applicationBackend == "function"
     const hasBackend = hasTextBackend || hasBinaryBackend || hasApplicationBackend
 
-    if ((mapping.richText || mapping.sourceMapV3) && !hasTextBackend ||
+    if ((mapping.richText || mapping.sourceMapV3 || mapping.binaryRanges) && !hasBackend ||
       mapping.sourceMapV3 && !mapping.richText ||
       mapping.binaryRanges && !hasBinaryBackend && !hasApplicationBackend) {
       invalidRegistry(`Registry record '${id}' declares mapping support without its required backend role.`, id)
@@ -163,11 +233,13 @@ export function createLanguageRegistry(candidateRecords) {
       invalidRegistry(`Registry record '${id}' declares an acceptance stage without its required role.`, id)
     }
 
-    if ((hasBackend || candidate.defaultFilename !== undefined) &&
+    const hasDefaultedBackend = hasTextBackend || hasBinaryBackend
+
+    if ((hasDefaultedBackend || candidate.defaultFilename !== undefined) &&
       (typeof candidate.defaultFilename != "string" || candidate.defaultFilename.length == 0)) {
       invalidRegistry(`Registry backend '${id}' requires a default filename.`, id)
     }
-    if ((hasBackend || candidate.mediaType !== undefined) &&
+    if ((hasDefaultedBackend || candidate.mediaType !== undefined) &&
       (typeof candidate.mediaType != "string" || candidate.mediaType.length == 0)) {
       invalidRegistry(`Registry backend '${id}' requires a media type.`, id)
     }
@@ -179,11 +251,13 @@ export function createLanguageRegistry(candidateRecords) {
     const record = deepFreeze(/** @type {LanguageRegistryRecord} */ ({
       acceptance,
       artifactMultiplicity,
+      features,
       id,
       mapping,
       roundTrip: candidate.roundTrip,
       ...(typeof candidate.defaultFilename == "string" ? {defaultFilename: candidate.defaultFilename} : {}),
       ...(typeof candidate.mediaType == "string" ? {mediaType: candidate.mediaType} : {}),
+      ...(typeof candidate.provider == "boolean" ? {provider: candidate.provider} : {}),
       ...(typeof candidate.frontend == "function" ? {frontend: candidate.frontend} : {}),
       ...(typeof candidate.textBackend == "function" ? {textBackend: candidate.textBackend} : {}),
       ...(typeof candidate.binaryBackend == "function" ? {binaryBackend: candidate.binaryBackend} : {}),
@@ -193,6 +267,7 @@ export function createLanguageRegistry(candidateRecords) {
     const descriptor = deepFreeze(/** @type {import("./semantic/types.js").LanguageCapabilities} */ ({
       acceptance,
       artifactMultiplicity,
+      features,
       id,
       mapping,
       roles: {
@@ -200,6 +275,7 @@ export function createLanguageRegistry(candidateRecords) {
         binaryBackend: typeof candidate.binaryBackend == "function",
         frontend: typeof candidate.frontend == "function",
         interoperability: typeof candidate.interoperability == "function",
+        provider: candidate.provider === true,
         textBackend: typeof candidate.textBackend == "function"
       },
       roundTrip: candidate.roundTrip
@@ -240,31 +316,37 @@ export function createLanguageRegistry(candidateRecords) {
  * PHP registry frontend wrapper.
  * @type {Frontend}
  */
-const phpFrontend = ({filename, source}) => parsePhp({filename, source})
+const phpFrontend = ({capabilities, filename, program, source}) => parsePhp({capabilities, filename, program, source})
 
 /**
  * Ruby registry frontend wrapper.
  * @type {Frontend}
  */
-const rubyFrontend = ({filename, source}) => parseRuby({filename, source})
+const rubyFrontend = ({capabilities, filename, program, source}) => parseRuby({capabilities, filename, program, source})
 
 /**
  * JavaScript registry frontend wrapper.
  * @type {Frontend}
  */
-const javaScriptFrontend = ({filename, source}) => parseJavaScriptTypeScript({filename, language: "javascript", source})
+const javaScriptFrontend = ({capabilities, filename, program, source}) => parseJavaScriptTypeScript({capabilities, filename, language: "javascript", program, source})
 
 /**
  * TypeScript registry frontend wrapper.
  * @type {Frontend}
  */
-const typeScriptFrontend = ({filename, source}) => parseJavaScriptTypeScript({filename, language: "typescript", source})
+const typeScriptFrontend = ({capabilities, filename, program, source}) => parseJavaScriptTypeScript({capabilities, filename, language: "typescript", program, source})
 
 /**
  * Java registry frontend wrapper.
  * @type {Frontend}
  */
-const javaFrontend = ({filename, source}) => parseJava({filename, source})
+const javaFrontend = ({capabilities, filename, program, source}) => parseJava({capabilities, filename, program, source})
+
+/**
+ * Kotlin registry frontend wrapper.
+ * @type {Frontend}
+ */
+const kotlinFrontend = ({filename, source}) => parseKotlin({filename, source})
 
 /**
  * Python registry frontend wrapper.
@@ -284,9 +366,15 @@ const csharpFrontend = ({filename, source}) => parseCSharp({filename, source})
  */
 const goFrontend = ({filename, source}) => parseGo({filename, source})
 
+/**
+ * Dart registry frontend wrapper.
+ * @type {Frontend}
+ */
+const dartFrontend = ({filename, source}) => parseDart({filename, source})
+
 const records = [
   language({
-    acceptance: {stages: ["parse", "generate", "execute"], toolchains: ["php"]},
+    acceptance: {stages: ["parse", "generate", "execute"], toolchains: ["php82"]},
     defaultFilename: "program.php",
     frontend: phpFrontend,
     id: "php",
@@ -325,6 +413,14 @@ const records = [
     mediaType: "text/x-java-source",
     textBackend: generateJava
   }),
+  language({
+    acceptance: {stages: ["parse", "generate", "compile", "execute"], toolchains: ["kotlinc", "java25"]},
+    defaultFilename: "Program.kt",
+    frontend: kotlinFrontend,
+    id: "kotlin",
+    mediaType: "text/x-kotlin",
+    textBackend: generateKotlin
+  }),
   language({
     acceptance: {stages: ["parse", "generate", "compile", "execute"], toolchains: ["python"]},
     defaultFilename: "program.py",
@@ -363,7 +459,57 @@ const records = [
   language({
     acceptance: {stages: ["parse", "generate", "compile", "link", "execute"], toolchains: ["clangpp"]},
     defaultFilename: "program.cpp", frontend: parseCpp, id: "cpp", mediaType: "text/x-c++src", textBackend: generateCpp
-  })
+  }),
+  language({
+    acceptance: {stages: ["parse", "generate", "compile", "validate", "execute"], toolchains: ["rustc", "cargo"]},
+    artifactMultiplicity: "multiple",
+    defaultFilename: "src/main.rs", frontend: parseRust, id: "rust", mediaType: "text/x-rust", textBackend: generateRustProject
+  }),
+  language({acceptance: {stages: ["parse", "generate", "compile", "execute"], toolchains: ["swiftc"]},
+    defaultFilename: "program.swift", frontend: parseSwift, id: "swift", mediaType: "text/x-swift", textBackend: generateSwift}),
+  language({
+    acceptance: {stages: ["parse", "generate", "restore", "compile", "validate", "execute"], toolchains: ["dart"]},
+    artifactMultiplicity: "multiple",
+    defaultFilename: "bin/program.dart",
+    features: {
+      closedRecords: false,
+      conditionControlledLoops: false,
+      effectfulCapabilitiesAndResources: false,
+      generalFunctionsAndCalls: true,
+      immutableCollections: false,
+      optionalValues: false,
+      orderedListIteration: false,
+      orderedMapIteration: false,
+      referenceClasses: false,
+      typedErrors: false,
+      typeParametersAndGenerics: false
+    },
+    frontend: dartFrontend,
+    id: "dart",
+    mediaType: "text/x-dart",
+    textBackend: generateDartPackage
+  }),
+  {
+    acceptance: {stages: ["generate", "validate", "instantiate", "execute"], toolchains: ["wasm-validate", "node", "chromium"]},
+    applicationBackend: generateBrowserWasm,
+    artifactMultiplicity: "multiple",
+    binaryBackend: generateBrowserWasm,
+    defaultFilename: "program.wasm",
+    features: {closedRecords: false, conditionControlledLoops: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
+    id: "wasm",
+    mapping: {binaryRanges: true, richText: true, sourceMapV3: true},
+    mediaType: "application/wasm",
+    roundTrip: false
+  },
+  {
+    acceptance: {stages: ["generate"], toolchains: []},
+    applicationBackend: generateIosApplication,
+    artifactMultiplicity: "multiple",
+    features: {closedRecords: false, conditionControlledLoops: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
+    id: "ios",
+    mapping: {binaryRanges: true, richText: true, sourceMapV3: true},
+    roundTrip: false
+  }
 ]
 
 export const languageRegistry = createLanguageRegistry(records)
@@ -381,7 +527,21 @@ export const supportedLanguages = Object.freeze(languageCapabilities
 function language(values) {
   return {
     artifactMultiplicity: "single",
+    features: {
+      closedRecords: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      conditionControlledLoops: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      effectfulCapabilitiesAndResources: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      generalFunctionsAndCalls: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      immutableCollections: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      optionalValues: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      orderedListIteration: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      orderedMapIteration: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      referenceClasses: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      typedErrors: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      typeParametersAndGenerics: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id))
+    },
     mapping: {binaryRanges: false, richText: true, sourceMapV3: true},
+    provider: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
     roundTrip: true,
     ...values
   }

package/src/mapping.js

@@ -514,7 +514,7 @@ export function composeSourceMaps(outer, inner) {
  * @param {object} generated - Generated program.
  * @param {string} generated.content - Exact generated content.
  * @param {string} generated.filename - Generated filename.
- * @param {import("./semantic/types.js").SemanticLanguage} generated.language - Generated language.
+ * @param {import("./semantic/types.js").GeneratedTextLanguage} generated.language - Generated text language.
  * @param {{filename: string, content: string, language?: import("./semantic/types.js").SemanticLanguage}[]} [generated.sources] - Exact source content overrides.
  * @returns {import("./semantic/types.js").SemantifoldMapping} Imported rich map.
  */
@@ -712,7 +712,7 @@ export function validateMapping(value) {
   const spans = mapping.spans
 
   if (!generated || typeof generated != "object" || typeof Reflect.get(generated, "filename") != "string" ||
-    typeof Reflect.get(generated, "content") != "string" || !isLanguage(Reflect.get(generated, "language")) ||
+    typeof Reflect.get(generated, "content") != "string" || !isGeneratedLanguage(Reflect.get(generated, "language")) ||
     !Array.isArray(mapping.sources) ||
     !Array.isArray(mapping.nodes) || !Array.isArray(mapping.symbols) || !Array.isArray(spans)) {
     throw new TypeError("Malformed SemantifoldMapping v1 envelope.")
@@ -728,7 +728,7 @@ export function validateMapping(value) {
   for (const source of mapping.sources) {
     if (!source || typeof source != "object" || typeof source.id != "string" || source.id.length == 0 || sourceIds.has(source.id) ||
       typeof source.filename != "string" || source.filename.length == 0 || source.content !== null && typeof source.content != "string" ||
-      source.language !== null && !isLanguage(source.language)) {
+      source.language !== null && !isSemanticLanguage(source.language)) {
       throw new TypeError("Malformed or duplicate SemantifoldMapping source.")
     }
     sourceIds.add(source.id)
@@ -763,8 +763,23 @@ export function validateMapping(value) {
 
   for (const symbol of mapping.symbols) {
     if (!symbol || typeof symbol != "object" || typeof symbol.id != "string" || symbol.id.length == 0 || symbolIds.has(symbol.id) ||
-      typeof symbol.name != "string" || symbol.name.length == 0 || !["function", "parameter", "local"].includes(symbol.kind) ||
-      !nodeIds.has(symbol.declarationNodeId) || !Array.isArray(symbol.references)) {
+      typeof symbol.name != "string" || symbol.name.length == 0 ||
+      !["capability", "resource", "failure", "operation", "record", "class", "error", "field", "constructor", "method", "function", "typeParameter", "parameter", "local", "iteration", "catch"].includes(symbol.kind) ||
+      !nodeIds.has(symbol.declarationNodeId) || !Array.isArray(symbol.references) ||
+      symbol.semanticDeclarationId !== undefined && (typeof symbol.semanticDeclarationId != "string" || !(
+        symbol.kind == "function" && /^(?:[a-z][a-z0-9._-]*#)?function:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "record" && /^(?:[a-z][a-z0-9._-]*#)?record:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "class" && /^(?:[a-z][a-z0-9._-]*#)?class:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "error" && /^(?:[a-z][a-z0-9._-]*#)?error:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "field" && /^(?:[a-z][a-z0-9._-]*#)?(?:record|class):[0-9]+:field:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "constructor" && /^(?:[a-z][a-z0-9._-]*#)?class:[0-9]+:constructor$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "method" && /^(?:[a-z][a-z0-9._-]*#)?class:[0-9]+:method:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "typeParameter" && /^(?:[a-z][a-z0-9._-]*#)?(?:function|record):[0-9]+:type:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "capability" && /^(?:module:[0-9]+\/)?capability:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "resource" && /^(?:module:[0-9]+\/)?capability:[0-9]+\/resource:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "failure" && /^(?:module:[0-9]+\/)?capability:[0-9]+\/failure:[0-9]+$/u.test(symbol.semanticDeclarationId) ||
+        symbol.kind == "operation" && /^(?:module:[0-9]+\/)?capability:[0-9]+\/operation:[0-9]+$/u.test(symbol.semanticDeclarationId)
+      ))) {
       throw new TypeError("Malformed or duplicate semantic symbol identity.")
     }
     symbolIds.add(symbol.id)
@@ -785,7 +800,7 @@ export function validateMapping(value) {
     validateLocationForSources(symbol.location, sourcesByFilename, sourceCoordinates)
     for (const reference of symbol.references) {
       if (!reference || typeof reference != "object" || !nodeIds.has(reference.nodeId) ||
-        !["declaration", "read", "write", "call"].includes(reference.role)) {
+        !["declaration", "type", "construct", "member", "read", "write", "call"].includes(reference.role)) {
         throw new TypeError("Malformed semantic symbol reference.")
       }
       validateLocationForSources(reference.location, sourcesByFilename, sourceCoordinates)
@@ -1099,13 +1114,22 @@ function validPoint(value) {
 }
 
 /**
- * Tests a supported semantic language value.
+ * Tests a supported semantic source-language value.
  * @param {unknown} value - Candidate language.
  * @returns {value is import("./semantic/types.js").SemanticLanguage} Whether supported.
  */
-function isLanguage(value) {
+function isSemanticLanguage(value) {
   return value == "php" || value == "ruby" || value == "javascript" || value == "typescript" || value == "java" ||
-    value == "python" || value == "csharp" || value == "go" || value == "c" || value == "cpp"
+    value == "kotlin" || value == "python" || value == "csharp" || value == "go" || value == "c" || value == "cpp" || value == "rust" || value == "swift" || value == "dart"
+}
+
+/**
+ * Tests a supported generated text language value.
+ * @param {unknown} value - Candidate language.
+ * @returns {value is import("./semantic/types.js").GeneratedTextLanguage} Whether supported.
+ */
+function isGeneratedLanguage(value) {
+  return value == "html" || isSemanticLanguage(value)
 }
 
 /**