semantifold 0.1.1 → 0.2.0

package/build/src/toolchains.js

@@ -0,0 +1,413 @@
+// @ts-check
+import { constants as fsConstants } from "node:fs";
+import { access, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { isDenseArray } from "./array.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { exceededOwnedDeadline, executeFileWithDeadline } from "./subprocess.js";
+import { isSupportedTimeoutMs, maximumTimeoutMs } from "./timeout.js";
+const defaultTimeoutMs = 10_000;
+export const canonicalToolchains = deepFreeze({
+    php: definition("php", "SEMANTIFOLD_PHP", ["--version"], /^PHP 8\./u),
+    ruby: definition("ruby", "SEMANTIFOLD_RUBY", ["--version"], /^ruby 3\./u),
+    node: definition("node", "SEMANTIFOLD_NODE", ["--version"], /^v24\./u),
+    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)
+});
+/**
+ * Discovers one repository-declared canonical toolchain.
+ * @param {keyof typeof canonicalToolchains} id - Canonical toolchain ID.
+ * @param {{environment?: Readonly<Record<string, string | undefined>>, override?: string, timeoutMs?: number}} [options] - Discovery options.
+ * @returns {Promise<import("./semantic/types.js").DiscoveredToolchain>} Exact executable and version.
+ */
+export async function discoverCanonicalToolchain(id, options = {}) {
+    if (typeof id != "string" || id.length == 0) {
+        invalidToolchain("Canonical toolchain ID must be a non-empty primitive string.", "toolchain");
+    }
+    if (!isPlainObject(options))
+        invalidToolchain("Canonical toolchain options must be an object.", id);
+    const definition = Object.hasOwn(canonicalToolchains, id)
+        ? canonicalToolchains[ /** @type {keyof typeof canonicalToolchains} */(id)]
+        : undefined;
+    if (!definition)
+        invalidToolchain(`Unknown canonical toolchain '${id}'.`, id);
+    const configurationEnvironment = options.environment === undefined
+        ? undefined
+        : snapshotEnvironment(options.environment, id);
+    const environment = configurationEnvironment ?? defaultEnvironment();
+    const configured = options.override === undefined
+        ? configurationEnvironment === undefined
+            ? process.env[definition.overrideEnvironmentVariable]
+            : configurationEnvironment[definition.overrideEnvironmentVariable]
+        : options.override;
+    return discoverToolchain({
+        canonicalCommand: definition.canonicalCommand,
+        environment,
+        id,
+        override: configured,
+        supportedVersion: definition.supportedVersion,
+        timeoutMs: options.timeoutMs,
+        versionArguments: definition.versionArguments
+    });
+}
+/**
+ * Resolves and versions one configured or canonical executable without invoking a shell.
+ * @param {object} input - Discovery request.
+ * @param {string} input.canonicalCommand - Canonical PATH command.
+ * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Explicit discovery environment.
+ * @param {string} input.id - Toolchain ID.
+ * @param {string} [input.override] - Configured absolute executable path.
+ * @param {RegExp} [input.supportedVersion] - Full captured-output version policy.
+ * @param {number} [input.timeoutMs] - Version command timeout.
+ * @param {string[]} input.versionArguments - Exact version argument array.
+ * @returns {Promise<import("./semantic/types.js").DiscoveredToolchain>} Discovered tool.
+ */
+export async function discoverToolchain(input) {
+    if (!isPlainObject(input))
+        invalidToolchain("Toolchain discovery requires a request object.", "toolchain");
+    const versionArgumentCandidate = input.versionArguments;
+    const versionArguments = isDenseArray(versionArgumentCandidate) ? [...versionArgumentCandidate] : undefined;
+    const candidate = {
+        canonicalCommand: input.canonicalCommand,
+        environment: input.environment === undefined ? defaultEnvironment() : input.environment,
+        id: input.id,
+        override: input.override,
+        supportedVersion: input.supportedVersion,
+        timeoutMs: input.timeoutMs === undefined ? defaultTimeoutMs : input.timeoutMs,
+        versionArguments
+    };
+    validateDiscovery(candidate);
+    const canonicalCommand = /** @type {string} */ (candidate.canonicalCommand);
+    const environment = /** @type {Readonly<Record<string, string | undefined>>} */ (candidate.environment);
+    const id = /** @type {string} */ (candidate.id);
+    const override = /** @type {string | undefined} */ (candidate.override);
+    const supportedVersion = candidate.supportedVersion instanceof RegExp
+        ? new RegExp(candidate.supportedVersion.source, candidate.supportedVersion.flags)
+        : undefined;
+    const timeoutMs = /** @type {number} */ (candidate.timeoutMs);
+    const validatedVersionArguments = /** @type {string[]} */ (candidate.versionArguments);
+    const normalizedEnvironment = deterministicEnvironment(environment);
+    const { executable, source } = override === undefined
+        ? await resolveCanonical(id, canonicalCommand, normalizedEnvironment.PATH ?? "")
+        : { executable: await resolveOverride(id, override, canonicalCommand), source: /** @type {const} */ ("override") };
+    /** @type {{stdout: string, stderr: string}} */
+    let result;
+    try {
+        result = await executeFileWithDeadline({
+            arguments: validatedVersionArguments,
+            environment: normalizedEnvironment,
+            executable,
+            maxBuffer: 1024 * 1024,
+            timeoutMs
+        });
+    }
+    catch (error) {
+        const processError = processErrorFields(error);
+        const timedOut = exceededOwnedDeadline(error);
+        throw new SemantifoldDiagnostic({
+            ...processError,
+            cause: error instanceof Error ? error : undefined,
+            code: timedOut ? "TOOL_VERSION_TIMEOUT" : "TOOL_VERSION_FAILURE",
+            command: canonicalCommand,
+            executable,
+            language: id,
+            message: timedOut
+                ? `Version command for '${executable}' exceeded ${timeoutMs}ms.`
+                : `Version command for '${executable}' failed.`,
+            stderr: processError.stderr,
+            stdout: processError.stdout
+        });
+    }
+    const { stderr, stdout } = result;
+    const versionOutput = [stdout, stderr].filter((value) => value.length > 0).join("\n").trim();
+    const version = versionOutput.split(/\r?\n/u)[0] ?? "";
+    if (version.length == 0) {
+        throw new SemantifoldDiagnostic({
+            code: "TOOL_VERSION_FAILURE",
+            command: canonicalCommand,
+            executable,
+            language: id,
+            message: `Version command for '${executable}' returned no version output.`,
+            stderr,
+            stdout
+        });
+    }
+    if (supportedVersion && !supportedVersion.test(versionOutput)) {
+        throw new SemantifoldDiagnostic({
+            code: "TOOL_UNSUPPORTED_VERSION",
+            command: canonicalCommand,
+            executable,
+            language: id,
+            message: `Executable '${executable}' reported unsupported version '${version}'.`,
+            stderr,
+            stdout,
+            version
+        });
+    }
+    return deepFreeze({
+        command: canonicalCommand,
+        executable,
+        id,
+        source,
+        version,
+        versionArguments: validatedVersionArguments,
+        versionOutput
+    });
+}
+/**
+ * Builds one canonical immutable toolchain declaration.
+ * @param {string} canonicalCommand - PATH command.
+ * @param {string} overrideEnvironmentVariable - Configured override variable.
+ * @param {string[]} versionArguments - Exact version arguments.
+ * @param {RegExp} supportedVersion - Supported version output.
+ * @returns {{canonicalCommand: string, overrideEnvironmentVariable: string, supportedVersion: RegExp, versionArguments: string[]}} Declaration.
+ */
+function definition(canonicalCommand, overrideEnvironmentVariable, versionArguments, supportedVersion) {
+    return { canonicalCommand, overrideEnvironmentVariable, supportedVersion, versionArguments };
+}
+/**
+ * Validates tool discovery before filesystem or process access.
+ * @param {{
+ *   canonicalCommand: unknown,
+ *   environment: unknown,
+ *   id: unknown,
+ *   override: unknown,
+ *   supportedVersion: unknown,
+ *   timeoutMs: unknown,
+ *   versionArguments: unknown
+ * }} input - Candidate discovery fields.
+ * @returns {void}
+ */
+function validateDiscovery(input) {
+    if (typeof input.id != "string" || input.id.length == 0 ||
+        typeof input.canonicalCommand != "string" || input.canonicalCommand.length == 0 ||
+        input.canonicalCommand.includes("/") || input.canonicalCommand.includes("\\") || input.canonicalCommand.includes("\0") ||
+        !isDenseArray(input.versionArguments) || !input.versionArguments.every(validArgument) ||
+        !isEnvironment(input.environment) || !isSupportedTimeoutMs(input.timeoutMs) ||
+        (input.override !== undefined && (typeof input.override != "string" || !path.isAbsolute(input.override) || input.override.includes("\0"))) ||
+        (input.supportedVersion !== undefined && (!(input.supportedVersion instanceof RegExp) || input.supportedVersion.global || input.supportedVersion.sticky))) {
+        invalidToolchain(`Toolchain discovery requires a canonical basename, absolute override, argument array, environment, and timeout from 1 through ${maximumTimeoutMs}ms.`, typeof input.id == "string" ? input.id : "toolchain");
+    }
+}
+/**
+ * Resolves one unambiguous canonical command from an explicit PATH.
+ * @param {string} id - Toolchain ID.
+ * @param {string} command - Canonical command.
+ * @param {string} pathValue - Explicit PATH.
+ * @returns {Promise<{executable: string, source: "canonical"}>} Exact executable.
+ */
+async function resolveCanonical(id, command, pathValue) {
+    const matches = new Map();
+    for (const directory of pathValue.split(path.delimiter)) {
+        if (directory.length == 0 || !path.isAbsolute(directory))
+            continue;
+        const candidate = path.join(directory, command);
+        try {
+            const exact = await resolveExecutableFile(candidate);
+            if (exact != undefined)
+                matches.set(exact, exact);
+        }
+        catch {
+            // A PATH candidate is absent or non-executable; discovery continues deterministically.
+        }
+    }
+    if (matches.size == 0) {
+        throw new SemantifoldDiagnostic({
+            code: "TOOL_NOT_FOUND",
+            command,
+            language: id,
+            message: `Canonical command '${command}' was not found as an executable on PATH.`
+        });
+    }
+    if (matches.size > 1) {
+        throw new SemantifoldDiagnostic({
+            code: "TOOL_AMBIGUOUS",
+            command,
+            language: id,
+            message: `Canonical command '${command}' resolves to multiple executables: ${[...matches.keys()].join(", ")}.`
+        });
+    }
+    return { executable: /** @type {string} */ ([...matches.keys()][0]), source: /** @type {const} */ ("canonical") };
+}
+/**
+ * Resolves one configured absolute executable.
+ * @param {string} id - Toolchain ID.
+ * @param {string} override - Absolute override.
+ * @param {string} command - Canonical command.
+ * @returns {Promise<string>} Exact executable path.
+ */
+async function resolveOverride(id, override, command) {
+    /** @type {Error | undefined} */
+    let cause;
+    try {
+        const exact = await resolveExecutableFile(override);
+        if (exact != undefined)
+            return exact;
+    }
+    catch (error) {
+        cause = error instanceof Error ? error : undefined;
+    }
+    throw new SemantifoldDiagnostic({
+        cause,
+        code: "TOOL_NOT_FOUND",
+        command,
+        executable: override,
+        language: id,
+        message: `Configured executable '${override}' is missing or not executable.`
+    });
+}
+/**
+ * Resolves one candidate to an executable regular file.
+ * @param {string} candidate - Candidate path.
+ * @returns {Promise<string | undefined>} Exact regular executable, if the file type is valid.
+ */
+async function resolveExecutableFile(candidate) {
+    const exact = await realpath(candidate);
+    const status = await stat(exact);
+    if (!status.isFile())
+        return undefined;
+    await access(exact, fsConstants.X_OK);
+    return exact;
+}
+/**
+ * Produces the minimal deterministic process environment.
+ * @param {Readonly<Record<string, string | undefined>>} environment - Explicit inputs.
+ * @returns {Readonly<Record<string, string>>} Normalized environment.
+ */
+export function deterministicEnvironment(environment = defaultEnvironment()) {
+    const entries = environmentEntries(environment);
+    if (entries == undefined)
+        invalidToolchain("Process environment must be a plain own-property data record of string or undefined values.", "environment");
+    /** @type {Record<string, string>} */
+    const normalized = Object.create(null);
+    for (const [key, value] of entries) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key) || key.includes("\0") || (value !== undefined && value.includes("\0"))) {
+            invalidToolchain("Process environment contains an invalid key or value.", "environment");
+        }
+        if (value !== undefined)
+            normalized[key] = value;
+    }
+    normalized.LANG = "C.UTF-8";
+    normalized.LC_ALL = "C.UTF-8";
+    normalized.TZ = "UTC";
+    normalized.PATH ??= "/usr/local/bin:/usr/bin:/bin";
+    return Object.freeze(normalized);
+}
+/**
+ * Retains only executable lookup from the ambient environment.
+ * @returns {Readonly<Record<string, string | undefined>>} Minimal default environment.
+ */
+function defaultEnvironment() {
+    return { PATH: process.env.PATH };
+}
+/**
+ * Narrows stable fields from a version subprocess rejection.
+ * @param {unknown} error - Process rejection.
+ * @returns {{exitCode: number | undefined, signal: string | undefined, stderr: string, stdout: string}} Stable fields.
+ */
+function processErrorFields(error) {
+    if (!error || typeof error != "object")
+        return { exitCode: undefined, signal: undefined, stderr: "", stdout: "" };
+    const value = /** @type {Record<string, unknown>} */ (error);
+    return {
+        exitCode: typeof value.code == "number" ? value.code : undefined,
+        signal: typeof value.signal == "string" ? value.signal : undefined,
+        stderr: typeof value.stderr == "string" ? value.stderr : "",
+        stdout: typeof value.stdout == "string" ? value.stdout : ""
+    };
+}
+/**
+ * Checks one shell-free argument.
+ * @param {unknown} value - Candidate argument.
+ * @returns {value is string} Whether the argument is safe to pass directly.
+ */
+function validArgument(value) {
+    return typeof value == "string" && !value.includes("\0");
+}
+/**
+ * Checks explicit process-environment values.
+ * @param {unknown} value - Candidate environment.
+ * @returns {value is Readonly<Record<string, string | undefined>>} Whether entries are strings or undefined.
+ */
+function isEnvironment(value) {
+    return environmentEntries(value) != undefined;
+}
+/**
+ * Detaches an explicit environment before canonical override lookup can yield.
+ * @param {unknown} value - Candidate environment record.
+ * @param {string} id - Toolchain identity.
+ * @returns {Readonly<Record<string, string | undefined>>} Owned environment data.
+ */
+function snapshotEnvironment(value, id) {
+    const entries = environmentEntries(value);
+    if (entries == undefined) {
+        invalidToolchain("Canonical toolchain environment must be a plain own-property data record of string or undefined values.", id);
+    }
+    /** @type {Record<string, string | undefined>} */
+    const snapshot = Object.create(null);
+    for (const [key, entry] of entries)
+        snapshot[key] = entry;
+    return Object.freeze(snapshot);
+}
+/**
+ * Reads only enumerable own data properties from an ordinary or null-prototype record.
+ * @param {unknown} value - Candidate environment record.
+ * @returns {[string, string | undefined][] | undefined} Detached entries when valid.
+ */
+function environmentEntries(value) {
+    if (typeof value != "object" || value == null || Array.isArray(value))
+        return undefined;
+    try {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            return undefined;
+        /** @type {[string, string | undefined][]} */
+        const entries = [];
+        for (const key of Reflect.ownKeys(value)) {
+            if (typeof key != "string")
+                return undefined;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (descriptor == undefined || !descriptor.enumerable || !("value" in descriptor) ||
+                (descriptor.value !== undefined && typeof descriptor.value != "string"))
+                return undefined;
+            entries.push([key, descriptor.value]);
+        }
+        return entries;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Checks for an ordinary string-keyed object.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain object.
+ */
+function isPlainObject(value) {
+    return typeof value == "object" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+/**
+ * Throws a normalized discovery-configuration diagnostic.
+ * @param {string} message - Failure detail.
+ * @param {string} id - Toolchain identity.
+ * @returns {never} Always throws.
+ */
+function invalidToolchain(message, id) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_TOOLCHAIN", language: id, message });
+}
+/**
+ * Deeply freezes canonical declarations and discovery results.
+ * @template T
+ * @param {T} value - Toolchain-owned value.
+ * @returns {T} Frozen value.
+ */
+function deepFreeze(value) {
+    if (!value || typeof value != "object" || Object.isFrozen(value))
+        return value;
+    for (const nested of Object.values(value))
+        deepFreeze(nested);
+    return Object.freeze(value);
+}
+//# 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})\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,11 +2,15 @@
 
 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, and Lezer owns Java. 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.
+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.
 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`.
 
-`index.js` is the public boundary. `parse({language, filename, source})` dispatches to an adapter. `generate({language, module})` validates and returns the compatibility source string. `generateArtifact(...)` uses the same emission path and returns code plus rich and v3 mappings. `src/mapping.js` owns validated lookup, deterministic serialization, mapping import/composition, and diagnostic remapping.
+`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.
+
+`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.
 
 ## Round trips
 
@@ -34,6 +38,6 @@ 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, and Lezer syntax nodes provide exact function, parameter, local, type, assignment, literal, call, and operator ranges. 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 Ruby byte offsets 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 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.
 
 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).

package/docs/language-support.md

@@ -1,5 +1,20 @@
 # Language support
 
+## Registered roles
+
+The immutable registry is authoritative for both dispatch and discovery:
+
+| ID | Frontend | Text backend | Binary backend | Application backend | Interoperability | Artifacts | Round trip | Mapping | Acceptance |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| `php` | yes | yes | no | no | no | single | yes | rich + v3 | parse, generate, execute (`php`) |
+| `ruby` | yes | yes | no | no | no | single | yes | rich + v3 | parse, generate, execute (`ruby`) |
+| `javascript` | yes | yes | no | no | no | single | yes | rich + v3 | parse, generate, execute (`node`) |
+| `typescript` | yes | yes | no | no | no | single | yes | rich + v3 | parse, generate, compile, execute (`tsc`, `node`) |
+| `java` | yes | yes | no | no | no | single | yes | rich + v3 | parse, generate, compile, execute (`javac`, `java`) |
+| `python` | yes | yes | no | no | no | single | yes | rich + v3 | parse, generate, compile, execute (`python3`) |
+
+`languageCapabilities` exposes this information as frozen data. A role is not inferred from the presence of another role: a future browser binary target need not have a frontend, and a future interoperability bridge need not be a general backend. `supportedLanguages` is the derived list of all six records with both frontend and text generation.
+
 ## Implemented subset
 
 | Language | Exact frontend scalar types | Generated entry point |
@@ -9,6 +24,7 @@
 | JavaScript | JSDoc `number`, `boolean`, and `string` on synchronous, non-generator functions and locals | `console.log(…)` |
 | TypeScript | exact `number`, `boolean`, and `string` keyword annotations on synchronous, non-generator functions and locals | `console.log(…)` |
 | Java | primitive `int`/`boolean` and exact `String` or `java.lang.String` declarations, plus a sequenced `public static void main` | `System.out.println(…)` in `Main` |
+| Python | exact `int`/`bool`/`str` annotations on every parameter, return, and initialized local | direct top-level `print(…)` in `program.py` |
 
 Across every language, a module contains at least one function with exactly two required parameters and a scalar return. Function bodies, entry points, and conditional branches are ordered lexical blocks. They may contain supported local declarations, plain assignments, nested conditionals, explicit returns, and prints in source order. Conditions require semantic `boolean`. An alternate is optional, and source `else if`/`elsif`/`elseif` normalizes to one nested conditional inside the alternate block. Non-void functions must explicitly return on every reachable path; an optional alternate is therefore accepted only when a later statement completes the fallthrough path. A statement following an unconditional return or an exhaustive returning conditional in the same block is unreachable and rejected. Entry points cannot return values.
 
@@ -18,6 +34,7 @@ Frontend conditional forms remain deliberately bounded:
 - PHP accepts braced `if`/`elseif`/`else`; alternative colon syntax, `switch`, `match`, inline HTML, and truthy conditions are rejected.
 - Ruby accepts ordinary `if`/`elsif`/`else` with explicit `return`; modifier conditionals, `unless`, `case`, implicit method returns, and truthy conditions are rejected.
 - Java requires braced ordinary branches while accepting a direct `else if`; switch forms, labels, assertions, synchronized blocks, local classes, and recovered grammar nodes are rejected.
+- Python accepts ordinary indented `if`/`elif`/`else`, with `pass` only as the source/backend representation of an otherwise empty semantic block. Truthiness, match, loops, exceptions, context managers, async/generators, nested declarations, and recovered grammar nodes are rejected.
 
 Every local is an explicitly typed simple identifier with an initializer. Parameters are immutable. Initializers are checked before their new binding becomes visible; assignment right-hand expressions are checked before the target update. Exact scalar types are preserved. Lexical function, branch, and entry scopes reject duplicate declarations, use before declaration, unresolved reads/writes, assignment to immutable bindings, type mismatch, and all shadowing or repeated local spellings in this initial capability. Module function names participate in the same no-shadowing contract, so no parameter or local may capture a callable name. Destructuring, multiple/uninitialized declarations, inferred types, arbitrary lvalues, compound/update assignment, globals/fields/constants, and parameter reassignment are unsupported.
 
@@ -37,6 +54,8 @@ Local source profiles are exact:
 $name = "value";
 ```
 
+- Python requires `name: int|bool|str = expression`. Locals default to mutable; an immutable declaration has the exact immediately preceding, equally indented `# @semantifold-immutable` carrier.
+
 The Ruby/PHP tags are Semantifold source-profile metadata, not native runtime immutability. Their adapters validate the exact tag shape, semantic validation rejects later writes, and generators reproduce the metadata so mutability round-trips.
 
 Expressions contain parameter/local identifiers, scalar literals, two-argument unqualified calls, and the following typed operations. Every operation node records its result type, and identifier/call operands are resolved before an operation is selected.
@@ -50,20 +69,22 @@ Expressions contain parameter/local identifiers, scalar literals, two-argument u
 | Integer ordering | `<`, `<=`, `>`, `>=` | `<`, `<=`, `>`, `>=` | `<`, `<=`, `>`, `>=` | `<`, `<=`, `>`, `>=` |
 | String concatenation | `+` | `+` | `.` | `+` |
 
+Python uses `+`, `-`, `*`, unary `-`, `not`, `and`, `or`, `==`, `!=`, and integer ordering with explicit generated parentheses. The same-type semantic checker distinguishes Boolean from integer even though CPython makes `bool` a runtime subclass of `int`.
+
 Operands evaluate left to right, and Boolean and/or short-circuit. Conditions require semantic `boolean`; Ruby, PHP, and JavaScript truthiness is not normalized. Equality is scalar value equality only, requires matching operand types, and never coerces. Java reference `==`/`!=` on strings is rejected; generated Java uses `.equals`. Return values, call arguments, initializers, assignments, and explicit operation result types must exactly match their declared scalar types. Generated operations are parenthesized so reparsing preserves the expression tree rather than relying on coincident target precedence.
 
 Integer literals are restricted to JavaScript's safe integer range, `Number.MIN_SAFE_INTEGER` through `Number.MAX_SAFE_INTEGER`, and semantic integers have one unsigned mathematical zero. JavaScript and TypeScript can form IEEE-754 `-0` through negation or multiplication, so generated modules containing either operation stringify their scalar print argument to render both zero signs as `0`; the parser recognizes and removes only this exact entry-point scaffold during reparse. Supported operations cannot otherwise observe a zero sign, and the semantic expression tree is neither rewritten nor folded. Java generation additionally requires primitive-`int` literals and rejects compile-time-known add/subtract/multiply/negate results outside `-2147483648` through `2147483647`. This validation uses exact arithmetic without replacing the semantic expression tree. Runtime arithmetic overflow for non-literal expressions is not a portable guarantee.
 
 String literals normalize to their parser-decoded Unicode scalar value. Original quotes and escapes are not retained. PHP and Ruby interpolation, JavaScript/TypeScript template substitution, Java text blocks, PHP heredoc/nowdoc, invalid source encodings, and lone surrogate values are rejected. Backends use target-specific escaping for quotes, backslashes, controls, Unicode, and interpolation introducers. Generated source reparses to the same value.
 
-Ruby accepts exactly two required positional parameters. Optional, rest, post, keyword, keyword-rest, and block parameters remain unsupported. Its three annotation comments must form the contiguous block immediately before their function. PHP rejects every `declare` form other than one optional exact `declare(strict_types=1)`. Java calls remain unqualified and `main` may not contain ignored statements.
+Ruby accepts exactly two required positional parameters. Optional, rest, post, keyword, keyword-rest, and block parameters remain unsupported. Its three annotation comments must form the contiguous block immediately before their function. PHP rejects every `declare` form other than one optional exact `declare(strict_types=1)`. Python rejects default, positional-only, keyword-only, variadic, keyword, and starred parameters/calls, quoted or compound annotations, bytes/f-strings/raw/triple/implicitly concatenated strings, decorators, imports, classes, comprehensions, lambdas, attributes, subscripts, and every other dynamic form. Java calls remain unqualified and `main` may not contain ignored statements.
 
-Backends retain narrow ASCII identifier rules and reject target reserved words for function names, parameter names, local declarations, assignment targets, call targets, and identifier references before emission. Bindings are never renamed. TypeScript rejects `arguments` and `eval` for function, parameter, local-declaration, and assignment-target bindings because generated modules are strict mode. PHP rejects exact `GLOBALS`, `_SERVER`, `_GET`, `_POST`, `_FILES`, `_COOKIE`, `_SESSION`, `_REQUEST`, `_ENV`, and `this` parameter bindings; only exact `GLOBALS` and `this` are also rejected for local declarations and assignment targets. PHP function/call names, lowercase near-collisions, assignable non-`GLOBALS` superglobals, and ordinary predefined variables retain their legal roles. Ruby rejects exact `_1` through `_9` function, parameter, local-declaration, and assignment-target bindings while retaining `_10`; references and callees keep their general target identifier policy. JavaScript and other targets retain their own identifier policies. Names owned by generated scaffolding are role-specific: entry locals cannot be `console` in JavaScript/TypeScript or `args`/`System` in Java; function parameters and locals cannot be the generated print receiver `console` in JavaScript/TypeScript or `System` in Java; and module functions cannot be `console` in JavaScript/TypeScript or `puts` in Ruby. Ruby locals named `puts` and PHP locals named `PHP_EOL` remain valid because the generated print forms do not resolve them as local bindings. Java method names and PHP function names occupy namespaces that do not capture their entry scaffolding. PHP boolean printing differs from the other targets; the cross-language execution contract therefore compares a string result rather than claiming portable boolean display formatting.
+Backends reject target reserved words for function names, parameter names, local declarations, assignment targets, call targets, and identifier references before emission. Bindings are never renamed. Python accepts Unicode XID spelling but rejects hard/soft keywords and the annotation/entry capture hazards `_`, `match`, `case`, `type`, `int`, `bool`, `str`, and `print`. TypeScript rejects `arguments` and `eval` for function, parameter, local-declaration, and assignment-target bindings because generated modules are strict mode. PHP rejects exact `GLOBALS`, `_SERVER`, `_GET`, `_POST`, `_FILES`, `_COOKIE`, `_SESSION`, `_REQUEST`, `_ENV`, and `this` parameter bindings; only exact `GLOBALS` and `this` are also rejected for local declarations and assignment targets. PHP function/call names, lowercase near-collisions, assignable non-`GLOBALS` superglobals, and ordinary predefined variables retain their legal roles. Ruby rejects exact `_1` through `_9` function, parameter, local-declaration, and assignment-target bindings while retaining `_10`; references and callees keep their general target identifier policy. JavaScript and other targets retain their own identifier policies. Names owned by generated scaffolding are role-specific: entry locals cannot be `console` in JavaScript/TypeScript or `args`/`System` in Java; function parameters and locals cannot be the generated print receiver `console` in JavaScript/TypeScript or `System` in Java; and module functions cannot be `console` in JavaScript/TypeScript or `puts` in Ruby. Ruby locals named `puts` and PHP locals named `PHP_EOL` remain valid because the generated print forms do not resolve them as local bindings. Java method names and PHP function names occupy namespaces that do not capture their entry scaffolding. PHP boolean printing differs from the other targets; the cross-language execution contract therefore compares a string result rather than claiming portable boolean display formatting.
 
 ## Diagnostics and limitations
 
-All five frontends preserve exact input content and parser-backed semantic token ranges in module provenance. All 25 input-to-output combinations produce range-based rich maps and Source Map v3 sidecars with UTF-16 coordinates and symbol names. Output code uses LF deterministically. Only JavaScript and TypeScript may opt into inline or external `sourceMappingURL` directives; other targets consume sidecars through Semantifold APIs. Mapping does not imply lossless formatting or support for syntax outside the semantic subset. See [source provenance and mappings](source-maps.md).
+All six frontends preserve exact input content and parser-backed semantic token ranges in module provenance. All 36 input-to-output combinations produce range-based rich maps and Source Map v3 sidecars with UTF-16 coordinates and symbol names. Output code uses LF deterministically. Only JavaScript and TypeScript may opt into inline or external `sourceMappingURL` directives; other targets consume sidecars through Semantifold APIs. Mapping does not imply lossless formatting or support for syntax outside the semantic subset. See [source provenance and mappings](source-maps.md).
 
-`UNSUPPORTED_SYNTAX` reports parsed constructs outside the subset with the best parser-provided source location. `MISSING_TYPE` reports missing or unsupported atomic annotations and identifies integer, boolean, and string as the supported scalar set. Parser failures use `PARSE_ERROR`. Semantic resolution/type failures use `DUPLICATE_BINDING`, `UNRESOLVED_BINDING`, `USE_BEFORE_DECLARATION`, `IMMUTABLE_ASSIGNMENT`, and `TYPE_MISMATCH`; flow failures use `NON_BOOLEAN_CONDITION`, `MISSING_RETURN`, `UNREACHABLE_STATEMENT`, `ILLEGAL_RETURN_CONTEXT`, and `UNSUPPORTED_STATEMENT`. Backends validate complete recursive block shape, flow, scalar payloads, binding/type agreement, mutability, identifiers, target bounds, and Java's fixed `Main.java` artifact basename before emission. Missing or structurally invalid blocks, statement arrays/elements, declaration names, mutability, type references, initializers, assignment targets/names, assigned expressions, conditional branches, and call-expression fields in caller-supplied IR use their nearest owning node location and report `UNSUPPORTED_CAPABILITY` rather than leaking a native error or producing partial source. A non-`Main.java` Java basename uses the same located capability diagnostic contract.
+`UNSUPPORTED_LANGUAGE` is exclusive to unknown or misspelled IDs. `UNSUPPORTED_ROLE` reports a known ID without the requested frontend, text/binary/application backend, artifact, or interoperability role. `UNSUPPORTED_CAPABILITY` reports a role that exists but cannot represent the requested semantic module or target feature. `UNSUPPORTED_SYNTAX` reports parsed constructs outside the subset with the best parser-provided source location. Python uses `MISSING_TYPE` only when a parameter, return, or first-local annotation is absent; a present annotation other than exact `int`, `bool`, or `str` is `UNSUPPORTED_SYNTAX` at that annotation. Parser failures use `PARSE_ERROR`. Semantic resolution/type failures use `DUPLICATE_BINDING`, `UNRESOLVED_BINDING`, `USE_BEFORE_DECLARATION`, `IMMUTABLE_ASSIGNMENT`, and `TYPE_MISMATCH`; flow failures use `NON_BOOLEAN_CONDITION`, `MISSING_RETURN`, `UNREACHABLE_STATEMENT`, `ILLEGAL_RETURN_CONTEXT`, and `UNSUPPORTED_STATEMENT`. Backends validate complete recursive block shape, flow, scalar payloads, binding/type agreement, mutability, identifiers, target bounds, and Java's fixed `Main.java` artifact basename before emission. Missing or structurally invalid blocks, statement arrays/elements, declaration names, mutability, type references, initializers, assignment targets/names, assigned expressions, conditional branches, and call-expression fields in caller-supplied IR use their nearest owning node location and report `UNSUPPORTED_CAPABILITY` rather than leaking a native error or producing partial source. A non-`Main.java` Java basename uses the same located capability diagnostic contract. Artifact-set generation requires a non-empty string language/target ID and accepts only the explicit `text`, `binary`, and `application` backend-role strings; malformed IDs or roles report `INVALID_ARTIFACT_SET` without coercing caller input, while an unknown string ID reports `UNSUPPORTED_LANGUAGE` and a valid role absent from a known registry record reports `UNSUPPORTED_ROLE`. Optional registry roles and backend metadata may be omitted with `undefined`; present malformed values, including `null`, report `INVALID_REGISTRY`. Invalid registry, artifact-set, byte-map, discovery, and runner inputs have their own normalized diagnostics rather than leaking native type or subprocess errors.
 
 Boxed or coercive types, inferred public types, TypeScript literal/enum/`any`/`unknown`/union types, PHP aliases/nullable declarations, Ruby `boolish`, Java `Boolean`/`char`, null values, floating point, decimal, bigint, symbols, regex values, byte strings, and interpolation are unsupported. Division, remainder, exponentiation, bitwise/shift/update/compound operations, Ruby/PHP `and`/`or`, loose equality, ternary/nullish forms, optional/safe navigation, ranges, casts/assertions, collection/object equality, operator overloading, implicit coercion, and constant folding are also excluded. There is no truthiness, implicit-return or statement-value model, void call statement (roadmap task 005), optional-value model, async/generator model, qualified calls other than Java string `.equals`, classes in the semantic representation, imports, loops, switches, exceptions, overloads, generics, packages, or source-format preservation. Ruby type comments remain a bounded RBS-style convention rather than a full signature parser, and Java generation retains the fixed `Main.java` contract.