semantifold 0.9.0 → 0.11.0

package/build/src/target-check.js

@@ -0,0 +1,796 @@
+// @ts-check
+import { lstat, mkdir, readdir, rm, rmdir } from "node:fs/promises";
+import path from "node:path";
+import { isDenseArray } from "./array.js";
+import { createGeneratedArtifactSet } from "./artifacts.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { languageRegistry } from "./language-registry.js";
+import { cancelledOwnedProcess, exceededOwnedDeadline, executeFileWithDeadline } from "./subprocess.js";
+import { isSupportedTimeoutMs, maximumTimeoutMs } from "./timeout.js";
+import { deterministicEnvironment } from "./toolchains.js";
+const defaultTimeoutMs = 20_000;
+const maximumOutputBytes = 1024 * 1024;
+const identityPattern = /^[a-z][a-z0-9-]*$/u;
+const mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+(?:;[\u0020-\u007e]+)?$/u;
+const rolePattern = /^[a-z][a-z0-9-]*$/u;
+const launchErrorCodes = new Set([
+    "E2BIG", "EACCES", "EAGAIN", "ELOOP", "EMFILE", "ENAMETOOLONG", "ENFILE", "ENOENT", "ENOEXEC", "ENOMEM",
+    "ENOTDIR", "ENOTSUP", "EPERM", "ETXTBSY"
+]);
+/** @type {WeakMap<TargetCheckRunner, {execute: typeof executeFileWithDeadline, now: () => number}>} */
+const targetCheckRunnerDependencies = new WeakMap();
+/**
+ * Creates and validates one target-owned developer check plan.
+ * @param {object} input - Exact staged target context.
+ * @param {import("./semantic/types.js").GeneratedArtifactSet} input.artifacts - Validated staged artifacts.
+ * @param {string} input.buildPath - Exact generation-scoped target build subtree.
+ * @param {string} input.projectId - Exact project identity.
+ * @param {string} input.sourcePath - Exact generation-scoped target source subtree.
+ * @param {string} input.targetId - Exact project target identity.
+ * @param {readonly import("./semantic/types.js").DiscoveredToolchain[]} input.tools - Discovered immutable tool records.
+ * @returns {import("./semantic/types.js").TargetCheckPlan} Validated immutable plan.
+ */
+export function createTargetCheckPlan(input) {
+    if (!isPlainObject(input) || !hasExactKeys(input, ["artifacts", "buildPath", "projectId", "sourcePath", "targetId", "tools"])) {
+        return invalidPlan("Target check planning requires only staged artifacts, candidate roots, identities, and tools.");
+    }
+    let artifacts;
+    try {
+        artifacts = createGeneratedArtifactSet(input.artifacts);
+    }
+    catch (error) {
+        return invalidPlan("Target check planning requires a valid generated artifact set.", "check", error);
+    }
+    const target = artifacts.target;
+    const record = languageRegistry.record(target);
+    const capability = record.check;
+    if (!capability.supported || typeof capability.factory != "function") {
+        throw new SemantifoldDiagnostic({
+            code: "UNSUPPORTED_TARGET_CHECK",
+            language: target,
+            message: "Registered target does not provide a developer check plan."
+        });
+    }
+    if (typeof input.projectId != "string" || !identityPattern.test(input.projectId) ||
+        typeof input.targetId != "string" || !identityPattern.test(input.targetId) ||
+        typeof input.sourcePath != "string" || !path.isAbsolute(input.sourcePath) ||
+        typeof input.buildPath != "string" || !path.isAbsolute(input.buildPath) ||
+        pathsOverlap(input.sourcePath, input.buildPath) || !isDenseArray(input.tools)) {
+        return invalidPlan("Target check planning received invalid identities, candidate roots, or tools.", target);
+    }
+    /** @type {import("./semantic/types.js").DiscoveredToolchain[]} */
+    const tools = [];
+    for (let index = 0; index < input.tools.length; index += 1) {
+        const tool = input.tools[index];
+        if (!isDiscoveredTool(tool) || !Object.isFrozen(tool) || !Object.isFrozen(tool.versionArguments)) {
+            return invalidPlan("Target check planning requires immutable discovered tool records.", target);
+        }
+        tools.push(tool);
+    }
+    if (tools.map(({ id }) => id).join("\0") != capability.toolchains.join("\0")) {
+        return invalidPlan("Target check planning tools must exactly match the target-declared developer-check toolchains.", target);
+    }
+    const context = Object.freeze({
+        artifacts,
+        buildPath: input.buildPath,
+        projectId: input.projectId,
+        sourcePath: input.sourcePath,
+        targetId: input.targetId,
+        tools: Object.freeze(tools)
+    });
+    let plan;
+    try {
+        plan = capability.factory(context);
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        return invalidPlan("Target check plan factory failed.", target, error);
+    }
+    const validated = validateTargetCheckPlan(plan);
+    const expectedArtifacts = new Set(context.artifacts.artifacts.map(artifact => path.join(context.sourcePath, artifact.path)));
+    if (validated.projectId != context.projectId || validated.targetId != context.targetId ||
+        validated.target != target || validated.sourcePath != context.sourcePath || validated.buildPath != context.buildPath ||
+        validated.artifactPaths.length != expectedArtifacts.size || validated.artifactPaths.some(artifact => !expectedArtifacts.has(artifact))) {
+        return invalidPlan("Target check plan changed its validated candidate context.", target);
+    }
+    return validated;
+}
+/**
+ * Owns ordered check subprocesses and settles only after each child closes.
+ */
+export class TargetCheckRunner {
+    /**
+     * Runs one already-staged immutable plan without executing generated application code.
+     * @param {import("./semantic/types.js").TargetCheckPlan} plan - Target-owned plan.
+     * @param {{onStage?: (result: import("./semantic/types.js").TargetCheckStageResult) => void, signal?: AbortSignal, timeoutMs?: number}} [options] - Lifecycle controls.
+     * @returns {Promise<import("./semantic/types.js").TargetCheckResult>} Successful check evidence and output metadata.
+     */
+    async run(plan, options = {}) {
+        const validated = validateTargetCheckPlan(plan);
+        const dependencies = targetCheckRunnerDependencies.get(this) ?? {
+            execute: executeFileWithDeadline,
+            now: () => performance.now()
+        };
+        if (!isPlainObject(options) || options.onStage !== undefined && typeof options.onStage != "function" ||
+            options.signal !== undefined && !(options.signal instanceof AbortSignal)) {
+            return invalidPlan("Target check runner options are invalid.", validated.target);
+        }
+        const timeoutMs = options.timeoutMs === undefined ? defaultTimeoutMs : options.timeoutMs;
+        if (!isSupportedTimeoutMs(timeoutMs)) {
+            return invalidPlan(`Target check timeout must be from 1 through ${maximumTimeoutMs}ms.`, validated.target);
+        }
+        /** @type {import("./semantic/types.js").TargetCheckStageResult[]} */
+        const results = [];
+        /** @type {unknown} */
+        let stageFailure;
+        let stageFailed = false;
+        try {
+            for (const stage of validated.stages) {
+                const startedAt = dependencies.now();
+                /** @type {import("./semantic/types.js").TargetCheckStageResult} */
+                let stageResult;
+                if (options.signal?.aborted)
+                    throw cancelledDiagnostic(stage, validated, 0);
+                try {
+                    await prepareStage(stage, validated);
+                }
+                catch (error) {
+                    throw preparationDiagnostic(error, stage, validated, elapsed(dependencies.now(), startedAt));
+                }
+                try {
+                    const output = await dependencies.execute({
+                        arguments: stage.argv,
+                        cwd: stage.cwd,
+                        environment: stage.environment,
+                        executable: stage.executable,
+                        maxBuffer: maximumOutputBytes,
+                        signal: options.signal,
+                        timeoutMs
+                    });
+                    stageResult = Object.freeze({
+                        argv: stage.argv,
+                        durationMs: elapsed(dependencies.now(), startedAt),
+                        exitCode: 0,
+                        signal: null,
+                        stage: stage.stage,
+                        stderr: output.stderr,
+                        stdout: output.stdout,
+                        tool: Object.freeze({
+                            command: stage.tool.command,
+                            executable: stage.tool.executable,
+                            id: stage.tool.id,
+                            source: stage.tool.source,
+                            version: stage.tool.version
+                        })
+                    });
+                }
+                catch (error) {
+                    throw processDiagnostic(error, stage, validated, timeoutMs, elapsed(dependencies.now(), startedAt));
+                }
+                results.push(stageResult);
+                options.onStage?.(stageResult);
+            }
+        }
+        catch (error) {
+            stageFailed = true;
+            stageFailure = error;
+        }
+        try {
+            await cleanupStageEnvironment(validated);
+        }
+        catch (error) {
+            const cleanup = cleanupDiagnostic(error, validated);
+            if (stageFailed && stageFailure instanceof Error)
+                throw preservePrimaryFailure(stageFailure, cleanup);
+            if (stageFailed)
+                throw new AggregateError([stageFailure, cleanup], "Target check failed and its owned transient environment could not be cleaned.", { cause: error });
+            throw cleanup;
+        }
+        if (stageFailed)
+            throw stageFailure;
+        const output = validated.stages.findLast(stage => stage.output !== null)?.output;
+        const outputs = output == null ? [] : await collectBuildOutputs(validated.buildPath, output);
+        return Object.freeze({
+            outputs: Object.freeze(outputs),
+            projectId: validated.projectId,
+            stages: Object.freeze(results),
+            target: validated.target,
+            targetId: validated.targetId
+        });
+    }
+}
+/**
+ * Creates a runner with focused instance-owned dependencies.
+ * @param {{execute: typeof executeFileWithDeadline, now: () => number}} dependencies - Testable lifecycle collaborators.
+ * @returns {TargetCheckRunner} Runner.
+ */
+export function createTargetCheckRunner(dependencies) {
+    if (!isPlainObject(dependencies) || typeof dependencies.execute != "function" || typeof dependencies.now != "function") {
+        throw new TypeError("Invalid target check runner dependencies.");
+    }
+    const runner = new TargetCheckRunner();
+    targetCheckRunnerDependencies.set(runner, dependencies);
+    return runner;
+}
+/**
+ * Validates a complete immutable plan before any process starts.
+ * @param {unknown} candidate - Candidate plan.
+ * @returns {import("./semantic/types.js").TargetCheckPlan} Exact validated plan.
+ */
+export function validateTargetCheckPlan(candidate) {
+    if (!isPlainObject(candidate) || !Object.isFrozen(candidate) || !hasExactKeys(candidate, [
+        "artifactPaths", "buildPath", "mode", "projectId", "schema", "sourcePath", "stages", "target", "targetId", "version"
+    ]))
+        return invalidPlan("Target check plan must be one immutable closed schema record.");
+    const target = typeof candidate.target == "string" ? candidate.target : "check";
+    const record = languageRegistry.record(target);
+    const capability = record.check;
+    if (!capability.supported || candidate.schema != "SemantifoldTargetCheckPlan" || candidate.version != 1 ||
+        candidate.mode != "developer-check" || typeof candidate.projectId != "string" || !identityPattern.test(candidate.projectId) ||
+        typeof candidate.targetId != "string" || !identityPattern.test(candidate.targetId) ||
+        typeof candidate.sourcePath != "string" || !path.isAbsolute(candidate.sourcePath) ||
+        typeof candidate.buildPath != "string" || !path.isAbsolute(candidate.buildPath) ||
+        pathsOverlap(candidate.sourcePath, candidate.buildPath)) {
+        return invalidPlan("Target check plan has invalid schema, mode, identity, target, or candidate roots.", target);
+    }
+    if (!isDenseArray(candidate.artifactPaths) || !Object.isFrozen(candidate.artifactPaths) || candidate.artifactPaths.length == 0 ||
+        !isDenseArray(candidate.stages) || !Object.isFrozen(candidate.stages) || candidate.stages.length == 0) {
+        return invalidPlan("Target check plan requires dense immutable artifact and stage vectors.", target);
+    }
+    const artifactPaths = new Set();
+    for (let index = 0; index < candidate.artifactPaths.length; index += 1) {
+        const artifactPath = candidate.artifactPaths[index];
+        if (typeof artifactPath != "string" || !ownedBy(candidate.sourcePath, artifactPath) || artifactPaths.has(artifactPath)) {
+            return invalidPlan("Every planned artifact must be a distinct absolute path inside the candidate source subtree.", target);
+        }
+        artifactPaths.add(artifactPath);
+    }
+    const plannedStageKinds = candidate.stages.map(stage => isPlainObject(stage) && typeof stage.stage == "string" ? stage.stage : "")
+        .filter((stage, index, stages) => index == 0 || stage != stages[index - 1]);
+    if (plannedStageKinds.join("\0") != capability.stages.join("\0")) {
+        return invalidPlan("Target check stages must exactly match the target-declared developer-check stages.", target);
+    }
+    const usedTools = new Set();
+    const referencedArtifactPaths = new Set();
+    for (let index = 0; index < candidate.stages.length; index += 1) {
+        const stage = candidate.stages[index];
+        if (!isPlainObject(stage) || !Object.isFrozen(stage) || !hasExactKeys(stage, [
+            "argv", "cwd", "environment", "environmentPaths", "executable", "inputHash", "inputs", "output", "pathArguments",
+            "stage", "tool", "transientPaths"
+        ]) || typeof stage.stage != "string" || stage.stage == "execute" ||
+            !record.acceptance.stages.includes(/** @type {import("./semantic/types.js").AcceptanceStage} */ (stage.stage))) {
+            return invalidPlan("Target check stages must be immutable, ordered, declared, and non-executing.", target);
+        }
+        const request = /** @type {import("./semantic/types.js").TargetCheckStageRequest} */ (stage);
+        if (!isDiscoveredTool(request.tool) || !Object.isFrozen(request.tool) || !Object.isFrozen(request.tool.versionArguments) ||
+            request.executable != request.tool.executable || !capability.toolchains.includes(request.tool.id)) {
+            return invalidPlan(`Target check stage '${request.stage}' uses an invalid or undeclared tool.`, target);
+        }
+        usedTools.add(request.tool.id);
+        if (!isDenseArray(request.argv) || !Object.isFrozen(request.argv) ||
+            !request.argv.every(argument => typeof argument == "string" && !argument.includes("\0")) ||
+            !isDenseArray(request.pathArguments) || !Object.isFrozen(request.pathArguments)) {
+            return invalidPlan(`Target check stage '${request.stage}' requires a dense immutable shell-free argv.`, target);
+        }
+        if (!validEnvironment(request.environment)) {
+            return invalidPlan(`Target check stage '${request.stage}' requires an immutable deterministic environment.`, target);
+        }
+        if (!validEnvironmentPaths(request.environmentPaths, request.environment, candidate.sourcePath, candidate.buildPath, capability.toolchains, usedTools)) {
+            return invalidPlan(`Target check stage '${request.stage}' has invalid environment-path ownership.`, target);
+        }
+        if (typeof request.cwd != "string" || !ownedByEither(candidate.sourcePath, candidate.buildPath, request.cwd)) {
+            return invalidPlan(`Target check stage '${request.stage}' working directory escapes the candidate target subtrees.`, target);
+        }
+        if (request.output !== null && !validOutput(request.output, candidate.buildPath)) {
+            return invalidPlan(`Target check stage '${request.stage}' has invalid compiler-output ownership.`, target);
+        }
+        if (!validTransientPaths(request.transientPaths, candidate.sourcePath, candidate.buildPath, artifactPaths)) {
+            return invalidPlan(`Target check stage '${request.stage}' has invalid transient-path ownership.`, target);
+        }
+        if (request.stage == "restore" ? typeof request.inputHash != "string" || !/^[a-f0-9]{64}$/u.test(request.inputHash) : request.inputHash !== null) {
+            return invalidPlan(`Target check stage '${request.stage}' has invalid restore-input identity.`, target);
+        }
+        if (!isDenseArray(request.inputs) || !Object.isFrozen(request.inputs) || request.inputs.length == 0) {
+            return invalidPlan(`Target check stage '${request.stage}' requires immutable declared inputs.`, target);
+        }
+        const stageInputs = new Set();
+        for (let inputIndex = 0; inputIndex < request.inputs.length; inputIndex += 1) {
+            const inputPath = request.inputs[inputIndex];
+            if (typeof inputPath != "string" || stageInputs.has(inputPath) || !ownedByEither(candidate.sourcePath, candidate.buildPath, inputPath)) {
+                return invalidPlan(`Target check stage '${request.stage}' has invalid or duplicate declared inputs.`, target);
+            }
+            if (ownedBy(candidate.sourcePath, inputPath)) {
+                if (!artifactPaths.has(inputPath)) {
+                    return invalidPlan(`Target check stage '${request.stage}' reads an undeclared staged artifact.`, target);
+                }
+                referencedArtifactPaths.add(inputPath);
+            }
+            stageInputs.add(inputPath);
+        }
+        const pathIndexes = new Set();
+        for (let pathIndex = 0; pathIndex < request.pathArguments.length; pathIndex += 1) {
+            const declaration = request.pathArguments[pathIndex];
+            if (!isPlainObject(declaration) || !Object.isFrozen(declaration) ||
+                !hasExactKeys(declaration, declaration.prefix === undefined ? ["index", "ownership"] : ["index", "ownership", "prefix"]) ||
+                typeof declaration.index != "number" || !Number.isInteger(declaration.index) || declaration.index < 0 ||
+                declaration.index >= request.argv.length ||
+                pathIndexes.has(declaration.index) || declaration.ownership != "source" && declaration.ownership != "build" ||
+                declaration.prefix !== undefined && (typeof declaration.prefix != "string" || declaration.prefix.length == 0 ||
+                    declaration.prefix.includes("\0"))) {
+                return invalidPlan(`Target check stage '${request.stage}' has invalid path-argument ownership.`, target);
+            }
+            const rawArgument = request.argv[declaration.index];
+            const argument = declaration.prefix === undefined
+                ? rawArgument
+                : rawArgument.startsWith(declaration.prefix)
+                    ? rawArgument.slice(declaration.prefix.length)
+                    : "";
+            const root = declaration.ownership == "source" ? candidate.sourcePath : candidate.buildPath;
+            if (argument != root && !ownedBy(root, argument)) {
+                return invalidPlan(`Target check stage '${request.stage}' path argument escapes its candidate subtree.`, target);
+            }
+            pathIndexes.add(declaration.index);
+        }
+        for (let argumentIndex = 0; argumentIndex < request.argv.length; argumentIndex += 1) {
+            if (path.isAbsolute(request.argv[argumentIndex]) && !pathIndexes.has(argumentIndex)) {
+                return invalidPlan(`Target check stage '${request.stage}' contains an unowned absolute path argument.`, target);
+            }
+        }
+    }
+    if (referencedArtifactPaths.size != artifactPaths.size) {
+        return invalidPlan("Target check plan must include every staged check artifact.", target);
+    }
+    if (capability.toolchains.some(toolchain => !usedTools.has(toolchain))) {
+        return invalidPlan("Target check plan omits a target-declared toolchain.", target);
+    }
+    return /** @type {import("./semantic/types.js").TargetCheckPlan} */ (candidate);
+}
+/**
+ * Collects every regular compiler output without following links.
+ * @param {string} buildPath - Exact owned build root.
+ * @param {import("./semantic/types.js").TargetCheckOutputOwnership} output - Output metadata.
+ * @returns {Promise<import("./semantic/types.js").PublicationBuildArtifactInput[]>} Ordered metadata.
+ */
+async function collectBuildOutputs(buildPath, output) {
+    /** @type {string[]} */
+    const files = [];
+    /** @type {{absolute: string, relative: string}[]} */
+    const pending = [{ absolute: buildPath, relative: "" }];
+    while (pending.length > 0) {
+        const current = /** @type {{absolute: string, relative: string}} */ (pending.pop());
+        let entries;
+        try {
+            entries = await readdir(current.absolute, { withFileTypes: true });
+        }
+        catch (error) {
+            return outputFailure("Compiler output subtree could not be inspected.", error);
+        }
+        entries.sort((left, right) => left.name.localeCompare(right.name, "en"));
+        for (let index = entries.length - 1; index >= 0; index -= 1) {
+            const entry = entries[index];
+            const relative = current.relative.length == 0 ? entry.name : `${current.relative}/${entry.name}`;
+            const absolute = path.join(current.absolute, entry.name);
+            if (entry.isDirectory())
+                pending.push({ absolute, relative });
+            else if (entry.isFile())
+                files.push(relative);
+            else
+                return outputFailure(`Compiler output '${relative}' is not a regular file or directory.`);
+        }
+    }
+    files.sort((left, right) => left.localeCompare(right, "en"));
+    for (const filename of files) {
+        try {
+            if (!(await lstat(path.join(buildPath, filename))).isFile()) {
+                return outputFailure(`Compiler output '${filename}' is not a regular file.`);
+            }
+        }
+        catch (error) {
+            return outputFailure(`Compiler output '${filename}' could not be inspected.`, error);
+        }
+    }
+    return files.map(filename => Object.freeze({ mediaType: output.mediaType, path: filename, role: output.role }));
+}
+/**
+ * Normalizes one child failure while retaining complete bounded output.
+ * @param {unknown} error - Opaque process failure.
+ * @param {import("./semantic/types.js").TargetCheckStageRequest} stage - Failed stage.
+ * @param {import("./semantic/types.js").TargetCheckPlan} plan - Plan context.
+ * @param {number} timeoutMs - Exact timeout.
+ * @param {number} durationMs - Observed duration.
+ * @returns {SemantifoldDiagnostic} Structured check failure.
+ */
+function processDiagnostic(error, stage, plan, timeoutMs, durationMs) {
+    const fields = processErrorFields(error);
+    const outputLimited = fields.nativeCode == "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+    const cancelled = !outputLimited && cancelledOwnedProcess(error);
+    const timedOut = !outputLimited && !cancelled && exceededOwnedDeadline(error);
+    const launchFailure = fields.nativeCode != undefined && launchErrorCodes.has(fields.nativeCode);
+    const signaled = !outputLimited && !cancelled && !timedOut && fields.signal != undefined;
+    const code = outputLimited ? "TARGET_CHECK_OUTPUT_LIMIT" : cancelled ? "TARGET_CHECK_CANCELLED" : timedOut
+        ? "TARGET_CHECK_TIMEOUT" : launchFailure ? "TARGET_CHECK_LAUNCH_FAILURE" : signaled
+        ? "TARGET_CHECK_SIGNAL" : "TARGET_CHECK_NONZERO_EXIT";
+    const reason = outputLimited ? `exceeded the ${maximumOutputBytes}-byte output limit` : cancelled
+        ? "was cancelled" : timedOut ? `timed out after ${timeoutMs}ms` : launchFailure
+        ? `could not launch (${fields.nativeCode})` : signaled ? `closed after signal ${fields.signal}`
+        : fields.exitCode == undefined ? "failed after launch" : `exited nonzero (${fields.exitCode})`;
+    return new SemantifoldDiagnostic({
+        cause: outputLimited ? undefined : error instanceof Error ? error : undefined,
+        code,
+        durationMs,
+        executable: stage.executable,
+        exitCode: fields.exitCode,
+        language: plan.target,
+        message: `Target '${plan.targetId}' stage '${stage.stage}' ${reason} using '${stage.executable}' (${stage.tool.version}).`,
+        projectId: plan.projectId,
+        signal: fields.signal,
+        stage: stage.stage,
+        stderr: fields.stderr,
+        stdout: fields.stdout,
+        targetId: plan.targetId,
+        toolId: stage.tool.id,
+        version: stage.tool.version
+    });
+}
+/**
+ * Creates target-owned environment directories before launch without touching source staging.
+ * @param {import("./semantic/types.js").TargetCheckStageRequest} stage - Validated stage.
+ * @param {import("./semantic/types.js").TargetCheckPlan} plan - Validated plan context.
+ * @returns {Promise<void>} Completion.
+ */
+async function prepareStage(stage, plan) {
+    for (const declaration of stage.environmentPaths) {
+        if (declaration.ownership == "build") {
+            await mkdir(stage.environment[declaration.name], { mode: 0o700, recursive: true });
+        }
+    }
+    for (const transientPath of stage.transientPaths) {
+        if (ownedBy(plan.buildPath, transientPath))
+            await mkdir(transientPath, { mode: 0o700, recursive: true });
+    }
+}
+/**
+ * Removes only explicitly declared generation-owned transient cache/home directories after every child has closed.
+ * @param {import("./semantic/types.js").TargetCheckPlan} plan - Validated plan.
+ * @returns {Promise<void>} Completion.
+ */
+async function cleanupStageEnvironment(plan) {
+    const owned = new Set();
+    for (const stage of plan.stages) {
+        for (const declaration of stage.environmentPaths) {
+            if (declaration.ownership == "build")
+                owned.add(stage.environment[declaration.name]);
+        }
+        for (const transientPath of stage.transientPaths)
+            owned.add(transientPath);
+    }
+    const paths = [...owned].sort((left, right) => right.length - left.length || right.localeCompare(left, "en"));
+    for (const ownedPath of paths) {
+        await rm(ownedPath, { force: true, recursive: true });
+        await removeEmptyParents(path.dirname(ownedPath), ownedBy(plan.buildPath, ownedPath) ? plan.buildPath : plan.sourcePath);
+    }
+}
+/**
+ * Removes empty transient ancestors without ever removing the candidate build root.
+ * @param {string} candidate - First possible empty ancestor.
+ * @param {string} root - Exact retained candidate root.
+ * @returns {Promise<void>} Completion.
+ */
+async function removeEmptyParents(candidate, root) {
+    let current = candidate;
+    while (ownedBy(root, current)) {
+        if ((await readdir(current)).length > 0)
+            return;
+        await rmdir(current);
+        current = path.dirname(current);
+    }
+}
+/**
+ * Preserves cache/home preparation failures separately from tool launch or compilation.
+ * @param {unknown} error - Filesystem failure.
+ * @param {import("./semantic/types.js").TargetCheckStageRequest} stage - Failed stage.
+ * @param {import("./semantic/types.js").TargetCheckPlan} plan - Plan context.
+ * @param {number} durationMs - Observed duration.
+ * @returns {SemantifoldDiagnostic} Structured failure.
+ */
+function preparationDiagnostic(error, stage, plan, durationMs) {
+    return new SemantifoldDiagnostic({
+        cause: error instanceof Error ? error : undefined,
+        code: "TARGET_CHECK_PREPARATION_FAILURE",
+        durationMs,
+        executable: stage.executable,
+        language: plan.target,
+        message: `Target '${plan.targetId}' stage '${stage.stage}' could not prepare its owned cache/home directories.`,
+        projectId: plan.projectId,
+        stage: stage.stage,
+        stderr: "",
+        stdout: "",
+        targetId: plan.targetId,
+        toolId: stage.tool.id,
+        version: stage.tool.version
+    });
+}
+/**
+ * Reports transient cache/home cleanup separately from native compiler diagnostics.
+ * @param {unknown} error - Filesystem failure.
+ * @param {import("./semantic/types.js").TargetCheckPlan} plan - Plan context.
+ * @returns {SemantifoldDiagnostic} Structured cleanup failure.
+ */
+function cleanupDiagnostic(error, plan) {
+    return new SemantifoldDiagnostic({
+        cause: error instanceof Error ? error : undefined,
+        code: "TARGET_CHECK_CLEANUP_FAILURE",
+        language: plan.target,
+        message: `Target '${plan.targetId}' could not remove its owned transient cache/home directories.`,
+        projectId: plan.projectId,
+        targetId: plan.targetId
+    });
+}
+/**
+ * Retains the first plan/process diagnostic while attaching bounded cleanup evidence.
+ * @param {Error} primaryFailure - First check failure.
+ * @param {SemantifoldDiagnostic} cleanupFailure - Structured cleanup failure.
+ * @returns {Error} Original failure with cleanup evidence in its cause chain.
+ */
+function preservePrimaryFailure(primaryFailure, cleanupFailure) {
+    const causes = primaryFailure.cause instanceof Error ? [primaryFailure.cause, cleanupFailure] : [cleanupFailure];
+    Object.defineProperty(primaryFailure, "cause", {
+        configurable: true,
+        value: new AggregateError(causes, "Target check failed and its owned transient environment cleanup also failed."),
+        writable: true
+    });
+    return primaryFailure;
+}
+/**
+ * Creates a structured failure when cancellation precedes stage launch.
+ * @param {import("./semantic/types.js").TargetCheckStageRequest} stage - Cancelled stage.
+ * @param {import("./semantic/types.js").TargetCheckPlan} plan - Plan context.
+ * @param {number} durationMs - Observed duration.
+ * @returns {SemantifoldDiagnostic} Structured cancellation diagnostic.
+ */
+function cancelledDiagnostic(stage, plan, durationMs) {
+    return new SemantifoldDiagnostic({
+        code: "TARGET_CHECK_CANCELLED",
+        durationMs,
+        executable: stage.executable,
+        language: plan.target,
+        message: `Target '${plan.targetId}' stage '${stage.stage}' was cancelled before launch.`,
+        projectId: plan.projectId,
+        stage: stage.stage,
+        stderr: "",
+        stdout: "",
+        targetId: plan.targetId,
+        toolId: stage.tool.id,
+        version: stage.tool.version
+    });
+}
+/**
+ * Extracts stable bounded child-process failure fields.
+ * @param {unknown} error - Opaque 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);
+    return {
+        exitCode: typeof value.code == "number" ? value.code : undefined,
+        nativeCode: typeof value.code == "string" ? 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 the complete immutable discovered-tool shape consumed by a plan.
+ * @param {unknown} value - Candidate tool record.
+ * @returns {value is import("./semantic/types.js").DiscoveredToolchain} Whether the tool shape is valid.
+ */
+function isDiscoveredTool(value) {
+    return isPlainObject(value) && typeof value.id == "string" && typeof value.command == "string" &&
+        typeof value.executable == "string" && path.isAbsolute(value.executable) && !value.executable.includes("\0") &&
+        (value.source == "canonical" || value.source == "override") && typeof value.version == "string" && value.version.length > 0 &&
+        typeof value.versionOutput == "string" && isDenseArray(value.versionArguments) &&
+        value.versionArguments.every(argument => typeof argument == "string" && !argument.includes("\0"));
+}
+/**
+ * Checks that an environment is immutable and already deterministic.
+ * @param {unknown} value - Candidate environment record.
+ * @returns {boolean} Whether the environment is normalized.
+ */
+function validEnvironment(value) {
+    if (!isPlainRecord(value) || !Object.isFrozen(value))
+        return false;
+    let normalized;
+    try {
+        normalized = deterministicEnvironment(/** @type {Readonly<Record<string, string>>} */ (value));
+    }
+    catch {
+        return false;
+    }
+    const actual = Object.entries(value).sort(([left], [right]) => left.localeCompare(right, "en"));
+    const expected = Object.entries(normalized).sort(([left], [right]) => left.localeCompare(right, "en"));
+    return JSON.stringify(actual) == JSON.stringify(expected);
+}
+/**
+ * Checks every absolute non-PATH environment value against an explicit candidate-owned directory or discovered-tool declaration.
+ * @param {unknown} value - Candidate declarations.
+ * @param {Readonly<Record<string, string>>} environment - Validated deterministic environment.
+ * @param {string} sourcePath - Candidate source root.
+ * @param {string} buildPath - Candidate build root.
+ * @param {readonly string[]} toolchains - Target-declared toolchain IDs.
+ * @param {Set<string>} usedTools - Validated tools used by this plan.
+ * @returns {value is readonly import("./semantic/types.js").TargetCheckEnvironmentPath[]} Whether ownership is complete.
+ */
+function validEnvironmentPaths(value, environment, sourcePath, buildPath, toolchains, usedTools) {
+    if (!isDenseArray(value) || !Object.isFrozen(value))
+        return false;
+    const names = new Set();
+    for (let index = 0; index < value.length; index += 1) {
+        const declaration = value[index];
+        if (!isPlainObject(declaration) || !Object.isFrozen(declaration) ||
+            !hasExactKeys(declaration, declaration.ownership == "tool" ? ["name", "ownership", "tool"] : ["name", "ownership"]) ||
+            typeof declaration.name != "string" || names.has(declaration.name))
+            return false;
+        const environmentPath = environment[declaration.name];
+        if (declaration.ownership == "tool") {
+            if (!isDiscoveredTool(declaration.tool) || !Object.isFrozen(declaration.tool) ||
+                !Object.isFrozen(declaration.tool.versionArguments) || !toolchains.includes(declaration.tool.id) ||
+                environmentPath != declaration.tool.executable)
+                return false;
+            usedTools.add(declaration.tool.id);
+            names.add(declaration.name);
+            continue;
+        }
+        if (declaration.ownership != "source" && declaration.ownership != "build")
+            return false;
+        const root = declaration.ownership == "source" ? sourcePath : buildPath;
+        if (typeof environmentPath != "string" || !ownedBy(root, environmentPath))
+            return false;
+        names.add(declaration.name);
+    }
+    for (const [name, environmentValue] of Object.entries(environment)) {
+        if (name != "PATH" && path.isAbsolute(environmentValue) && !names.has(name))
+            return false;
+    }
+    return true;
+}
+/**
+ * Checks generation-owned transient cache/intermediate directories.
+ * @param {unknown} value - Candidate path vector.
+ * @param {string} sourcePath - Candidate source root.
+ * @param {string} buildPath - Candidate build root.
+ * @param {Set<string>} artifactPaths - Exact staged artifact paths.
+ * @returns {value is readonly string[]} Whether paths are immutable distinct candidate descendants.
+ */
+function validTransientPaths(value, sourcePath, buildPath, artifactPaths) {
+    if (!isDenseArray(value) || !Object.isFrozen(value))
+        return false;
+    const paths = new Set();
+    for (let index = 0; index < value.length; index += 1) {
+        const transientPath = value[index];
+        if (typeof transientPath != "string" || !ownedBy(sourcePath, transientPath) && !ownedBy(buildPath, transientPath) ||
+            paths.has(transientPath) || ownedBy(sourcePath, transientPath) && [...artifactPaths].some(artifactPath => transientPath == artifactPath || pathsOverlap(transientPath, artifactPath)))
+            return false;
+        paths.add(transientPath);
+    }
+    return true;
+}
+/**
+ * Checks compiler-output metadata against the owned build root.
+ * @param {unknown} value - Candidate output record.
+ * @param {string} buildPath - Exact candidate build root.
+ * @returns {boolean} Whether output ownership is valid.
+ */
+function validOutput(value, buildPath) {
+    return isPlainObject(value) && Object.isFrozen(value) && hasExactKeys(value, ["mediaType", "ownership", "path", "role"]) &&
+        value.ownership == "build" && value.path == buildPath && typeof value.mediaType == "string" &&
+        mediaTypePattern.test(value.mediaType) && typeof value.role == "string" && rolePattern.test(value.role);
+}
+/**
+ * Checks strict descendant ownership without accepting the root itself.
+ * @param {string} root - Absolute owned root.
+ * @param {string} candidate - Absolute candidate path.
+ * @returns {boolean} Whether the candidate is a strict descendant.
+ */
+function ownedBy(root, candidate) {
+    if (!path.isAbsolute(candidate))
+        return false;
+    const relative = path.relative(root, candidate);
+    return relative.length > 0 && !relative.startsWith(`..${path.sep}`) && relative != ".." && !path.isAbsolute(relative);
+}
+/**
+ * Checks candidate ownership by either exact target subtree.
+ * @param {string} sourcePath - Exact source root.
+ * @param {string} buildPath - Exact build root.
+ * @param {string} candidate - Candidate working directory.
+ * @returns {boolean} Whether either target subtree owns the candidate.
+ */
+function ownedByEither(sourcePath, buildPath, candidate) {
+    return candidate == sourcePath || candidate == buildPath || ownedBy(sourcePath, candidate) || ownedBy(buildPath, candidate);
+}
+/**
+ * Checks whether two absolute roots overlap in either direction.
+ * @param {string} left - First root.
+ * @param {string} right - Second root.
+ * @returns {boolean} Whether the roots overlap.
+ */
+function pathsOverlap(left, right) {
+    return left == right || ownedBy(left, right) || ownedBy(right, left);
+}
+/**
+ * Normalizes one monotonic duration observation.
+ * @param {number} endedAt - End observation.
+ * @param {number} startedAt - Start observation.
+ * @returns {number} Finite non-negative duration.
+ */
+function elapsed(endedAt, startedAt) {
+    const duration = endedAt - startedAt;
+    return Number.isFinite(duration) && duration >= 0 ? duration : 0;
+}
+/**
+ * Throws one compiler-output inspection diagnostic.
+ * @param {string} message - Failure detail.
+ * @param {unknown} [cause] - Optional underlying failure.
+ * @returns {never} Always throws.
+ */
+function outputFailure(message, cause) {
+    throw new SemantifoldDiagnostic({
+        cause: cause instanceof Error ? cause : undefined,
+        code: "TARGET_CHECK_OUTPUT_INVALID",
+        language: "check",
+        message
+    });
+}
+/**
+ * Throws one invalid-plan diagnostic.
+ * @param {string} message - Failure detail.
+ * @param {string} [target] - Target diagnostic identity.
+ * @param {unknown} [cause] - Optional underlying failure.
+ * @returns {never} Always throws.
+ */
+function invalidPlan(message, target = "check", cause) {
+    throw new SemantifoldDiagnostic({
+        cause: cause instanceof Error ? cause : undefined,
+        code: "INVALID_TARGET_CHECK_PLAN",
+        language: target,
+        message
+    });
+}
+/**
+ * Checks for an ordinary object-prototype record.
+ * @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;
+}
+/**
+ * Checks for an own-property string-data record with an ordinary or null prototype.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain data record.
+ */
+function isPlainRecord(value) {
+    if (typeof value != "object" || value == null || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return false;
+    return Reflect.ownKeys(value).every(key => {
+        if (typeof key != "string")
+            return false;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        return descriptor != undefined && descriptor.enumerable && "value" in descriptor && typeof descriptor.value == "string";
+    });
+}
+/**
+ * Checks one closed object-key set.
+ * @param {Record<string, unknown>} value - Candidate record.
+ * @param {string[]} keys - Exact allowed keys.
+ * @returns {boolean} Whether the key sets match.
+ */
+function hasExactKeys(value, keys) {
+    return Object.keys(value).sort().join("\0") == [...keys].sort().join("\0");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"target-check.js","sourceRoot":"","sources":["../../src/target-check.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {lstat, mkdir, readdir, rm, rmdir} from \"node:fs/promises\"\nimport path from \"node:path\"\nimport {isDenseArray} from \"./array.js\"\nimport {createGeneratedArtifactSet} from \"./artifacts.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {languageRegistry} from \"./language-registry.js\"\nimport {cancelledOwnedProcess, exceededOwnedDeadline, executeFileWithDeadline} from \"./subprocess.js\"\nimport {isSupportedTimeoutMs, maximumTimeoutMs} from \"./timeout.js\"\nimport {deterministicEnvironment} from \"./toolchains.js\"\n\nconst defaultTimeoutMs = 20_000\nconst maximumOutputBytes = 1024 * 1024\nconst identityPattern = /^[a-z][a-z0-9-]*$/u\nconst mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\\/[A-Za-z0-9!#$&^_.+-]+(?:;[\\u0020-\\u007e]+)?$/u\nconst rolePattern = /^[a-z][a-z0-9-]*$/u\nconst launchErrorCodes = new Set([\n  \"E2BIG\", \"EACCES\", \"EAGAIN\", \"ELOOP\", \"EMFILE\", \"ENAMETOOLONG\", \"ENFILE\", \"ENOENT\", \"ENOEXEC\", \"ENOMEM\",\n  \"ENOTDIR\", \"ENOTSUP\", \"EPERM\", \"ETXTBSY\"\n])\n/** @type {WeakMap<TargetCheckRunner, {execute: typeof executeFileWithDeadline, now: () => number}>} */\nconst targetCheckRunnerDependencies = new WeakMap()\n\n/**\n * Creates and validates one target-owned developer check plan.\n * @param {object} input - Exact staged target context.\n * @param {import(\"./semantic/types.js\").GeneratedArtifactSet} input.artifacts - Validated staged artifacts.\n * @param {string} input.buildPath - Exact generation-scoped target build subtree.\n * @param {string} input.projectId - Exact project identity.\n * @param {string} input.sourcePath - Exact generation-scoped target source subtree.\n * @param {string} input.targetId - Exact project target identity.\n * @param {readonly import(\"./semantic/types.js\").DiscoveredToolchain[]} input.tools - Discovered immutable tool records.\n * @returns {import(\"./semantic/types.js\").TargetCheckPlan} Validated immutable plan.\n */\nexport function createTargetCheckPlan(input) {\n  if (!isPlainObject(input) || !hasExactKeys(input, [\"artifacts\", \"buildPath\", \"projectId\", \"sourcePath\", \"targetId\", \"tools\"])) {\n    return invalidPlan(\"Target check planning requires only staged artifacts, candidate roots, identities, and tools.\")\n  }\n  let artifacts\n\n  try {\n    artifacts = createGeneratedArtifactSet(input.artifacts)\n  } catch (error) {\n    return invalidPlan(\"Target check planning requires a valid generated artifact set.\", \"check\", error)\n  }\n  const target = artifacts.target\n  const record = languageRegistry.record(target)\n  const capability = record.check\n\n  if (!capability.supported || typeof capability.factory != \"function\") {\n    throw new SemantifoldDiagnostic({\n      code: \"UNSUPPORTED_TARGET_CHECK\",\n      language: target,\n      message: \"Registered target does not provide a developer check plan.\"\n    })\n  }\n  if (typeof input.projectId != \"string\" || !identityPattern.test(input.projectId) ||\n    typeof input.targetId != \"string\" || !identityPattern.test(input.targetId) ||\n    typeof input.sourcePath != \"string\" || !path.isAbsolute(input.sourcePath) ||\n    typeof input.buildPath != \"string\" || !path.isAbsolute(input.buildPath) ||\n    pathsOverlap(input.sourcePath, input.buildPath) || !isDenseArray(input.tools)) {\n    return invalidPlan(\"Target check planning received invalid identities, candidate roots, or tools.\", target)\n  }\n  /** @type {import(\"./semantic/types.js\").DiscoveredToolchain[]} */\n  const tools = []\n\n  for (let index = 0; index < input.tools.length; index += 1) {\n    const tool = input.tools[index]\n\n    if (!isDiscoveredTool(tool) || !Object.isFrozen(tool) || !Object.isFrozen(tool.versionArguments)) {\n      return invalidPlan(\"Target check planning requires immutable discovered tool records.\", target)\n    }\n    tools.push(tool)\n  }\n  if (tools.map(({id}) => id).join(\"\\0\") != capability.toolchains.join(\"\\0\")) {\n    return invalidPlan(\"Target check planning tools must exactly match the target-declared developer-check toolchains.\", target)\n  }\n  const context = Object.freeze({\n    artifacts,\n    buildPath: input.buildPath,\n    projectId: input.projectId,\n    sourcePath: input.sourcePath,\n    targetId: input.targetId,\n    tools: Object.freeze(tools)\n  })\n  let plan\n\n  try {\n    plan = capability.factory(context)\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    return invalidPlan(\"Target check plan factory failed.\", target, error)\n  }\n  const validated = validateTargetCheckPlan(plan)\n  const expectedArtifacts = new Set(context.artifacts.artifacts.map(artifact => path.join(context.sourcePath, artifact.path)))\n\n  if (validated.projectId != context.projectId || validated.targetId != context.targetId ||\n    validated.target != target || validated.sourcePath != context.sourcePath || validated.buildPath != context.buildPath ||\n    validated.artifactPaths.length != expectedArtifacts.size || validated.artifactPaths.some(artifact => !expectedArtifacts.has(artifact))) {\n    return invalidPlan(\"Target check plan changed its validated candidate context.\", target)\n  }\n\n  return validated\n}\n\n/**\n * Owns ordered check subprocesses and settles only after each child closes.\n */\nexport class TargetCheckRunner {\n  /**\n   * Runs one already-staged immutable plan without executing generated application code.\n   * @param {import(\"./semantic/types.js\").TargetCheckPlan} plan - Target-owned plan.\n   * @param {{onStage?: (result: import(\"./semantic/types.js\").TargetCheckStageResult) => void, signal?: AbortSignal, timeoutMs?: number}} [options] - Lifecycle controls.\n   * @returns {Promise<import(\"./semantic/types.js\").TargetCheckResult>} Successful check evidence and output metadata.\n   */\n  async run(plan, options = {}) {\n    const validated = validateTargetCheckPlan(plan)\n    const dependencies = targetCheckRunnerDependencies.get(this) ?? {\n      execute: executeFileWithDeadline,\n      now: () => performance.now()\n    }\n\n    if (!isPlainObject(options) || options.onStage !== undefined && typeof options.onStage != \"function\" ||\n      options.signal !== undefined && !(options.signal instanceof AbortSignal)) {\n      return invalidPlan(\"Target check runner options are invalid.\", validated.target)\n    }\n    const timeoutMs = options.timeoutMs === undefined ? defaultTimeoutMs : options.timeoutMs\n\n    if (!isSupportedTimeoutMs(timeoutMs)) {\n      return invalidPlan(`Target check timeout must be from 1 through ${maximumTimeoutMs}ms.`, validated.target)\n    }\n    /** @type {import(\"./semantic/types.js\").TargetCheckStageResult[]} */\n    const results = []\n    /** @type {unknown} */\n    let stageFailure\n    let stageFailed = false\n\n    try {\n      for (const stage of validated.stages) {\n        const startedAt = dependencies.now()\n        /** @type {import(\"./semantic/types.js\").TargetCheckStageResult} */\n        let stageResult\n\n        if (options.signal?.aborted) throw cancelledDiagnostic(stage, validated, 0)\n        try {\n          await prepareStage(stage, validated)\n        } catch (error) {\n          throw preparationDiagnostic(error, stage, validated, elapsed(dependencies.now(), startedAt))\n        }\n        try {\n          const output = await dependencies.execute({\n            arguments: stage.argv,\n            cwd: stage.cwd,\n            environment: stage.environment,\n            executable: stage.executable,\n            maxBuffer: maximumOutputBytes,\n            signal: options.signal,\n            timeoutMs\n          })\n          stageResult = Object.freeze({\n            argv: stage.argv,\n            durationMs: elapsed(dependencies.now(), startedAt),\n            exitCode: 0,\n            signal: null,\n            stage: stage.stage,\n            stderr: output.stderr,\n            stdout: output.stdout,\n            tool: Object.freeze({\n              command: stage.tool.command,\n              executable: stage.tool.executable,\n              id: stage.tool.id,\n              source: stage.tool.source,\n              version: stage.tool.version\n            })\n          })\n\n        } catch (error) {\n          throw processDiagnostic(error, stage, validated, timeoutMs, elapsed(dependencies.now(), startedAt))\n        }\n        results.push(stageResult)\n        options.onStage?.(stageResult)\n      }\n    } catch (error) {\n      stageFailed = true\n      stageFailure = error\n    }\n    try {\n      await cleanupStageEnvironment(validated)\n    } catch (error) {\n      const cleanup = cleanupDiagnostic(error, validated)\n\n      if (stageFailed && stageFailure instanceof Error) throw preservePrimaryFailure(stageFailure, cleanup)\n      if (stageFailed) throw new AggregateError([stageFailure, cleanup],\n        \"Target check failed and its owned transient environment could not be cleaned.\", {cause: error})\n      throw cleanup\n    }\n    if (stageFailed) throw stageFailure\n    const output = validated.stages.findLast(stage => stage.output !== null)?.output\n    const outputs = output == null ? [] : await collectBuildOutputs(validated.buildPath, output)\n\n    return Object.freeze({\n      outputs: Object.freeze(outputs),\n      projectId: validated.projectId,\n      stages: Object.freeze(results),\n      target: validated.target,\n      targetId: validated.targetId\n    })\n  }\n}\n\n/**\n * Creates a runner with focused instance-owned dependencies.\n * @param {{execute: typeof executeFileWithDeadline, now: () => number}} dependencies - Testable lifecycle collaborators.\n * @returns {TargetCheckRunner} Runner.\n */\nexport function createTargetCheckRunner(dependencies) {\n  if (!isPlainObject(dependencies) || typeof dependencies.execute != \"function\" || typeof dependencies.now != \"function\") {\n    throw new TypeError(\"Invalid target check runner dependencies.\")\n  }\n  const runner = new TargetCheckRunner()\n\n  targetCheckRunnerDependencies.set(runner, dependencies)\n\n  return runner\n}\n\n/**\n * Validates a complete immutable plan before any process starts.\n * @param {unknown} candidate - Candidate plan.\n * @returns {import(\"./semantic/types.js\").TargetCheckPlan} Exact validated plan.\n */\nexport function validateTargetCheckPlan(candidate) {\n  if (!isPlainObject(candidate) || !Object.isFrozen(candidate) || !hasExactKeys(candidate, [\n    \"artifactPaths\", \"buildPath\", \"mode\", \"projectId\", \"schema\", \"sourcePath\", \"stages\", \"target\", \"targetId\", \"version\"\n  ])) return invalidPlan(\"Target check plan must be one immutable closed schema record.\")\n  const target = typeof candidate.target == \"string\" ? candidate.target : \"check\"\n  const record = languageRegistry.record(target)\n  const capability = record.check\n\n  if (!capability.supported || candidate.schema != \"SemantifoldTargetCheckPlan\" || candidate.version != 1 ||\n    candidate.mode != \"developer-check\" || typeof candidate.projectId != \"string\" || !identityPattern.test(candidate.projectId) ||\n    typeof candidate.targetId != \"string\" || !identityPattern.test(candidate.targetId) ||\n    typeof candidate.sourcePath != \"string\" || !path.isAbsolute(candidate.sourcePath) ||\n    typeof candidate.buildPath != \"string\" || !path.isAbsolute(candidate.buildPath) ||\n    pathsOverlap(candidate.sourcePath, candidate.buildPath)) {\n    return invalidPlan(\"Target check plan has invalid schema, mode, identity, target, or candidate roots.\", target)\n  }\n  if (!isDenseArray(candidate.artifactPaths) || !Object.isFrozen(candidate.artifactPaths) || candidate.artifactPaths.length == 0 ||\n    !isDenseArray(candidate.stages) || !Object.isFrozen(candidate.stages) || candidate.stages.length == 0) {\n    return invalidPlan(\"Target check plan requires dense immutable artifact and stage vectors.\", target)\n  }\n  const artifactPaths = new Set()\n\n  for (let index = 0; index < candidate.artifactPaths.length; index += 1) {\n    const artifactPath = candidate.artifactPaths[index]\n\n    if (typeof artifactPath != \"string\" || !ownedBy(candidate.sourcePath, artifactPath) || artifactPaths.has(artifactPath)) {\n      return invalidPlan(\"Every planned artifact must be a distinct absolute path inside the candidate source subtree.\", target)\n    }\n    artifactPaths.add(artifactPath)\n  }\n  const plannedStageKinds = candidate.stages.map(stage => isPlainObject(stage) && typeof stage.stage == \"string\" ? stage.stage : \"\")\n    .filter((stage, index, stages) => index == 0 || stage != stages[index - 1])\n\n  if (plannedStageKinds.join(\"\\0\") != capability.stages.join(\"\\0\")) {\n    return invalidPlan(\"Target check stages must exactly match the target-declared developer-check stages.\", target)\n  }\n  const usedTools = new Set()\n  const referencedArtifactPaths = new Set()\n\n  for (let index = 0; index < candidate.stages.length; index += 1) {\n    const stage = candidate.stages[index]\n    if (!isPlainObject(stage) || !Object.isFrozen(stage) || !hasExactKeys(stage, [\n      \"argv\", \"cwd\", \"environment\", \"environmentPaths\", \"executable\", \"inputHash\", \"inputs\", \"output\", \"pathArguments\",\n      \"stage\", \"tool\", \"transientPaths\"\n    ]) || typeof stage.stage != \"string\" || stage.stage == \"execute\" ||\n      !record.acceptance.stages.includes(/** @type {import(\"./semantic/types.js\").AcceptanceStage} */ (stage.stage))) {\n      return invalidPlan(\"Target check stages must be immutable, ordered, declared, and non-executing.\", target)\n    }\n    const request = /** @type {import(\"./semantic/types.js\").TargetCheckStageRequest} */ (stage)\n\n    if (!isDiscoveredTool(request.tool) || !Object.isFrozen(request.tool) || !Object.isFrozen(request.tool.versionArguments) ||\n      request.executable != request.tool.executable || !capability.toolchains.includes(request.tool.id)) {\n      return invalidPlan(`Target check stage '${request.stage}' uses an invalid or undeclared tool.`, target)\n    }\n    usedTools.add(request.tool.id)\n    if (!isDenseArray(request.argv) || !Object.isFrozen(request.argv) ||\n      !request.argv.every(argument => typeof argument == \"string\" && !argument.includes(\"\\0\")) ||\n      !isDenseArray(request.pathArguments) || !Object.isFrozen(request.pathArguments)) {\n      return invalidPlan(`Target check stage '${request.stage}' requires a dense immutable shell-free argv.`, target)\n    }\n    if (!validEnvironment(request.environment)) {\n      return invalidPlan(`Target check stage '${request.stage}' requires an immutable deterministic environment.`, target)\n    }\n    if (!validEnvironmentPaths(request.environmentPaths, request.environment, candidate.sourcePath, candidate.buildPath,\n      capability.toolchains, usedTools)) {\n      return invalidPlan(`Target check stage '${request.stage}' has invalid environment-path ownership.`, target)\n    }\n    if (typeof request.cwd != \"string\" || !ownedByEither(candidate.sourcePath, candidate.buildPath, request.cwd)) {\n      return invalidPlan(`Target check stage '${request.stage}' working directory escapes the candidate target subtrees.`, target)\n    }\n    if (request.output !== null && !validOutput(request.output, candidate.buildPath)) {\n      return invalidPlan(`Target check stage '${request.stage}' has invalid compiler-output ownership.`, target)\n    }\n    if (!validTransientPaths(request.transientPaths, candidate.sourcePath, candidate.buildPath, artifactPaths)) {\n      return invalidPlan(`Target check stage '${request.stage}' has invalid transient-path ownership.`, target)\n    }\n    if (request.stage == \"restore\" ? typeof request.inputHash != \"string\" || !/^[a-f0-9]{64}$/u.test(request.inputHash) : request.inputHash !== null) {\n      return invalidPlan(`Target check stage '${request.stage}' has invalid restore-input identity.`, target)\n    }\n    if (!isDenseArray(request.inputs) || !Object.isFrozen(request.inputs) || request.inputs.length == 0) {\n      return invalidPlan(`Target check stage '${request.stage}' requires immutable declared inputs.`, target)\n    }\n    const stageInputs = new Set()\n\n    for (let inputIndex = 0; inputIndex < request.inputs.length; inputIndex += 1) {\n      const inputPath = request.inputs[inputIndex]\n\n      if (typeof inputPath != \"string\" || stageInputs.has(inputPath) || !ownedByEither(candidate.sourcePath, candidate.buildPath, inputPath)) {\n        return invalidPlan(`Target check stage '${request.stage}' has invalid or duplicate declared inputs.`, target)\n      }\n      if (ownedBy(candidate.sourcePath, inputPath)) {\n        if (!artifactPaths.has(inputPath)) {\n          return invalidPlan(`Target check stage '${request.stage}' reads an undeclared staged artifact.`, target)\n        }\n        referencedArtifactPaths.add(inputPath)\n      }\n      stageInputs.add(inputPath)\n    }\n    const pathIndexes = new Set()\n    for (let pathIndex = 0; pathIndex < request.pathArguments.length; pathIndex += 1) {\n      const declaration = request.pathArguments[pathIndex]\n\n      if (!isPlainObject(declaration) || !Object.isFrozen(declaration) ||\n        !hasExactKeys(declaration, declaration.prefix === undefined ? [\"index\", \"ownership\"] : [\"index\", \"ownership\", \"prefix\"]) ||\n        typeof declaration.index != \"number\" || !Number.isInteger(declaration.index) || declaration.index < 0 ||\n        declaration.index >= request.argv.length ||\n        pathIndexes.has(declaration.index) || declaration.ownership != \"source\" && declaration.ownership != \"build\" ||\n        declaration.prefix !== undefined && (typeof declaration.prefix != \"string\" || declaration.prefix.length == 0 ||\n          declaration.prefix.includes(\"\\0\"))) {\n        return invalidPlan(`Target check stage '${request.stage}' has invalid path-argument ownership.`, target)\n      }\n      const rawArgument = request.argv[declaration.index]\n      const argument = declaration.prefix === undefined\n        ? rawArgument\n        : rawArgument.startsWith(declaration.prefix)\n          ? rawArgument.slice(declaration.prefix.length)\n          : \"\"\n      const root = declaration.ownership == \"source\" ? candidate.sourcePath : candidate.buildPath\n\n      if (argument != root && !ownedBy(root, argument)) {\n        return invalidPlan(`Target check stage '${request.stage}' path argument escapes its candidate subtree.`, target)\n      }\n      pathIndexes.add(declaration.index)\n    }\n    for (let argumentIndex = 0; argumentIndex < request.argv.length; argumentIndex += 1) {\n      if (path.isAbsolute(request.argv[argumentIndex]) && !pathIndexes.has(argumentIndex)) {\n        return invalidPlan(`Target check stage '${request.stage}' contains an unowned absolute path argument.`, target)\n      }\n    }\n  }\n  if (referencedArtifactPaths.size != artifactPaths.size) {\n    return invalidPlan(\"Target check plan must include every staged check artifact.\", target)\n  }\n  if (capability.toolchains.some(toolchain => !usedTools.has(toolchain))) {\n    return invalidPlan(\"Target check plan omits a target-declared toolchain.\", target)\n  }\n\n  return /** @type {import(\"./semantic/types.js\").TargetCheckPlan} */ (candidate)\n}\n\n/**\n * Collects every regular compiler output without following links.\n * @param {string} buildPath - Exact owned build root.\n * @param {import(\"./semantic/types.js\").TargetCheckOutputOwnership} output - Output metadata.\n * @returns {Promise<import(\"./semantic/types.js\").PublicationBuildArtifactInput[]>} Ordered metadata.\n */\nasync function collectBuildOutputs(buildPath, output) {\n  /** @type {string[]} */\n  const files = []\n  /** @type {{absolute: string, relative: string}[]} */\n  const pending = [{absolute: buildPath, relative: \"\"}]\n\n  while (pending.length > 0) {\n    const current = /** @type {{absolute: string, relative: string}} */ (pending.pop())\n    let entries\n\n    try {\n      entries = await readdir(current.absolute, {withFileTypes: true})\n    } catch (error) {\n      return outputFailure(\"Compiler output subtree could not be inspected.\", error)\n    }\n    entries.sort((left, right) => left.name.localeCompare(right.name, \"en\"))\n    for (let index = entries.length - 1; index >= 0; index -= 1) {\n      const entry = entries[index]\n      const relative = current.relative.length == 0 ? entry.name : `${current.relative}/${entry.name}`\n      const absolute = path.join(current.absolute, entry.name)\n\n      if (entry.isDirectory()) pending.push({absolute, relative})\n      else if (entry.isFile()) files.push(relative)\n      else return outputFailure(`Compiler output '${relative}' is not a regular file or directory.`)\n    }\n  }\n  files.sort((left, right) => left.localeCompare(right, \"en\"))\n  for (const filename of files) {\n    try {\n      if (!(await lstat(path.join(buildPath, filename))).isFile()) {\n        return outputFailure(`Compiler output '${filename}' is not a regular file.`)\n      }\n    } catch (error) {\n      return outputFailure(`Compiler output '${filename}' could not be inspected.`, error)\n    }\n  }\n\n  return files.map(filename => Object.freeze({mediaType: output.mediaType, path: filename, role: output.role}))\n}\n\n/**\n * Normalizes one child failure while retaining complete bounded output.\n * @param {unknown} error - Opaque process failure.\n * @param {import(\"./semantic/types.js\").TargetCheckStageRequest} stage - Failed stage.\n * @param {import(\"./semantic/types.js\").TargetCheckPlan} plan - Plan context.\n * @param {number} timeoutMs - Exact timeout.\n * @param {number} durationMs - Observed duration.\n * @returns {SemantifoldDiagnostic} Structured check failure.\n */\nfunction processDiagnostic(error, stage, plan, timeoutMs, durationMs) {\n  const fields = processErrorFields(error)\n  const outputLimited = fields.nativeCode == \"ERR_CHILD_PROCESS_STDIO_MAXBUFFER\"\n  const cancelled = !outputLimited && cancelledOwnedProcess(error)\n  const timedOut = !outputLimited && !cancelled && exceededOwnedDeadline(error)\n  const launchFailure = fields.nativeCode != undefined && launchErrorCodes.has(fields.nativeCode)\n  const signaled = !outputLimited && !cancelled && !timedOut && fields.signal != undefined\n  const code = outputLimited ? \"TARGET_CHECK_OUTPUT_LIMIT\" : cancelled ? \"TARGET_CHECK_CANCELLED\" : timedOut\n    ? \"TARGET_CHECK_TIMEOUT\" : launchFailure ? \"TARGET_CHECK_LAUNCH_FAILURE\" : signaled\n      ? \"TARGET_CHECK_SIGNAL\" : \"TARGET_CHECK_NONZERO_EXIT\"\n  const reason = outputLimited ? `exceeded the ${maximumOutputBytes}-byte output limit` : cancelled\n    ? \"was cancelled\" : timedOut ? `timed out after ${timeoutMs}ms` : launchFailure\n      ? `could not launch (${fields.nativeCode})` : signaled ? `closed after signal ${fields.signal}`\n        : fields.exitCode == undefined ? \"failed after launch\" : `exited nonzero (${fields.exitCode})`\n\n  return new SemantifoldDiagnostic({\n    cause: outputLimited ? undefined : error instanceof Error ? error : undefined,\n    code,\n    durationMs,\n    executable: stage.executable,\n    exitCode: fields.exitCode,\n    language: plan.target,\n    message: `Target '${plan.targetId}' stage '${stage.stage}' ${reason} using '${stage.executable}' (${stage.tool.version}).`,\n    projectId: plan.projectId,\n    signal: fields.signal,\n    stage: stage.stage,\n    stderr: fields.stderr,\n    stdout: fields.stdout,\n    targetId: plan.targetId,\n    toolId: stage.tool.id,\n    version: stage.tool.version\n  })\n}\n\n/**\n * Creates target-owned environment directories before launch without touching source staging.\n * @param {import(\"./semantic/types.js\").TargetCheckStageRequest} stage - Validated stage.\n * @param {import(\"./semantic/types.js\").TargetCheckPlan} plan - Validated plan context.\n * @returns {Promise<void>} Completion.\n */\nasync function prepareStage(stage, plan) {\n  for (const declaration of stage.environmentPaths) {\n    if (declaration.ownership == \"build\") {\n      await mkdir(stage.environment[declaration.name], {mode: 0o700, recursive: true})\n    }\n  }\n  for (const transientPath of stage.transientPaths) {\n    if (ownedBy(plan.buildPath, transientPath)) await mkdir(transientPath, {mode: 0o700, recursive: true})\n  }\n}\n\n/**\n * Removes only explicitly declared generation-owned transient cache/home directories after every child has closed.\n * @param {import(\"./semantic/types.js\").TargetCheckPlan} plan - Validated plan.\n * @returns {Promise<void>} Completion.\n */\nasync function cleanupStageEnvironment(plan) {\n  const owned = new Set()\n\n  for (const stage of plan.stages) {\n    for (const declaration of stage.environmentPaths) {\n      if (declaration.ownership == \"build\") owned.add(stage.environment[declaration.name])\n    }\n    for (const transientPath of stage.transientPaths) owned.add(transientPath)\n  }\n  const paths = [...owned].sort((left, right) => right.length - left.length || right.localeCompare(left, \"en\"))\n\n  for (const ownedPath of paths) {\n    await rm(ownedPath, {force: true, recursive: true})\n    await removeEmptyParents(path.dirname(ownedPath), ownedBy(plan.buildPath, ownedPath) ? plan.buildPath : plan.sourcePath)\n  }\n}\n\n/**\n * Removes empty transient ancestors without ever removing the candidate build root.\n * @param {string} candidate - First possible empty ancestor.\n * @param {string} root - Exact retained candidate root.\n * @returns {Promise<void>} Completion.\n */\nasync function removeEmptyParents(candidate, root) {\n  let current = candidate\n\n  while (ownedBy(root, current)) {\n    if ((await readdir(current)).length > 0) return\n    await rmdir(current)\n    current = path.dirname(current)\n  }\n}\n\n/**\n * Preserves cache/home preparation failures separately from tool launch or compilation.\n * @param {unknown} error - Filesystem failure.\n * @param {import(\"./semantic/types.js\").TargetCheckStageRequest} stage - Failed stage.\n * @param {import(\"./semantic/types.js\").TargetCheckPlan} plan - Plan context.\n * @param {number} durationMs - Observed duration.\n * @returns {SemantifoldDiagnostic} Structured failure.\n */\nfunction preparationDiagnostic(error, stage, plan, durationMs) {\n  return new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code: \"TARGET_CHECK_PREPARATION_FAILURE\",\n    durationMs,\n    executable: stage.executable,\n    language: plan.target,\n    message: `Target '${plan.targetId}' stage '${stage.stage}' could not prepare its owned cache/home directories.`,\n    projectId: plan.projectId,\n    stage: stage.stage,\n    stderr: \"\",\n    stdout: \"\",\n    targetId: plan.targetId,\n    toolId: stage.tool.id,\n    version: stage.tool.version\n  })\n}\n\n/**\n * Reports transient cache/home cleanup separately from native compiler diagnostics.\n * @param {unknown} error - Filesystem failure.\n * @param {import(\"./semantic/types.js\").TargetCheckPlan} plan - Plan context.\n * @returns {SemantifoldDiagnostic} Structured cleanup failure.\n */\nfunction cleanupDiagnostic(error, plan) {\n  return new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code: \"TARGET_CHECK_CLEANUP_FAILURE\",\n    language: plan.target,\n    message: `Target '${plan.targetId}' could not remove its owned transient cache/home directories.`,\n    projectId: plan.projectId,\n    targetId: plan.targetId\n  })\n}\n\n/**\n * Retains the first plan/process diagnostic while attaching bounded cleanup evidence.\n * @param {Error} primaryFailure - First check failure.\n * @param {SemantifoldDiagnostic} cleanupFailure - Structured cleanup failure.\n * @returns {Error} Original failure with cleanup evidence in its cause chain.\n */\nfunction preservePrimaryFailure(primaryFailure, cleanupFailure) {\n  const causes = primaryFailure.cause instanceof Error ? [primaryFailure.cause, cleanupFailure] : [cleanupFailure]\n\n  Object.defineProperty(primaryFailure, \"cause\", {\n    configurable: true,\n    value: new AggregateError(causes, \"Target check failed and its owned transient environment cleanup also failed.\"),\n    writable: true\n  })\n\n  return primaryFailure\n}\n\n/**\n * Creates a structured failure when cancellation precedes stage launch.\n * @param {import(\"./semantic/types.js\").TargetCheckStageRequest} stage - Cancelled stage.\n * @param {import(\"./semantic/types.js\").TargetCheckPlan} plan - Plan context.\n * @param {number} durationMs - Observed duration.\n * @returns {SemantifoldDiagnostic} Structured cancellation diagnostic.\n */\nfunction cancelledDiagnostic(stage, plan, durationMs) {\n  return new SemantifoldDiagnostic({\n    code: \"TARGET_CHECK_CANCELLED\",\n    durationMs,\n    executable: stage.executable,\n    language: plan.target,\n    message: `Target '${plan.targetId}' stage '${stage.stage}' was cancelled before launch.`,\n    projectId: plan.projectId,\n    stage: stage.stage,\n    stderr: \"\",\n    stdout: \"\",\n    targetId: plan.targetId,\n    toolId: stage.tool.id,\n    version: stage.tool.version\n  })\n}\n\n/**\n * Extracts stable bounded child-process failure fields.\n * @param {unknown} error - Opaque 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\n  return {\n    exitCode: typeof value.code == \"number\" ? value.code : undefined,\n    nativeCode: typeof value.code == \"string\" ? 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 the complete immutable discovered-tool shape consumed by a plan.\n * @param {unknown} value - Candidate tool record.\n * @returns {value is import(\"./semantic/types.js\").DiscoveredToolchain} Whether the tool shape is valid.\n */\nfunction isDiscoveredTool(value) {\n  return isPlainObject(value) && typeof value.id == \"string\" && typeof value.command == \"string\" &&\n    typeof value.executable == \"string\" && path.isAbsolute(value.executable) && !value.executable.includes(\"\\0\") &&\n    (value.source == \"canonical\" || value.source == \"override\") && typeof value.version == \"string\" && value.version.length > 0 &&\n    typeof value.versionOutput == \"string\" && isDenseArray(value.versionArguments) &&\n    value.versionArguments.every(argument => typeof argument == \"string\" && !argument.includes(\"\\0\"))\n}\n\n/**\n * Checks that an environment is immutable and already deterministic.\n * @param {unknown} value - Candidate environment record.\n * @returns {boolean} Whether the environment is normalized.\n */\nfunction validEnvironment(value) {\n  if (!isPlainRecord(value) || !Object.isFrozen(value)) return false\n  let normalized\n\n  try {\n    normalized = deterministicEnvironment(/** @type {Readonly<Record<string, string>>} */ (value))\n  } catch {\n    return false\n  }\n  const actual = Object.entries(value).sort(([left], [right]) => left.localeCompare(right, \"en\"))\n  const expected = Object.entries(normalized).sort(([left], [right]) => left.localeCompare(right, \"en\"))\n\n  return JSON.stringify(actual) == JSON.stringify(expected)\n}\n\n/**\n * Checks every absolute non-PATH environment value against an explicit candidate-owned directory or discovered-tool declaration.\n * @param {unknown} value - Candidate declarations.\n * @param {Readonly<Record<string, string>>} environment - Validated deterministic environment.\n * @param {string} sourcePath - Candidate source root.\n * @param {string} buildPath - Candidate build root.\n * @param {readonly string[]} toolchains - Target-declared toolchain IDs.\n * @param {Set<string>} usedTools - Validated tools used by this plan.\n * @returns {value is readonly import(\"./semantic/types.js\").TargetCheckEnvironmentPath[]} Whether ownership is complete.\n */\nfunction validEnvironmentPaths(value, environment, sourcePath, buildPath, toolchains, usedTools) {\n  if (!isDenseArray(value) || !Object.isFrozen(value)) return false\n  const names = new Set()\n\n  for (let index = 0; index < value.length; index += 1) {\n    const declaration = value[index]\n\n    if (!isPlainObject(declaration) || !Object.isFrozen(declaration) ||\n      !hasExactKeys(declaration, declaration.ownership == \"tool\" ? [\"name\", \"ownership\", \"tool\"] : [\"name\", \"ownership\"]) ||\n      typeof declaration.name != \"string\" || names.has(declaration.name)) return false\n    const environmentPath = environment[declaration.name]\n\n    if (declaration.ownership == \"tool\") {\n      if (!isDiscoveredTool(declaration.tool) || !Object.isFrozen(declaration.tool) ||\n        !Object.isFrozen(declaration.tool.versionArguments) || !toolchains.includes(declaration.tool.id) ||\n        environmentPath != declaration.tool.executable) return false\n      usedTools.add(declaration.tool.id)\n      names.add(declaration.name)\n      continue\n    }\n    if (declaration.ownership != \"source\" && declaration.ownership != \"build\") return false\n    const root = declaration.ownership == \"source\" ? sourcePath : buildPath\n\n    if (typeof environmentPath != \"string\" || !ownedBy(root, environmentPath)) return false\n    names.add(declaration.name)\n  }\n  for (const [name, environmentValue] of Object.entries(environment)) {\n    if (name != \"PATH\" && path.isAbsolute(environmentValue) && !names.has(name)) return false\n  }\n\n  return true\n}\n\n/**\n * Checks generation-owned transient cache/intermediate directories.\n * @param {unknown} value - Candidate path vector.\n * @param {string} sourcePath - Candidate source root.\n * @param {string} buildPath - Candidate build root.\n * @param {Set<string>} artifactPaths - Exact staged artifact paths.\n * @returns {value is readonly string[]} Whether paths are immutable distinct candidate descendants.\n */\nfunction validTransientPaths(value, sourcePath, buildPath, artifactPaths) {\n  if (!isDenseArray(value) || !Object.isFrozen(value)) return false\n  const paths = new Set()\n\n  for (let index = 0; index < value.length; index += 1) {\n    const transientPath = value[index]\n\n    if (typeof transientPath != \"string\" || !ownedBy(sourcePath, transientPath) && !ownedBy(buildPath, transientPath) ||\n      paths.has(transientPath) || ownedBy(sourcePath, transientPath) && [...artifactPaths].some(artifactPath =>\n        transientPath == artifactPath || pathsOverlap(transientPath, artifactPath))) return false\n    paths.add(transientPath)\n  }\n\n  return true\n}\n\n/**\n * Checks compiler-output metadata against the owned build root.\n * @param {unknown} value - Candidate output record.\n * @param {string} buildPath - Exact candidate build root.\n * @returns {boolean} Whether output ownership is valid.\n */\nfunction validOutput(value, buildPath) {\n  return isPlainObject(value) && Object.isFrozen(value) && hasExactKeys(value, [\"mediaType\", \"ownership\", \"path\", \"role\"]) &&\n    value.ownership == \"build\" && value.path == buildPath && typeof value.mediaType == \"string\" &&\n    mediaTypePattern.test(value.mediaType) && typeof value.role == \"string\" && rolePattern.test(value.role)\n}\n\n/**\n * Checks strict descendant ownership without accepting the root itself.\n * @param {string} root - Absolute owned root.\n * @param {string} candidate - Absolute candidate path.\n * @returns {boolean} Whether the candidate is a strict descendant.\n */\nfunction ownedBy(root, candidate) {\n  if (!path.isAbsolute(candidate)) return false\n  const relative = path.relative(root, candidate)\n\n  return relative.length > 0 && !relative.startsWith(`..${path.sep}`) && relative != \"..\" && !path.isAbsolute(relative)\n}\n\n/**\n * Checks candidate ownership by either exact target subtree.\n * @param {string} sourcePath - Exact source root.\n * @param {string} buildPath - Exact build root.\n * @param {string} candidate - Candidate working directory.\n * @returns {boolean} Whether either target subtree owns the candidate.\n */\nfunction ownedByEither(sourcePath, buildPath, candidate) {\n  return candidate == sourcePath || candidate == buildPath || ownedBy(sourcePath, candidate) || ownedBy(buildPath, candidate)\n}\n\n/**\n * Checks whether two absolute roots overlap in either direction.\n * @param {string} left - First root.\n * @param {string} right - Second root.\n * @returns {boolean} Whether the roots overlap.\n */\nfunction pathsOverlap(left, right) {\n  return left == right || ownedBy(left, right) || ownedBy(right, left)\n}\n\n/**\n * Normalizes one monotonic duration observation.\n * @param {number} endedAt - End observation.\n * @param {number} startedAt - Start observation.\n * @returns {number} Finite non-negative duration.\n */\nfunction elapsed(endedAt, startedAt) {\n  const duration = endedAt - startedAt\n\n  return Number.isFinite(duration) && duration >= 0 ? duration : 0\n}\n\n/**\n * Throws one compiler-output inspection diagnostic.\n * @param {string} message - Failure detail.\n * @param {unknown} [cause] - Optional underlying failure.\n * @returns {never} Always throws.\n */\nfunction outputFailure(message, cause) {\n  throw new SemantifoldDiagnostic({\n    cause: cause instanceof Error ? cause : undefined,\n    code: \"TARGET_CHECK_OUTPUT_INVALID\",\n    language: \"check\",\n    message\n  })\n}\n\n/**\n * Throws one invalid-plan diagnostic.\n * @param {string} message - Failure detail.\n * @param {string} [target] - Target diagnostic identity.\n * @param {unknown} [cause] - Optional underlying failure.\n * @returns {never} Always throws.\n */\nfunction invalidPlan(message, target = \"check\", cause) {\n  throw new SemantifoldDiagnostic({\n    cause: cause instanceof Error ? cause : undefined,\n    code: \"INVALID_TARGET_CHECK_PLAN\",\n    language: target,\n    message\n  })\n}\n\n/**\n * Checks for an ordinary object-prototype record.\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 * Checks for an own-property string-data record with an ordinary or null prototype.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is a plain data record.\n */\nfunction isPlainRecord(value) {\n  if (typeof value != \"object\" || value == null || Array.isArray(value)) return false\n  const prototype = Object.getPrototypeOf(value)\n\n  if (prototype !== Object.prototype && prototype !== null) return false\n  return Reflect.ownKeys(value).every(key => {\n    if (typeof key != \"string\") return false\n    const descriptor = Object.getOwnPropertyDescriptor(value, key)\n\n    return descriptor != undefined && descriptor.enumerable && \"value\" in descriptor && typeof descriptor.value == \"string\"\n  })\n}\n\n/**\n * Checks one closed object-key set.\n * @param {Record<string, unknown>} value - Candidate record.\n * @param {string[]} keys - Exact allowed keys.\n * @returns {boolean} Whether the key sets match.\n */\nfunction hasExactKeys(value, keys) {\n  return Object.keys(value).sort().join(\"\\0\") == [...keys].sort().join(\"\\0\")\n}\n"]}