semantifold 0.2.0 → 0.3.0

package/build/src/subprocess.js

@@ -15,7 +15,25 @@ const deadlineFailures = new WeakSet();
  * @param {number} input.timeoutMs - Deadline before termination begins.
  * @returns {Promise<{stderr: string, stdout: string}>} Output after the owned process group closes.
  */
-export function executeFileWithDeadline({ arguments: processArguments, cwd, environment, executable, maxBuffer, timeoutMs }) {
+export function executeFileWithDeadline(input) {
+    return executeFileWithDeadlineUsing(input, registerChildSpawn);
+}
+/**
+ * Creates an executor whose spawn observation belongs only to that executor instance.
+ * @param {object} dependencies - Internal lifecycle dependencies.
+ * @param {(child: import("node:child_process").ChildProcess, listener: () => void) => void} dependencies.registerSpawnListener - Registers deadline initialization.
+ * @returns {typeof executeFileWithDeadline} Owned subprocess executor.
+ */
+export function createExecuteFileWithDeadline({ registerSpawnListener }) {
+    return (input) => executeFileWithDeadlineUsing(input, registerSpawnListener);
+}
+/**
+ * Executes with exact instance-owned spawn observation.
+ * @param {Parameters<typeof executeFileWithDeadline>[0]} input - Process request.
+ * @param {(child: import("node:child_process").ChildProcess, listener: () => void) => void} registerSpawnListener - Registers deadline initialization.
+ * @returns {Promise<{stderr: string, stdout: string}>} Output after the owned process group closes.
+ */
+function executeFileWithDeadlineUsing({ arguments: processArguments, cwd, environment, executable, maxBuffer, timeoutMs }, registerSpawnListener) {
     if (process.platform == "win32") {
         return Promise.reject(Object.assign(new Error("Owned process-tree termination is unavailable on this platform."), {
             code: "ENOTSUP",
@@ -49,7 +67,7 @@ export function executeFileWithDeadline({ arguments: processArguments, cwd, envi
         child.once("error", (error) => {
             launchError = error;
         });
-        child.once("spawn", () => {
+        registerSpawnListener(child, () => {
             if (processGroupId == undefined || !verifyOwnedProcessGroup(processGroupId)) {
                 launchError = Object.assign(new Error("Spawned subprocess did not establish its required process group."), { code: "ENOTSUP" });
                 child.kill("SIGKILL");
@@ -134,6 +152,14 @@ export function executeFileWithDeadline({ arguments: processArguments, cwd, envi
         }
     });
 }
+/**
+ * Registers production deadline initialization on the child's real spawn event.
+ * @param {import("node:child_process").ChildProcess} child - Exact spawned child.
+ * @param {() => void} listener - Deadline initialization.
+ */
+function registerChildSpawn(child, listener) {
+    child.once("spawn", listener);
+}
 /**
  * Creates one byte-bounded UTF-8 stream capture.
  * @param {number} maximumBytes - Maximum captured bytes.
@@ -204,4 +230,4 @@ function signalOwnedProcessGroup(processGroupId, signal) {
 export function exceededOwnedDeadline(error) {
     return typeof error == "object" && error != null && deadlineFailures.has(error);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subprocess.js","sourceRoot":"","sources":["../../src/subprocess.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {spawn} from \"node:child_process\"\nimport {StringDecoder} from \"node:string_decoder\"\n\nconst forcedTerminationGraceMs = 250\nconst retainedPipeGraceMs = 250\nconst deadlineFailures = new WeakSet()\n\n/**\n * Executes one exact file while owning its complete bounded lifecycle.\n * @param {object} input - Process request.\n * @param {readonly string[]} input.arguments - Exact argument array.\n * @param {string} [input.cwd] - Working directory.\n * @param {Readonly<Record<string, string>>} input.environment - Exact environment.\n * @param {string} input.executable - Exact executable path.\n * @param {number} input.maxBuffer - Maximum bytes captured per output stream.\n * @param {number} input.timeoutMs - Deadline before termination begins.\n * @returns {Promise<{stderr: string, stdout: string}>} Output after the owned process group closes.\n */\nexport function executeFileWithDeadline({arguments: processArguments, cwd, environment, executable, maxBuffer, timeoutMs}) {\n  if (process.platform == \"win32\") {\n    return Promise.reject(Object.assign(new Error(\"Owned process-tree termination is unavailable on this platform.\"), {\n      code: \"ENOTSUP\",\n      stderr: \"\",\n      stdout: \"\"\n    }))\n  }\n\n  return new Promise((resolve, reject) => {\n    /** @type {ReturnType<typeof setTimeout> | undefined} */\n    let deadlineTimer\n    /** @type {ReturnType<typeof setTimeout> | undefined} */\n    let forceTimer\n    /** @type {ReturnType<typeof setTimeout> | undefined} */\n    let pipeTimer\n    /** @type {Error | undefined} */\n    let launchError\n    let deadlineExceeded = false\n    let outputExceeded = false\n    let settled = false\n    const stderr = outputCapture(maxBuffer, () => terminateForOutputLimit())\n    const stdout = outputCapture(maxBuffer, () => terminateForOutputLimit())\n    const child = spawn(executable, [...processArguments], {\n      cwd,\n      detached: true,\n      env: environment,\n      stdio: [\"ignore\", \"pipe\", \"pipe\"]\n    })\n    const processGroupId = child.pid\n\n    child.stderr.on(\"data\", stderr.receive)\n    child.stdout.on(\"data\", stdout.receive)\n    child.once(\"error\", (error) => {\n      launchError = error\n    })\n    child.once(\"spawn\", () => {\n      if (processGroupId == undefined || !verifyOwnedProcessGroup(processGroupId)) {\n        launchError = Object.assign(new Error(\"Spawned subprocess did not establish its required process group.\"), {code: \"ENOTSUP\"})\n        child.kill(\"SIGKILL\")\n        return\n      }\n\n      deadlineTimer = setTimeout(() => {\n        if (settled) return\n        deadlineExceeded = true\n        beginTermination(processGroupId)\n      }, timeoutMs)\n    })\n    child.once(\"close\", (code, signal) => {\n      settled = true\n      if (deadlineTimer != undefined) clearTimeout(deadlineTimer)\n      if (forceTimer != undefined) clearTimeout(forceTimer)\n      if (pipeTimer != undefined) clearTimeout(pipeTimer)\n      const capturedStderr = stderr.finish()\n      const capturedStdout = stdout.finish()\n\n      if (launchError) {\n        reject(Object.assign(launchError, {stderr: capturedStderr, stdout: capturedStdout}))\n      } else if (outputExceeded) {\n        reject(Object.assign(new Error(`Subprocess exceeded its ${maxBuffer}-byte output capture limit.`), {\n          code: \"ERR_CHILD_PROCESS_STDIO_MAXBUFFER\",\n          signal,\n          stderr: capturedStderr,\n          stdout: capturedStdout\n        }))\n      } else if (deadlineExceeded) {\n        const timeoutError = Object.assign(new Error(\"Subprocess exceeded its owned deadline.\"), {\n          code,\n          signal,\n          stderr: capturedStderr,\n          stdout: capturedStdout\n        })\n\n        deadlineFailures.add(timeoutError)\n        reject(timeoutError)\n      } else if (code != 0 || signal != null) {\n        reject(Object.assign(new Error(\"Subprocess failed after launch.\"), {\n          code,\n          signal,\n          stderr: capturedStderr,\n          stdout: capturedStdout\n        }))\n      } else resolve({stderr: capturedStderr, stdout: capturedStdout})\n    })\n\n    /** Begins bounded termination after output capture crosses its limit. */\n    function terminateForOutputLimit() {\n      if (outputExceeded || settled) return\n      outputExceeded = true\n      if (processGroupId != undefined) beginTermination(processGroupId)\n    }\n\n    /**\n     * Signals the owned group now and escalates if its inherited pipes remain open.\n     * @param {number} ownedGroupId - Spawn-verified process-group identity.\n     */\n    function beginTermination(ownedGroupId) {\n      signalOwnedProcessGroup(ownedGroupId, \"SIGTERM\")\n      if (!settled && forceTimer == undefined) {\n        forceTimer = setTimeout(() => {\n          if (settled) return\n          signalOwnedProcessGroup(ownedGroupId, \"SIGKILL\")\n          pipeTimer = setTimeout(() => {\n            if (settled) return\n            child.stdout.destroy()\n            child.stderr.destroy()\n          }, retainedPipeGraceMs)\n        }, forcedTerminationGraceMs)\n      }\n    }\n  })\n}\n\n/**\n * Creates one byte-bounded UTF-8 stream capture.\n * @param {number} maximumBytes - Maximum captured bytes.\n * @param {() => void} onExceeded - First-overflow callback.\n * @returns {{finish: () => string, receive: (chunk: Buffer) => void}} Capture callbacks.\n */\nfunction outputCapture(maximumBytes, onExceeded) {\n  const decoder = new StringDecoder(\"utf8\")\n  let byteLength = 0\n  let content = \"\"\n  let exceeded = false\n\n  return {\n    finish() {\n      return content + decoder.end()\n    },\n    receive(chunk) {\n      if (exceeded) return\n      const remaining = maximumBytes - byteLength\n\n      if (chunk.length > remaining) {\n        if (remaining > 0) content += decoder.write(chunk.subarray(0, remaining))\n        exceeded = true\n        onExceeded()\n        return\n      }\n      byteLength += chunk.length\n      content += decoder.write(chunk)\n    }\n  }\n}\n\n/**\n * Verifies that the spawned child is the live leader of its distinct POSIX group.\n * @param {number} processGroupId - Spawn-returned child PID and required group ID.\n * @returns {boolean} Whether the owned group exists.\n */\nfunction verifyOwnedProcessGroup(processGroupId) {\n  try {\n    process.kill(-processGroupId, 0)\n    return true\n  } catch (error) {\n    if (error instanceof Error && \"code\" in error && error.code == \"ESRCH\") return false\n    throw error\n  }\n}\n\n/**\n * Signals only the verified process group created for the exact spawned child.\n * @param {number} processGroupId - Spawn-returned child PID and POSIX process-group ID.\n * @param {\"SIGKILL\" | \"SIGTERM\"} signal - Lifecycle signal.\n * @returns {void}\n */\nfunction signalOwnedProcessGroup(processGroupId, signal) {\n  try {\n    process.kill(-processGroupId, signal)\n  } catch (error) {\n    if (!(error instanceof Error && \"code\" in error && error.code == \"ESRCH\")) throw error\n  }\n}\n\n/**\n * Reports whether this module's deadline timer initiated termination.\n * @param {unknown} error - Subprocess failure.\n * @returns {boolean} Whether the failure belongs to an owned deadline.\n */\nexport function exceededOwnedDeadline(error) {\n  return typeof error == \"object\" && error != null && deadlineFailures.has(error)\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subprocess.js","sourceRoot":"","sources":["../../src/subprocess.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {spawn} from \"node:child_process\"\nimport {StringDecoder} from \"node:string_decoder\"\n\nconst forcedTerminationGraceMs = 250\nconst retainedPipeGraceMs = 250\nconst deadlineFailures = new WeakSet()\n\n/**\n * Executes one exact file while owning its complete bounded lifecycle.\n * @param {object} input - Process request.\n * @param {readonly string[]} input.arguments - Exact argument array.\n * @param {string} [input.cwd] - Working directory.\n * @param {Readonly<Record<string, string>>} input.environment - Exact environment.\n * @param {string} input.executable - Exact executable path.\n * @param {number} input.maxBuffer - Maximum bytes captured per output stream.\n * @param {number} input.timeoutMs - Deadline before termination begins.\n * @returns {Promise<{stderr: string, stdout: string}>} Output after the owned process group closes.\n */\nexport function executeFileWithDeadline(input) {\n  return executeFileWithDeadlineUsing(input, registerChildSpawn)\n}\n\n/**\n * Creates an executor whose spawn observation belongs only to that executor instance.\n * @param {object} dependencies - Internal lifecycle dependencies.\n * @param {(child: import(\"node:child_process\").ChildProcess, listener: () => void) => void} dependencies.registerSpawnListener - Registers deadline initialization.\n * @returns {typeof executeFileWithDeadline} Owned subprocess executor.\n */\nexport function createExecuteFileWithDeadline({registerSpawnListener}) {\n  return (input) => executeFileWithDeadlineUsing(input, registerSpawnListener)\n}\n\n/**\n * Executes with exact instance-owned spawn observation.\n * @param {Parameters<typeof executeFileWithDeadline>[0]} input - Process request.\n * @param {(child: import(\"node:child_process\").ChildProcess, listener: () => void) => void} registerSpawnListener - Registers deadline initialization.\n * @returns {Promise<{stderr: string, stdout: string}>} Output after the owned process group closes.\n */\nfunction executeFileWithDeadlineUsing({arguments: processArguments, cwd, environment, executable, maxBuffer, timeoutMs}, registerSpawnListener) {\n  if (process.platform == \"win32\") {\n    return Promise.reject(Object.assign(new Error(\"Owned process-tree termination is unavailable on this platform.\"), {\n      code: \"ENOTSUP\",\n      stderr: \"\",\n      stdout: \"\"\n    }))\n  }\n\n  return new Promise((resolve, reject) => {\n    /** @type {ReturnType<typeof setTimeout> | undefined} */\n    let deadlineTimer\n    /** @type {ReturnType<typeof setTimeout> | undefined} */\n    let forceTimer\n    /** @type {ReturnType<typeof setTimeout> | undefined} */\n    let pipeTimer\n    /** @type {Error | undefined} */\n    let launchError\n    let deadlineExceeded = false\n    let outputExceeded = false\n    let settled = false\n    const stderr = outputCapture(maxBuffer, () => terminateForOutputLimit())\n    const stdout = outputCapture(maxBuffer, () => terminateForOutputLimit())\n    const child = spawn(executable, [...processArguments], {\n      cwd,\n      detached: true,\n      env: environment,\n      stdio: [\"ignore\", \"pipe\", \"pipe\"]\n    })\n    const processGroupId = child.pid\n\n    child.stderr.on(\"data\", stderr.receive)\n    child.stdout.on(\"data\", stdout.receive)\n    child.once(\"error\", (error) => {\n      launchError = error\n    })\n    registerSpawnListener(child, () => {\n      if (processGroupId == undefined || !verifyOwnedProcessGroup(processGroupId)) {\n        launchError = Object.assign(new Error(\"Spawned subprocess did not establish its required process group.\"), {code: \"ENOTSUP\"})\n        child.kill(\"SIGKILL\")\n        return\n      }\n\n      deadlineTimer = setTimeout(() => {\n        if (settled) return\n        deadlineExceeded = true\n        beginTermination(processGroupId)\n      }, timeoutMs)\n    })\n    child.once(\"close\", (code, signal) => {\n      settled = true\n      if (deadlineTimer != undefined) clearTimeout(deadlineTimer)\n      if (forceTimer != undefined) clearTimeout(forceTimer)\n      if (pipeTimer != undefined) clearTimeout(pipeTimer)\n      const capturedStderr = stderr.finish()\n      const capturedStdout = stdout.finish()\n\n      if (launchError) {\n        reject(Object.assign(launchError, {stderr: capturedStderr, stdout: capturedStdout}))\n      } else if (outputExceeded) {\n        reject(Object.assign(new Error(`Subprocess exceeded its ${maxBuffer}-byte output capture limit.`), {\n          code: \"ERR_CHILD_PROCESS_STDIO_MAXBUFFER\",\n          signal,\n          stderr: capturedStderr,\n          stdout: capturedStdout\n        }))\n      } else if (deadlineExceeded) {\n        const timeoutError = Object.assign(new Error(\"Subprocess exceeded its owned deadline.\"), {\n          code,\n          signal,\n          stderr: capturedStderr,\n          stdout: capturedStdout\n        })\n\n        deadlineFailures.add(timeoutError)\n        reject(timeoutError)\n      } else if (code != 0 || signal != null) {\n        reject(Object.assign(new Error(\"Subprocess failed after launch.\"), {\n          code,\n          signal,\n          stderr: capturedStderr,\n          stdout: capturedStdout\n        }))\n      } else resolve({stderr: capturedStderr, stdout: capturedStdout})\n    })\n\n    /** Begins bounded termination after output capture crosses its limit. */\n    function terminateForOutputLimit() {\n      if (outputExceeded || settled) return\n      outputExceeded = true\n      if (processGroupId != undefined) beginTermination(processGroupId)\n    }\n\n    /**\n     * Signals the owned group now and escalates if its inherited pipes remain open.\n     * @param {number} ownedGroupId - Spawn-verified process-group identity.\n     */\n    function beginTermination(ownedGroupId) {\n      signalOwnedProcessGroup(ownedGroupId, \"SIGTERM\")\n      if (!settled && forceTimer == undefined) {\n        forceTimer = setTimeout(() => {\n          if (settled) return\n          signalOwnedProcessGroup(ownedGroupId, \"SIGKILL\")\n          pipeTimer = setTimeout(() => {\n            if (settled) return\n            child.stdout.destroy()\n            child.stderr.destroy()\n          }, retainedPipeGraceMs)\n        }, forcedTerminationGraceMs)\n      }\n    }\n  })\n}\n\n/**\n * Registers production deadline initialization on the child's real spawn event.\n * @param {import(\"node:child_process\").ChildProcess} child - Exact spawned child.\n * @param {() => void} listener - Deadline initialization.\n */\nfunction registerChildSpawn(child, listener) {\n  child.once(\"spawn\", listener)\n}\n\n/**\n * Creates one byte-bounded UTF-8 stream capture.\n * @param {number} maximumBytes - Maximum captured bytes.\n * @param {() => void} onExceeded - First-overflow callback.\n * @returns {{finish: () => string, receive: (chunk: Buffer) => void}} Capture callbacks.\n */\nfunction outputCapture(maximumBytes, onExceeded) {\n  const decoder = new StringDecoder(\"utf8\")\n  let byteLength = 0\n  let content = \"\"\n  let exceeded = false\n\n  return {\n    finish() {\n      return content + decoder.end()\n    },\n    receive(chunk) {\n      if (exceeded) return\n      const remaining = maximumBytes - byteLength\n\n      if (chunk.length > remaining) {\n        if (remaining > 0) content += decoder.write(chunk.subarray(0, remaining))\n        exceeded = true\n        onExceeded()\n        return\n      }\n      byteLength += chunk.length\n      content += decoder.write(chunk)\n    }\n  }\n}\n\n/**\n * Verifies that the spawned child is the live leader of its distinct POSIX group.\n * @param {number} processGroupId - Spawn-returned child PID and required group ID.\n * @returns {boolean} Whether the owned group exists.\n */\nfunction verifyOwnedProcessGroup(processGroupId) {\n  try {\n    process.kill(-processGroupId, 0)\n    return true\n  } catch (error) {\n    if (error instanceof Error && \"code\" in error && error.code == \"ESRCH\") return false\n    throw error\n  }\n}\n\n/**\n * Signals only the verified process group created for the exact spawned child.\n * @param {number} processGroupId - Spawn-returned child PID and POSIX process-group ID.\n * @param {\"SIGKILL\" | \"SIGTERM\"} signal - Lifecycle signal.\n * @returns {void}\n */\nfunction signalOwnedProcessGroup(processGroupId, signal) {\n  try {\n    process.kill(-processGroupId, signal)\n  } catch (error) {\n    if (!(error instanceof Error && \"code\" in error && error.code == \"ESRCH\")) throw error\n  }\n}\n\n/**\n * Reports whether this module's deadline timer initiated termination.\n * @param {unknown} error - Subprocess failure.\n * @returns {boolean} Whether the failure belongs to an owned deadline.\n */\nexport function exceededOwnedDeadline(error) {\n  return typeof error == \"object\" && error != null && deadlineFailures.has(error)\n}\n"]}

package/build/src/toolchains.d.ts

@@ -41,6 +41,30 @@ export declare const canonicalToolchains: {
         supportedVersion: RegExp;
         versionArguments: string[];
     };
+    dotnet: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
+    go: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
+    clangpp: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
+    clang: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
 };
 /**
  * Discovers one repository-declared canonical toolchain.

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;;0BAkKA,MAAM;qCAA+B,MAAM;0BAAoB,MAAM;0BAAoB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA1J/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,CAiGtE;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;;0BAsKA,MAAM;qCAA+B,MAAM;0BAAoB,MAAM;0BAAoB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA1J/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,CAiGtE;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

@@ -14,7 +14,11 @@ export const canonicalToolchains = deepFreeze({
     tsc: definition("tsc", "SEMANTIFOLD_TSC", ["--version"], /^Version 7\./u),
     javac: definition("javac", "SEMANTIFOLD_JAVAC", ["-version"], /^javac (?:1[7-9]|2[0-9])\./u),
     java: definition("java", "SEMANTIFOLD_JAVA", ["-version"], /^(?:openjdk|java) version "(?:1[7-9]|2[0-9])\./u),
-    python: definition("python3", "SEMANTIFOLD_PYTHON", ["--version"], /^Python 3\./u)
+    python: definition("python3", "SEMANTIFOLD_PYTHON", ["--version"], /^Python 3\./u),
+    dotnet: definition("dotnet", "SEMANTIFOLD_DOTNET", ["--version"], /^10\./u),
+    go: definition("go", "SEMANTIFOLD_GO", ["version"], /^go version go1\.26\.\d+ linux\/amd64$/u),
+    clangpp: definition("clang++", "SEMANTIFOLD_CLANGPP", ["--version"], /^Ubuntu clang version 21\.1\.8 [^\n]+\nTarget: x86_64-pc-linux-gnu\n/u),
+    clang: definition("clang", "SEMANTIFOLD_CLANG", ["--version"], /^Ubuntu clang version 21\.1\.8 [^\n]+\nTarget: x86_64-pc-linux-gnu\n/u)
 });
 /**
  * Discovers one repository-declared canonical toolchain.
@@ -410,4 +414,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":"AAAA,YAAY;AAEZ,OAAO,EAAC,SAAS,IAAI,WAAW,EAAC,MAAM,SAAS,CAAA;AAChD,OAAO,EAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACvD,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,EAAC,YAAY,EAAC,MAAM,YAAY,CAAA;AACvC,OAAO,EAAC,qBAAqB,EAAC,MAAM,iBAAiB,CAAA;AACrD,OAAO,EAAC,qBAAqB,EAAE,uBAAuB,EAAC,MAAM,iBAAiB,CAAA;AAC9E,OAAO,EAAC,oBAAoB,EAAE,gBAAgB,EAAC,MAAM,cAAc,CAAA;AAEnE,MAAM,gBAAgB,GAAG,MAAM,CAAA;AAE/B,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;IAC5C,GAAG,EAAE,UAAU,CAAC,KAAK,EAAE,iBAAiB,EAAE,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACrE,IAAI,EAAE,UAAU,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,WAAW,CAAC,EAAE,YAAY,CAAC;IACzE,IAAI,EAAE,UAAU,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,WAAW,CAAC,EAAE,SAAS,CAAC;IACtE,GAAG,EAAE,UAAU,CAAC,KAAK,EAAE,iBAAiB,EAAE,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACzE,KAAK,EAAE,UAAU,CAAC,OAAO,EAAE,mBAAmB,EAAE,CAAC,UAAU,CAAC,EAAE,6BAA6B,CAAC;IAC5F,IAAI,EAAE,UAAU,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,UAAU,CAAC,EAAE,iDAAiD,CAAC;IAC7G,MAAM,EAAE,UAAU,CAAC,SAAS,EAAE,oBAAoB,EAAE,CAAC,WAAW,CAAC,EAAE,cAAc,CAAC;CACnF,CAAC,CAAA;AAEF;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE;IAC/D,IAAI,OAAO,EAAE,IAAI,QAAQ,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QAC5C,gBAAgB,CAAC,8DAA8D,EAAE,WAAW,CAAC,CAAA;IAC/F,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;QAAE,gBAAgB,CAAC,gDAAgD,EAAE,EAAE,CAAC,CAAA;IACnG,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,EAAE,CAAC;QACvD,CAAC,CAAC,mBAAmB,EAAC,+CAAgD,CAAC,EAAE,CAAC,CAAC;QAC3E,CAAC,CAAC,SAAS,CAAA;IAEb,IAAI,CAAC,UAAU;QAAE,gBAAgB,CAAC,gCAAgC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;IAC7E,MAAM,wBAAwB,GAAG,OAAO,CAAC,WAAW,KAAK,SAAS;QAChE,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,mBAAmB,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAA;IAChD,MAAM,WAAW,GAAG,wBAAwB,IAAI,kBAAkB,EAAE,CAAA;IACpE,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,KAAK,SAAS;QAC/C,CAAC,CAAC,wBAAwB,KAAK,SAAS;YACtC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,2BAA2B,CAAC;YACrD,CAAC,CAAC,wBAAwB,CAAC,UAAU,CAAC,2BAA2B,CAAC;QACpE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAA;IAEpB,OAAO,iBAAiB,CAAC;QACvB,gBAAgB,EAAE,UAAU,CAAC,gBAAgB;QAC7C,WAAW;QACX,EAAE;QACF,QAAQ,EAAE,UAAU;QACpB,gBAAgB,EAAE,UAAU,CAAC,gBAAgB;QAC7C,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,gBAAgB,EAAE,UAAU,CAAC,gBAAgB;KAC9C,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,KAAK;IAC3C,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;QAAE,gBAAgB,CAAC,gDAAgD,EAAE,WAAW,CAAC,CAAA;IAC1G,MAAM,wBAAwB,GAAG,KAAK,CAAC,gBAAgB,CAAA;IACvD,MAAM,gBAAgB,GAAG,YAAY,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;IAC3G,MAAM,SAAS,GAAG;QAChB,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,WAAW,EAAE,KAAK,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW;QACvF,EAAE,EAAE,KAAK,CAAC,EAAE;QACZ,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,SAAS,EAAE,KAAK,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS;QAC7E,gBAAgB;KACjB,CAAA;IAED,iBAAiB,CAAC,SAAS,CAAC,CAAA;IAC5B,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAA;IAC3E,MAAM,WAAW,GAAG,2DAA2D,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;IACvG,MAAM,EAAE,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,CAAA;IAC/C,MAAM,QAAQ,GAAG,iCAAiC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAA;IACvE,MAAM,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,YAAY,MAAM;QACnE,CAAC,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE,SAAS,CAAC,gBAAgB,CAAC,KAAK,CAAC;QACjF,CAAC,CAAC,SAAS,CAAA;IACb,MAAM,SAAS,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;IAC7D,MAAM,yBAAyB,GAAG,uBAAuB,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAA;IACtF,MAAM,qBAAqB,GAAG,wBAAwB,CAAC,WAAW,CAAC,CAAA;IACnE,MAAM,EAAC,UAAU,EAAE,MAAM,EAAC,GAAG,QAAQ,KAAK,SAAS;QACjD,CAAC,CAAC,MAAM,gBAAgB,CAAC,EAAE,EAAE,gBAAgB,EAAE,qBAAqB,CAAC,IAAI,IAAI,EAAE,CAAC;QAChF,CAAC,CAAC,EAAC,UAAU,EAAE,MAAM,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAE,gBAAgB,CAAC,EAAE,MAAM,EAAE,oBAAoB,CAAC,CAAC,UAAU,CAAC,EAAC,CAAA;IAClH,+CAA+C;IAC/C,IAAI,MAAM,CAAA;IAEV,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,uBAAuB,CAAC;YACrC,SAAS,EAAE,yBAAyB;YACpC,WAAW,EAAE,qBAAqB;YAClC,UAAU;YACV,SAAS,EAAE,IAAI,GAAG,IAAI;YACtB,SAAS;SACV,CAAC,CAAA;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,YAAY,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAA;QAC9C,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAA;QAE7C,MAAM,IAAI,qBAAqB,CAAC;YAC9B,GAAG,YAAY;YACf,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS;YACjD,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,sBAAsB;YAChE,OAAO,EAAE,gBAAgB;YACzB,UAAU;YACV,QAAQ,EAAE,EAAE;YACZ,OAAO,EAAE,QAAQ;gBACf,CAAC,CAAC,wBAAwB,UAAU,cAAc,SAAS,KAAK;gBAChE,CAAC,CAAC,wBAAwB,UAAU,WAAW;YACjD,MAAM,EAAE,YAAY,CAAC,MAAM;YAC3B,MAAM,EAAE,YAAY,CAAC,MAAM;SAC5B,CAAC,CAAA;IACJ,CAAC;IAED,MAAM,EAAC,MAAM,EAAE,MAAM,EAAC,GAAG,MAAM,CAAA;IAC/B,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAA;IAC5F,MAAM,OAAO,GAAG,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;IAEtD,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,qBAAqB,CAAC;YAC9B,IAAI,EAAE,sBAAsB;YAC5B,OAAO,EAAE,gBAAgB;YACzB,UAAU;YACV,QAAQ,EAAE,EAAE;YACZ,OAAO,EAAE,wBAAwB,UAAU,+BAA+B;YAC1E,MAAM;YACN,MAAM;SACP,CAAC,CAAA;IACJ,CAAC;IACD,IAAI,gBAAgB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;QAC9D,MAAM,IAAI,qBAAqB,CAAC;YAC9B,IAAI,EAAE,0BAA0B;YAChC,OAAO,EAAE,gBAAgB;YACzB,UAAU;YACV,QAAQ,EAAE,EAAE;YACZ,OAAO,EAAE,eAAe,UAAU,mCAAmC,OAAO,IAAI;YAChF,MAAM;YACN,MAAM;YACN,OAAO;SACR,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,UAAU,CAAC;QAChB,OAAO,EAAE,gBAAgB;QACzB,UAAU;QACV,EAAE;QACF,MAAM;QACN,OAAO;QACP,gBAAgB,EAAE,yBAAyB;QAC3C,aAAa;KACd,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,UAAU,CAAC,gBAAgB,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,gBAAgB;IACnG,OAAO,EAAC,gBAAgB,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,gBAAgB,EAAC,CAAA;AAC5F,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,iBAAiB,CAAC,KAAK;IAC9B,IAAI,OAAO,KAAK,CAAC,EAAE,IAAI,QAAQ,IAAI,KAAK,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC;QACrD,OAAO,KAAK,CAAC,gBAAgB,IAAI,QAAQ,IAAI,KAAK,CAAC,gBAAgB,CAAC,MAAM,IAAI,CAAC;QAC/E,KAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC;QACtH,CAAC,YAAY,CAAC,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,aAAa,CAAC;QACrF,CAAC,aAAa,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,SAAS,CAAC;QAC3E,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,OAAO,KAAK,CAAC,QAAQ,IAAI,QAAQ,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1I,CAAC,KAAK,CAAC,gBAAgB,KAAK,SAAS,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,gBAAgB,YAAY,MAAM,CAAC,IAAI,KAAK,CAAC,gBAAgB,CAAC,MAAM,IAAI,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QAC5J,gBAAgB,CAAC,iIAAiI,gBAAgB,KAAK,EACrK,OAAO,KAAK,CAAC,EAAE,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAA;IACzD,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,gBAAgB,CAAC,EAAE,EAAE,OAAO,EAAE,SAAS;IACpD,MAAM,OAAO,GAAG,IAAI,GAAG,EAAE,CAAA;IAEzB,KAAK,MAAM,SAAS,IAAI,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QACxD,IAAI,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;YAAE,SAAQ;QAClE,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;QAE/C,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,qBAAqB,CAAC,SAAS,CAAC,CAAA;YAEpD,IAAI,KAAK,IAAI,SAAS;gBAAE,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QACnD,CAAC;QAAC,MAAM,CAAC;YACP,uFAAuF;QACzF,CAAC;IACH,CAAC;IAED,IAAI,OAAO,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,qBAAqB,CAAC;YAC9B,IAAI,EAAE,gBAAgB;YACtB,OAAO;YACP,QAAQ,EAAE,EAAE;YACZ,OAAO,EAAE,sBAAsB,OAAO,2CAA2C;SAClF,CAAC,CAAA;IACJ,CAAC;IACD,IAAI,OAAO,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,qBAAqB,CAAC;YAC9B,IAAI,EAAE,gBAAgB;YACtB,OAAO;YACP,QAAQ,EAAE,EAAE;YACZ,OAAO,EAAE,sBAAsB,OAAO,uCAAuC,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;SAC/G,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,EAAC,UAAU,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,oBAAoB,CAAC,CAAC,WAAW,CAAC,EAAC,CAAA;AACjH,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO;IAClD,gCAAgC;IAChC,IAAI,KAAK,CAAA;IAET,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,qBAAqB,CAAC,QAAQ,CAAC,CAAA;QAEnD,IAAI,KAAK,IAAI,SAAS;YAAE,OAAO,KAAK,CAAA;IACtC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,KAAK,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAA;IACpD,CAAC;IAED,MAAM,IAAI,qBAAqB,CAAC;QAC9B,KAAK;QACL,IAAI,EAAE,gBAAgB;QACtB,OAAO;QACP,UAAU,EAAE,QAAQ;QACpB,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE,0BAA0B,QAAQ,iCAAiC;KAC7E,CAAC,CAAA;AACJ,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,qBAAqB,CAAC,SAAS;IAC5C,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC,CAAA;IACvC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,CAAA;IAEhC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,SAAS,CAAA;IACtC,MAAM,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;IAErC,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,WAAW,GAAG,kBAAkB,EAAE;IACzE,MAAM,OAAO,GAAG,kBAAkB,CAAC,WAAW,CAAC,CAAA;IAE/C,IAAI,OAAO,IAAI,SAAS;QAAE,gBAAgB,CAAC,6FAA6F,EAAE,aAAa,CAAC,CAAA;IACxJ,qCAAqC;IACrC,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAEtC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,OAAO,EAAE,CAAC;QACnC,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAClH,gBAAgB,CAAC,uDAAuD,EAAE,aAAa,CAAC,CAAA;QAC1F,CAAC;QACD,IAAI,KAAK,KAAK,SAAS;YAAE,UAAU,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;IAClD,CAAC;IACD,UAAU,CAAC,IAAI,GAAG,SAAS,CAAA;IAC3B,UAAU,CAAC,MAAM,GAAG,SAAS,CAAA;IAC7B,UAAU,CAAC,EAAE,GAAG,KAAK,CAAA;IACrB,UAAU,CAAC,IAAI,KAAK,8BAA8B,CAAA;IAElD,OAAO,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;AAClC,CAAC;AAED;;;GAGG;AACH,SAAS,kBAAkB;IACzB,OAAO,EAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,IAAI,EAAC,CAAA;AACjC,CAAC;AAED;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,KAAK;IAC/B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,IAAI,QAAQ;QAAE,OAAO,EAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAC,CAAA;IAC/G,MAAM,KAAK,GAAG,sCAAsC,CAAC,CAAC,KAAK,CAAC,CAAA;IAE5D,OAAO;QACL,QAAQ,EAAE,OAAO,KAAK,CAAC,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;QAChE,MAAM,EAAE,OAAO,KAAK,CAAC,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;QAClE,MAAM,EAAE,OAAO,KAAK,CAAC,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;QAC3D,MAAM,EAAE,OAAO,KAAK,CAAC,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;KAC5D,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,KAAK;IAC1B,OAAO,OAAO,KAAK,IAAI,QAAQ,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;AAC1D,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,KAAK;IAC1B,OAAO,kBAAkB,CAAC,KAAK,CAAC,IAAI,SAAS,CAAA;AAC/C,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,KAAK,EAAE,EAAE;IACpC,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAA;IAEzC,IAAI,OAAO,IAAI,SAAS,EAAE,CAAC;QACzB,gBAAgB,CAAC,yGAAyG,EAAE,EAAE,CAAC,CAAA;IACjI,CAAC;IACD,iDAAiD;IACjD,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAEpC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,OAAO;QAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;IAEzD,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;AAChC,CAAC;AAED;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,KAAK;IAC/B,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAA;IAEvF,IAAI,CAAC;QACH,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;QAE9C,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI;YAAE,OAAO,SAAS,CAAA;QAC1E,6CAA6C;QAC7C,MAAM,OAAO,GAAG,EAAE,CAAA;QAElB,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzC,IAAI,OAAO,GAAG,IAAI,QAAQ;gBAAE,OAAO,SAAS,CAAA;YAC5C,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;YAE9D,IAAI,UAAU,IAAI,SAAS,IAAI,CAAC,UAAU,CAAC,UAAU,IAAI,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC;gBAC/E,CAAC,UAAU,CAAC,KAAK,KAAK,SAAS,IAAI,OAAO,UAAU,CAAC,KAAK,IAAI,QAAQ,CAAC;gBAAE,OAAO,SAAS,CAAA;YAC3F,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;QACvC,CAAC;QAED,OAAO,OAAO,CAAA;IAChB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,KAAK;IAC1B,OAAO,OAAO,KAAK,IAAI,QAAQ,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,CAAA;AAC/H,CAAC;AAED;;;;;GAKG;AACH,SAAS,gBAAgB,CAAC,OAAO,EAAE,EAAE;IACnC,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,mBAAmB,EAAE,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAC,CAAC,CAAA;AACrF,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,KAAK;IACvB,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IAE9E,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;QAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAE7D,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AAC7B,CAAC","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  php: definition(\"php\", \"SEMANTIFOLD_PHP\", [\"--version\"], /^PHP 8\\./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  python: definition(\"python3\", \"SEMANTIFOLD_PYTHON\", [\"--version\"], /^Python 3\\./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 captured-output 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 versionOutput = [stdout, stderr].filter((value) => value.length > 0).join(\"\\n\").trim()\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  php: definition(\"php\", \"SEMANTIFOLD_PHP\", [\"--version\"], /^PHP 8\\./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  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})\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 captured-output 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 versionOutput = [stdout, stderr].filter((value) => value.length > 0).join(\"\\n\").trim()\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/docs/architecture.md

@@ -2,15 +2,25 @@
 
 Semantifold has three explicit layers.
 
-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 the exact official `tree-sitter`/`tree-sitter-python` pair owns Python. 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. The Node Tree-sitter binding feeds strings as UTF-16LE and exposes code-unit indexes; the Python adapter rejects lone surrogates and verifies those boundaries through the shared UTF-8-byte-to-UTF-16 converter.
+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 the exact official `tree-sitter` binding with the official Python, C#, or Go grammar owns those languages. 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. The Node Tree-sitter binding feeds strings as UTF-16LE and exposes code-unit indexes; its adapters reject lone surrogates, exhaustively traverse named/anonymous/comment/directive/error/missing children, and verify 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. Scalar types are exact `integer`, `boolean`, or `string` references. Literal nodes carry JavaScript-safe integer, primitive boolean, or parser-decoded Unicode scalar values. Unary and binary expressions carry a closed semantic `operation` and explicit result `type`, never a source operator symbol. Every function, entry point, consequent, and alternate owns a located `Block` containing ordered `Statement` nodes. Statements are local declarations, assignments, conditionals, explicit returns, or prints; an `IfStatement` has a Boolean condition, a consequent block, and an optional alternate block. Source-spelled `else if`, `elsif`, and `elseif` normalize to an alternate block containing one nested conditional.
-3. Source backends in `src/backends/` validate their semantic capabilities before emitting target syntax. Shared validation owns recursive block shape, reachability and all-path return analysis, recursively complete expressions, exhaustive operation/type signatures, function signatures, lexical binding scopes, mutability, declaration-before-use, and strict condition/return/argument/initializer/assignment types. Target-specific validation adds identifier rules, entry-scaffolding name collisions, Java's signed 32-bit `int` literal and compile-time-known arithmetic range, and target string escaping. Every emitter recursively writes blocks and statements through `SourceWriter`; semantic tokens, target anchors, and synthetic layout are mapped as they are emitted. A backend either returns a complete executable program or raises `UNSUPPORTED_CAPABILITY`; it never silently drops nodes or lets an emitter discover malformed shape through a `TypeError`.
+3. Source backends in `src/backends/` validate their semantic capabilities before emitting target syntax. Shared validation owns recursive block shape, reachability and all-path return analysis, recursively complete expressions, exhaustive operation/type signatures, function signatures, lexical binding scopes, mutability, declaration-before-use, and strict condition/return/argument/initializer/assignment types. Target-specific validation adds identifier rules, entry-scaffolding name collisions, Java's signed 32-bit `int` range, C#'s checked signed-64-bit operation range, Go's known signed-64-bit range and round-trip mutability rule, and target string escaping. Every emitter recursively writes blocks and statements through `SourceWriter`; semantic tokens, target anchors, and synthetic layout are mapped as they are emitted. The C# backend validates the complete module and all filename/map options first, writes mapped `Program.cs`, constructs fixed source-free `Semantifold.csproj`, and submits one ordered candidate set for transactional validation. The Go backend likewise validates before writing, then returns fixed synthetic `go.mod` followed by mapped, gofmt-stable `main.go`; manifest-first ordering lets native setup inspect configuration before source without exposing either artifact early. A backend either returns a complete executable program/project or raises `UNSUPPORTED_CAPABILITY`; it never silently drops nodes, exposes a partial artifact, or lets an emitter discover malformed shape through a `TypeError`.
 
 `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, artifact multiplicity, round-trip support, rich/v3/byte mapping forms, and acceptance stages/toolchains from those records; `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. `parse({language, filename, source})` resolves only the frontend role. `generate({language, module})` and `generateArtifact(...)` resolve a single-text backend, validate the full module, and preserve the compatibility source/artifact contracts. `generateArtifactSet(...)` is additive and is required for multi-artifact, binary, and application targets. An unknown ID is `UNSUPPORTED_LANGUAGE`; a known ID without the requested role is `UNSUPPORTED_ROLE`; `UNSUPPORTED_CAPABILITY` remains a backend-with-role rejection of the requested semantic content. `src/artifacts.js` owns transactional generated-file validation, `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. `parse({language, filename, source})` resolves only the frontend role. `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, and C backends. `generateArtifactSet(...)` is additive and is required for C#, Go, C, and other multi-artifact, binary, and application targets. It forwards filename and mapping options to a multi backend so unsupported options cannot disappear. An unknown ID is `UNSUPPORTED_LANGUAGE`; a known ID without the requested role is `UNSUPPORTED_ROLE`; `UNSUPPORTED_CAPABILITY` remains a backend-with-role rejection of the requested semantic content. `src/artifacts.js` owns transactional generated-file validation, `src/binary-mapping.js` owns byte provenance, and `src/mapping.js` owns text lookup, serialization, import/composition, and diagnostic remapping.
+
+`src/toolchains.js` resolves configured absolute overrides or one unambiguous canonical PATH executable, runs a bounded version command, and returns its exact real path and captured version. The `dotnet` contract accepts SDK major 10 through `SEMANTIFOLD_DOTNET` or canonical `dotnet`; the `go` contract accepts only Go 1.26.x on Linux/amd64 through `SEMANTIFOLD_GO` or canonical `go`, with `gofmt` taken from the same GOROOT. `src/acceptance.js` validates all artifacts and ordered stages—including the distinct `restore` stage between generation and compilation—before filesystem mutation, materializes only safe generated paths in a unique temporary directory, invokes exact executable/argument arrays without a shell, fixes `LANG`, `LC_ALL`, and `TZ`, captures output, distinguishes discovery/version/launch/timeout/nonzero failures, records the precise failed stage, and removes the directory. Go acceptance uses isolated caches with downloads, cgo, workspaces, and automatic toolchain selection disabled. The runner performs no network discovery, installation, or runtime download.
+
+## Future standard-library portability
+
+Standard-library portability is a planned extension of these layers, not current behavior. A frontend will substitute a source-language **language compatibility stdlib/facade** only after parser-backed module resolution proves the native library and symbol identity. The facade is portable executable source that enters the same frontend and semantic layers as application code. It calls a versioned **canonical Semantifold stdlib contract/capability**, never a target API or pair-specific bridge.
 
-`src/toolchains.js` resolves configured absolute overrides or one unambiguous canonical PATH executable, runs a bounded version command, and returns its exact real path and captured version. `src/acceptance.js` validates all artifacts and stages before filesystem mutation, materializes only safe generated paths in a unique temporary directory, invokes exact executable/argument arrays without a shell, fixes `LANG`, `LC_ALL`, and `TZ`, captures output, distinguishes discovery/version/launch/timeout/nonzero failures, records the precise failed stage, and removes the directory. It performs no network discovery, installation, or runtime download.
+Artifact generation will compile the application and only its used compatibility modules, then link only the required **target host provider/native binding** modules. Providers implement canonical capabilities with the target's genuine native stdlib behind a protected host-native boundary unavailable to ordinary application and facade code; that isolation also prevents same-language generation from recursively selecting its own compatibility facade. Contract and target validation must finish before any artifact is exposed. Unsupported source identity, source APIs, target capabilities, or semantic mismatches produce located diagnostics rather than partial output.
+
+Generated target code may preserve source API class or function names in a collision-safe compatibility namespace or import alias while using valid target syntax. A later backend may replace a facade/provider path with direct idiomatic lowering only when equivalence is proven; it is never the correctness baseline. Linking, tree-shaking, contract precision, namespace rules, and the full compile flow are defined in the [authoritative standard-library portability design](standard-library-portability.md).
 
 ## Round trips
 
@@ -28,7 +38,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`; unknown runtime overflow remains outside the portable guarantee.
+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`. 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.
 
 ## Blocks, flow, and bindings
 
@@ -38,6 +48,10 @@ Binding identity is resolver-owned and exposed as deterministic module-local str
 
 ## 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 named/anonymous nodes provide exact function, parameter, local, type, assignment, literal, call, branch, and operator ranges. The Python adapter traverses every child, rejects error/missing recovery, and never substitutes source-text parsing after a rejected tree node. 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 byte coordinates become 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 named and anonymous nodes provide exact function, parameter, local, type, assignment, literal, call, branch, 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. 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).
+
+## Task019 CPP integration
+
+`src/frontends/cpp.js` independently consumes official CPP snapshots and validates exact qualified types, condition clauses, inline support and CPP ordered regions. `src/backends/cpp.js` emits one mapped `program.cpp`; `cpp-runtime.js` owns fixed C++20 libstdc++ support and `cpp-validation.js` proves known owned-value sizes. C and CPP reuse `ordered-expressions.js` for occurrence planning/signatures and `native-validation.js` for bounded graphs, with the owning language preserved in diagnostics. The CPP frontend compares complete CPP CST structure against its canonical CPP output; it never calls the C frontend. The private runtime explicitly selects its official grammar and exports only frozen parser-neutral values. No semantic IR, standalone package identity, parser export, artifact contract or standard-library architecture is expanded. See the [CPP profile](cpp.md).

package/docs/c.md

@@ -0,0 +1,60 @@
+# C source and native target profile
+
+Task 018 implements the existing Tasks 001–004 semantic subset as independent language `c`. Use `parse({language: "c", filename, source})` and `generateArtifactSet({language: "c", module})`. Generation returns mapped `program.c` first and synthetic support artifact `semantifold_runtime.h` second, with deterministic LF content. Only an omitted filename or exact `program.c` is accepted. Mapping filename/directive options are rejected. Single-artifact generation reports `UNSUPPORTED_ROLE`; C has no binary-backend, interoperability, project-graph, or FFI role.
+
+## Scalars, arithmetic and lifetime
+
+| Semantic value | Exact C representation | Rules |
+| --- | --- | --- |
+| `integer` | `int64_t` | Safe nonnegative decimal literal payloads; negative values are unary negation. Generated literals use `INT64_C`. |
+| `boolean` | `bool` | Exact `true`/`false`; no integer conversion or truthiness. |
+| `string` | `SemantifoldString` | Immutable `const unsigned char *data` plus `size_t length`, containing valid UTF-8 bytes including embedded NUL. |
+
+The qualified ABI is Linux x86-64: eight-bit bytes, 64-bit `int64_t` and `size_t`, `PTRDIFF_MAX == INT64_MAX`, and eight bytes of arena metadata per allocation. Header static assertions enforce these assumptions at compilation. Caller identifiers begin with an ASCII letter and continue with ASCII letters, digits or underscores. C keywords, imported standard-header names/types/macros, implementation-reserved names, and the `semantifold_`, `SEMANTIFOLD_` and `Semantifold` namespaces are protected in both directions; generation never renames a collision.
+
+Boolean literals must have exact lowercase `true`/`false` spelling. The frozen grammar also classifies `TRUE`/`FALSE` expression tokens as Booleans, so those uppercase spellings are rejected as both expressions and caller identifiers, including parameters, locals and functions. They are not aliases or implicit constants. The imported `<limits.h>` macro `MB_LEN_MAX` is also reserved in both directions; a target collision receives a located `UNSUPPORTED_CAPABILITY` before any artifact is returned.
+
+Every add, subtract, multiply and negate uses a checked helper. Clang overflow builtins detect signed-64-bit overflow without evaluating undefined signed arithmetic; negation is checked subtraction from zero. Known literal arithmetic outside signed 64-bit is rejected with `UNSUPPORTED_CAPABILITY` before generation. Dynamic overflow cleans the arena, writes exactly `semantifold: integer overflow\n` to stderr and exits with status 70. This is a target failure boundary outside semantic user control; it does not add exceptions or wider portable integer guarantees to the IR. `INT64_MIN` prints correctly using unsigned magnitude conversion. A negative or negative-zero `IntegerLiteral` payload is rejected; unary negation remains a supported operation.
+
+`SEMANTIFOLD_STRING("...")` borrows a static C string-literal array, excluding its terminating byte by `sizeof(literal) - 1`. The strict C17 profile limits each decoded literal to 4095 UTF-8 bytes; larger literal objects fail before artifacts. Runtime concatenations can exceed that literal translation limit. Generated tokens encode each UTF-8 byte with three-digit octal escapes, avoiding locale changes, escape munching and embedded-NUL truncation. The frontend decodes only parser-owned ordinary string content and valid simple/octal/hex byte escapes, then verifies complete UTF-8. Copies, parameter passing and returns copy only the descriptor. They do not allocate, mutate, transfer ownership, or end the underlying lifetime.
+
+A hexadecimal escape must end at the same boundary in C and the parser. The frozen grammar consumes at most four hex digits per escape node, while C consumes every following hex digit. An escape followed immediately by a parser-owned content node starting with another hex digit is therefore rejected with located `UNSUPPORTED_SYNTAX`, even if its numeric value would fit in a byte. For example, `"\x000041"` is rejected rather than decoded as NUL plus `41`; native C produces `A`. Bounded byte escapes such as `"\x41"`, `"\x0041"` and `"\x43G"`, separate escaped UTF-8 bytes, octal escapes and embedded NUL remain supported. No source reparsing or dependency modification repairs a split escape.
+
+Each concatenation allocates one arena node, including empty concatenations. The requested object contains the metadata plus exactly the two explicit byte lengths; it does not require a string terminator. Before allocation, the header checks each length, their sum, metadata addition and cumulative arena accounting against `PTRDIFF_MAX`. It then checks `malloc`, links the owned node and copies nonempty byte ranges. Known literal/local length growth and known allocation lower bounds receive corresponding preflight checks without rewriting the semantic IR. Unknown lengths remain checked at runtime. Size failure writes `semantifold: allocation size\n`; allocation failure writes `semantifold: allocation failure\n`. Both clean existing allocations and exit 70.
+
+Canonical `main` calls `semantifold_cleanup()` once after semantic entry statements and returns zero. Cleanup frees each owned node and clears the arena. Returned slices and branch-local descriptor copies therefore remain valid until entry completion. The same cleanup runs before every generated fatal exit. No allocation hook, pointer operation, free, lifetime choice or ownership state is exposed to portable code. Printing uses `fwrite` with explicit lengths, canonical ASCII integer/boolean formatting and one LF. Output failure follows the same fatal policy with `semantifold: output failure\n`; stdout is flushed after each print.
+
+## Accepted source and complete CST validation
+
+The unchanged root-bundled private legacy boundary supplies recursively frozen C CST data from exact `tree-sitter@0.21.1` and `tree-sitter-c@0.23.2`. `src/frontends/c-parser.js` describes that private plain-data boundary; native handles and parser-specific objects never enter semantic values. Every child, field, anonymous token, extra, error, missing node and recovery flag is traversed before meaning is returned. Coordinates and token origins refer to the original UTF-16 source, including astral characters and CRLF. There is no parser-source scan, compiler-based interpretation, preprocessing fallback or source-text recovery.
+
+Ordinary source contains the exact support-header include, at least one `static` semantic function with two named explicitly typed parameters, and final `int main(void)`. Functions return exact scalars. Bodies admit initialized single scalar locals, plain assignment, prints through the matching scalar helper, explicit returns and braced conditionals, including `else if`. `const` locals are immutable; other locals are mutable, and parameters are immutable. Main ends with the exact cleanup call and `return 0`. Raw calls must refer to a preceding or current function definition. Caller-authored forward calls requiring implicit C declarations are rejected; canonical generated prototypes support forward calls and recursion.
+
+Only direct semantic calls and the exact scalar/literal/print helpers are recognized. Caller-authored calls nested in an operator operand or another call's argument are rejected because ordinary C does not establish the required semantic evaluation order. Trigraph preprocessing in parser-backed comments or string content is rejected. No user preprocessing, typedef substitution, global data, complex/multiple declarator, qualifier beyond local `const`, array, struct, union, enum, pointer, function pointer, cast, address/dereference, member access, ownership call, `sizeof`, comma/ternary, loop, switch, goto, update, compound operator, conversion or arbitrary external call is accepted.
+
+The nested-call restriction includes every scalar helper: checked integer add/subtract/multiply/negate and string concat/equal/not-equal. Helper syntax does not prove ordering; allocation and checked-operation failures are observable. Only the exact `INT64_C` and `SEMANTIFOLD_STRING` literal macros are exempt. A helper can remain the root expression of an initializer, assignment, return, print or condition, with call-free operands or literal macros. Caller code must sequence helper results into locals before passing them to another helper/callee or using them inside unary/binary expressions. For example, `return semantifold_integer_add(left, right) + right;` is rejected at the helper call; `int64_t sum = semantifold_integer_add(left, right); return sum + right;` is supported.
+
+Generated ordered regions remain supported because the backend emits each helper as a separate temporary initializer with already-sequenced operands. The frontend reconstructs nesting from those temporary references, then still validates the complete canonical CST. A marker does not exempt an actual nested helper call from the rejection boundary. This correction and its focused RED/GREEN evidence are recorded for [PR 20](https://github.com/kaspernj/semantifold/pull/20) in the [Task 018 delivery record](../todo/018-c-source-and-target.md).
+
+Before discarding any parser-backed comment, the frontend rejects backslash-line-ending splices and line comments containing content after a lone CR. The pinned parser can otherwise hide text that native C executes, including a statement following `// comment` plus a bare CR or a block-comment terminator split by backslash-newline. This validation precedes semantic extraction and generated-region comparison. Ordinary line/block comments, exact generated markers, and normal CRLF remain supported and execute under the same strict compiler profile. A split comment opener that the grammar already rejects remains a located `PARSE_ERROR`; compiler output is never used to recover source meaning.
+
+## Ordered expressions and exact reparse
+
+After complete semantic/target validation and before creating a writer, the C backend plans each expression occurrence in semantic left-to-right order. It treats every call as potentially observable. Each call and enclosing nontrivial operation gets its exact scalar type and a consecutive six-digit name such as `semantifold_ordered_000001`. Eager left preludes precede right preludes. Short-circuit results receive a temporary initialized from the left value, an exact conditional RHS prelude and one final result write using the original `&&` or `||` operator. That token retains the original operator mapping; the generated conditional and temporary names are synthetic. The pure result then feeds the original local initializer, assignment, return, print or conditional test. Branches recursively contain their own regions. The public IR is never rewritten.
+
+Every semantic statement is surrounded by exact paired comments:
+
+```c
+/* semantifold:ordered-expression:c:v1 begin 000001 <64 lowercase hex digits> */
+/* semantifold:ordered-expression:c:v1 end 000001 <same digest> */
+```
+
+The digest is SHA-256 over the closed consumer/expression signature implemented in `ordered-expressions.js`, excluding locations. It detects changed operators/consumers; it is not an authentication mechanism or a substitute for tree validation. Generated files start with exact `/* semantifold:program:c:v1 */`, followed by the include, matching ordered prototypes, semantic definitions and main. Exact generated `(void)name;` uses prevent warnings for unused functions, parameters and locals; they are accepted only at their canonical positions.
+
+The frontend first reconstructs a private candidate from complete region child lists and direct temporary references, requiring each temporary to be consumed exactly once and rejecting duplicate declarations, extra reads and dead values before shared validation. The candidate must also meet the C graph/occurrence bounds. It then resolves semantic types, regenerates the canonical plan, parses that candidate C through the same CST boundary and compares the **entire original CST** against the canonical CST. Every significant node type, child count, field, token, marker, temporary type/number, initializer, dependency, conditional RHS, write, consumer, prototype and discard position must agree. Only ordinary comments and whitespace are ignored. No candidate module escapes before this comparison. Generated programs must use the complete canonical profile; isolated marker fragments or mixed ordinary/generated statements are rejected.
+
+Missing, duplicated, reordered, forged or wrong-version markers; extra/dead/escaping temporaries; wrong types/operators/consumers; altered scaffold casts/prototypes; and malformed semantic content inside a generated region all report located `UNSUPPORTED_SYNTAX`. Parser recovery remains `PARSE_ERROR`. Backend malformed IR, collisions, invalid required locations, cycles, target bounds and unsupported options report `UNSUPPORTED_CAPABILITY`. The unchanged legacy parser accepts at most 32,767 UTF-16 code units per source input; a direct real-parser boundary test proves success at 32,767 and its native failure at 32,768. The C frontend gives a located size diagnostic, and the backend performs an exact output-length preflight before constructing the provenance writer or exposing artifacts. It rejects generated programs above that same limit. No buffer override, parser-payload change or source trimming bypasses this boundary. The bounded C plan also rejects semantic graph depth above 512 or more than 999,999 expanded graph occurrences before recursive validation/emission; occurrence names and statement IDs never widen or wrap.
+
+Rich mappings and Source Map v3 retain original operator, call, literal, binding and final-consumer origins. All generated declarations/names/markers, prototypes, unused-binding uses, short-circuit control and cleanup are synthetic with related semantic origins. Shared IR objects receive distinct occurrence paths, temporary names and map records. The header is a synthetic artifact related to the module root.
+
+See [testing](testing.md) for package pins, portable qualification commands, strict C17 flags, mandatory O0/O2 sanitizer execution, ownership instrumentation and original-five crossings. These changes neither publish a package nor extend the standard-library portability contract.