semantifold 0.5.0 → 0.6.0

package/build/src/toolchains.d.ts

@@ -101,6 +101,12 @@ export declare const canonicalToolchains: {
         supportedVersion: RegExp;
         versionArguments: string[];
     };
+    zig: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
     swiftc: {
         canonicalCommand: string;
         overrideEnvironmentVariable: string;

package/build/src/toolchains.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolchains.d.ts","sourceRoot":"","sources":["../../src/toolchains.js"],"names":[],"mappings":"AAYA,eAAO,MAAM,mBAAmB;;0BAmLA,MAAM;qCAA+B,MAAM;0BAAoB,MAAM;0BAAoB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA5J/H,CAAA;AAEF;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,EAAE,EAJxC,MAAM,OAAO,mBAI2B,EAAE,OAAO,AAHzD,CACA,EADQ;IAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAG5C,GAFpD,OAAO,CAAC,OAAO,qBAAqB,EAAE,mBAAmB,CAAC,CA+BtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAT1C;IAAsB,gBAAgB,EAA9B,MAAM,CACd;IAA6D,WAAW,AAAxE,CACA,EADQ,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CACpD;IAAsB,EAAE,EAAhB,MAAM,CACd;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAAuB,gBAAgB,AAAvC,CACA,EADQ,MAAM,CACd;IAAuB,SAAS,AAAhC,CACA,EADQ,MAAM,CACd;IAAwB,gBAAgB,EAAhC,MAAM,EAAE,CAChB;CAE0C,GAFhC,OAAO,CAAC,OAAO,qBAAqB,EAAE,mBAAmB,CAAC,CAmGtE;AA+HD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,GAHzC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAGqB,GAF9D,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqB5C"}
+{"version":3,"file":"toolchains.d.ts","sourceRoot":"","sources":["../../src/toolchains.js"],"names":[],"mappings":"AAYA,eAAO,MAAM,mBAAmB;;0BAoLA,MAAM;qCAA+B,MAAM;0BAAoB,MAAM;0BAAoB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA5J/H,CAAA;AAEF;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,EAAE,EAJxC,MAAM,OAAO,mBAI2B,EAAE,OAAO,AAHzD,CACA,EADQ;IAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAG5C,GAFpD,OAAO,CAAC,OAAO,qBAAqB,EAAE,mBAAmB,CAAC,CA+BtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAT1C;IAAsB,gBAAgB,EAA9B,MAAM,CACd;IAA6D,WAAW,AAAxE,CACA,EADQ,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CACpD;IAAsB,EAAE,EAAhB,MAAM,CACd;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAAuB,gBAAgB,AAAvC,CACA,EADQ,MAAM,CACd;IAAuB,SAAS,AAAhC,CACA,EADQ,MAAM,CACd;IAAwB,gBAAgB,EAAhC,MAAM,EAAE,CAChB;CAE0C,GAFhC,OAAO,CAAC,OAAO,qBAAqB,EAAE,mBAAmB,CAAC,CAmGtE;AA+HD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,GAHzC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAGqB,GAF9D,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqB5C"}

package/build/src/toolchains.js

@@ -25,6 +25,7 @@ export const canonicalToolchains = deepFreeze({
     clang: definition("clang", "SEMANTIFOLD_CLANG", ["--version"], /^Ubuntu clang version 21\.1\.8 [^\n]+\nTarget: x86_64-pc-linux-gnu\n/u),
     rustc: definition("rustc", "SEMANTIFOLD_RUSTC", ["--version", "--verbose"], /^rustc 1\.98\.1 \(48a229cea 2026-09-01\)\nbinary: rustc\ncommit-hash: 48a229ceaefd4985c50990b14116b6d856af0985\ncommit-date: 2026-09-01\nhost: x86_64-unknown-linux-gnu\nrelease: 1\.98\.1\nLLVM version: 22\.1\.8$/u),
     cargo: definition("cargo", "SEMANTIFOLD_CARGO", ["--version", "--verbose"], /^cargo 1\.98\.1 \(797e8a9bc 2026-08-05\)\nrelease: 1\.98\.1\ncommit-hash: 797e8a9bca276c1c9f9f738d2a20f484fa4eea9d\ncommit-date: 2026-08-05\nhost: x86_64-unknown-linux-gnu\n/u),
+    zig: definition("zig", "SEMANTIFOLD_ZIG", ["version"], /^0\.15\.2$/u),
     swiftc: definition("swiftc", "SEMANTIFOLD_SWIFTC", ["--driver-mode=swiftc", "--version"], /^Swift version 6\.3\.3 \(swift-6\.3\.3-RELEASE\)\nTarget: x86_64-unknown-linux-gnu$/u),
     "wasm-validate": definition("wasm-validate", "SEMANTIFOLD_WASM_VALIDATE", ["--version"], /^1\.0\.36$/u),
     chromium: definition("chromium", "SEMANTIFOLD_CHROMIUM", ["--version"], /^Google Chrome 152\.0\.7977\.82$/u)
@@ -425,4 +426,4 @@ function deepFreeze(value) {
         deepFreeze(nested);
     return Object.freeze(value);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolchains.js","sourceRoot":"","sources":["../../src/toolchains.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {constants as fsConstants} from \"node:fs\"\nimport {access, realpath, stat} from \"node:fs/promises\"\nimport path from \"node:path\"\nimport {isDenseArray} from \"./array.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {exceededOwnedDeadline, executeFileWithDeadline} from \"./subprocess.js\"\nimport {isSupportedTimeoutMs, maximumTimeoutMs} from \"./timeout.js\"\n\nconst defaultTimeoutMs = 10_000\n\nexport const canonicalToolchains = deepFreeze({\n  dart: definition(\"dart\", \"SEMANTIFOLD_DART\", [\"--version\"],\n    /^Dart SDK version: 3\\.13\\.3 \\(stable\\) \\(Tue Sep 1 01:07:17 2026 -0700\\) on \"linux_x64\"$/u),\n  php: definition(\"php\", \"SEMANTIFOLD_PHP\", [\"--version\"], /^PHP 8\\./u),\n  php82: definition(\"php\", \"SEMANTIFOLD_PHP\", [\"--version\"], /^PHP (?:8\\.(?:[2-9]|[1-9][0-9]+)|(?:9|[1-9][0-9]+)\\.[0-9]+)\\./u),\n  ruby: definition(\"ruby\", \"SEMANTIFOLD_RUBY\", [\"--version\"], /^ruby 3\\./u),\n  node: definition(\"node\", \"SEMANTIFOLD_NODE\", [\"--version\"], /^v24\\./u),\n  tsc: definition(\"tsc\", \"SEMANTIFOLD_TSC\", [\"--version\"], /^Version 7\\./u),\n  javac: definition(\"javac\", \"SEMANTIFOLD_JAVAC\", [\"-version\"], /^javac (?:1[7-9]|2[0-9])\\./u),\n  java: definition(\"java\", \"SEMANTIFOLD_JAVA\", [\"-version\"], /^(?:openjdk|java) version \"(?:1[7-9]|2[0-9])\\./u),\n  java25: definition(\"java\", \"SEMANTIFOLD_JAVA\", [\"-version\"],\n    /^openjdk version \"25\\.0\\.4\" 2026-07-21\\nOpenJDK Runtime Environment \\(build 25\\.0\\.4\\+7-1-((?:24|26)\\.04)-Ubuntu\\)\\nOpenJDK 64-Bit Server VM \\(build 25\\.0\\.4\\+7-1-\\1-Ubuntu, mixed mode, sharing\\)$/u),\n  kotlinc: definition(\"kotlinc\", \"SEMANTIFOLD_KOTLINC\", [\"-version\"], /^info: kotlinc-jvm 2\\.4\\.20 \\(JRE 25\\.0\\.4\\+7-1-(?:24|26)\\.04-Ubuntu\\)$/u),\n  python: definition(\"python3\", \"SEMANTIFOLD_PYTHON\", [\"--version\"], /^Python 3\\./u),\n  dotnet: definition(\"dotnet\", \"SEMANTIFOLD_DOTNET\", [\"--version\"], /^10\\./u),\n  go: definition(\"go\", \"SEMANTIFOLD_GO\", [\"version\"], /^go version go1\\.26\\.\\d+ linux\\/amd64$/u),\n  clangpp: definition(\"clang++\", \"SEMANTIFOLD_CLANGPP\", [\"--version\"], /^Ubuntu clang version 21\\.1\\.8 [^\\n]+\\nTarget: x86_64-pc-linux-gnu\\n/u),\n  clang: definition(\"clang\", \"SEMANTIFOLD_CLANG\", [\"--version\"], /^Ubuntu clang version 21\\.1\\.8 [^\\n]+\\nTarget: x86_64-pc-linux-gnu\\n/u),\n  rustc: definition(\"rustc\", \"SEMANTIFOLD_RUSTC\", [\"--version\", \"--verbose\"], /^rustc 1\\.98\\.1 \\(48a229cea 2026-09-01\\)\\nbinary: rustc\\ncommit-hash: 48a229ceaefd4985c50990b14116b6d856af0985\\ncommit-date: 2026-09-01\\nhost: x86_64-unknown-linux-gnu\\nrelease: 1\\.98\\.1\\nLLVM version: 22\\.1\\.8$/u),\n  cargo: definition(\"cargo\", \"SEMANTIFOLD_CARGO\", [\"--version\", \"--verbose\"], /^cargo 1\\.98\\.1 \\(797e8a9bc 2026-08-05\\)\\nrelease: 1\\.98\\.1\\ncommit-hash: 797e8a9bca276c1c9f9f738d2a20f484fa4eea9d\\ncommit-date: 2026-08-05\\nhost: x86_64-unknown-linux-gnu\\n/u),\n  swiftc: definition(\"swiftc\", \"SEMANTIFOLD_SWIFTC\", [\"--driver-mode=swiftc\", \"--version\"], /^Swift version 6\\.3\\.3 \\(swift-6\\.3\\.3-RELEASE\\)\\nTarget: x86_64-unknown-linux-gnu$/u),\n  \"wasm-validate\": definition(\"wasm-validate\", \"SEMANTIFOLD_WASM_VALIDATE\", [\"--version\"], /^1\\.0\\.36$/u),\n  chromium: definition(\"chromium\", \"SEMANTIFOLD_CHROMIUM\", [\"--version\"], /^Google Chrome 152\\.0\\.7977\\.82$/u)\n})\n\n/**\n * Discovers one repository-declared canonical toolchain.\n * @param {keyof typeof canonicalToolchains} id - Canonical toolchain ID.\n * @param {{environment?: Readonly<Record<string, string | undefined>>, override?: string, timeoutMs?: number}} [options] - Discovery options.\n * @returns {Promise<import(\"./semantic/types.js\").DiscoveredToolchain>} Exact executable and version.\n */\nexport async function discoverCanonicalToolchain(id, options = {}) {\n  if (typeof id != \"string\" || id.length == 0) {\n    invalidToolchain(\"Canonical toolchain ID must be a non-empty primitive string.\", \"toolchain\")\n  }\n  if (!isPlainObject(options)) invalidToolchain(\"Canonical toolchain options must be an object.\", id)\n  const definition = Object.hasOwn(canonicalToolchains, id)\n    ? canonicalToolchains[/** @type {keyof typeof canonicalToolchains} */ (id)]\n    : undefined\n\n  if (!definition) invalidToolchain(`Unknown canonical toolchain '${id}'.`, id)\n  const configurationEnvironment = options.environment === undefined\n    ? undefined\n    : snapshotEnvironment(options.environment, id)\n  const environment = configurationEnvironment ?? defaultEnvironment()\n  const configured = options.override === undefined\n    ? configurationEnvironment === undefined\n      ? process.env[definition.overrideEnvironmentVariable]\n      : configurationEnvironment[definition.overrideEnvironmentVariable]\n    : options.override\n\n  return discoverToolchain({\n    canonicalCommand: definition.canonicalCommand,\n    environment,\n    id,\n    override: configured,\n    supportedVersion: definition.supportedVersion,\n    timeoutMs: options.timeoutMs,\n    versionArguments: definition.versionArguments\n  })\n}\n\n/**\n * Resolves and versions one configured or canonical executable without invoking a shell.\n * @param {object} input - Discovery request.\n * @param {string} input.canonicalCommand - Canonical PATH command.\n * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Explicit discovery environment.\n * @param {string} input.id - Toolchain ID.\n * @param {string} [input.override] - Configured absolute executable path.\n * @param {RegExp} [input.supportedVersion] - Full selected-stream version policy.\n * @param {number} [input.timeoutMs] - Version command timeout.\n * @param {string[]} input.versionArguments - Exact version argument array.\n * @returns {Promise<import(\"./semantic/types.js\").DiscoveredToolchain>} Discovered tool.\n */\nexport async function discoverToolchain(input) {\n  if (!isPlainObject(input)) invalidToolchain(\"Toolchain discovery requires a request object.\", \"toolchain\")\n  const versionArgumentCandidate = input.versionArguments\n  const versionArguments = isDenseArray(versionArgumentCandidate) ? [...versionArgumentCandidate] : undefined\n  const candidate = {\n    canonicalCommand: input.canonicalCommand,\n    environment: input.environment === undefined ? defaultEnvironment() : input.environment,\n    id: input.id,\n    override: input.override,\n    supportedVersion: input.supportedVersion,\n    timeoutMs: input.timeoutMs === undefined ? defaultTimeoutMs : input.timeoutMs,\n    versionArguments\n  }\n\n  validateDiscovery(candidate)\n  const canonicalCommand = /** @type {string} */ (candidate.canonicalCommand)\n  const environment = /** @type {Readonly<Record<string, string | undefined>>} */ (candidate.environment)\n  const id = /** @type {string} */ (candidate.id)\n  const override = /** @type {string | undefined} */ (candidate.override)\n  const supportedVersion = candidate.supportedVersion instanceof RegExp\n    ? new RegExp(candidate.supportedVersion.source, candidate.supportedVersion.flags)\n    : undefined\n  const timeoutMs = /** @type {number} */ (candidate.timeoutMs)\n  const validatedVersionArguments = /** @type {string[]} */ (candidate.versionArguments)\n  const normalizedEnvironment = deterministicEnvironment(environment)\n  const {executable, source} = override === undefined\n    ? await resolveCanonical(id, canonicalCommand, normalizedEnvironment.PATH ?? \"\")\n    : {executable: await resolveOverride(id, override, canonicalCommand), source: /** @type {const} */ (\"override\")}\n  /** @type {{stdout: string, stderr: string}} */\n  let result\n\n  try {\n    result = await executeFileWithDeadline({\n      arguments: validatedVersionArguments,\n      environment: normalizedEnvironment,\n      executable,\n      maxBuffer: 1024 * 1024,\n      timeoutMs\n    })\n  } catch (error) {\n    const processError = processErrorFields(error)\n    const timedOut = exceededOwnedDeadline(error)\n\n    throw new SemantifoldDiagnostic({\n      ...processError,\n      cause: error instanceof Error ? error : undefined,\n      code: timedOut ? \"TOOL_VERSION_TIMEOUT\" : \"TOOL_VERSION_FAILURE\",\n      command: canonicalCommand,\n      executable,\n      language: id,\n      message: timedOut\n        ? `Version command for '${executable}' exceeded ${timeoutMs}ms.`\n        : `Version command for '${executable}' failed.`,\n      stderr: processError.stderr,\n      stdout: processError.stdout\n    })\n  }\n\n  const {stderr, stdout} = result\n  const normalizedStdout = stdout.trim()\n  const normalizedStderr = stderr.trim()\n  const versionOutput = normalizedStdout.length > 0 ? normalizedStdout : normalizedStderr\n  const version = versionOutput.split(/\\r?\\n/u)[0] ?? \"\"\n\n  if (version.length == 0) {\n    throw new SemantifoldDiagnostic({\n      code: \"TOOL_VERSION_FAILURE\",\n      command: canonicalCommand,\n      executable,\n      language: id,\n      message: `Version command for '${executable}' returned no version output.`,\n      stderr,\n      stdout\n    })\n  }\n  if (supportedVersion && !supportedVersion.test(versionOutput)) {\n    throw new SemantifoldDiagnostic({\n      code: \"TOOL_UNSUPPORTED_VERSION\",\n      command: canonicalCommand,\n      executable,\n      language: id,\n      message: `Executable '${executable}' reported unsupported version '${version}'.`,\n      stderr,\n      stdout,\n      version\n    })\n  }\n\n  return deepFreeze({\n    command: canonicalCommand,\n    executable,\n    id,\n    source,\n    version,\n    versionArguments: validatedVersionArguments,\n    versionOutput\n  })\n}\n\n/**\n * Builds one canonical immutable toolchain declaration.\n * @param {string} canonicalCommand - PATH command.\n * @param {string} overrideEnvironmentVariable - Configured override variable.\n * @param {string[]} versionArguments - Exact version arguments.\n * @param {RegExp} supportedVersion - Supported version output.\n * @returns {{canonicalCommand: string, overrideEnvironmentVariable: string, supportedVersion: RegExp, versionArguments: string[]}} Declaration.\n */\nfunction definition(canonicalCommand, overrideEnvironmentVariable, versionArguments, supportedVersion) {\n  return {canonicalCommand, overrideEnvironmentVariable, supportedVersion, versionArguments}\n}\n\n/**\n * Validates tool discovery before filesystem or process access.\n * @param {{\n *   canonicalCommand: unknown,\n *   environment: unknown,\n *   id: unknown,\n *   override: unknown,\n *   supportedVersion: unknown,\n *   timeoutMs: unknown,\n *   versionArguments: unknown\n * }} input - Candidate discovery fields.\n * @returns {void}\n */\nfunction validateDiscovery(input) {\n  if (typeof input.id != \"string\" || input.id.length == 0 ||\n    typeof input.canonicalCommand != \"string\" || input.canonicalCommand.length == 0 ||\n    input.canonicalCommand.includes(\"/\") || input.canonicalCommand.includes(\"\\\\\") || input.canonicalCommand.includes(\"\\0\") ||\n    !isDenseArray(input.versionArguments) || !input.versionArguments.every(validArgument) ||\n    !isEnvironment(input.environment) || !isSupportedTimeoutMs(input.timeoutMs) ||\n    (input.override !== undefined && (typeof input.override != \"string\" || !path.isAbsolute(input.override) || input.override.includes(\"\\0\"))) ||\n    (input.supportedVersion !== undefined && (!(input.supportedVersion instanceof RegExp) || input.supportedVersion.global || input.supportedVersion.sticky))) {\n    invalidToolchain(`Toolchain discovery requires a canonical basename, absolute override, argument array, environment, and timeout from 1 through ${maximumTimeoutMs}ms.`,\n      typeof input.id == \"string\" ? input.id : \"toolchain\")\n  }\n}\n\n/**\n * Resolves one unambiguous canonical command from an explicit PATH.\n * @param {string} id - Toolchain ID.\n * @param {string} command - Canonical command.\n * @param {string} pathValue - Explicit PATH.\n * @returns {Promise<{executable: string, source: \"canonical\"}>} Exact executable.\n */\nasync function resolveCanonical(id, command, pathValue) {\n  const matches = new Map()\n\n  for (const directory of pathValue.split(path.delimiter)) {\n    if (directory.length == 0 || !path.isAbsolute(directory)) continue\n    const candidate = path.join(directory, command)\n\n    try {\n      const exact = await resolveExecutableFile(candidate)\n\n      if (exact != undefined) matches.set(exact, exact)\n    } catch {\n      // A PATH candidate is absent or non-executable; discovery continues deterministically.\n    }\n  }\n\n  if (matches.size == 0) {\n    throw new SemantifoldDiagnostic({\n      code: \"TOOL_NOT_FOUND\",\n      command,\n      language: id,\n      message: `Canonical command '${command}' was not found as an executable on PATH.`\n    })\n  }\n  if (matches.size > 1) {\n    throw new SemantifoldDiagnostic({\n      code: \"TOOL_AMBIGUOUS\",\n      command,\n      language: id,\n      message: `Canonical command '${command}' resolves to multiple executables: ${[...matches.keys()].join(\", \")}.`\n    })\n  }\n\n  return {executable: /** @type {string} */ ([...matches.keys()][0]), source: /** @type {const} */ (\"canonical\")}\n}\n\n/**\n * Resolves one configured absolute executable.\n * @param {string} id - Toolchain ID.\n * @param {string} override - Absolute override.\n * @param {string} command - Canonical command.\n * @returns {Promise<string>} Exact executable path.\n */\nasync function resolveOverride(id, override, command) {\n  /** @type {Error | undefined} */\n  let cause\n\n  try {\n    const exact = await resolveExecutableFile(override)\n\n    if (exact != undefined) return exact\n  } catch (error) {\n    cause = error instanceof Error ? error : undefined\n  }\n\n  throw new SemantifoldDiagnostic({\n    cause,\n    code: \"TOOL_NOT_FOUND\",\n    command,\n    executable: override,\n    language: id,\n    message: `Configured executable '${override}' is missing or not executable.`\n  })\n}\n\n/**\n * Resolves one candidate to an executable regular file.\n * @param {string} candidate - Candidate path.\n * @returns {Promise<string | undefined>} Exact regular executable, if the file type is valid.\n */\nasync function resolveExecutableFile(candidate) {\n  const exact = await realpath(candidate)\n  const status = await stat(exact)\n\n  if (!status.isFile()) return undefined\n  await access(exact, fsConstants.X_OK)\n\n  return exact\n}\n\n/**\n * Produces the minimal deterministic process environment.\n * @param {Readonly<Record<string, string | undefined>>} environment - Explicit inputs.\n * @returns {Readonly<Record<string, string>>} Normalized environment.\n */\nexport function deterministicEnvironment(environment = defaultEnvironment()) {\n  const entries = environmentEntries(environment)\n\n  if (entries == undefined) invalidToolchain(\"Process environment must be a plain own-property data record of string or undefined values.\", \"environment\")\n  /** @type {Record<string, string>} */\n  const normalized = Object.create(null)\n\n  for (const [key, value] of entries) {\n    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key) || key.includes(\"\\0\") || (value !== undefined && value.includes(\"\\0\"))) {\n      invalidToolchain(\"Process environment contains an invalid key or value.\", \"environment\")\n    }\n    if (value !== undefined) normalized[key] = value\n  }\n  normalized.LANG = \"C.UTF-8\"\n  normalized.LC_ALL = \"C.UTF-8\"\n  normalized.TZ = \"UTC\"\n  normalized.PATH ??= \"/usr/local/bin:/usr/bin:/bin\"\n\n  return Object.freeze(normalized)\n}\n\n/**\n * Retains only executable lookup from the ambient environment.\n * @returns {Readonly<Record<string, string | undefined>>} Minimal default environment.\n */\nfunction defaultEnvironment() {\n  return {PATH: process.env.PATH}\n}\n\n/**\n * Narrows stable fields from a version subprocess rejection.\n * @param {unknown} error - Process rejection.\n * @returns {{exitCode: number | undefined, signal: string | undefined, stderr: string, stdout: string}} Stable fields.\n */\nfunction processErrorFields(error) {\n  if (!error || typeof error != \"object\") return {exitCode: undefined, signal: undefined, stderr: \"\", stdout: \"\"}\n  const value = /** @type {Record<string, unknown>} */ (error)\n\n  return {\n    exitCode: typeof value.code == \"number\" ? value.code : undefined,\n    signal: typeof value.signal == \"string\" ? value.signal : undefined,\n    stderr: typeof value.stderr == \"string\" ? value.stderr : \"\",\n    stdout: typeof value.stdout == \"string\" ? value.stdout : \"\"\n  }\n}\n\n/**\n * Checks one shell-free argument.\n * @param {unknown} value - Candidate argument.\n * @returns {value is string} Whether the argument is safe to pass directly.\n */\nfunction validArgument(value) {\n  return typeof value == \"string\" && !value.includes(\"\\0\")\n}\n\n/**\n * Checks explicit process-environment values.\n * @param {unknown} value - Candidate environment.\n * @returns {value is Readonly<Record<string, string | undefined>>} Whether entries are strings or undefined.\n */\nfunction isEnvironment(value) {\n  return environmentEntries(value) != undefined\n}\n\n/**\n * Detaches an explicit environment before canonical override lookup can yield.\n * @param {unknown} value - Candidate environment record.\n * @param {string} id - Toolchain identity.\n * @returns {Readonly<Record<string, string | undefined>>} Owned environment data.\n */\nfunction snapshotEnvironment(value, id) {\n  const entries = environmentEntries(value)\n\n  if (entries == undefined) {\n    invalidToolchain(\"Canonical toolchain environment must be a plain own-property data record of string or undefined values.\", id)\n  }\n  /** @type {Record<string, string | undefined>} */\n  const snapshot = Object.create(null)\n\n  for (const [key, entry] of entries) snapshot[key] = entry\n\n  return Object.freeze(snapshot)\n}\n\n/**\n * Reads only enumerable own data properties from an ordinary or null-prototype record.\n * @param {unknown} value - Candidate environment record.\n * @returns {[string, string | undefined][] | undefined} Detached entries when valid.\n */\nfunction environmentEntries(value) {\n  if (typeof value != \"object\" || value == null || Array.isArray(value)) return undefined\n\n  try {\n    const prototype = Object.getPrototypeOf(value)\n\n    if (prototype !== Object.prototype && prototype !== null) return undefined\n    /** @type {[string, string | undefined][]} */\n    const entries = []\n\n    for (const key of Reflect.ownKeys(value)) {\n      if (typeof key != \"string\") return undefined\n      const descriptor = Object.getOwnPropertyDescriptor(value, key)\n\n      if (descriptor == undefined || !descriptor.enumerable || !(\"value\" in descriptor) ||\n        (descriptor.value !== undefined && typeof descriptor.value != \"string\")) return undefined\n      entries.push([key, descriptor.value])\n    }\n\n    return entries\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Checks for an ordinary string-keyed object.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  return typeof value == \"object\" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Throws a normalized discovery-configuration diagnostic.\n * @param {string} message - Failure detail.\n * @param {string} id - Toolchain identity.\n * @returns {never} Always throws.\n */\nfunction invalidToolchain(message, id) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_TOOLCHAIN\", language: id, message})\n}\n\n/**\n * Deeply freezes canonical declarations and discovery results.\n * @template T\n * @param {T} value - Toolchain-owned value.\n * @returns {T} Frozen value.\n */\nfunction deepFreeze(value) {\n  if (!value || typeof value != \"object\" || Object.isFrozen(value)) return value\n\n  for (const nested of Object.values(value)) deepFreeze(nested)\n\n  return Object.freeze(value)\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolchains.js","sourceRoot":"","sources":["../../src/toolchains.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {constants as fsConstants} from \"node:fs\"\nimport {access, realpath, stat} from \"node:fs/promises\"\nimport path from \"node:path\"\nimport {isDenseArray} from \"./array.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {exceededOwnedDeadline, executeFileWithDeadline} from \"./subprocess.js\"\nimport {isSupportedTimeoutMs, maximumTimeoutMs} from \"./timeout.js\"\n\nconst defaultTimeoutMs = 10_000\n\nexport const canonicalToolchains = deepFreeze({\n  dart: definition(\"dart\", \"SEMANTIFOLD_DART\", [\"--version\"],\n    /^Dart SDK version: 3\\.13\\.3 \\(stable\\) \\(Tue Sep 1 01:07:17 2026 -0700\\) on \"linux_x64\"$/u),\n  php: definition(\"php\", \"SEMANTIFOLD_PHP\", [\"--version\"], /^PHP 8\\./u),\n  php82: definition(\"php\", \"SEMANTIFOLD_PHP\", [\"--version\"], /^PHP (?:8\\.(?:[2-9]|[1-9][0-9]+)|(?:9|[1-9][0-9]+)\\.[0-9]+)\\./u),\n  ruby: definition(\"ruby\", \"SEMANTIFOLD_RUBY\", [\"--version\"], /^ruby 3\\./u),\n  node: definition(\"node\", \"SEMANTIFOLD_NODE\", [\"--version\"], /^v24\\./u),\n  tsc: definition(\"tsc\", \"SEMANTIFOLD_TSC\", [\"--version\"], /^Version 7\\./u),\n  javac: definition(\"javac\", \"SEMANTIFOLD_JAVAC\", [\"-version\"], /^javac (?:1[7-9]|2[0-9])\\./u),\n  java: definition(\"java\", \"SEMANTIFOLD_JAVA\", [\"-version\"], /^(?:openjdk|java) version \"(?:1[7-9]|2[0-9])\\./u),\n  java25: definition(\"java\", \"SEMANTIFOLD_JAVA\", [\"-version\"],\n    /^openjdk version \"25\\.0\\.4\" 2026-07-21\\nOpenJDK Runtime Environment \\(build 25\\.0\\.4\\+7-1-((?:24|26)\\.04)-Ubuntu\\)\\nOpenJDK 64-Bit Server VM \\(build 25\\.0\\.4\\+7-1-\\1-Ubuntu, mixed mode, sharing\\)$/u),\n  kotlinc: definition(\"kotlinc\", \"SEMANTIFOLD_KOTLINC\", [\"-version\"], /^info: kotlinc-jvm 2\\.4\\.20 \\(JRE 25\\.0\\.4\\+7-1-(?:24|26)\\.04-Ubuntu\\)$/u),\n  python: definition(\"python3\", \"SEMANTIFOLD_PYTHON\", [\"--version\"], /^Python 3\\./u),\n  dotnet: definition(\"dotnet\", \"SEMANTIFOLD_DOTNET\", [\"--version\"], /^10\\./u),\n  go: definition(\"go\", \"SEMANTIFOLD_GO\", [\"version\"], /^go version go1\\.26\\.\\d+ linux\\/amd64$/u),\n  clangpp: definition(\"clang++\", \"SEMANTIFOLD_CLANGPP\", [\"--version\"], /^Ubuntu clang version 21\\.1\\.8 [^\\n]+\\nTarget: x86_64-pc-linux-gnu\\n/u),\n  clang: definition(\"clang\", \"SEMANTIFOLD_CLANG\", [\"--version\"], /^Ubuntu clang version 21\\.1\\.8 [^\\n]+\\nTarget: x86_64-pc-linux-gnu\\n/u),\n  rustc: definition(\"rustc\", \"SEMANTIFOLD_RUSTC\", [\"--version\", \"--verbose\"], /^rustc 1\\.98\\.1 \\(48a229cea 2026-09-01\\)\\nbinary: rustc\\ncommit-hash: 48a229ceaefd4985c50990b14116b6d856af0985\\ncommit-date: 2026-09-01\\nhost: x86_64-unknown-linux-gnu\\nrelease: 1\\.98\\.1\\nLLVM version: 22\\.1\\.8$/u),\n  cargo: definition(\"cargo\", \"SEMANTIFOLD_CARGO\", [\"--version\", \"--verbose\"], /^cargo 1\\.98\\.1 \\(797e8a9bc 2026-08-05\\)\\nrelease: 1\\.98\\.1\\ncommit-hash: 797e8a9bca276c1c9f9f738d2a20f484fa4eea9d\\ncommit-date: 2026-08-05\\nhost: x86_64-unknown-linux-gnu\\n/u),\n  zig: definition(\"zig\", \"SEMANTIFOLD_ZIG\", [\"version\"], /^0\\.15\\.2$/u),\n  swiftc: definition(\"swiftc\", \"SEMANTIFOLD_SWIFTC\", [\"--driver-mode=swiftc\", \"--version\"], /^Swift version 6\\.3\\.3 \\(swift-6\\.3\\.3-RELEASE\\)\\nTarget: x86_64-unknown-linux-gnu$/u),\n  \"wasm-validate\": definition(\"wasm-validate\", \"SEMANTIFOLD_WASM_VALIDATE\", [\"--version\"], /^1\\.0\\.36$/u),\n  chromium: definition(\"chromium\", \"SEMANTIFOLD_CHROMIUM\", [\"--version\"], /^Google Chrome 152\\.0\\.7977\\.82$/u)\n})\n\n/**\n * Discovers one repository-declared canonical toolchain.\n * @param {keyof typeof canonicalToolchains} id - Canonical toolchain ID.\n * @param {{environment?: Readonly<Record<string, string | undefined>>, override?: string, timeoutMs?: number}} [options] - Discovery options.\n * @returns {Promise<import(\"./semantic/types.js\").DiscoveredToolchain>} Exact executable and version.\n */\nexport async function discoverCanonicalToolchain(id, options = {}) {\n  if (typeof id != \"string\" || id.length == 0) {\n    invalidToolchain(\"Canonical toolchain ID must be a non-empty primitive string.\", \"toolchain\")\n  }\n  if (!isPlainObject(options)) invalidToolchain(\"Canonical toolchain options must be an object.\", id)\n  const definition = Object.hasOwn(canonicalToolchains, id)\n    ? canonicalToolchains[/** @type {keyof typeof canonicalToolchains} */ (id)]\n    : undefined\n\n  if (!definition) invalidToolchain(`Unknown canonical toolchain '${id}'.`, id)\n  const configurationEnvironment = options.environment === undefined\n    ? undefined\n    : snapshotEnvironment(options.environment, id)\n  const environment = configurationEnvironment ?? defaultEnvironment()\n  const configured = options.override === undefined\n    ? configurationEnvironment === undefined\n      ? process.env[definition.overrideEnvironmentVariable]\n      : configurationEnvironment[definition.overrideEnvironmentVariable]\n    : options.override\n\n  return discoverToolchain({\n    canonicalCommand: definition.canonicalCommand,\n    environment,\n    id,\n    override: configured,\n    supportedVersion: definition.supportedVersion,\n    timeoutMs: options.timeoutMs,\n    versionArguments: definition.versionArguments\n  })\n}\n\n/**\n * Resolves and versions one configured or canonical executable without invoking a shell.\n * @param {object} input - Discovery request.\n * @param {string} input.canonicalCommand - Canonical PATH command.\n * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Explicit discovery environment.\n * @param {string} input.id - Toolchain ID.\n * @param {string} [input.override] - Configured absolute executable path.\n * @param {RegExp} [input.supportedVersion] - Full selected-stream version policy.\n * @param {number} [input.timeoutMs] - Version command timeout.\n * @param {string[]} input.versionArguments - Exact version argument array.\n * @returns {Promise<import(\"./semantic/types.js\").DiscoveredToolchain>} Discovered tool.\n */\nexport async function discoverToolchain(input) {\n  if (!isPlainObject(input)) invalidToolchain(\"Toolchain discovery requires a request object.\", \"toolchain\")\n  const versionArgumentCandidate = input.versionArguments\n  const versionArguments = isDenseArray(versionArgumentCandidate) ? [...versionArgumentCandidate] : undefined\n  const candidate = {\n    canonicalCommand: input.canonicalCommand,\n    environment: input.environment === undefined ? defaultEnvironment() : input.environment,\n    id: input.id,\n    override: input.override,\n    supportedVersion: input.supportedVersion,\n    timeoutMs: input.timeoutMs === undefined ? defaultTimeoutMs : input.timeoutMs,\n    versionArguments\n  }\n\n  validateDiscovery(candidate)\n  const canonicalCommand = /** @type {string} */ (candidate.canonicalCommand)\n  const environment = /** @type {Readonly<Record<string, string | undefined>>} */ (candidate.environment)\n  const id = /** @type {string} */ (candidate.id)\n  const override = /** @type {string | undefined} */ (candidate.override)\n  const supportedVersion = candidate.supportedVersion instanceof RegExp\n    ? new RegExp(candidate.supportedVersion.source, candidate.supportedVersion.flags)\n    : undefined\n  const timeoutMs = /** @type {number} */ (candidate.timeoutMs)\n  const validatedVersionArguments = /** @type {string[]} */ (candidate.versionArguments)\n  const normalizedEnvironment = deterministicEnvironment(environment)\n  const {executable, source} = override === undefined\n    ? await resolveCanonical(id, canonicalCommand, normalizedEnvironment.PATH ?? \"\")\n    : {executable: await resolveOverride(id, override, canonicalCommand), source: /** @type {const} */ (\"override\")}\n  /** @type {{stdout: string, stderr: string}} */\n  let result\n\n  try {\n    result = await executeFileWithDeadline({\n      arguments: validatedVersionArguments,\n      environment: normalizedEnvironment,\n      executable,\n      maxBuffer: 1024 * 1024,\n      timeoutMs\n    })\n  } catch (error) {\n    const processError = processErrorFields(error)\n    const timedOut = exceededOwnedDeadline(error)\n\n    throw new SemantifoldDiagnostic({\n      ...processError,\n      cause: error instanceof Error ? error : undefined,\n      code: timedOut ? \"TOOL_VERSION_TIMEOUT\" : \"TOOL_VERSION_FAILURE\",\n      command: canonicalCommand,\n      executable,\n      language: id,\n      message: timedOut\n        ? `Version command for '${executable}' exceeded ${timeoutMs}ms.`\n        : `Version command for '${executable}' failed.`,\n      stderr: processError.stderr,\n      stdout: processError.stdout\n    })\n  }\n\n  const {stderr, stdout} = result\n  const normalizedStdout = stdout.trim()\n  const normalizedStderr = stderr.trim()\n  const versionOutput = normalizedStdout.length > 0 ? normalizedStdout : normalizedStderr\n  const version = versionOutput.split(/\\r?\\n/u)[0] ?? \"\"\n\n  if (version.length == 0) {\n    throw new SemantifoldDiagnostic({\n      code: \"TOOL_VERSION_FAILURE\",\n      command: canonicalCommand,\n      executable,\n      language: id,\n      message: `Version command for '${executable}' returned no version output.`,\n      stderr,\n      stdout\n    })\n  }\n  if (supportedVersion && !supportedVersion.test(versionOutput)) {\n    throw new SemantifoldDiagnostic({\n      code: \"TOOL_UNSUPPORTED_VERSION\",\n      command: canonicalCommand,\n      executable,\n      language: id,\n      message: `Executable '${executable}' reported unsupported version '${version}'.`,\n      stderr,\n      stdout,\n      version\n    })\n  }\n\n  return deepFreeze({\n    command: canonicalCommand,\n    executable,\n    id,\n    source,\n    version,\n    versionArguments: validatedVersionArguments,\n    versionOutput\n  })\n}\n\n/**\n * Builds one canonical immutable toolchain declaration.\n * @param {string} canonicalCommand - PATH command.\n * @param {string} overrideEnvironmentVariable - Configured override variable.\n * @param {string[]} versionArguments - Exact version arguments.\n * @param {RegExp} supportedVersion - Supported version output.\n * @returns {{canonicalCommand: string, overrideEnvironmentVariable: string, supportedVersion: RegExp, versionArguments: string[]}} Declaration.\n */\nfunction definition(canonicalCommand, overrideEnvironmentVariable, versionArguments, supportedVersion) {\n  return {canonicalCommand, overrideEnvironmentVariable, supportedVersion, versionArguments}\n}\n\n/**\n * Validates tool discovery before filesystem or process access.\n * @param {{\n *   canonicalCommand: unknown,\n *   environment: unknown,\n *   id: unknown,\n *   override: unknown,\n *   supportedVersion: unknown,\n *   timeoutMs: unknown,\n *   versionArguments: unknown\n * }} input - Candidate discovery fields.\n * @returns {void}\n */\nfunction validateDiscovery(input) {\n  if (typeof input.id != \"string\" || input.id.length == 0 ||\n    typeof input.canonicalCommand != \"string\" || input.canonicalCommand.length == 0 ||\n    input.canonicalCommand.includes(\"/\") || input.canonicalCommand.includes(\"\\\\\") || input.canonicalCommand.includes(\"\\0\") ||\n    !isDenseArray(input.versionArguments) || !input.versionArguments.every(validArgument) ||\n    !isEnvironment(input.environment) || !isSupportedTimeoutMs(input.timeoutMs) ||\n    (input.override !== undefined && (typeof input.override != \"string\" || !path.isAbsolute(input.override) || input.override.includes(\"\\0\"))) ||\n    (input.supportedVersion !== undefined && (!(input.supportedVersion instanceof RegExp) || input.supportedVersion.global || input.supportedVersion.sticky))) {\n    invalidToolchain(`Toolchain discovery requires a canonical basename, absolute override, argument array, environment, and timeout from 1 through ${maximumTimeoutMs}ms.`,\n      typeof input.id == \"string\" ? input.id : \"toolchain\")\n  }\n}\n\n/**\n * Resolves one unambiguous canonical command from an explicit PATH.\n * @param {string} id - Toolchain ID.\n * @param {string} command - Canonical command.\n * @param {string} pathValue - Explicit PATH.\n * @returns {Promise<{executable: string, source: \"canonical\"}>} Exact executable.\n */\nasync function resolveCanonical(id, command, pathValue) {\n  const matches = new Map()\n\n  for (const directory of pathValue.split(path.delimiter)) {\n    if (directory.length == 0 || !path.isAbsolute(directory)) continue\n    const candidate = path.join(directory, command)\n\n    try {\n      const exact = await resolveExecutableFile(candidate)\n\n      if (exact != undefined) matches.set(exact, exact)\n    } catch {\n      // A PATH candidate is absent or non-executable; discovery continues deterministically.\n    }\n  }\n\n  if (matches.size == 0) {\n    throw new SemantifoldDiagnostic({\n      code: \"TOOL_NOT_FOUND\",\n      command,\n      language: id,\n      message: `Canonical command '${command}' was not found as an executable on PATH.`\n    })\n  }\n  if (matches.size > 1) {\n    throw new SemantifoldDiagnostic({\n      code: \"TOOL_AMBIGUOUS\",\n      command,\n      language: id,\n      message: `Canonical command '${command}' resolves to multiple executables: ${[...matches.keys()].join(\", \")}.`\n    })\n  }\n\n  return {executable: /** @type {string} */ ([...matches.keys()][0]), source: /** @type {const} */ (\"canonical\")}\n}\n\n/**\n * Resolves one configured absolute executable.\n * @param {string} id - Toolchain ID.\n * @param {string} override - Absolute override.\n * @param {string} command - Canonical command.\n * @returns {Promise<string>} Exact executable path.\n */\nasync function resolveOverride(id, override, command) {\n  /** @type {Error | undefined} */\n  let cause\n\n  try {\n    const exact = await resolveExecutableFile(override)\n\n    if (exact != undefined) return exact\n  } catch (error) {\n    cause = error instanceof Error ? error : undefined\n  }\n\n  throw new SemantifoldDiagnostic({\n    cause,\n    code: \"TOOL_NOT_FOUND\",\n    command,\n    executable: override,\n    language: id,\n    message: `Configured executable '${override}' is missing or not executable.`\n  })\n}\n\n/**\n * Resolves one candidate to an executable regular file.\n * @param {string} candidate - Candidate path.\n * @returns {Promise<string | undefined>} Exact regular executable, if the file type is valid.\n */\nasync function resolveExecutableFile(candidate) {\n  const exact = await realpath(candidate)\n  const status = await stat(exact)\n\n  if (!status.isFile()) return undefined\n  await access(exact, fsConstants.X_OK)\n\n  return exact\n}\n\n/**\n * Produces the minimal deterministic process environment.\n * @param {Readonly<Record<string, string | undefined>>} environment - Explicit inputs.\n * @returns {Readonly<Record<string, string>>} Normalized environment.\n */\nexport function deterministicEnvironment(environment = defaultEnvironment()) {\n  const entries = environmentEntries(environment)\n\n  if (entries == undefined) invalidToolchain(\"Process environment must be a plain own-property data record of string or undefined values.\", \"environment\")\n  /** @type {Record<string, string>} */\n  const normalized = Object.create(null)\n\n  for (const [key, value] of entries) {\n    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key) || key.includes(\"\\0\") || (value !== undefined && value.includes(\"\\0\"))) {\n      invalidToolchain(\"Process environment contains an invalid key or value.\", \"environment\")\n    }\n    if (value !== undefined) normalized[key] = value\n  }\n  normalized.LANG = \"C.UTF-8\"\n  normalized.LC_ALL = \"C.UTF-8\"\n  normalized.TZ = \"UTC\"\n  normalized.PATH ??= \"/usr/local/bin:/usr/bin:/bin\"\n\n  return Object.freeze(normalized)\n}\n\n/**\n * Retains only executable lookup from the ambient environment.\n * @returns {Readonly<Record<string, string | undefined>>} Minimal default environment.\n */\nfunction defaultEnvironment() {\n  return {PATH: process.env.PATH}\n}\n\n/**\n * Narrows stable fields from a version subprocess rejection.\n * @param {unknown} error - Process rejection.\n * @returns {{exitCode: number | undefined, signal: string | undefined, stderr: string, stdout: string}} Stable fields.\n */\nfunction processErrorFields(error) {\n  if (!error || typeof error != \"object\") return {exitCode: undefined, signal: undefined, stderr: \"\", stdout: \"\"}\n  const value = /** @type {Record<string, unknown>} */ (error)\n\n  return {\n    exitCode: typeof value.code == \"number\" ? value.code : undefined,\n    signal: typeof value.signal == \"string\" ? value.signal : undefined,\n    stderr: typeof value.stderr == \"string\" ? value.stderr : \"\",\n    stdout: typeof value.stdout == \"string\" ? value.stdout : \"\"\n  }\n}\n\n/**\n * Checks one shell-free argument.\n * @param {unknown} value - Candidate argument.\n * @returns {value is string} Whether the argument is safe to pass directly.\n */\nfunction validArgument(value) {\n  return typeof value == \"string\" && !value.includes(\"\\0\")\n}\n\n/**\n * Checks explicit process-environment values.\n * @param {unknown} value - Candidate environment.\n * @returns {value is Readonly<Record<string, string | undefined>>} Whether entries are strings or undefined.\n */\nfunction isEnvironment(value) {\n  return environmentEntries(value) != undefined\n}\n\n/**\n * Detaches an explicit environment before canonical override lookup can yield.\n * @param {unknown} value - Candidate environment record.\n * @param {string} id - Toolchain identity.\n * @returns {Readonly<Record<string, string | undefined>>} Owned environment data.\n */\nfunction snapshotEnvironment(value, id) {\n  const entries = environmentEntries(value)\n\n  if (entries == undefined) {\n    invalidToolchain(\"Canonical toolchain environment must be a plain own-property data record of string or undefined values.\", id)\n  }\n  /** @type {Record<string, string | undefined>} */\n  const snapshot = Object.create(null)\n\n  for (const [key, entry] of entries) snapshot[key] = entry\n\n  return Object.freeze(snapshot)\n}\n\n/**\n * Reads only enumerable own data properties from an ordinary or null-prototype record.\n * @param {unknown} value - Candidate environment record.\n * @returns {[string, string | undefined][] | undefined} Detached entries when valid.\n */\nfunction environmentEntries(value) {\n  if (typeof value != \"object\" || value == null || Array.isArray(value)) return undefined\n\n  try {\n    const prototype = Object.getPrototypeOf(value)\n\n    if (prototype !== Object.prototype && prototype !== null) return undefined\n    /** @type {[string, string | undefined][]} */\n    const entries = []\n\n    for (const key of Reflect.ownKeys(value)) {\n      if (typeof key != \"string\") return undefined\n      const descriptor = Object.getOwnPropertyDescriptor(value, key)\n\n      if (descriptor == undefined || !descriptor.enumerable || !(\"value\" in descriptor) ||\n        (descriptor.value !== undefined && typeof descriptor.value != \"string\")) return undefined\n      entries.push([key, descriptor.value])\n    }\n\n    return entries\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Checks for an ordinary string-keyed object.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  return typeof value == \"object\" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Throws a normalized discovery-configuration diagnostic.\n * @param {string} message - Failure detail.\n * @param {string} id - Toolchain identity.\n * @returns {never} Always throws.\n */\nfunction invalidToolchain(message, id) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_TOOLCHAIN\", language: id, message})\n}\n\n/**\n * Deeply freezes canonical declarations and discovery results.\n * @template T\n * @param {T} value - Toolchain-owned value.\n * @returns {T} Frozen value.\n */\nfunction deepFreeze(value) {\n  if (!value || typeof value != \"object\" || Object.isFrozen(value)) return value\n\n  for (const nested of Object.values(value)) deepFreeze(nested)\n\n  return Object.freeze(value)\n}\n"]}

package/build/src/zig-bindings.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Collects semantic binding reads and explicit assignment targets for Zig's compile-error-level binding checks.
+ * @param {import("./semantic/types.js").Block} block - Complete function or entry block.
+ * @returns {{reads: Set<string>, writes: Set<string>}} Binding usage by exact source name.
+ */
+export declare function collectZigBindingUsage(block: import("./semantic/types.js").Block): {
+    reads: Set<string>;
+    writes: Set<string>;
+};
+//# sourceMappingURL=zig-bindings.d.ts.map

package/build/src/zig-bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zig-bindings.d.ts","sourceRoot":"","sources":["../../src/zig-bindings.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAHjC,OAAO,qBAAqB,EAAE,KAGG,GAF/B;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAC,CAwCrD"}

package/build/src/zig-bindings.js

@@ -0,0 +1,54 @@
+// @ts-check
+/**
+ * Collects semantic binding reads and explicit assignment targets for Zig's compile-error-level binding checks.
+ * @param {import("./semantic/types.js").Block} block - Complete function or entry block.
+ * @returns {{reads: Set<string>, writes: Set<string>}} Binding usage by exact source name.
+ */
+export function collectZigBindingUsage(block) {
+    const reads = new Set();
+    const writes = new Set();
+    /**
+     * Records every binding read in one expression.
+     * @param {import("./semantic/types.js").Expression} expression - Expression to traverse.
+     */
+    const expression = (expression) => {
+        if (expression.kind == "IdentifierExpression")
+            reads.add(expression.name);
+        else if (expression.kind == "CallExpression")
+            expression.arguments.forEach(argument => expressionVisit(argument));
+        else if (expression.kind == "UnaryExpression")
+            expressionVisit(expression.operand);
+        else if (expression.kind == "BinaryExpression") {
+            expressionVisit(expression.left);
+            expressionVisit(expression.right);
+        }
+    };
+    const expressionVisit = expression;
+    /**
+     * Records reads and writes throughout one block subtree.
+     * @param {import("./semantic/types.js").Block} current - Block to traverse.
+     */
+    const visit = (current) => {
+        for (const statement of current.statements) {
+            if (statement.kind == "LocalDeclaration")
+                expressionVisit(statement.initializer);
+            else if (statement.kind == "AssignmentStatement") {
+                writes.add(statement.target.name);
+                expressionVisit(statement.expression);
+            }
+            else if (statement.kind == "IfStatement") {
+                expressionVisit(statement.condition);
+                visit(statement.consequent);
+                if (statement.alternate)
+                    visit(statement.alternate);
+            }
+            else if (statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement")
+                expressionVisit(statement.expression);
+            else if (statement.kind == "ReturnStatement" && statement.expression)
+                expressionVisit(statement.expression);
+        }
+    };
+    visit(block);
+    return { reads, writes };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemlnLWJpbmRpbmdzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ppZy1iaW5kaW5ncy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVo7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxzQkFBc0IsQ0FBQyxLQUFLO0lBQzFDLE1BQU0sS0FBSyxHQUFHLElBQUksR0FBRyxFQUFFLENBQUE7SUFDdkIsTUFBTSxNQUFNLEdBQUcsSUFBSSxHQUFHLEVBQUUsQ0FBQTtJQUN4Qjs7O09BR0c7SUFDSCxNQUFNLFVBQVUsR0FBRyxDQUFDLFVBQVUsRUFBRSxFQUFFO1FBQ2hDLElBQUksVUFBVSxDQUFDLElBQUksSUFBSSxzQkFBc0I7WUFBRSxLQUFLLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQTthQUNwRSxJQUFJLFVBQVUsQ0FBQyxJQUFJLElBQUksZ0JBQWdCO1lBQUUsVUFBVSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxlQUFlLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQTthQUM1RyxJQUFJLFVBQVUsQ0FBQyxJQUFJLElBQUksaUJBQWlCO1lBQUUsZUFBZSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQTthQUM3RSxJQUFJLFVBQVUsQ0FBQyxJQUFJLElBQUksa0JBQWtCLEVBQUUsQ0FBQztZQUMvQyxlQUFlLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFBO1lBQ2hDLGVBQWUsQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDbkMsQ0FBQztJQUNILENBQUMsQ0FBQTtJQUNELE1BQU0sZUFBZSxHQUFHLFVBQVUsQ0FBQTtJQUNsQzs7O09BR0c7SUFDSCxNQUFNLEtBQUssR0FBRyxDQUFDLE9BQU8sRUFBRSxFQUFFO1FBQ3hCLEtBQUssTUFBTSxTQUFTLElBQUksT0FBTyxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQzNDLElBQUksU0FBUyxDQUFDLElBQUksSUFBSSxrQkFBa0I7Z0JBQUUsZUFBZSxDQUFDLFNBQVMsQ0FBQyxXQUFXLENBQUMsQ0FBQTtpQkFDM0UsSUFBSSxTQUFTLENBQUMsSUFBSSxJQUFJLHFCQUFxQixFQUFFLENBQUM7Z0JBQ2pELE1BQU0sQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQTtnQkFDakMsZUFBZSxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsQ0FBQTtZQUN2QyxDQUFDO2lCQUFNLElBQUksU0FBUyxDQUFDLElBQUksSUFBSSxhQUFhLEVBQUUsQ0FBQztnQkFDM0MsZUFBZSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsQ0FBQTtnQkFDcEMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsQ0FBQTtnQkFDM0IsSUFBSSxTQUFTLENBQUMsU0FBUztvQkFBRSxLQUFLLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxDQUFBO1lBQ3JELENBQUM7aUJBQU0sSUFBSSxTQUFTLENBQUMsSUFBSSxJQUFJLHFCQUFxQixJQUFJLFNBQVMsQ0FBQyxJQUFJLElBQUksZ0JBQWdCO2dCQUFFLGVBQWUsQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLENBQUE7aUJBQzFILElBQUksU0FBUyxDQUFDLElBQUksSUFBSSxpQkFBaUIsSUFBSSxTQUFTLENBQUMsVUFBVTtnQkFBRSxlQUFlLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxDQUFBO1FBQzdHLENBQUM7SUFDSCxDQUFDLENBQUE7SUFFRCxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDWixPQUFPLEVBQUMsS0FBSyxFQUFFLE1BQU0sRUFBQyxDQUFBO0FBQ3hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcblxuLyoqXG4gKiBDb2xsZWN0cyBzZW1hbnRpYyBiaW5kaW5nIHJlYWRzIGFuZCBleHBsaWNpdCBhc3NpZ25tZW50IHRhcmdldHMgZm9yIFppZydzIGNvbXBpbGUtZXJyb3ItbGV2ZWwgYmluZGluZyBjaGVja3MuXG4gKiBAcGFyYW0ge2ltcG9ydChcIi4vc2VtYW50aWMvdHlwZXMuanNcIikuQmxvY2t9IGJsb2NrIC0gQ29tcGxldGUgZnVuY3Rpb24gb3IgZW50cnkgYmxvY2suXG4gKiBAcmV0dXJucyB7e3JlYWRzOiBTZXQ8c3RyaW5nPiwgd3JpdGVzOiBTZXQ8c3RyaW5nPn19IEJpbmRpbmcgdXNhZ2UgYnkgZXhhY3Qgc291cmNlIG5hbWUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjb2xsZWN0WmlnQmluZGluZ1VzYWdlKGJsb2NrKSB7XG4gIGNvbnN0IHJlYWRzID0gbmV3IFNldCgpXG4gIGNvbnN0IHdyaXRlcyA9IG5ldyBTZXQoKVxuICAvKipcbiAgICogUmVjb3JkcyBldmVyeSBiaW5kaW5nIHJlYWQgaW4gb25lIGV4cHJlc3Npb24uXG4gICAqIEBwYXJhbSB7aW1wb3J0KFwiLi9zZW1hbnRpYy90eXBlcy5qc1wiKS5FeHByZXNzaW9ufSBleHByZXNzaW9uIC0gRXhwcmVzc2lvbiB0byB0cmF2ZXJzZS5cbiAgICovXG4gIGNvbnN0IGV4cHJlc3Npb24gPSAoZXhwcmVzc2lvbikgPT4ge1xuICAgIGlmIChleHByZXNzaW9uLmtpbmQgPT0gXCJJZGVudGlmaWVyRXhwcmVzc2lvblwiKSByZWFkcy5hZGQoZXhwcmVzc2lvbi5uYW1lKVxuICAgIGVsc2UgaWYgKGV4cHJlc3Npb24ua2luZCA9PSBcIkNhbGxFeHByZXNzaW9uXCIpIGV4cHJlc3Npb24uYXJndW1lbnRzLmZvckVhY2goYXJndW1lbnQgPT4gZXhwcmVzc2lvblZpc2l0KGFyZ3VtZW50KSlcbiAgICBlbHNlIGlmIChleHByZXNzaW9uLmtpbmQgPT0gXCJVbmFyeUV4cHJlc3Npb25cIikgZXhwcmVzc2lvblZpc2l0KGV4cHJlc3Npb24ub3BlcmFuZClcbiAgICBlbHNlIGlmIChleHByZXNzaW9uLmtpbmQgPT0gXCJCaW5hcnlFeHByZXNzaW9uXCIpIHtcbiAgICAgIGV4cHJlc3Npb25WaXNpdChleHByZXNzaW9uLmxlZnQpXG4gICAgICBleHByZXNzaW9uVmlzaXQoZXhwcmVzc2lvbi5yaWdodClcbiAgICB9XG4gIH1cbiAgY29uc3QgZXhwcmVzc2lvblZpc2l0ID0gZXhwcmVzc2lvblxuICAvKipcbiAgICogUmVjb3JkcyByZWFkcyBhbmQgd3JpdGVzIHRocm91Z2hvdXQgb25lIGJsb2NrIHN1YnRyZWUuXG4gICAqIEBwYXJhbSB7aW1wb3J0KFwiLi9zZW1hbnRpYy90eXBlcy5qc1wiKS5CbG9ja30gY3VycmVudCAtIEJsb2NrIHRvIHRyYXZlcnNlLlxuICAgKi9cbiAgY29uc3QgdmlzaXQgPSAoY3VycmVudCkgPT4ge1xuICAgIGZvciAoY29uc3Qgc3RhdGVtZW50IG9mIGN1cnJlbnQuc3RhdGVtZW50cykge1xuICAgICAgaWYgKHN0YXRlbWVudC5raW5kID09IFwiTG9jYWxEZWNsYXJhdGlvblwiKSBleHByZXNzaW9uVmlzaXQoc3RhdGVtZW50LmluaXRpYWxpemVyKVxuICAgICAgZWxzZSBpZiAoc3RhdGVtZW50LmtpbmQgPT0gXCJBc3NpZ25tZW50U3RhdGVtZW50XCIpIHtcbiAgICAgICAgd3JpdGVzLmFkZChzdGF0ZW1lbnQudGFyZ2V0Lm5hbWUpXG4gICAgICAgIGV4cHJlc3Npb25WaXNpdChzdGF0ZW1lbnQuZXhwcmVzc2lvbilcbiAgICAgIH0gZWxzZSBpZiAoc3RhdGVtZW50LmtpbmQgPT0gXCJJZlN0YXRlbWVudFwiKSB7XG4gICAgICAgIGV4cHJlc3Npb25WaXNpdChzdGF0ZW1lbnQuY29uZGl0aW9uKVxuICAgICAgICB2aXNpdChzdGF0ZW1lbnQuY29uc2VxdWVudClcbiAgICAgICAgaWYgKHN0YXRlbWVudC5hbHRlcm5hdGUpIHZpc2l0KHN0YXRlbWVudC5hbHRlcm5hdGUpXG4gICAgICB9IGVsc2UgaWYgKHN0YXRlbWVudC5raW5kID09IFwiRXhwcmVzc2lvblN0YXRlbWVudFwiIHx8IHN0YXRlbWVudC5raW5kID09IFwiUHJpbnRTdGF0ZW1lbnRcIikgZXhwcmVzc2lvblZpc2l0KHN0YXRlbWVudC5leHByZXNzaW9uKVxuICAgICAgZWxzZSBpZiAoc3RhdGVtZW50LmtpbmQgPT0gXCJSZXR1cm5TdGF0ZW1lbnRcIiAmJiBzdGF0ZW1lbnQuZXhwcmVzc2lvbikgZXhwcmVzc2lvblZpc2l0KHN0YXRlbWVudC5leHByZXNzaW9uKVxuICAgIH1cbiAgfVxuXG4gIHZpc2l0KGJsb2NrKVxuICByZXR1cm4ge3JlYWRzLCB3cml0ZXN9XG59XG4iXX0=

package/docs/android.md

@@ -72,8 +72,8 @@ Every Android SDK payload is a direct immutable official archive verified before
 
 The Android repository archives above come from Google's official [`repository2-3.xml`](https://dl.google.com/android/repository/repository2-3.xml) and [`sys-img2-3.xml`](https://dl.google.com/android/repository/sys-img/google_apis/sys-img2-3.xml) package metadata; the emulator build and published SHA-256 come from the official [Android Emulator download archive](https://developer.android.com/studio/emulator_archive). `scripts/bootstrap-android.sh` is the only online preparation stage. It verifies immutable archives, installs them directly, registers the archived emulator through a checked-in exact local-package descriptor, verifies their embedded exact revision metadata, creates the named API-35 AVD, and warms the fixed Gradle cache with a disposable project. `scripts/accept-android.sh` generates a fresh project, creates its ephemeral debug key only inside the private acceptance root, and runs lint, JUnit, debug application assembly, and instrumentation assembly with Gradle `--offline` plus pinned UTF-8, English, UTC, heap, no-daemon, no-parallel, no-build-cache settings. Missing tools, package revisions, or cache content fail with `SEMANTIFOLD_ANDROID_INFRASTRUCTURE` rather than skipping.
 
-The only declared Gradle library dependencies are exact non-transitive `testImplementation("junit:junit:4.13.2")` and `testRuntimeOnly("org.hamcrest:hamcrest-core:1.3")`. Hamcrest Core supplies the `org.hamcrest.SelfDescribing` linkage that JUnit's Gradle runner loads before generated test code; it does not enter application compilation or runtime. The generated unit test uses only JUnit's `@Test` annotation, compares the platform list directly, and raises a platform `AssertionError`. Kotlin's implicit stdlib dependency is disabled. Compilation reads the checksum-pinned compiler distribution's `kotlin-stdlib.jar` directly as a compiler task input, not as a Gradle dependency; generated bytecode uses JVM/Android platform facilities and the file is never placed on a runtime configuration or packaging input. Acceptance requires an empty debug runtime dependency graph, exactly JUnit and Hamcrest Core in the unit-test runtime graph, and no JUnit, Hamcrest, `kotlin/jvm/internal`, or `kotlin/collections` payload in the application APK.
+The only declared Gradle library dependencies are exact non-transitive `testImplementation("junit:junit:4.13.2")`, exact non-transitive `testRuntimeOnly("org.hamcrest:hamcrest-core:1.3")`, and `androidTestImplementation(files(semantifoldKotlinStdlib))` from the checksum-pinned Kotlin compiler distribution. Hamcrest Core supplies the `org.hamcrest.SelfDescribing` linkage that JUnit's Gradle runner loads before generated test code; neither unit-test library enters application compilation or runtime. The generated unit test uses only JUnit's `@Test` annotation, compares the platform list directly, and raises a platform `AssertionError`. Kotlin's implicit stdlib dependency is disabled. Compilation reads the pinned distribution's `kotlin-stdlib.jar` directly as a compiler task input, while the explicit `androidTest` file dependency packages that same verified runtime only into the instrumentation APK so generated Kotlin instrumentation is self-contained. Acceptance requires an empty debug runtime dependency graph, excludes only Gradle's exact structural `project :app (*)` self-project entry from the unit-test report, requires exactly JUnit and Hamcrest Core among external unit-test dependencies, rejects every other project dependency form, permits no JUnit, Hamcrest, `kotlin/jvm/internal`, or `kotlin/collections` payload in the application APK, and requires `kotlin.jvm.internal.Intrinsics` in the instrumentation APK. A rejected graph reports only the parser-matched full dependency descriptions, preserving Gradle syntax without exposing the complete build log.
 
-Real emulator acceptance runs only in TensorBuzz with `/dev/kvm:/dev/kvm`. It fails before startup unless `/dev/kvm` is usable and `emulator -accel-check` affirms acceleration, exclusively locks fixed `emulator-5580` plus its private adb server on port `5581`, never invokes `adb root` or changes KVM permissions, boots with `-accel on -wipe-data -no-snapshot`, installs both APKs, launches the app, and invokes the runner through the explicit `<applicationId>.test` test application ID. Exact UTF-8 output is passed as base64 to platform instrumentation. The test checks the native labelled view, exact text, visibility, class, accessibility importance, absent content description, and activity recreation. CI then stops that emulator, boots a second fresh emulator, reinstalls/relaunches, and repeats. Screenshots/UI XML are always produced; failure also records logcat, adb state, emulator command line, and an exact reason.
+Real emulator acceptance runs only in TensorBuzz with `/dev/kvm:/dev/kvm`. It fails before startup unless `/dev/kvm` is usable and `emulator -accel-check` affirms acceleration, exclusively locks the complete fixed port set: emulator console `5580`, its transport `5581`, and the distinct private adb server `5038` outside the emulator port range. It never invokes `adb root` or changes KVM permissions, boots `emulator-5580` with `-accel on -wipe-data -no-snapshot`, installs both APKs, launches the app, and invokes the runner through the explicit `<applicationId>.test` test application ID. Exact UTF-8 output is passed as base64 to platform instrumentation. The test checks the native labelled view, exact text, visibility, class, accessibility importance, absent content description, and activity recreation. CI then stops that emulator, boots a second fresh emulator, reinstalls/relaunches, and repeats. Screenshots/UI XML are always produced; failure records logcat, adb state, emulator command line, and an exact reason, then emits one fail-loud reason header plus labeled final 16 KiB excerpts from available text diagnostics while leaving binary screenshots and full process data unprinted in their capture files.
 
 Local environments without KVM do not attempt software emulation. Release signing, physical devices, accounts, Play Console, publication, Compose, fragments/navigation, WebView, platform channels, NDK/JNI, reflection, permissions, services, storage/networking, and background behavior are outside Task 028.

package/docs/architecture.md

@@ -4,13 +4,13 @@ Semantifold has three explicit layers.
 
 Task 018's C path follows these layers through the unchanged root-bundled private legacy CST boundary. `src/frontends/c.js` owns all C trees and exhaustive profile validation. `src/backends/native-validation.js` checks native graph/location limits and `c-validation.js` checks C memory limits; `ordered-expressions.js` plans occurrence-specific evaluation without modifying IR; `c.js` emits mapped `program.c`; and `c-runtime.js` supplies the synthetic immutable-slice/arena header. The C frontend reconstructs candidates only from complete CST regions, resolves them with the existing semantic validator, and compares the original whole CST against the re-parsed canonical backend plan before returning a module. This same-language validation keeps target generation free of parser objects. See the [C profile](c.md).
 
-1. Frontend adapters in `src/frontends/` invoke mature language parsers and translate only recognized syntax. Babel owns JavaScript and TypeScript parsing, `php-parser` owns PHP, Prism owns Ruby, Lezer owns Java, and qualified Tree-sitter bindings and grammars own Python, C#, Go, C, CPP, Rust, Swift, Kotlin, and Dart. Their AST/CST objects never appear in the public API. Adapters enumerate supported children and reject every other parser node; filtering syntax away is not a normalization strategy. Prism node offsets and comment byte ranges are converted from UTF-8 to JavaScript UTF-16 offsets before semantic location construction and metadata source slicing. Tree-sitter adapters reject lone surrogates, exhaustively traverse named/anonymous/comment/directive/error/missing children, and verify reported boundaries through the shared UTF-8-byte-to-UTF-16 converter. The Go adapter additionally collapses only exact `package main`, optional `fmt`, ordered semantic functions, and a final zero-argument `func main()` into the shared module/entry shape; assignment occurrences, not Go's uniformly mutable `var` syntax, determine semantic local mutability.
+1. Frontend adapters in `src/frontends/` invoke mature language parsers and translate only recognized syntax. Babel owns JavaScript and TypeScript parsing, `php-parser` owns PHP, Prism owns Ruby, Lezer owns Java, and qualified Tree-sitter bindings and grammars own Python, C#, Go, C, CPP, Rust, Swift, Kotlin, Dart, and Zig. Their AST/CST objects never appear in the public API. Adapters enumerate supported children and reject every other parser node; filtering syntax away is not a normalization strategy. Prism node offsets and comment byte ranges are converted from UTF-8 to JavaScript UTF-16 offsets before semantic location construction and metadata source slicing. Tree-sitter adapters reject lone surrogates, exhaustively traverse named/anonymous/comment/directive/error/missing children, and verify reported boundaries through the shared UTF-8-byte-to-UTF-16 converter. The Go adapter additionally collapses only exact `package main`, optional `fmt`, ordered semantic functions, and a final zero-argument `func main()` into the shared module/entry shape; assignment occurrences, not Go's uniformly mutable `var` syntax, determine semantic local mutability.
 2. `src/semantic/` defines the shared JSDoc-typed discriminated representation and one-based, filename-bearing UTF-16 source locations. `provenance.js` indexes exact source content, deterministic semantic paths/node IDs, resolved symbol IDs, parser-token subranges, and closed source/derived/synthetic origins without exposing parser objects. Task 010's `SemanticProgram` adds dependency-first logical modules, a caller-order multi-source registry, explicit import/export nodes, one selected entry module, and stable module-qualified declaration identities; native filenames, package names, and target paths remain outside semantic resolution. Value types are scalar `integer`/`boolean`/`string` references or recursive acyclic `ListType`, unordered string-keyed `MapType`, insertion-ordered `OrderedMapType`, `OptionalType`, nominal `RecordType`, nominal Task 033 `ReferenceType`, and Task 034 linear `OwnedResourceType`/`OwnedReferenceType`; `void` exists only as a callable return. Task 012 adds invariant unbounded declaration-owned `TypeParameter` values, scoped `TypeVariableReference` leaves, and exact ordered arguments on generic record types. Task 011 adds nominal `ErrorType` only for catch bindings and error constructions, never as an ordinary parameter/local/return value. Task 034 adds compiler-authorized capability/resource/failure/operation declarations, complete resolved `EffectCallExpression` sites, and explicit `OwnedMoveExpression`/`OwnedBorrowExpression` nodes. Every function and reference class/member has a deterministic declaration identity; every list, ordered-map, condition-controlled loop, capability member, and effect site has a deterministic module-local identity. Every direct function, constructor, receiver method, and effect call carries exact resolution facts. Literal and access nodes distinguish scalars, collections, presence/absence, nominal values/references/resources, errors, receivers, and private fields. Unary and binary expressions carry a closed semantic `operation` and explicit result `type`, never a source operator symbol. Every function, constructor, method, entry point, branch, loop, try body, and catch body owns a located `Block` containing ordered `Statement` nodes. Statements additionally include exact `ForEachMapStatement`, strict-Boolean precondition `WhileStatement`, identity-resolved `BreakStatement`/`ContinueStatement`, private receiver-field writes, `RaiseStatement`, and one-handler `TryStatement`; general exception constructs have no semantic node. `lifetime.js` retains distinct normal/return/raise/break/continue ownership states and proves every owner terminal or transferred at every reachable scope exit. Task 033 class identity/private state remains single-module semantics; Task 034's effect/resource nodes stay compiler-authorized and single-module by default, Task 035 extends Task 010 `SemanticProgram` with versioned canonical capability modules and negotiated provider link requirements, and Task 036 adds exact facade-resolution evidence plus compiler-owned source/module roles and a complete selected-facade descriptor.
 3. Source and binary backends in `src/backends/` validate their semantic capabilities before emitting target syntax or bytes. Shared validation owns recursive block shape, reachability and all-path abrupt-completion analysis, recursively complete expressions, exhaustive operation/type signatures, function signatures, lexical binding scopes, mutability, declaration-before-use, strict condition/return/argument/initializer/assignment types, fixed-point propagation of nominal unchecked errors, and Task 034 capability/effect/resource graph integrity. `backends/effects.js` rejects unsupported authority/target/context combinations before writer allocation and plans nested eager effects into statement-local collision-safe temporaries in semantic evaluation order. Dependency-first Task 010 validation carries ordinary inferred error sets across resolved function-import identities; both single-module generation and program mode accept compiler-authorized capability modules, while program mode additionally resolves their canonical standard-library contract references and links negotiated target host provider artifacts before any writer allocation. Target-specific validation adds identifier rules, entry-scaffolding name collisions, numeric/memory/resource bounds, and target string representation. The single-module original five retain one fixed compiler-owned Task 034 probe binding, and program mode materializes the same probe behavior as a tree-shaken provider artifact under a protected native binding. Text emitters write through `SourceWriter`; the Wasm encoder writes through an annotated binary writer so every byte range is semantic or explicitly synthetic. A backend either returns a complete executable program/project/application set or raises `UNSUPPORTED_CAPABILITY`; it never silently drops nodes, exposes a partial artifact, or lets an emitter discover malformed shape through a native error.
 
-`src/language-registry.js` is the sole ordered dispatch and discovery source. Its deeply frozen records bind implementations to independent frontend, text-backend, binary-backend, application-backend, and interoperability roles. Public descriptors derive role booleans, semantic feature flags, artifact multiplicity, round-trip support, rich/v3/byte mapping forms, and acceptance stages/toolchains from those records; `generalFunctionsAndCalls` is true for PHP, Ruby, JavaScript, TypeScript, Java, and Dart; every later feature flag remains true only for the original five. `supportedLanguages` is the derived compatibility view containing IDs with both a frontend and text backend. Duplicate IDs, unknown record fields, malformed capabilities, and unordered acceptance stages fail as `INVALID_REGISTRY`.
+`src/language-registry.js` is the sole ordered dispatch and discovery source. Its deeply frozen records bind implementations to independent frontend, text-backend, binary-backend, application-backend, and interoperability roles. Public descriptors derive role booleans, semantic feature flags, artifact multiplicity, round-trip support, rich/v3/byte mapping forms, and acceptance stages/toolchains from those records; `generalFunctionsAndCalls` is true for PHP, Ruby, JavaScript, TypeScript, Java, Dart, and Zig; every later feature flag remains true only for the original five. `supportedLanguages` is the derived compatibility view containing IDs with both a frontend and text backend. Duplicate IDs, unknown record fields, malformed capabilities, and unordered acceptance stages fail as `INVALID_REGISTRY`.
 
-`index.js` is the public boundary. `createCapabilityAuthority(input)` validates, detaches, and freezes explicit Task 034 compilation authority. `parse({language, filename, source, capabilityAuthority?})` resolves only the frontend role; omitted authority retains the legacy empty capability set and explicit `null` is malformed. `parseProgram(...)` composes only the original-five parser adapters over an explicit complete source set, resolves declarations by identity, performs no I/O, and accepts the same optional compiler authority so program modules may carry Task 034 capability declarations and a Task 035 standard-library contract descriptor. `createStdlibContractRegistry`, `listStdlibModules`, and `resolveStdlibModule` own the versioned canonical contract registry; `createStdlibProviderRegistry` and `listStdlibProviders` own the target host provider registry; `negotiateStdlibProviders` computes the transitive capability closure; and Task 036's `createStdlibFacadeRegistry`, `listStdlibFacades`, and `resolveStdlibFacade` expose detached versioned source-language facade definitions. `generate({language, module})` and `generateArtifact(...)` resolve a single-text backend, validate the full module, and preserve the compatibility source/artifact contracts; they intentionally reject the multiple-artifact C#, Go, C, Rust, Dart, and Wasm backends. `generateArtifactSet(...)` remains the additive single-module artifact boundary, while `generateProgramArtifactSet(...)` plans and validates a complete original-five program before any writer allocation. An unknown ID is `UNSUPPORTED_LANGUAGE`; a known ID missing the program cohort is `UNSUPPORTED_ROLE`; `UNSUPPORTED_CAPABILITY` remains a backend-with-role rejection of semantic content or target layout. `src/artifacts.js` owns transactional generated-file validation and detached, deeply frozen JSON metadata snapshots, including JSON object keys without prototype interpretation. `src/binary-mapping.js` owns byte provenance, and `src/mapping.js` owns text lookup, serialization, import/composition, and diagnostic remapping.
+`index.js` is the public boundary. `createCapabilityAuthority(input)` validates, detaches, and freezes explicit Task 034 compilation authority. `parse({language, filename, source, capabilityAuthority?})` resolves only the frontend role; omitted authority retains the legacy empty capability set and explicit `null` is malformed. `parseProgram(...)` composes only the original-five parser adapters over an explicit complete source set, resolves declarations by identity, performs no I/O, and accepts the same optional compiler authority so program modules may carry Task 034 capability declarations and a Task 035 standard-library contract descriptor. `createStdlibContractRegistry`, `listStdlibModules`, and `resolveStdlibModule` own the versioned canonical contract registry; `createStdlibProviderRegistry` and `listStdlibProviders` own the target host provider registry; `negotiateStdlibProviders` computes the transitive capability closure; and Task 036's `createStdlibFacadeRegistry`, `listStdlibFacades`, and `resolveStdlibFacade` expose detached versioned source-language facade definitions. `generate({language, module})` and `generateArtifact(...)` resolve a single-text backend, validate the full module, and preserve the compatibility source/artifact contracts; they intentionally reject the multiple-artifact C#, Go, C, Rust, Dart, Zig, and Wasm backends. `generateArtifactSet(...)` remains the additive single-module artifact boundary, while `generateProgramArtifactSet(...)` plans and validates a complete original-five program before any writer allocation. An unknown ID is `UNSUPPORTED_LANGUAGE`; a known ID missing the program cohort is `UNSUPPORTED_ROLE`; `UNSUPPORTED_CAPABILITY` remains a backend-with-role rejection of semantic content or target layout. `src/artifacts.js` owns transactional generated-file validation and detached, deeply frozen JSON metadata snapshots, including JSON object keys without prototype interpretation. `src/binary-mapping.js` owns byte provenance, and `src/mapping.js` owns text lookup, serialization, import/composition, and diagnostic remapping.
 
 The [iOS application target](ios.md) is a target-only spoke on that artifact boundary. `src/backends/ios.js` reuses Task 010 project/source ownership and the Task 022 Tasks 001–004 Swift capability profile, validates the complete graph/configuration/asset layout, then emits captured namespaced Swift plus synthetic SwiftUI, unsigned project, test, asset-catalog, and versioned manifest artifacts. Apple lifecycle/configuration/resources do not enter semantic IR, and generation performs no filesystem access. There is no public project materializer: transactional create-only directory publication is deferred because Node's public filesystem API cannot combine atomic no-replace publication with descriptor-relative no-follow staging and cleanup without a separately authorized native boundary. No best-effort writer replaces that guarantee. Linux semantic/tool/packed-generator proofs are implemented; Apple/Xcode/Simulator proof remains explicitly deferred.
 
@@ -52,7 +52,7 @@ Frontend source capabilities and backend target capabilities are intentionally s
 
 Binary operands evaluate left to right. `BooleanAnd` and `BooleanOr` are short-circuit operations. Equality accepts only two operands of the same supported scalar type and means scalar value equality. Semantic integers are mathematical integers with one unsigned zero; IEEE-754 signed zero is not a distinct semantic value. Backends map meaning rather than copying syntax: PHP concatenation is `.`, Java string equality is `.equals`, JavaScript/TypeScript/PHP equality is strict, and other operations use their target's matching native construct. Because supported operations cannot otherwise distinguish signed zero, JavaScript and TypeScript canonically stringify observable scalar output when a module contains integer negation or multiplication. Their frontends unwrap that exact parser-native output scaffold during generated-source reparse, retaining the original operation tree without constant folding. Every emitted operation is conservatively parenthesized; generated-source reparsing reconstructs the same semantic tree.
 
-A source-valid semantic name can be rejected for a target reserved word, and a safe semantic integer can be rejected by Java's narrower `int` range. Java validates literal-only integer operation trees with exact mathematical integers without folding the IR, rejecting known results outside signed 32-bit `int`. Kotlin rejects known results outside the semantic safe range and routes dynamic arithmetic through private `Math.*Exact` helpers followed by the same bound check. C# performs the same proof against signed 64-bit and emits an exact `checked(...)` wrapper for every integer arithmetic/negate operation while the project also enables overflow checking. Go performs the signed-64-bit proof without folding, but non-literal runtime overflow retains native `int64` wrap behavior and remains outside the portable result guarantee. Dart rejects statically known results outside the semantic safe range and routes dynamic add/subtract/multiply/negate through exact private `BigInt` helpers before conversion to `int`; a private Boolean identity helper prevents analyzer constant-fold warnings without changing short-circuit evaluation. Only the complete canonical support CST authorizes either helper family during generated-source reparse.
+A source-valid semantic name can be rejected for a target reserved word, and a safe semantic integer can be rejected by Java's narrower `int` range. Java validates literal-only integer operation trees with exact mathematical integers without folding the IR, rejecting known results outside signed 32-bit `int`. Kotlin rejects known results outside the semantic safe range and routes dynamic arithmetic through private `Math.*Exact` helpers followed by the same bound check. C# performs the same proof against signed 64-bit and emits an exact `checked(...)` wrapper for every integer arithmetic/negate operation while the project also enables overflow checking. Go performs the signed-64-bit proof without folding, but non-literal runtime overflow retains native `int64` wrap behavior and remains outside the portable result guarantee. Dart rejects statically known results outside the semantic safe range and routes dynamic add/subtract/multiply/negate through exact private `BigInt` helpers before conversion to `int`; a private Boolean identity helper prevents analyzer constant-fold warnings without changing short-circuit evaluation. Zig proves known expressions fit `i64` and routes every dynamic add/subtract/multiply/negate through exact overflow intrinsics and one status-70 failure boundary shared by Debug, ReleaseSafe, and ReleaseFast. Only each backend's complete canonical support CST authorizes its helper family during generated-source reparse.
 
 ## Blocks, flow, and bindings
 
@@ -66,7 +66,7 @@ Task007 adds explicit `OptionalType`, presence/absence construction, simple-iden
 
 ## Provenance and generated mappings
 
-Frontend offsets remain parser-owned. Babel token positions, php-parser nodes/tokens, Prism byte locations/comment carriers, Lezer syntax nodes, and Tree-sitter Python/C#/Go/C/CPP/Rust/Swift/Kotlin named and anonymous nodes provide exact function, parameter, local, type, assignment, literal, call, branch, error declaration/construction, catch type/binding, message read, and operator ranges. Every Tree-sitter adapter traverses every child, rejects propagated error/missing recovery, and never substitutes source-text parsing after a rejected tree node. Error declarations and catches receive their own symbols; construction/type and catch-binding message-read references resolve through the same deterministic provenance graph. The JavaScript/TypeScript adapter indexes Babel tokens once by start offset, using direct identifier lookup and bounded binary-search token lookup instead of rescanning the full token stream per semantic node. Source normalization converts only coordinates; it never normalizes source content. CRLF and lone CR count as line breaks and parser coordinates become verified UTF-16 offsets.
+Frontend offsets remain parser-owned. Babel token positions, php-parser nodes/tokens, Prism byte locations/comment carriers, Lezer syntax nodes, and Tree-sitter Python/C#/Go/C/CPP/Rust/Swift/Kotlin/Dart/Zig named and anonymous nodes provide exact function, parameter, local, type, assignment, literal, call, branch, error declaration/construction, catch type/binding, message read, and operator ranges. Every Tree-sitter adapter traverses every child, rejects propagated error/missing recovery, and never substitutes source-text parsing after a rejected tree node. Error declarations and catches receive their own symbols; construction/type and catch-binding message-read references resolve through the same deterministic provenance graph. The JavaScript/TypeScript adapter indexes Babel tokens once by start offset, using direct identifier lookup and bounded binary-search token lookup instead of rescanning the full token stream per semantic node. Source normalization converts only coordinates; it never normalizes source content. CRLF and lone CR count as line breaks and parser coordinates become verified UTF-16 offsets.
 
 Each semantic node carries a JSON-safe source-provenance association through reorder, insertion, deletion, cloning, and serialization. Generation rebuilds canonical paths and node/symbol identities from current traversal and validates any serialized caller provenance before use; aggregate path/kind coincidence is never used to associate a different node. Shared caller objects receive deterministic occurrence records keyed by current JSON Pointer, so reused parameters, types, expressions, and valid statements do not collapse distinct emitted locations. Malformed caller registries, including empty source filenames, are discarded before canonical source fallback. This permits legacy and multi-source caller IR while preventing duplicate/stale IDs, mismatched source ownership, or out-of-bounds ranges from becoming semantic authority. The source-aware writer makes all output spans explicit, retains every contextual origin range across composition boundaries, and leaves no coarse legacy emitter path. Rich maps are frozen and indexed after validation; generated, original, node, and symbol queries include contextual related provenance without duplicate spans. See [source provenance and mappings](source-maps.md).
 
@@ -89,3 +89,9 @@ Rust/Cargo discovery requires the exact qualified 1.98.1 commits and Linux x86-6
 Task023 adds `kotlin` through the root Tree-sitter 0.25.1 boundary and the exact ABI-14 Semantifold packaging fork of the community Kotlin grammar. The adapter consumes every CST edge, accepts only explicit Tasks001-004 Kotlin forms, and recognizes generated checked-arithmetic support only when the complete canonical helper CST is present. Parser trees and helper authority remain frontend-private.
 
 The backend emits one mapped `Program.kt` and validates its final source through the registered Kotlin frontend before returning it. `generateArtifactSet()` wraps that entry with detached immutable Kotlin2.4/API2.4/JVM25 compiler and `java -jar Program.jar` metadata; it does not create a Gradle project or expose compiler artifacts. Exact `kotlinc` 2.4.20 and OpenJDK25 discovery and real compilation/execution remain acceptance concerns, never generation effects. See the [Kotlin/JVM profile](kotlin.md).
+
+## Zig parser boundary and native project
+
+Task031 adds `zig` through a second private compatible Tree-sitter workspace because the qualified grammar requires exact binding 0.22.4 rather than the root 0.25.1 or legacy 0.21.1 bindings. Its nested ordinary `file:` production dependency bundles exact grammar 1.1.2 and exposes only recursively frozen parser-neutral CST snapshots. The adapter validates every child edge, UTF-16 conversion, recovery flag, canonical runtime/helper region, source bound, and depth bound before shared semantic validation.
+
+The Zig backend preflights the complete graph and emits synthetic `build.zig` plus mapped `src/main.zig`. A fixed global arena owns all concatenated `[]const u8` slices until the exact entry-shell defer; semantic values never observe ownership or pointer identity. Checked arithmetic and allocation/output failures use explicit status-70 boundaries, so optimizer mode cannot change semantic behavior. Final source reparses through the same private frontend; filesystem materialization, formatting, builds, isolated caches, and Debug/ReleaseSafe/ReleaseFast execution remain acceptance-only effects. See the [Zig profile](zig.md).

package/docs/goals.md

@@ -2,7 +2,7 @@
 
 Semantifold's long-term goal is a language-neutral toolkit for understanding, transforming, generating, and eventually executing programs through a shared high-level semantic representation. The representation should make types, control flow, calls, declarations, diagnostics, and source provenance understandable without exposing a language parser's private tree.
 
-The current source tree proves one minimal Tasks 001–004 vertical slice across fourteen registered source languages: PHP, Ruby, JavaScript, TypeScript, Java, Kotlin/JVM, strictly annotated Python, canonical C#, bounded Go, C17, C++20, Rust edition 2021, Swift, and Dart. Dart additionally implements the bounded Task 005 required-function/call profile; the original five retain the delivered Task 013 acceptance gate for the combined Tasks 001–008 profile, Task 009 nominal closed records, Task 010 explicit acyclic multi-source semantic programs, Task 011 exact nominal typed unchecked errors, and Task 012 invariant unbounded function/record type parameters with closed applications and argument-only first-order call inference. Task 014 is delivered through PR #41, Task 032 through PR #42, Task 033 through PR #43, and Task 034 through PR #44. Task 035 is delivered through PR #45 and merge commit `a2aad9d4932bfc6087adc4ff8bca43678c92413c`, with versioned canonical standard-library contracts, target host providers and protected native bindings, capability negotiation, and program-mode provider linking. Task 036 is delivered through PR #46 and merge `9aba48f9d48bcef4fd4c9275aec14bfcc4f0904c`; it adds bounded versioned executable qualification facades and exact parser-backed native identity resolution for the original five. Task 037 adds only the first concrete Ruby-source-to-PHP-target blocking TCP/line-output slice on those foundations. The source tree includes versioned source provenance, deterministic semantic node/symbol identity, range-based generated mappings, Source Map v3 interop, composition, and diagnostic remapping across those bounded profiles. The published `semantifold@0.3.0` release predates these additions. Neither the source tree nor that release provides a general analyzer, transformation API, interpreter, optimizer, implicit project/package discovery, debugger integration, coverage remapping, or lossless formatter.
+The current source tree proves one minimal Tasks 001–004 vertical slice across fifteen registered source languages: PHP, Ruby, JavaScript, TypeScript, Java, Kotlin/JVM, strictly annotated Python, canonical C#, bounded Go, C17, C++20, Rust edition 2021, Swift, Dart, and Zig. Dart and Zig additionally implement the bounded Task 005 required-function/call profile; the original five retain the delivered Task 013 acceptance gate for the combined Tasks 001–008 profile, Task 009 nominal closed records, Task 010 explicit acyclic multi-source semantic programs, Task 011 exact nominal typed unchecked errors, and Task 012 invariant unbounded function/record type parameters with closed applications and argument-only first-order call inference. Task 014 is delivered through PR #41, Task 032 through PR #42, Task 033 through PR #43, and Task 034 through PR #44. Task 035 is delivered through PR #45 and merge commit `a2aad9d4932bfc6087adc4ff8bca43678c92413c`, with versioned canonical standard-library contracts, target host providers and protected native bindings, capability negotiation, and program-mode provider linking. Task 036 is delivered through PR #46 and merge `9aba48f9d48bcef4fd4c9275aec14bfcc4f0904c`; it adds bounded versioned executable qualification facades and exact parser-backed native identity resolution for the original five. Task 037 adds only the first concrete Ruby-source-to-PHP-target blocking TCP/line-output slice on those foundations. The source tree includes versioned source provenance, deterministic semantic node/symbol identity, range-based generated mappings, Source Map v3 interop, composition, and diagnostic remapping across those bounded profiles. The published `semantifold@0.5.0` release predates Task 031. Neither the source tree nor that release provides a general analyzer, transformation API, interpreter, optimizer, implicit project/package discovery, debugger integration, coverage remapping, or lossless formatter.
 
 The long-term product direction includes bounded standard-library portability through [language compatibility stdlib/facades, canonical Semantifold stdlib contracts/capabilities, and target host providers/native bindings](standard-library-portability.md). That direction is incremental and versioned; it does not promise arbitrary standard-library coverage or arbitrary-application translation. The `0.3.0` release has no imports, classes or methods, loops, optional values, typed errors, resources, host APIs, or stdlib portability.
 

package/docs/language-support.md

@@ -20,11 +20,12 @@ The immutable registry is authoritative for both dispatch and discovery:
 | `rust` | yes | yes | no | no | no | no | no | no | no | no | no | no | no | no | no | no | multiple | yes | rich + v3 | parse, generate, compile, validate, execute (`rustc`, `cargo`) |
 | `swift` | yes | yes | no | no | no | no | no | no | no | no | no | no | no | no | no | no | single | yes | rich + v3 | parse, generate, compile, execute (`swiftc`) |
 | `dart` | yes | yes | no | no | no | yes | no | no | no | no | no | no | no | no | no | no | multiple | yes | rich + v3 | parse, generate, restore, compile, validate, execute (`dart`) |
+| `zig` | yes | yes | no | no | no | yes | no | no | no | no | no | no | no | no | no | no | multiple | yes | rich + v3 | parse, generate, compile, validate, execute (`zig`) |
 | `wasm` | no | no | yes | yes | no | no | no | no | no | no | no | no | no | no | no | no | multiple | no | rich text + v3 + byte ranges | generate, validate, instantiate, execute (`wasm-validate`, `node`, `chromium`) |
 | `ios` | no | no | no | yes | no | no | no | no | no | no | no | no | no | no | no | no | multiple | no | rich text + v3 + byte ranges | generate (Apple acceptance deferred) |
 | `android` | no | no | no | yes | no | no | no | no | no | no | no | no | no | no | no | no | multiple | no | rich text + v3 + byte ranges | generate, compile, validate, instantiate, execute (`android`, TensorBuzz KVM) |
 
-`languageCapabilities` exposes all seventeen records as frozen data, including `features.generalFunctionsAndCalls`, `features.immutableCollections`, `features.optionalValues`, `features.orderedListIteration`, `features.orderedMapIteration`, `features.conditionControlledLoops`, `features.referenceClasses`, `features.effectfulCapabilitiesAndResources`, `features.closedRecords`, `features.typedErrors`, and `features.typeParametersAndGenerics`. A role or semantic feature is not inferred from another role: browser Wasm has binary/application backends without a frontend or text backend, while `ios` and `android` have only application backends. None has a source round trip or general interoperability role; Android retains the Kotlin/JVM Tasks 001–004 function subset while adding resolved Task 010 module linkage in its application shell. `supportedLanguages` is the derived list of fourteen records with both frontend and text generation. C#, Go, and C return two text artifacts; Rust and Dart return three; Wasm returns one binary and three text artifacts; iOS and Android return deterministic multi-artifact application projects. Their callers use `generateArtifactSet()`; the legacy single-artifact APIs reject unavailable roles with `UNSUPPORTED_ROLE`.
+`languageCapabilities` exposes all eighteen records as frozen data, including `features.generalFunctionsAndCalls`, `features.immutableCollections`, `features.optionalValues`, `features.orderedListIteration`, `features.orderedMapIteration`, `features.conditionControlledLoops`, `features.referenceClasses`, `features.effectfulCapabilitiesAndResources`, `features.closedRecords`, `features.typedErrors`, and `features.typeParametersAndGenerics`. A role or semantic feature is not inferred from another role: browser Wasm has binary/application backends without a frontend or text backend, while `ios` and `android` have only application backends. None has a source round trip or general interoperability role; Android retains the Kotlin/JVM Tasks 001–004 function subset while adding resolved Task 010 module linkage in its application shell. `supportedLanguages` is the derived list of fifteen records with both frontend and text generation. C#, Go, C, and Zig return two text artifacts; Rust and Dart return three; Wasm returns one binary and three text artifacts; iOS and Android return deterministic multi-artifact application projects. Their callers use `generateArtifactSet()`; the legacy single-artifact APIs reject unavailable roles with `UNSUPPORTED_ROLE`.
 
 ## Task 026 iOS application generation
 
@@ -50,7 +51,7 @@ The shared negative corpus covers parser recovery, missing types, truthiness, mi
 
 ## Task 005 general functions and calls
 
-PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, and Dart accept any number of required positional parameters, including zero. The module resolver collects every unique function signature before validating bodies, assigns declarations deterministic `function:N` identities, and binds each direct call to that identity plus its ordered parameter and return types. This permits forward calls, nested calls, direct recursion, and unambiguous mutual recursion without overload or dynamic dispatch. Arity and every positional scalar type must match exactly.
+PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, Dart, and Zig accept any number of required positional parameters, including zero. The module resolver collects every unique function signature before validating bodies, assigns declarations deterministic `function:N` identities, and binds each direct call to that identity plus its ordered parameter and return types. This permits forward calls, nested calls, direct recursion, and unambiguous mutual recursion without overload or dynamic dispatch. Arity and every positional scalar type must match exactly.
 
 Function returns are `integer`, `boolean`, `string`, or `void`. A non-void function has an expression on every reachable return and returns on every reachable path. A void function may fall through or use a bare return, and its call is legal only as an `ExpressionStatement`. Void is never a value: it cannot type a parameter or local, initialize or assign a binding, become an argument or operand, be printed, or be returned as a value. Generation revalidates declaration identities and complete resolved signatures in externally supplied IR. Function names, parameters, return annotations, callees, arguments, and resolution references retain deterministic parser-backed provenance and mappings.
 
@@ -61,6 +62,7 @@ The source profiles remain deliberately exact:
 - PHP accepts simple typed by-value required parameters, an explicit scalar or `void` return, and unqualified direct calls. Defaults, variadics, named/unpacked/by-reference arguments, by-reference parameters or returns, methods, dynamic/qualified calls, implicit nullability, and missing types are rejected; Task 007 adds only its exact explicit nullable profile.
 - Java accepts the established private-static semantic method profile with explicit supported parameter and scalar-or-void result types inside `public final class Main`, plus receiver-free direct calls and the exact entry method. Generated zero-parameter signatures named `getClass`, `hashCode`, `clone`, `toString`, `notify`, `notifyAll`, `wait`, or `finalize` conflict with inherited `java.lang.Object` instance methods and are rejected before emission; nonconflicting scalar-parameter overloads of those names remain available. Overload sets, instance/receiver/qualified/static-import ambiguity, varargs, bounded/defaulted/wildcard/raw generics, constructors, throws clauses, and non-static semantic methods are rejected.
 - Dart accepts synchronous top-level functions with exact explicit `int`, `bool`, `String`, or `void` returns, explicitly typed required positional parameters, initialized typed locals, direct calls, and exact `void main()`/`print`. Inference, `var`, inferred `final`, optional/named/default arguments, methods/classes, generics, imports, dynamic/nullability, collections, exceptions, async, and isolates are rejected. Generated Dart alone may contain formatter-added trailing commas and the complete canonical private runtime prefix; neither grants those forms to ordinary source. See [Dart source and target](dart.md).
+- Zig accepts top-level functions with exact explicit `i64`, `bool`, `[]const u8`, or `void` returns, explicitly typed required positional parameters, initialized typed `const`/`var` locals, direct calls, and the exact generated support/`pub fn main()` shell. Inference, optional/default/rest parameters, methods, containers, user slices/pointers/allocators, imports beyond the canonical standard-library support, error unions, `comptime`, generics, reflection, FFI, async, and concurrency are rejected. See [Zig source and target](zig.md).
 
 Python, C#, C, C++, Rust, Swift, Kotlin/JVM, Go, and browser Wasm remain on their Task 025 Tasks 001–004 profile. Their registry feature flag is false, their existing exact-two/scalar-return behavior is unchanged, and a Task-005-only arity, void return, or void call statement is a located `UNSUPPORTED_CAPABILITY` before source, bytes, or a partial artifact set is exposed. This boundary does not broaden the future Task 013 aggregate acceptance.
 
@@ -220,6 +222,8 @@ This acceptance remains original-five-only and does not itself expand to the lat
 | C++ | exact `std::int64_t`, `bool`, and owned `std::string` | checked scalar print helpers in `int main()` |
 | Rust | exact `i64`, `bool`, owned `String`; typed `let`/`let mut`, canonical safe decimal `i64` literal suffix | exact scalar print helpers in `fn main()` |
 | Swift | exact `Int64`, `Bool`, and `String`; explicitly typed `let`/`var` | direct top-level `print(…)` in `program.swift` |
+| Dart | exact `int`, `bool`, and `String`; explicitly typed `final`/typed mutable locals | exact `void main()` and `print(…)` in `bin/program.dart` |
+| Zig | exact `i64`, `bool`, and immutable UTF-8 `[]const u8`; explicitly typed `const`/`var` | checked scalar output helpers in exact `pub fn main() void` in `src/main.zig` |
 
 C uses the unchanged private root-bundled legacy CST boundary and the [complete C17 profile](c.md). It generates deterministic `program.c` plus `semantifold_runtime.h`, checks signed integer arithmetic and arena sizes, and sequences every call and nontrivial expression through exact versioned regions. Caller-authored nested calls with unspecified C order are rejected. Generated regions reparse only after whole-CST comparison verifies types, numbering, uses, order, consumers, prototypes and cleanup. No user pointer, ownership, preprocessing, general FFI or C++ behavior enters semantic IR. Real Clang O0/O2 execution and ASan/UBSan/leak checks are mandatory on the qualified Linux lane.
 
@@ -304,9 +308,9 @@ The two executable compiler-owned Ruby facades compile through ordinary semantic
 
 Line reads block without a configurable timeout, decode incremental UTF-8, retain LF and CRLF, return the final unterminated line once, and use absence only for clean EOF. Output adds LF only when missing. Connect/read/decode/write/close failures remain typed, and either outcome of the first close attempt makes the resource terminal. TCP servers, TLS, UDP, Unix sockets, nonblocking or async I/O, cancellation, arbitrary encodings/framing, other Ruby APIs/output forms, other source facades, and other target providers remain unsupported. See the [standard-library portability design](standard-library-portability.md) and [dependency-ordered implementation plan](plans/2026-09-05-standard-library-portability.md).
 
-All fourteen frontends preserve exact input content and parser-backed semantic token ranges in module provenance. The original-six 36-combination matrix remains byte-characterized; Tasks 017–020 and 022–024 add their own native/managed and original-five crossing coverage. Go's `main.go` has complete range-based rich/v3 mappings; manifest-first `go.mod` has synthetic configuration provenance related to the module root. CPP, Rust, Swift, Kotlin, and Dart map original occurrences and synthetic target support. Output text uses LF deterministically. Only JavaScript and TypeScript may opt into inline or external `sourceMappingURL` directives; C#, Go, C, CPP, Rust, Swift, Kotlin, and Dart reject unsupported mapping directive/filename options instead of silently dropping them. Mapping does not imply lossless formatting or support for syntax outside the semantic subset. See [source provenance and mappings](source-maps.md).
+All fifteen frontends preserve exact input content and parser-backed semantic token ranges in module provenance. The original-six 36-combination matrix remains byte-characterized; Tasks 017–020, 022–024, and 031 add their own native/managed and original-five crossing coverage. Go's `main.go` has complete range-based rich/v3 mappings; manifest-first `go.mod` has synthetic configuration provenance related to the module root. CPP, Rust, Swift, Kotlin, Dart, and Zig map original occurrences and synthetic target support. Output text uses LF deterministically. Only JavaScript and TypeScript may opt into inline or external `sourceMappingURL` directives; C#, Go, C, CPP, Rust, Swift, Kotlin, Dart, and Zig reject unsupported mapping directive/filename options instead of silently dropping them. Mapping does not imply lossless formatting or support for syntax outside the semantic subset. See [source provenance and mappings](source-maps.md).
 
-`UNSUPPORTED_LANGUAGE` is exclusive to unknown or misspelled IDs. `UNSUPPORTED_ROLE` reports a known ID without the requested frontend, text/binary/application backend, artifact, or interoperability role, including C#, Go, C, Rust, and Dart through a legacy single-artifact API. `UNSUPPORTED_CAPABILITY` reports a role that exists but cannot represent the requested semantic module or target feature. `UNSUPPORTED_SYNTAX` reports parsed constructs outside the subset with the best parser-provided source location. Missing public annotations use `MISSING_TYPE`; a present unsupported type is `UNSUPPORTED_SYNTAX` at that annotation. Parser failures use `PARSE_ERROR`. Semantic resolution/type failures use `DUPLICATE_BINDING`, `UNRESOLVED_BINDING`, `USE_BEFORE_DECLARATION`, `IMMUTABLE_ASSIGNMENT`, and `TYPE_MISMATCH`; Task 005 additionally uses `VOID_AS_VALUE`, `VOID_RETURN_VALUE`, and `MISSING_RETURN_VALUE`. Task 033 adds `DUPLICATE_CLASS`, `DUPLICATE_PRIVATE_FIELD`, `DUPLICATE_CONSTRUCTOR`, `DUPLICATE_METHOD`, `INCOMPLETE_INITIALIZATION`, `ILLEGAL_PRIVATE_ACCESS`, `UNKNOWN_CLASS`, `INVALID_METHOD_RECEIVER`, `UNKNOWN_METHOD`, `CONSTRUCTOR_ARITY_MISMATCH`, and `METHOD_ARITY_MISMATCH`. Task 034 adds `MISSING_CAPABILITY_AUTHORITY`, `INVALID_CAPABILITY_AUTHORITY`, `UNDECLARED_EFFECT`, `UNDECLARED_FAILURE`, `INVALID_EFFECT_ORDER`, `RESOURCE_TYPE_MISMATCH`, `RESOURCE_MOVE_REQUIRED`, `INVALID_RESOURCE_TRANSFER`, `RESOURCE_ALIAS`, `INVALID_RESOURCE_BORROW`, `BORROW_ESCAPE`, `USE_AFTER_MOVE`, `USE_AFTER_CLOSE`, `RESOURCE_STATE_MISMATCH`, `LEAKED_RESOURCE`, and `FAILURE_ABSENCE_CONFLATION`; a repeated close in the bounded probe uses its declared terminal failure rather than `DOUBLE_CLOSE`. Task 035 adds `STDLIB_CONTRACT_INVALID`, `STDLIB_MODULE_UNKNOWN`, `STDLIB_OPERATION_UNDECLARED`, `STDLIB_VERSION_INCOMPATIBLE`, `STDLIB_VERSION_MALFORMED`, `STDLIB_PROVIDER_INVALID`, `STDLIB_PROVIDER_MISSING`, `STDLIB_PROVIDER_AMBIGUOUS`, `STDLIB_PROVIDER_DEPENDENCY_MISSING`, `STDLIB_PROVIDER_CYCLE`, `STDLIB_LINK_FAILURE`, and `STDLIB_NAME_COLLISION`. Task 036 adds `STDLIB_FACADE_INVALID`, `STDLIB_FACADE_IDENTITY_UNPROVED`, `STDLIB_FACADE_MEMBER_UNSUPPORTED`, `STDLIB_FACADE_VERSION_MALFORMED`, `STDLIB_FACADE_VERSION_INCOMPATIBLE`, `STDLIB_FACADE_DYNAMIC_REFERENCE`, `STDLIB_FACADE_REFLECTION_UNSUPPORTED`, `STDLIB_FACADE_NATIVE_EXTENSION_UNSUPPORTED`, `STDLIB_FACADE_SHADOWED`, `STDLIB_FACADE_REOPENED`, `STDLIB_FACADE_AUTHORITY_FORGED`, `STDLIB_FACADE_NAME_COLLISION`, `STDLIB_FACADE_DECLARATION_MISMATCH`, and `STDLIB_FACADE_DESCRIPTOR_INVALID`; Task 037 additionally uses `STDLIB_PROTECTED_BINDING_ACCESS` for portable attempts to reach canonical operations directly. Resolution failures retain parser locations, while descriptor/link failures are transactional. Flow failures use `NON_BOOLEAN_CONDITION`, `MISSING_RETURN`, `UNREACHABLE_STATEMENT`, `ILLEGAL_RETURN_CONTEXT`, `ILLEGAL_BREAK_CONTEXT`, `ILLEGAL_CONTINUE_CONTEXT`, `INVALID_LOOP_TARGET`, `CROSS_FUNCTION_LOOP_TARGET`, and `UNSUPPORTED_STATEMENT`. Backends validate complete recursive block shape, flow, scalar payloads, binding/type agreement, call resolutions, mutability, loop context, identifiers, target bounds, and fixed artifact contracts before emission. Missing or structurally invalid caller IR reports located `UNSUPPORTED_CAPABILITY` rather than leaking a native error or producing partial source. A non-`Main.java` Java basename, non-`Program.cs` C# filename, non-`main.go` Go filename, non-`program.c` C filename, or non-`src/main.rs` Rust filename, non-`bin/program.dart` Dart filename uses that same contract. Artifact-set generation requires a non-empty string language/target ID and accepts only the explicit `text`, `binary`, and `application` backend-role strings; malformed IDs or roles report `INVALID_ARTIFACT_SET` without coercing caller input, while an unknown string ID reports `UNSUPPORTED_LANGUAGE` and a valid role absent from a known registry record reports `UNSUPPORTED_ROLE`. Optional registry roles and backend metadata may be omitted with `undefined`; present malformed values, including `null`, report `INVALID_REGISTRY`. Invalid registry, artifact-set, byte-map, discovery, and runner inputs have their own normalized diagnostics rather than leaking native type or subprocess errors.
+`UNSUPPORTED_LANGUAGE` is exclusive to unknown or misspelled IDs. `UNSUPPORTED_ROLE` reports a known ID without the requested frontend, text/binary/application backend, artifact, or interoperability role, including C#, Go, C, Rust, Dart, and Zig through a legacy single-artifact API. `UNSUPPORTED_CAPABILITY` reports a role that exists but cannot represent the requested semantic module or target feature. `UNSUPPORTED_SYNTAX` reports parsed constructs outside the subset with the best parser-provided source location. Missing public annotations use `MISSING_TYPE`; a present unsupported type is `UNSUPPORTED_SYNTAX` at that annotation. Parser failures use `PARSE_ERROR`. Semantic resolution/type failures use `DUPLICATE_BINDING`, `UNRESOLVED_BINDING`, `USE_BEFORE_DECLARATION`, `IMMUTABLE_ASSIGNMENT`, and `TYPE_MISMATCH`; Task 005 additionally uses `VOID_AS_VALUE`, `VOID_RETURN_VALUE`, and `MISSING_RETURN_VALUE`. Task 033 adds `DUPLICATE_CLASS`, `DUPLICATE_PRIVATE_FIELD`, `DUPLICATE_CONSTRUCTOR`, `DUPLICATE_METHOD`, `INCOMPLETE_INITIALIZATION`, `ILLEGAL_PRIVATE_ACCESS`, `UNKNOWN_CLASS`, `INVALID_METHOD_RECEIVER`, `UNKNOWN_METHOD`, `CONSTRUCTOR_ARITY_MISMATCH`, and `METHOD_ARITY_MISMATCH`. Task 034 adds `MISSING_CAPABILITY_AUTHORITY`, `INVALID_CAPABILITY_AUTHORITY`, `UNDECLARED_EFFECT`, `UNDECLARED_FAILURE`, `INVALID_EFFECT_ORDER`, `RESOURCE_TYPE_MISMATCH`, `RESOURCE_MOVE_REQUIRED`, `INVALID_RESOURCE_TRANSFER`, `RESOURCE_ALIAS`, `INVALID_RESOURCE_BORROW`, `BORROW_ESCAPE`, `USE_AFTER_MOVE`, `USE_AFTER_CLOSE`, `RESOURCE_STATE_MISMATCH`, `LEAKED_RESOURCE`, and `FAILURE_ABSENCE_CONFLATION`; a repeated close in the bounded probe uses its declared terminal failure rather than `DOUBLE_CLOSE`. Task 035 adds `STDLIB_CONTRACT_INVALID`, `STDLIB_MODULE_UNKNOWN`, `STDLIB_OPERATION_UNDECLARED`, `STDLIB_VERSION_INCOMPATIBLE`, `STDLIB_VERSION_MALFORMED`, `STDLIB_PROVIDER_INVALID`, `STDLIB_PROVIDER_MISSING`, `STDLIB_PROVIDER_AMBIGUOUS`, `STDLIB_PROVIDER_DEPENDENCY_MISSING`, `STDLIB_PROVIDER_CYCLE`, `STDLIB_LINK_FAILURE`, and `STDLIB_NAME_COLLISION`. Task 036 adds `STDLIB_FACADE_INVALID`, `STDLIB_FACADE_IDENTITY_UNPROVED`, `STDLIB_FACADE_MEMBER_UNSUPPORTED`, `STDLIB_FACADE_VERSION_MALFORMED`, `STDLIB_FACADE_VERSION_INCOMPATIBLE`, `STDLIB_FACADE_DYNAMIC_REFERENCE`, `STDLIB_FACADE_REFLECTION_UNSUPPORTED`, `STDLIB_FACADE_NATIVE_EXTENSION_UNSUPPORTED`, `STDLIB_FACADE_SHADOWED`, `STDLIB_FACADE_REOPENED`, `STDLIB_FACADE_AUTHORITY_FORGED`, `STDLIB_FACADE_NAME_COLLISION`, `STDLIB_FACADE_DECLARATION_MISMATCH`, and `STDLIB_FACADE_DESCRIPTOR_INVALID`; Task 037 additionally uses `STDLIB_PROTECTED_BINDING_ACCESS` for portable attempts to reach canonical operations directly. Resolution failures retain parser locations, while descriptor/link failures are transactional. Flow failures use `NON_BOOLEAN_CONDITION`, `MISSING_RETURN`, `UNREACHABLE_STATEMENT`, `ILLEGAL_RETURN_CONTEXT`, `ILLEGAL_BREAK_CONTEXT`, `ILLEGAL_CONTINUE_CONTEXT`, `INVALID_LOOP_TARGET`, `CROSS_FUNCTION_LOOP_TARGET`, and `UNSUPPORTED_STATEMENT`. Backends validate complete recursive block shape, flow, scalar payloads, binding/type agreement, call resolutions, mutability, loop context, identifiers, target bounds, and fixed artifact contracts before emission. Missing or structurally invalid caller IR reports located `UNSUPPORTED_CAPABILITY` rather than leaking a native error or producing partial source. A non-`Main.java` Java basename, non-`Program.cs` C# filename, non-`main.go` Go filename, non-`program.c` C filename, non-`src/main.rs` Rust filename, non-`bin/program.dart` Dart filename, or non-`src/main.zig` Zig filename uses that same contract. Artifact-set generation requires a non-empty string language/target ID and accepts only the explicit `text`, `binary`, and `application` backend-role strings; malformed IDs or roles report `INVALID_ARTIFACT_SET` without coercing caller input, while an unknown string ID reports `UNSUPPORTED_LANGUAGE` and a valid role absent from a known registry record reports `UNSUPPORTED_ROLE`. Optional registry roles and backend metadata may be omitted with `undefined`; present malformed values, including `null`, report `INVALID_REGISTRY`. Invalid registry, artifact-set, byte-map, discovery, and runner inputs have their own normalized diagnostics rather than leaking native type or subprocess errors.
 
 Boxed or coercive types, inferred public types, TypeScript literal/enum/`any`/`unknown`/arbitrary-union types, PHP aliases or implicit nullable declarations, Ruby `boolish`, Java `Boolean`/`char`, universal null values, floating point, decimal, bigint, symbols, regex values, byte strings, and interpolation are unsupported. Division, remainder, exponentiation, bitwise/shift/update/compound operations, Ruby/PHP `and`/`or`, loose equality, ternary/nullish forms, optional/safe navigation, ranges, general casts/assertions, collection/object equality, operator overloading, implicit coercion, and constant folding are also excluded; the sole assertion exception is Task 006's exact TypeScript `Map#get(...)!` wrapper, whose lookup must be independently total. Task 007 supplies only the exact explicit optional model, Task 008 only exact ordered list loops, Task 010 only explicit supplied source projects, Task 011 only the exact nominal unchecked-error model above, Task 012 only the exact unbounded invariant generic profile above, Task 014 only the exact ordered-map pair loop above, Task 032 only the exact strict-Boolean precondition loop above, Task 033 only the exact closed reference-class profile above, and Task 034 only the explicit single-module probe effect/resource profile above. There is no truthiness, implicit-return or general statement-value model, async/generator model, open/inherited/virtual class model, implicit import discovery, post-condition/basic/range loops, arbitrary or ordinary-map iteration, switches, exception behavior beyond Task 011 and declared Task 034 failures, overloads, advanced generic/effect type systems, implicit resource cleanup, unsafe native handles, package-manager resolution, or source-format preservation. The sole value-free expression statements are resolved void function and method calls in the original-five cohort. Ruby type comments remain a bounded RBS-style convention rather than a full signature parser, and single-module Java generation retains the fixed `Main.java` contract.