semantifold 0.1.1 → 0.3.0

package/build/src/acceptance.js

@@ -0,0 +1,358 @@
+// @ts-check
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { isDenseArray } from "./array.js";
+import { createGeneratedArtifactSet } from "./artifacts.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { exceededOwnedDeadline, executeFileWithDeadline } from "./subprocess.js";
+import { isSupportedTimeoutMs, maximumTimeoutMs } from "./timeout.js";
+import { deterministicEnvironment } from "./toolchains.js";
+const acceptanceMaxBuffer = 16 * 1024 * 1024;
+const launchErrorCodes = new Set([
+    "E2BIG", "EACCES", "EAGAIN", "ELOOP", "EMFILE", "ENAMETOOLONG", "ENFILE", "ENOENT", "ENOEXEC", "ENOMEM", "ENOTDIR", "ENOTSUP", "EPERM", "ETXTBSY"
+]);
+const orderedStages = Object.freeze(["parse", "generate", "restore", "compile", "link", "validate", "instantiate", "execute"]);
+const stageIndexes = new Map(orderedStages.map((stage, index) => [stage, index]));
+/**
+ * Materializes one artifact set and runs ordered acceptance stages without a shell.
+ * @param {object} input - Acceptance request.
+ * @param {import("./semantic/types.js").GeneratedArtifactSet} input.artifacts - Complete input artifacts.
+ * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Explicit process environment.
+ * @param {{arguments: string[], stage: import("./semantic/types.js").AcceptanceStage, tool: import("./semantic/types.js").DiscoveredToolchain}[]} input.stages - Ordered stages.
+ * @param {string} input.target - Target identity.
+ * @param {number} [input.timeoutMs] - Per-stage timeout.
+ * @returns {Promise<import("./semantic/types.js").AcceptanceResult>} Captured results after cleanup.
+ */
+export async function runAcceptanceStages(input) {
+    return await runAcceptanceStagesWithDependencies(input, rm);
+}
+/**
+ * Creates an acceptance runner with instance-owned cleanup behavior.
+ * @param {object} dependencies - Internal runner dependencies.
+ * @param {typeof rm} dependencies.removeDirectory - Isolated-directory removal operation.
+ * @returns {typeof runAcceptanceStages} Acceptance runner.
+ */
+export function createAcceptanceRunner({ removeDirectory }) {
+    return async (input) => await runAcceptanceStagesWithDependencies(input, removeDirectory);
+}
+/**
+ * Runs acceptance with exact instance-owned dependencies.
+ * @param {Parameters<typeof runAcceptanceStages>[0]} input - Acceptance request.
+ * @param {typeof rm} removeDirectory - Isolated-directory removal operation.
+ * @returns {ReturnType<typeof runAcceptanceStages>} Captured results after cleanup.
+ */
+async function runAcceptanceStagesWithDependencies(input, removeDirectory) {
+    if (!isPlainObject(input))
+        invalidRunner("Acceptance requires a request object.", "acceptance");
+    const artifacts = /** @type {import("./semantic/types.js").GeneratedArtifactSet} */ (input.artifacts);
+    const environment = /** @type {Readonly<Record<string, string | undefined>>} */ (input.environment === undefined ? { PATH: process.env.PATH } : input.environment);
+    const stages = /** @type {{arguments: string[], stage: import("./semantic/types.js").AcceptanceStage, tool: import("./semantic/types.js").DiscoveredToolchain}[]} */ (input.stages);
+    const target = /** @type {string} */ (input.target);
+    const timeoutMs = /** @type {number} */ (input.timeoutMs === undefined ? 10_000 : input.timeoutMs);
+    const request = validateRequest({ artifacts, environment, stages, target, timeoutMs });
+    const directory = await createAcceptanceDirectory(request.target);
+    /** @type {unknown} */
+    let primaryFailure;
+    /** @type {import("./semantic/types.js").AcceptanceResult | undefined} */
+    let result;
+    let primaryFailed = false;
+    try {
+        await materializeArtifacts(request.artifacts, directory, request.target);
+        /** @type {import("./semantic/types.js").AcceptanceStageResult[]} */
+        const results = [];
+        for (const stage of request.stages) {
+            try {
+                const result = await executeFileWithDeadline({
+                    arguments: stage.arguments,
+                    cwd: directory,
+                    environment: request.environment,
+                    executable: stage.tool.executable,
+                    maxBuffer: acceptanceMaxBuffer,
+                    timeoutMs: request.timeoutMs
+                });
+                results.push(Object.freeze({
+                    arguments: Object.freeze([...stage.arguments]),
+                    executable: stage.tool.executable,
+                    stage: stage.stage,
+                    stderr: result.stderr,
+                    stdout: result.stdout,
+                    version: stage.tool.version
+                }));
+            }
+            catch (error) {
+                throw processDiagnostic(error, stage, request.target, request.timeoutMs);
+            }
+        }
+        result = Object.freeze({ directory, stages: Object.freeze(results), target: request.target });
+    }
+    catch (error) {
+        primaryFailed = true;
+        primaryFailure = error;
+    }
+    /** @type {unknown} */
+    let cleanupFailure;
+    let cleanupFailed = false;
+    try {
+        await removeAcceptanceDirectory(directory, request.target, removeDirectory);
+    }
+    catch (error) {
+        cleanupFailed = true;
+        cleanupFailure = error;
+    }
+    if (primaryFailed && cleanupFailed && primaryFailure instanceof Error) {
+        throw preservePrimaryFailure(primaryFailure, cleanupFailure, request.target);
+    }
+    if (primaryFailed)
+        throw primaryFailure;
+    if (cleanupFailed)
+        throw cleanupFailure;
+    return /** @type {import("./semantic/types.js").AcceptanceResult} */ (result);
+}
+/**
+ * Validates and detaches a staged acceptance request before filesystem mutation.
+ * @param {{
+ *   artifacts: import("./semantic/types.js").GeneratedArtifactSet,
+ *   environment: Readonly<Record<string, string | undefined>>,
+ *   stages: {arguments: string[], stage: import("./semantic/types.js").AcceptanceStage, tool: import("./semantic/types.js").DiscoveredToolchain}[],
+ *   target: string,
+ *   timeoutMs: number
+ * }} input - Candidate request.
+ * @returns {{
+ *   artifacts: import("./semantic/types.js").GeneratedArtifactSet,
+ *   environment: Readonly<Record<string, string>>,
+ *   stages: {arguments: string[], stage: import("./semantic/types.js").AcceptanceStage, tool: Readonly<{executable: string, version: string}>}[],
+ *   target: string,
+ *   timeoutMs: number
+ * }} Validated request.
+ */
+function validateRequest(input) {
+    try {
+        if (typeof input.target != "string" || input.target.length == 0 || !isSupportedTimeoutMs(input.timeoutMs) ||
+            !isDenseArray(input.stages) || input.stages.length == 0) {
+            invalidRunner(`Acceptance requires a target, timeout from 1 through ${maximumTimeoutMs}ms, and non-empty ordered stages.`, input.target);
+        }
+        const artifacts = createGeneratedArtifactSet(input.artifacts);
+        if (artifacts.target != input.target)
+            invalidRunner("Acceptance target must match the generated artifact-set target.", input.target);
+        const environment = deterministicEnvironment(input.environment);
+        let previousIndex = -1;
+        const seen = new Set();
+        /** @type {{arguments: string[], stage: import("./semantic/types.js").AcceptanceStage, tool: Readonly<{executable: string, version: string}>}[]} */
+        const stages = [];
+        for (let stagePosition = 0; stagePosition < input.stages.length; stagePosition += 1) {
+            const stage = input.stages[stagePosition];
+            if (!isPlainObject(stage))
+                invalidRunner("Acceptance stages must be distinct known stage records.", input.target);
+            const stageName = stage.stage;
+            if (typeof stageName != "string" || !stageIndexes.has(stageName) || seen.has(stageName)) {
+                invalidRunner("Acceptance stages must be distinct known stage records.", input.target);
+            }
+            const index = /** @type {number} */ (stageIndexes.get(stageName));
+            if (index < previousIndex)
+                invalidRunner("Acceptance stages must follow parse-to-execute order.", input.target);
+            previousIndex = index;
+            seen.add(stageName);
+            const argumentCandidate = stage.arguments;
+            const stageArguments = isDenseArray(argumentCandidate) ? [...argumentCandidate] : undefined;
+            const toolCandidate = stage.tool;
+            const tool = isPlainObject(toolCandidate) ? Object.freeze({
+                executable: toolCandidate.executable,
+                id: toolCandidate.id,
+                source: toolCandidate.source,
+                version: toolCandidate.version
+            }) : undefined;
+            if (stageArguments == undefined || !stageArguments.every((argument) => typeof argument == "string" && !argument.includes("\0")) ||
+                !isTool(tool))
+                invalidRunner(`Acceptance stage '${stageName}' has an invalid tool or argument array.`, input.target);
+            stages.push(Object.freeze({ arguments: stageArguments, stage: stageName, tool }));
+        }
+        return { artifacts, environment, stages, target: input.target, timeoutMs: input.timeoutMs };
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic && error.code == "INVALID_ACCEPTANCE_RUNNER")
+            throw error;
+        if (error instanceof SemantifoldDiagnostic) {
+            throw new SemantifoldDiagnostic({
+                cause: error,
+                code: "INVALID_ACCEPTANCE_RUNNER",
+                language: typeof input.target == "string" ? input.target : "acceptance",
+                message: `Acceptance runner input is invalid: ${error.detail}`
+            });
+        }
+        return invalidRunner("Acceptance runner input is invalid.", typeof input.target == "string" ? input.target : "acceptance", error);
+    }
+}
+/**
+ * Normalizes a subprocess failure with exact stage and toolchain context.
+ * @param {unknown} error - Subprocess rejection.
+ * @param {{arguments: string[], stage: string, tool: Readonly<{executable: string, version: string}>}} stage - Failed stage.
+ * @param {string} target - Acceptance target.
+ * @param {number} timeoutMs - Configured stage timeout.
+ * @returns {SemantifoldDiagnostic} Normalized failure.
+ */
+function processDiagnostic(error, stage, target, timeoutMs) {
+    const fields = processErrorFields(error);
+    const outputLimited = fields.nativeCode == "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+    const timedOut = !outputLimited && exceededOwnedDeadline(error);
+    const launchFailure = fields.nativeCode != undefined && launchErrorCodes.has(fields.nativeCode);
+    const signaled = !outputLimited && !timedOut && fields.signal != undefined;
+    const code = outputLimited ? "ACCEPTANCE_OUTPUT_LIMIT" : timedOut ? "ACCEPTANCE_TIMEOUT" : launchFailure ? "ACCEPTANCE_LAUNCH_FAILURE" : signaled
+        ? "ACCEPTANCE_SIGNAL"
+        : "ACCEPTANCE_NONZERO_EXIT";
+    const reason = outputLimited ? `exceeded the ${acceptanceMaxBuffer}-byte output capture limit (${fields.nativeCode})` : timedOut
+        ? `timed out after ${timeoutMs}ms` : launchFailure
+        ? `could not launch (${fields.nativeCode})`
+        : signaled ? `terminated by signal ${fields.signal}`
+            : fields.exitCode != undefined ? `exited nonzero (${fields.exitCode})`
+                : `failed after launch (${fields.nativeCode ?? "unknown"})`;
+    return new SemantifoldDiagnostic({
+        cause: outputLimited ? undefined : error instanceof Error ? error : undefined,
+        code,
+        executable: stage.tool.executable,
+        exitCode: fields.exitCode,
+        language: target,
+        message: `Acceptance stage '${stage.stage}' ${reason} using '${stage.tool.executable}' (${stage.tool.version}).`,
+        signal: fields.signal,
+        stage: stage.stage,
+        stderr: fields.stderr,
+        stdout: fields.stdout,
+        version: stage.tool.version
+    });
+}
+/**
+ * Narrows the stable fields of an opaque child-process failure.
+ * @param {unknown} error - Process rejection.
+ * @returns {{exitCode: number | undefined, nativeCode: string | undefined, signal: string | undefined, stderr: string, stdout: string}} Stable fields.
+ */
+function processErrorFields(error) {
+    if (!error || typeof error != "object")
+        return { exitCode: undefined, nativeCode: undefined, signal: undefined, stderr: "", stdout: "" };
+    const value = /** @type {Record<string, unknown>} */ (error);
+    const nativeCode = typeof value.code == "string" ? value.code : undefined;
+    const outputLimited = nativeCode == "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+    return {
+        exitCode: typeof value.code == "number" ? value.code : undefined,
+        nativeCode,
+        signal: typeof value.signal == "string" ? value.signal : undefined,
+        stderr: !outputLimited && typeof value.stderr == "string" ? value.stderr : "",
+        stdout: !outputLimited && typeof value.stdout == "string" ? value.stdout : ""
+    };
+}
+/**
+ * Checks the discovered-tool fields consumed by the runner.
+ * @param {unknown} value - Candidate tool.
+ * @returns {value is import("./semantic/types.js").DiscoveredToolchain} Whether the tool contract is present.
+ */
+function isTool(value) {
+    return isPlainObject(value) && typeof value.id == "string" && typeof value.executable == "string" && path.isAbsolute(value.executable) &&
+        !value.executable.includes("\0") && typeof value.version == "string" && value.version.length > 0 &&
+        (value.source == "canonical" || value.source == "override");
+}
+/**
+ * Keeps the primary acceptance error while recording bounded cleanup evidence in its cause chain.
+ * @param {Error} primaryFailure - Original materialization or stage failure.
+ * @param {unknown} cleanupFailure - Cleanup rejection.
+ * @param {string} target - Acceptance target.
+ * @returns {Error} The original primary error with structured cleanup evidence.
+ */
+function preservePrimaryFailure(primaryFailure, cleanupFailure, target) {
+    const cleanupEvidence = new SemantifoldDiagnostic({
+        code: "ACCEPTANCE_CLEANUP_FAILURE",
+        language: cleanupFailure instanceof SemantifoldDiagnostic ? cleanupFailure.language : target,
+        message: "Isolated acceptance-directory cleanup failed after the primary acceptance failure."
+    });
+    const causes = primaryFailure.cause instanceof Error ? [primaryFailure.cause, cleanupEvidence] : [cleanupEvidence];
+    Object.defineProperty(primaryFailure, "cause", {
+        configurable: true,
+        value: new AggregateError(causes, "Acceptance failed and isolated-directory cleanup also failed."),
+        writable: true
+    });
+    return primaryFailure;
+}
+/**
+ * Throws a normalized runner-configuration diagnostic.
+ * @param {string} message - Failure detail.
+ * @param {unknown} target - Candidate target identity.
+ * @param {unknown} [error] - Preserved cause.
+ * @returns {never} Always throws.
+ */
+function invalidRunner(message, target, error) {
+    throw new SemantifoldDiagnostic({
+        cause: error instanceof Error ? error : undefined,
+        code: "INVALID_ACCEPTANCE_RUNNER",
+        language: typeof target == "string" && target.length > 0 ? target : "acceptance",
+        message
+    });
+}
+/**
+ * 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;
+}
+/**
+ * Removes the isolated acceptance directory with a normalized failure.
+ * @param {string} directory - Exact temporary directory.
+ * @param {string} target - Acceptance target.
+ * @param {typeof rm} removeDirectory - Instance-owned removal operation.
+ * @returns {Promise<void>} Cleanup completion.
+ */
+async function removeAcceptanceDirectory(directory, target, removeDirectory) {
+    try {
+        await removeDirectory(directory, { force: true, recursive: true });
+    }
+    catch (error) {
+        throw new SemantifoldDiagnostic({
+            cause: error instanceof Error ? error : undefined,
+            code: "ACCEPTANCE_CLEANUP_FAILURE",
+            language: target,
+            message: `Failed to remove isolated acceptance directory '${directory}'.`
+        });
+    }
+}
+/**
+ * Creates one isolated acceptance directory with a normalized setup failure.
+ * @param {string} target - Acceptance target.
+ * @returns {Promise<string>} Exact temporary directory.
+ */
+async function createAcceptanceDirectory(target) {
+    try {
+        return await mkdtemp(path.join(os.tmpdir(), "semantifold-acceptance-"));
+    }
+    catch (error) {
+        throw new SemantifoldDiagnostic({
+            cause: error instanceof Error ? error : undefined,
+            code: "ACCEPTANCE_SETUP_FAILURE",
+            language: target,
+            message: "Failed to create an isolated acceptance directory."
+        });
+    }
+}
+/**
+ * Writes only the already-validated generated artifacts into the isolated directory.
+ * @param {import("./semantic/types.js").GeneratedArtifactSet} artifacts - Complete validated set.
+ * @param {string} directory - Exact temporary directory.
+ * @param {string} target - Acceptance target.
+ * @returns {Promise<void>} Materialization completion.
+ */
+async function materializeArtifacts(artifacts, directory, target) {
+    for (const artifact of artifacts.artifacts) {
+        const filename = path.join(directory, ...artifact.path.split("/"));
+        try {
+            await mkdir(path.dirname(filename), { recursive: true });
+            await writeFile(filename, artifact.content);
+        }
+        catch (error) {
+            throw new SemantifoldDiagnostic({
+                cause: error instanceof Error ? error : undefined,
+                code: "ACCEPTANCE_MATERIALIZATION_FAILURE",
+                language: target,
+                message: `Failed to materialize generated artifact '${artifact.path}'.`
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"acceptance.js","sourceRoot":"","sources":["../../src/acceptance.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {mkdir, mkdtemp, rm, writeFile} from \"node:fs/promises\"\nimport os from \"node:os\"\nimport path from \"node:path\"\nimport {isDenseArray} from \"./array.js\"\nimport {createGeneratedArtifactSet} from \"./artifacts.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {exceededOwnedDeadline, executeFileWithDeadline} from \"./subprocess.js\"\nimport {isSupportedTimeoutMs, maximumTimeoutMs} from \"./timeout.js\"\nimport {deterministicEnvironment} from \"./toolchains.js\"\n\nconst acceptanceMaxBuffer = 16 * 1024 * 1024\nconst launchErrorCodes = new Set([\n  \"E2BIG\", \"EACCES\", \"EAGAIN\", \"ELOOP\", \"EMFILE\", \"ENAMETOOLONG\", \"ENFILE\", \"ENOENT\", \"ENOEXEC\", \"ENOMEM\", \"ENOTDIR\", \"ENOTSUP\", \"EPERM\", \"ETXTBSY\"\n])\nconst orderedStages = Object.freeze([\"parse\", \"generate\", \"restore\", \"compile\", \"link\", \"validate\", \"instantiate\", \"execute\"])\nconst stageIndexes = new Map(orderedStages.map((stage, index) => [stage, index]))\n\n/**\n * Materializes one artifact set and runs ordered acceptance stages without a shell.\n * @param {object} input - Acceptance request.\n * @param {import(\"./semantic/types.js\").GeneratedArtifactSet} input.artifacts - Complete input artifacts.\n * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Explicit process environment.\n * @param {{arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: import(\"./semantic/types.js\").DiscoveredToolchain}[]} input.stages - Ordered stages.\n * @param {string} input.target - Target identity.\n * @param {number} [input.timeoutMs] - Per-stage timeout.\n * @returns {Promise<import(\"./semantic/types.js\").AcceptanceResult>} Captured results after cleanup.\n */\nexport async function runAcceptanceStages(input) {\n  return await runAcceptanceStagesWithDependencies(input, rm)\n}\n\n/**\n * Creates an acceptance runner with instance-owned cleanup behavior.\n * @param {object} dependencies - Internal runner dependencies.\n * @param {typeof rm} dependencies.removeDirectory - Isolated-directory removal operation.\n * @returns {typeof runAcceptanceStages} Acceptance runner.\n */\nexport function createAcceptanceRunner({removeDirectory}) {\n  return async (input) => await runAcceptanceStagesWithDependencies(input, removeDirectory)\n}\n\n/**\n * Runs acceptance with exact instance-owned dependencies.\n * @param {Parameters<typeof runAcceptanceStages>[0]} input - Acceptance request.\n * @param {typeof rm} removeDirectory - Isolated-directory removal operation.\n * @returns {ReturnType<typeof runAcceptanceStages>} Captured results after cleanup.\n */\nasync function runAcceptanceStagesWithDependencies(input, removeDirectory) {\n  if (!isPlainObject(input)) invalidRunner(\"Acceptance requires a request object.\", \"acceptance\")\n  const artifacts = /** @type {import(\"./semantic/types.js\").GeneratedArtifactSet} */ (input.artifacts)\n  const environment = /** @type {Readonly<Record<string, string | undefined>>} */ (\n    input.environment === undefined ? {PATH: process.env.PATH} : input.environment)\n  const stages = /** @type {{arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: import(\"./semantic/types.js\").DiscoveredToolchain}[]} */ (input.stages)\n  const target = /** @type {string} */ (input.target)\n  const timeoutMs = /** @type {number} */ (input.timeoutMs === undefined ? 10_000 : input.timeoutMs)\n  const request = validateRequest({artifacts, environment, stages, target, timeoutMs})\n  const directory = await createAcceptanceDirectory(request.target)\n  /** @type {unknown} */\n  let primaryFailure\n  /** @type {import(\"./semantic/types.js\").AcceptanceResult | undefined} */\n  let result\n  let primaryFailed = false\n\n  try {\n    await materializeArtifacts(request.artifacts, directory, request.target)\n\n    /** @type {import(\"./semantic/types.js\").AcceptanceStageResult[]} */\n    const results = []\n\n    for (const stage of request.stages) {\n      try {\n        const result = await executeFileWithDeadline({\n          arguments: stage.arguments,\n          cwd: directory,\n          environment: request.environment,\n          executable: stage.tool.executable,\n          maxBuffer: acceptanceMaxBuffer,\n          timeoutMs: request.timeoutMs\n        })\n\n        results.push(Object.freeze({\n          arguments: Object.freeze([...stage.arguments]),\n          executable: stage.tool.executable,\n          stage: stage.stage,\n          stderr: result.stderr,\n          stdout: result.stdout,\n          version: stage.tool.version\n        }))\n      } catch (error) {\n        throw processDiagnostic(error, stage, request.target, request.timeoutMs)\n      }\n    }\n\n    result = Object.freeze({directory, stages: Object.freeze(results), target: request.target})\n  } catch (error) {\n    primaryFailed = true\n    primaryFailure = error\n  }\n\n  /** @type {unknown} */\n  let cleanupFailure\n  let cleanupFailed = false\n\n  try {\n    await removeAcceptanceDirectory(directory, request.target, removeDirectory)\n  } catch (error) {\n    cleanupFailed = true\n    cleanupFailure = error\n  }\n\n  if (primaryFailed && cleanupFailed && primaryFailure instanceof Error) {\n    throw preservePrimaryFailure(primaryFailure, cleanupFailure, request.target)\n  }\n  if (primaryFailed) throw primaryFailure\n  if (cleanupFailed) throw cleanupFailure\n\n  return /** @type {import(\"./semantic/types.js\").AcceptanceResult} */ (result)\n}\n\n/**\n * Validates and detaches a staged acceptance request before filesystem mutation.\n * @param {{\n *   artifacts: import(\"./semantic/types.js\").GeneratedArtifactSet,\n *   environment: Readonly<Record<string, string | undefined>>,\n *   stages: {arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: import(\"./semantic/types.js\").DiscoveredToolchain}[],\n *   target: string,\n *   timeoutMs: number\n * }} input - Candidate request.\n * @returns {{\n *   artifacts: import(\"./semantic/types.js\").GeneratedArtifactSet,\n *   environment: Readonly<Record<string, string>>,\n *   stages: {arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: Readonly<{executable: string, version: string}>}[],\n *   target: string,\n *   timeoutMs: number\n * }} Validated request.\n */\nfunction validateRequest(input) {\n  try {\n    if (typeof input.target != \"string\" || input.target.length == 0 || !isSupportedTimeoutMs(input.timeoutMs) ||\n      !isDenseArray(input.stages) || input.stages.length == 0) {\n      invalidRunner(`Acceptance requires a target, timeout from 1 through ${maximumTimeoutMs}ms, and non-empty ordered stages.`, input.target)\n    }\n    const artifacts = createGeneratedArtifactSet(input.artifacts)\n\n    if (artifacts.target != input.target) invalidRunner(\"Acceptance target must match the generated artifact-set target.\", input.target)\n    const environment = deterministicEnvironment(input.environment)\n    let previousIndex = -1\n    const seen = new Set()\n    /** @type {{arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: Readonly<{executable: string, version: string}>}[]} */\n    const stages = []\n\n    for (let stagePosition = 0; stagePosition < input.stages.length; stagePosition += 1) {\n      const stage = input.stages[stagePosition]\n\n      if (!isPlainObject(stage)) invalidRunner(\"Acceptance stages must be distinct known stage records.\", input.target)\n      const stageName = stage.stage\n\n      if (typeof stageName != \"string\" || !stageIndexes.has(stageName) || seen.has(stageName)) {\n        invalidRunner(\"Acceptance stages must be distinct known stage records.\", input.target)\n      }\n      const index = /** @type {number} */ (stageIndexes.get(stageName))\n\n      if (index < previousIndex) invalidRunner(\"Acceptance stages must follow parse-to-execute order.\", input.target)\n      previousIndex = index\n      seen.add(stageName)\n      const argumentCandidate = stage.arguments\n      const stageArguments = isDenseArray(argumentCandidate) ? [...argumentCandidate] : undefined\n      const toolCandidate = stage.tool\n      const tool = isPlainObject(toolCandidate) ? Object.freeze({\n        executable: toolCandidate.executable,\n        id: toolCandidate.id,\n        source: toolCandidate.source,\n        version: toolCandidate.version\n      }) : undefined\n\n      if (stageArguments == undefined || !stageArguments.every((argument) => typeof argument == \"string\" && !argument.includes(\"\\0\")) ||\n        !isTool(tool)) invalidRunner(`Acceptance stage '${stageName}' has an invalid tool or argument array.`, input.target)\n\n      stages.push(Object.freeze({arguments: stageArguments, stage: stageName, tool}))\n    }\n\n    return {artifacts, environment, stages, target: input.target, timeoutMs: input.timeoutMs}\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic && error.code == \"INVALID_ACCEPTANCE_RUNNER\") throw error\n    if (error instanceof SemantifoldDiagnostic) {\n      throw new SemantifoldDiagnostic({\n        cause: error,\n        code: \"INVALID_ACCEPTANCE_RUNNER\",\n        language: typeof input.target == \"string\" ? input.target : \"acceptance\",\n        message: `Acceptance runner input is invalid: ${error.detail}`\n      })\n    }\n\n    return invalidRunner(\"Acceptance runner input is invalid.\", typeof input.target == \"string\" ? input.target : \"acceptance\", error)\n  }\n}\n\n/**\n * Normalizes a subprocess failure with exact stage and toolchain context.\n * @param {unknown} error - Subprocess rejection.\n * @param {{arguments: string[], stage: string, tool: Readonly<{executable: string, version: string}>}} stage - Failed stage.\n * @param {string} target - Acceptance target.\n * @param {number} timeoutMs - Configured stage timeout.\n * @returns {SemantifoldDiagnostic} Normalized failure.\n */\nfunction processDiagnostic(error, stage, target, timeoutMs) {\n  const fields = processErrorFields(error)\n  const outputLimited = fields.nativeCode == \"ERR_CHILD_PROCESS_STDIO_MAXBUFFER\"\n  const timedOut = !outputLimited && exceededOwnedDeadline(error)\n  const launchFailure = fields.nativeCode != undefined && launchErrorCodes.has(fields.nativeCode)\n  const signaled = !outputLimited && !timedOut && fields.signal != undefined\n  const code = outputLimited ? \"ACCEPTANCE_OUTPUT_LIMIT\" : timedOut ? \"ACCEPTANCE_TIMEOUT\" : launchFailure ? \"ACCEPTANCE_LAUNCH_FAILURE\" : signaled\n    ? \"ACCEPTANCE_SIGNAL\"\n    : \"ACCEPTANCE_NONZERO_EXIT\"\n  const reason = outputLimited ? `exceeded the ${acceptanceMaxBuffer}-byte output capture limit (${fields.nativeCode})` : timedOut\n    ? `timed out after ${timeoutMs}ms` : launchFailure\n    ? `could not launch (${fields.nativeCode})`\n    : signaled ? `terminated by signal ${fields.signal}`\n    : fields.exitCode != undefined ? `exited nonzero (${fields.exitCode})`\n    : `failed after launch (${fields.nativeCode ?? \"unknown\"})`\n\n  return new SemantifoldDiagnostic({\n    cause: outputLimited ? undefined : error instanceof Error ? error : undefined,\n    code,\n    executable: stage.tool.executable,\n    exitCode: fields.exitCode,\n    language: target,\n    message: `Acceptance stage '${stage.stage}' ${reason} using '${stage.tool.executable}' (${stage.tool.version}).`,\n    signal: fields.signal,\n    stage: stage.stage,\n    stderr: fields.stderr,\n    stdout: fields.stdout,\n    version: stage.tool.version\n  })\n}\n\n/**\n * Narrows the stable fields of an opaque child-process failure.\n * @param {unknown} error - Process rejection.\n * @returns {{exitCode: number | undefined, nativeCode: string | undefined, signal: string | undefined, stderr: string, stdout: string}} Stable fields.\n */\nfunction processErrorFields(error) {\n  if (!error || typeof error != \"object\") return {exitCode: undefined, nativeCode: undefined, signal: undefined, stderr: \"\", stdout: \"\"}\n  const value = /** @type {Record<string, unknown>} */ (error)\n  const nativeCode = typeof value.code == \"string\" ? value.code : undefined\n  const outputLimited = nativeCode == \"ERR_CHILD_PROCESS_STDIO_MAXBUFFER\"\n\n  return {\n    exitCode: typeof value.code == \"number\" ? value.code : undefined,\n    nativeCode,\n    signal: typeof value.signal == \"string\" ? value.signal : undefined,\n    stderr: !outputLimited && typeof value.stderr == \"string\" ? value.stderr : \"\",\n    stdout: !outputLimited && typeof value.stdout == \"string\" ? value.stdout : \"\"\n  }\n}\n\n/**\n * Checks the discovered-tool fields consumed by the runner.\n * @param {unknown} value - Candidate tool.\n * @returns {value is import(\"./semantic/types.js\").DiscoveredToolchain} Whether the tool contract is present.\n */\nfunction isTool(value) {\n  return isPlainObject(value) && typeof value.id == \"string\" && typeof value.executable == \"string\" && path.isAbsolute(value.executable) &&\n    !value.executable.includes(\"\\0\") && typeof value.version == \"string\" && value.version.length > 0 &&\n    (value.source == \"canonical\" || value.source == \"override\")\n}\n\n/**\n * Keeps the primary acceptance error while recording bounded cleanup evidence in its cause chain.\n * @param {Error} primaryFailure - Original materialization or stage failure.\n * @param {unknown} cleanupFailure - Cleanup rejection.\n * @param {string} target - Acceptance target.\n * @returns {Error} The original primary error with structured cleanup evidence.\n */\nfunction preservePrimaryFailure(primaryFailure, cleanupFailure, target) {\n  const cleanupEvidence = new SemantifoldDiagnostic({\n    code: \"ACCEPTANCE_CLEANUP_FAILURE\",\n    language: cleanupFailure instanceof SemantifoldDiagnostic ? cleanupFailure.language : target,\n    message: \"Isolated acceptance-directory cleanup failed after the primary acceptance failure.\"\n  })\n  const causes = primaryFailure.cause instanceof Error ? [primaryFailure.cause, cleanupEvidence] : [cleanupEvidence]\n\n  Object.defineProperty(primaryFailure, \"cause\", {\n    configurable: true,\n    value: new AggregateError(causes, \"Acceptance failed and isolated-directory cleanup also failed.\"),\n    writable: true\n  })\n\n  return primaryFailure\n}\n\n/**\n * Throws a normalized runner-configuration diagnostic.\n * @param {string} message - Failure detail.\n * @param {unknown} target - Candidate target identity.\n * @param {unknown} [error] - Preserved cause.\n * @returns {never} Always throws.\n */\nfunction invalidRunner(message, target, error) {\n  throw new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code: \"INVALID_ACCEPTANCE_RUNNER\",\n    language: typeof target == \"string\" && target.length > 0 ? target : \"acceptance\",\n    message\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 * Removes the isolated acceptance directory with a normalized failure.\n * @param {string} directory - Exact temporary directory.\n * @param {string} target - Acceptance target.\n * @param {typeof rm} removeDirectory - Instance-owned removal operation.\n * @returns {Promise<void>} Cleanup completion.\n */\nasync function removeAcceptanceDirectory(directory, target, removeDirectory) {\n  try {\n    await removeDirectory(directory, {force: true, recursive: true})\n  } catch (error) {\n    throw new SemantifoldDiagnostic({\n      cause: error instanceof Error ? error : undefined,\n      code: \"ACCEPTANCE_CLEANUP_FAILURE\",\n      language: target,\n      message: `Failed to remove isolated acceptance directory '${directory}'.`\n    })\n  }\n}\n\n/**\n * Creates one isolated acceptance directory with a normalized setup failure.\n * @param {string} target - Acceptance target.\n * @returns {Promise<string>} Exact temporary directory.\n */\nasync function createAcceptanceDirectory(target) {\n  try {\n    return await mkdtemp(path.join(os.tmpdir(), \"semantifold-acceptance-\"))\n  } catch (error) {\n    throw new SemantifoldDiagnostic({\n      cause: error instanceof Error ? error : undefined,\n      code: \"ACCEPTANCE_SETUP_FAILURE\",\n      language: target,\n      message: \"Failed to create an isolated acceptance directory.\"\n    })\n  }\n}\n\n/**\n * Writes only the already-validated generated artifacts into the isolated directory.\n * @param {import(\"./semantic/types.js\").GeneratedArtifactSet} artifacts - Complete validated set.\n * @param {string} directory - Exact temporary directory.\n * @param {string} target - Acceptance target.\n * @returns {Promise<void>} Materialization completion.\n */\nasync function materializeArtifacts(artifacts, directory, target) {\n  for (const artifact of artifacts.artifacts) {\n    const filename = path.join(directory, ...artifact.path.split(\"/\"))\n\n    try {\n      await mkdir(path.dirname(filename), {recursive: true})\n      await writeFile(filename, artifact.content)\n    } catch (error) {\n      throw new SemantifoldDiagnostic({\n        cause: error instanceof Error ? error : undefined,\n        code: \"ACCEPTANCE_MATERIALIZATION_FAILURE\",\n        language: target,\n        message: `Failed to materialize generated artifact '${artifact.path}'.`\n      })\n    }\n  }\n}\n"]}

package/build/src/array.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks that every index below an array's length is an own property.
+ * @param {unknown} value - Candidate ordered array.
+ * @returns {value is unknown[]} Whether the value is a dense array.
+ */
+export declare function isDenseArray(value: unknown): value is unknown[];
+//# sourceMappingURL=array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/array.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAHvB,OAGuB,GAFrB,KAAK,IAAI,OAAO,EAAE,CAa9B"}

package/build/src/array.js

@@ -0,0 +1,18 @@
+// @ts-check
+/**
+ * Checks that every index below an array's length is an own property.
+ * @param {unknown} value - Candidate ordered array.
+ * @returns {value is unknown[]} Whether the value is a dense array.
+ */
+export function isDenseArray(value) {
+    if (!Array.isArray(value))
+        return false;
+    let indexedProperties = 0;
+    for (const property of Object.getOwnPropertyNames(value)) {
+        const index = Number(property);
+        if (Number.isInteger(index) && index >= 0 && index < value.length && String(index) == property)
+            indexedProperties += 1;
+    }
+    return indexedProperties == value.length;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXJyYXkuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUFDLEtBQUs7SUFDaEMsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO1FBQUUsT0FBTyxLQUFLLENBQUE7SUFDdkMsSUFBSSxpQkFBaUIsR0FBRyxDQUFDLENBQUE7SUFFekIsS0FBSyxNQUFNLFFBQVEsSUFBSSxNQUFNLENBQUMsbUJBQW1CLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUN6RCxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUE7UUFFOUIsSUFBSSxNQUFNLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxJQUFJLEtBQUssSUFBSSxDQUFDLElBQUksS0FBSyxHQUFHLEtBQUssQ0FBQyxNQUFNLElBQUksTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLFFBQVE7WUFBRSxpQkFBaUIsSUFBSSxDQUFDLENBQUE7SUFDeEgsQ0FBQztJQUVELE9BQU8saUJBQWlCLElBQUksS0FBSyxDQUFDLE1BQU0sQ0FBQTtBQUMxQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbi8qKlxuICogQ2hlY2tzIHRoYXQgZXZlcnkgaW5kZXggYmVsb3cgYW4gYXJyYXkncyBsZW5ndGggaXMgYW4gb3duIHByb3BlcnR5LlxuICogQHBhcmFtIHt1bmtub3dufSB2YWx1ZSAtIENhbmRpZGF0ZSBvcmRlcmVkIGFycmF5LlxuICogQHJldHVybnMge3ZhbHVlIGlzIHVua25vd25bXX0gV2hldGhlciB0aGUgdmFsdWUgaXMgYSBkZW5zZSBhcnJheS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzRGVuc2VBcnJheSh2YWx1ZSkge1xuICBpZiAoIUFycmF5LmlzQXJyYXkodmFsdWUpKSByZXR1cm4gZmFsc2VcbiAgbGV0IGluZGV4ZWRQcm9wZXJ0aWVzID0gMFxuXG4gIGZvciAoY29uc3QgcHJvcGVydHkgb2YgT2JqZWN0LmdldE93blByb3BlcnR5TmFtZXModmFsdWUpKSB7XG4gICAgY29uc3QgaW5kZXggPSBOdW1iZXIocHJvcGVydHkpXG5cbiAgICBpZiAoTnVtYmVyLmlzSW50ZWdlcihpbmRleCkgJiYgaW5kZXggPj0gMCAmJiBpbmRleCA8IHZhbHVlLmxlbmd0aCAmJiBTdHJpbmcoaW5kZXgpID09IHByb3BlcnR5KSBpbmRleGVkUHJvcGVydGllcyArPSAxXG4gIH1cblxuICByZXR1cm4gaW5kZXhlZFByb3BlcnRpZXMgPT0gdmFsdWUubGVuZ3RoXG59XG4iXX0=

package/build/src/artifact-path.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Validates filename metadata without imposing artifact-set path semantics.
+ * @param {unknown} value - Candidate filename.
+ * @returns {value is string} Whether the value is a non-empty single-line string.
+ */
+export declare function isValidFilenameMetadata(value: unknown): value is string;
+/**
+ * Validates a safe relative POSIX artifact path.
+ * @param {unknown} value - Candidate path.
+ * @returns {value is string} Whether the value is safe.
+ */
+export declare function isSafeArtifactPath(value: unknown): value is string;
+//# sourceMappingURL=artifact-path.d.ts.map

package/build/src/artifact-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-path.d.ts","sourceRoot":"","sources":["../../src/artifact-path.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAHlC,OAGkC,GAFhC,KAAK,IAAI,MAAM,CAI3B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAH7B,OAG6B,GAF3B,KAAK,IAAI,MAAM,CAe3B"}

package/build/src/artifact-path.js

@@ -0,0 +1,30 @@
+// @ts-check
+import { hasOnlyUnicodeScalars } from "./semantic/scalars.js";
+const lineTerminatorPattern = /[\n\r\u2028\u2029]/u;
+/**
+ * Validates filename metadata without imposing artifact-set path semantics.
+ * @param {unknown} value - Candidate filename.
+ * @returns {value is string} Whether the value is a non-empty single-line string.
+ */
+export function isValidFilenameMetadata(value) {
+    return typeof value == "string" && value.length > 0 && !lineTerminatorPattern.test(value);
+}
+/**
+ * Validates a safe relative POSIX artifact path.
+ * @param {unknown} value - Candidate path.
+ * @returns {value is string} Whether the value is safe.
+ */
+export function isSafeArtifactPath(value) {
+    if (typeof value != "string" || value.length == 0 || value.includes("\\") || value.includes("\0") ||
+        !hasOnlyUnicodeScalars(value))
+        return false;
+    if (value.startsWith("/") || /^[A-Za-z]:/u.test(value))
+        return false;
+    const parts = value.split("/");
+    return parts.every((part) => part.length > 0 && part != "." && part != ".." &&
+        [...part].every((character) => {
+            const codePoint = character.codePointAt(0);
+            return codePoint != undefined && codePoint > 31 && codePoint != 127;
+        }));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/artifacts.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Transactionally validates and constructs one deterministic generated artifact set.
+ * @param {unknown} candidate - Artifact-set fields.
+ * @returns {import("./semantic/types.js").GeneratedArtifactSet} Detached immutable set.
+ */
+export declare function createGeneratedArtifactSet(candidate: unknown): import("./semantic/types.js").GeneratedArtifactSet;
+//# sourceMappingURL=artifacts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../src/artifacts.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAHzC,OAGyC,GAFvC,OAAO,qBAAqB,EAAE,oBAAoB,CAgG9D"}