ttsc 0.30.4 → 0.31.1

package/lib/compiler/internal/build/normalizeBuildOutput.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBuildOutput = normalizeBuildOutput;
+const CompilerDiagnostics_1 = require("./CompilerDiagnostics");
+/**
+ * Normalise a raw spawn result into a `TtscBuildResult`.
+ *
+ * When `diagnostics` is absent they are parsed from the text output. When the
+ * process exited non-zero but stderr is empty and stdout is non-empty, stdout
+ * is moved to stderr so the error is visible to callers who only check stderr.
+ * All other result metadata, including emit provenance, is preserved.
+ *
+ * @evidence contracts/common.md#principled-implementation Explicit diagnostics take precedence over text parsing; failure-output relocation preserves status and emit-provenance metadata while making captured error text visible.
+ * @evidence contracts/common.md#clear-and-simple-design Output normalization and optional parsing share one entry point; a private parser owns summary skipping and indented message continuation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Parsed compiler formats and actual process status determine results; unmatched text is not fabricated into a successful diagnostic record.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains absent diagnostics and the failure-output relocation; the private parser explains continuation and summary handling.
+ * @evidence contracts/portability.md#os-neutral-implementation Diagnostic filenames use the native path normalizer with optional compiler cwd; CRLF and LF output are both recognized without case-policy guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Absent diagnostics require ANSI stripping and line splitting followed by format matches on each line. Continuation chunks are joined once per diagnostic instead of repeatedly concatenating a growing message; temporary lines, chunks and records scale with captured output. Supplied arrays bypass this work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Preparsed diagnostics are reused directly instead of reconstructing the same records from stdout and stderr.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This adapter returns data without owning a process, persistent cache or retained history.
+ */
+function normalizeBuildOutput(result, cwd) {
+    const diagnostics = result.diagnostics ?? parseCompilerDiagnostics(result, cwd);
+    if (result.status === 0 || result.stderr.trim().length !== 0) {
+        return { ...result, diagnostics };
+    }
+    if (result.stdout.trim().length === 0) {
+        return { ...result, diagnostics };
+    }
+    return {
+        ...result,
+        diagnostics,
+        stdout: "",
+        stderr: result.stdout,
+    };
+}
+/**
+ * Parse structured diagnostics from the combined stderr+stdout text when the
+ * caller did not supply pre-parsed diagnostics. ANSI escape codes are stripped
+ * and `TSFILE:` / `Found N errors` summary lines are skipped.
+ */
+function parseCompilerDiagnostics(result, cwd) {
+    const lines = CompilerDiagnostics_1.CompilerDiagnostics.stripAnsi(`${result.stderr}\n${result.stdout}`).split(/\r?\n/);
+    const out = [];
+    let current;
+    let messageChunks = [];
+    for (const line of lines) {
+        if (line.length === 0 || /^TSFILE:\s*/.test(line)) {
+            continue;
+        }
+        if (/^Found\s+\d+\s+errors?/i.test(line)) {
+            continue;
+        }
+        const diagnostic = CompilerDiagnostics_1.CompilerDiagnostics.parseDiagnosticLine(line, cwd);
+        if (diagnostic !== null) {
+            if (current !== undefined)
+                current.messageText = messageChunks.join("\n");
+            current = diagnostic;
+            messageChunks = [diagnostic.messageText];
+            out.push(current);
+            continue;
+        }
+        if (current !== undefined && /^\s+/.test(line)) {
+            messageChunks.push(line.trimEnd());
+        }
+    }
+    if (current !== undefined)
+        current.messageText = messageChunks.join("\n");
+    return out;
+}
+//# sourceMappingURL=normalizeBuildOutput.js.map

package/lib/compiler/internal/build/normalizeBuildOutput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeBuildOutput.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/normalizeBuildOutput.ts"],"names":[],"mappings":";;;AAEA,+DAA4D;AAE5D;;;;;;;;;;;;;;;;;GAiBG;AACH,8BACE,MAA0B,EAC1B,GAAY;IAEZ,MAAM,WAAW,GACf,MAAM,CAAC,WAAW,IAAI,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9D,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7D,OAAO,EAAE,GAAG,MAAM,EAAE,WAAW,EAAE,CAAC;IACpC,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtC,OAAO,EAAE,GAAG,MAAM,EAAE,WAAW,EAAE,CAAC;IACpC,CAAC;IACD,OAAO;QACL,GAAG,MAAM;QACT,WAAW;QACX,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,MAAM,CAAC,MAAM;KACtB,CAAC;AACJ,CAAC;AAUD;;;;GAIG;AACH,SAAS,wBAAwB,CAC/B,MAAkD,EAClD,GAAuB;IAEvB,MAAM,KAAK,GAAG,yCAAmB,CAAC,SAAS,CACzC,GAAG,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,CACrC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,MAAM,GAAG,GAA8B,EAAE,CAAC;IAC1C,IAAI,OAA4C,CAAC;IACjD,IAAI,aAAa,GAAa,EAAE,CAAC;IACjC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAClD,SAAS;QACX,CAAC;QACD,IAAI,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,SAAS;QACX,CAAC;QAED,MAAM,UAAU,GAAG,yCAAmB,CAAC,mBAAmB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACtE,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;YACxB,IAAI,OAAO,KAAK,SAAS;gBAAE,OAAO,CAAC,WAAW,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC1E,OAAO,GAAG,UAAU,CAAC;YACrB,aAAa,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;YACzC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAClB,SAAS;QACX,CAAC;QAED,IAAI,OAAO,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/C,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IACD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,CAAC,WAAW,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1E,OAAO,GAAG,CAAC;AACb,CAAC"}

package/lib/compiler/internal/build/parseProjectInputSnapshot.d.ts

@@ -0,0 +1,26 @@
+import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
+import type { ITtscProjectInputSnapshot } from "../../../structures/internal/ITtscProjectInputSnapshot";
+/**
+ * Parse and validate the JSON a native host printed for `project-inputs`.
+ *
+ * Every path in the snapshot (root, files, globs, reload files and directories)
+ * must satisfy host-native absolute namespace admission; relative/empty paths
+ * and Windows device namespaces are rejected with the plugin's name. This is
+ * native namespace admission, not an existence, access or watcher-capability
+ * check; silently dropping rejected declarations would hide an unsupported
+ * dependency. Optional reload lists default to empty.
+ *
+ * These checks cover host-published input lists; the later merge reconstructs
+ * declared alias lists from these spellings rather than trusting extra JSON.
+ *
+ * @evidence contracts/common.md#principled-implementation Unknown JSON is narrowed by required object and string-array checks, then native path admission; missing reload arrays receive the protocol's empty meaning.
+ * @evidence contracts/common.md#clear-and-simple-design JSON syntax, snapshot shape and path admission are separate checks, yielding plugin-attributed errors before normalized arrays are returned.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Invalid published inputs throw instead of being silently dropped or replaced by guessed project paths.
+ * @evidence contracts/common.md#meaningful-documentation Native prose describes invalid input effects, optional reload defaults and the later reconstruction of alias metadata.
+ * @evidence contracts/portability.md#os-neutral-implementation The host-platform path classifier admits native drive/UNC or POSIX absolute input syntax and rejects device namespaces without case folding or shell interpretation.
+ * @evidence contracts/performance.md#efficient-algorithms JSON parsing/property copying follows payload/field bytes; field-array checks and pair construction visit all declared paths before the first-invalid search. Native path classification adds each path's scan/normalization costs and temporary text; pair storage grows with path count, and this parser supplies no payload-byte ceiling.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Host output must be validated on this invocation; this parser does not coordinate repeated host production or retain an earlier snapshot.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Parsed values and validation arrays are local or returned, without persistent retention or acquired resources.
+ */
+export declare function parseProjectInputSnapshot(text: string, plugin: ITtscLoadedNativePlugin): ITtscProjectInputSnapshot;

package/lib/compiler/internal/build/parseProjectInputSnapshot.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProjectInputSnapshot = parseProjectInputSnapshot;
+const isAbsoluteLocalProjectInputPath_1 = require("./isAbsoluteLocalProjectInputPath");
+/**
+ * Parse and validate the JSON a native host printed for `project-inputs`.
+ *
+ * Every path in the snapshot (root, files, globs, reload files and directories)
+ * must satisfy host-native absolute namespace admission; relative/empty paths
+ * and Windows device namespaces are rejected with the plugin's name. This is
+ * native namespace admission, not an existence, access or watcher-capability
+ * check; silently dropping rejected declarations would hide an unsupported
+ * dependency. Optional reload lists default to empty.
+ *
+ * These checks cover host-published input lists; the later merge reconstructs
+ * declared alias lists from these spellings rather than trusting extra JSON.
+ *
+ * @evidence contracts/common.md#principled-implementation Unknown JSON is narrowed by required object and string-array checks, then native path admission; missing reload arrays receive the protocol's empty meaning.
+ * @evidence contracts/common.md#clear-and-simple-design JSON syntax, snapshot shape and path admission are separate checks, yielding plugin-attributed errors before normalized arrays are returned.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Invalid published inputs throw instead of being silently dropped or replaced by guessed project paths.
+ * @evidence contracts/common.md#meaningful-documentation Native prose describes invalid input effects, optional reload defaults and the later reconstruction of alias metadata.
+ * @evidence contracts/portability.md#os-neutral-implementation The host-platform path classifier admits native drive/UNC or POSIX absolute input syntax and rejects device namespaces without case folding or shell interpretation.
+ * @evidence contracts/performance.md#efficient-algorithms JSON parsing/property copying follows payload/field bytes; field-array checks and pair construction visit all declared paths before the first-invalid search. Native path classification adds each path's scan/normalization costs and temporary text; pair storage grows with path count, and this parser supplies no payload-byte ceiling.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Host output must be validated on this invocation; this parser does not coordinate repeated host production or retain an earlier snapshot.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Parsed values and validation arrays are local or returned, without persistent retention or acquired resources.
+ */
+function parseProjectInputSnapshot(text, plugin) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`ttsc.project-inputs: ${plugin.name ?? plugin.binary} returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof value !== "object" ||
+        value === null ||
+        typeof value.root !== "string" ||
+        !isStringArray(value.files) ||
+        !isStringArray(value.globs) ||
+        (value.reloadDirectories !==
+            undefined &&
+            !isStringArray(value.reloadDirectories)) ||
+        (value.reloadFiles !== undefined &&
+            !isStringArray(value.reloadFiles))) {
+        throw new Error(`ttsc.project-inputs: ${plugin.name ?? plugin.binary} returned an invalid snapshot`);
+    }
+    const snapshot = value;
+    const invalid = [
+        ["root", snapshot.root],
+        ...snapshot.files.map((file) => ["file", file]),
+        ...snapshot.globs.map((glob) => ["glob", glob]),
+        ...(snapshot.reloadDirectories ?? []).map((directory) => ["reload directory", directory]),
+        ...(snapshot.reloadFiles ?? []).map((file) => ["reload file", file]),
+    ].find(([, location]) => location.length === 0 || !(0, isAbsoluteLocalProjectInputPath_1.isAbsoluteLocalProjectInputPath)(location));
+    if (invalid !== undefined) {
+        throw new Error(`ttsc.project-inputs: ${plugin.name ?? plugin.binary} returned an invalid snapshot: ${invalid[0]} ${JSON.stringify(invalid[1])} is not an absolute local path`);
+    }
+    return {
+        ...snapshot,
+        reloadDirectories: snapshot.reloadDirectories ?? [],
+        reloadFiles: snapshot.reloadFiles ?? [],
+    };
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((item) => typeof item === "string"));
+}
+//# sourceMappingURL=parseProjectInputSnapshot.js.map

package/lib/compiler/internal/build/parseProjectInputSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseProjectInputSnapshot.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/parseProjectInputSnapshot.ts"],"names":[],"mappings":";;;AAEA,uFAAoF;AAEpF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mCACE,IAAY,EACZ,MAA+B;IAE/B,IAAI,KAAc,CAAC;IACnB,IAAI,CAAC;QACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,wBAAwB,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,MAAM,2BAClD,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAC;IACJ,CAAC;IACD,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,OAAQ,KAA4B,CAAC,IAAI,KAAK,QAAQ;QACtD,CAAC,aAAa,CAAE,KAA6B,CAAC,KAAK,CAAC;QACpD,CAAC,aAAa,CAAE,KAA6B,CAAC,KAAK,CAAC;QACpD,CAAE,KAAyC,CAAC,iBAAiB;YAC3D,SAAS;YACT,CAAC,aAAa,CACX,KAAyC,CAAC,iBAAiB,CAC7D,CAAC;QACJ,CAAE,KAAmC,CAAC,WAAW,KAAK,SAAS;YAC7D,CAAC,aAAa,CAAE,KAAmC,CAAC,WAAW,CAAC,CAAC,EACnE,CAAC;QACD,MAAM,IAAI,KAAK,CACb,wBAAwB,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,MAAM,+BAA+B,CACpF,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,KAA6C,CAAC;IAC/D,MAAM,OAAO,GAAG;QACd,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC;QACvB,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAU,CAAC;QACxD,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAU,CAAC;QACxD,GAAG,CAAC,QAAQ,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,GAAG,CACvC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,kBAAkB,EAAE,SAAS,CAAU,CACxD;QACD,GAAG,CAAC,QAAQ,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,GAAG,CACjC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,aAAa,EAAE,IAAI,CAAU,CACzC;KACF,CAAC,IAAI,CACJ,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,EAAE,CACf,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAA,iEAA+B,EAAC,QAAQ,CAAC,CACtE,CAAC;IACF,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CACb,wBAAwB,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,MAAM,kCAAkC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,gCAAgC,CAC/J,CAAC;IACJ,CAAC;IACD,OAAO;QACL,GAAG,QAAQ;QACX,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB,IAAI,EAAE;QACnD,WAAW,EAAE,QAAQ,CAAC,WAAW,IAAI,EAAE;KACxC,CAAC;AACJ,CAAC;AAED,SAAS,aAAa,CAAC,KAAc;IACnC,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CACxE,CAAC;AACJ,CAAC"}

package/lib/compiler/internal/build/planResidentCheckEntries.d.ts

@@ -0,0 +1,21 @@
+import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
+import type { ResidentCheckEntryPlan } from "./ResidentCheckEntryPlan";
+/**
+ * Plan every configured check entry while sharing resident processes only by
+ * binary/name/argument identity.
+ *
+ * Forwarded compiler flags are part of that identity even though they travel
+ * through the environment. Configuration positions remain distinct so shared
+ * processes do not collapse check executions or change delivery order.
+ *
+ * @evidence contracts/common.md#principled-implementation Capability-gated resident keys include binary, plugin name, argv and forwarded compiler payload, while each check retains its own configuration index.
+ * @evidence contracts/common.md#clear-and-simple-design Filtering selects check-stage entries and mapping records their execution plan; process-key construction is isolated from per-entry scheduling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Resident support comes from declared capabilities rather than binary-name guesses; duplicate entries are not silently skipped.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes process sharing, environment-carried compiler arguments and separate configured executions.
+ * @evidence contracts/portability.md#os-neutral-implementation Binary and argv remain separate native process inputs; JSON encodes argument boundaries without shell quoting or path case assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering scans all plugins, then mapping visits selected checks and calls the argument composer once per entry. Cost includes those composer calls and resident-key string/JSON bytes; the current composer serializes the full plugin manifest separately for every configured check. Returned storage scales with selected entries and their argument/key bytes.
+ * @evidence contracts/performance.md#reuse-equivalent-work Equivalent resident startup selections receive the same key; the session additionally requires stable execution context and resets topology before reuse.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Plans describe process selection but acquire no sidecars or retained requests themselves.
+ */
+export declare function planResidentCheckEntries(plugins: readonly ITtscLoadedNativePlugin[], createArgs: (plugin: ITtscLoadedNativePlugin) => string[], tsgoArgs?: string, compilerArgsCwd?: string): ResidentCheckEntryPlan[];

package/lib/compiler/internal/build/planResidentCheckEntries.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planResidentCheckEntries = planResidentCheckEntries;
+/**
+ * Plan every configured check entry while sharing resident processes only by
+ * binary/name/argument identity.
+ *
+ * Forwarded compiler flags are part of that identity even though they travel
+ * through the environment. Configuration positions remain distinct so shared
+ * processes do not collapse check executions or change delivery order.
+ *
+ * @evidence contracts/common.md#principled-implementation Capability-gated resident keys include binary, plugin name, argv and forwarded compiler payload, while each check retains its own configuration index.
+ * @evidence contracts/common.md#clear-and-simple-design Filtering selects check-stage entries and mapping records their execution plan; process-key construction is isolated from per-entry scheduling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Resident support comes from declared capabilities rather than binary-name guesses; duplicate entries are not silently skipped.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes process sharing, environment-carried compiler arguments and separate configured executions.
+ * @evidence contracts/portability.md#os-neutral-implementation Binary and argv remain separate native process inputs; JSON encodes argument boundaries without shell quoting or path case assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering scans all plugins, then mapping visits selected checks and calls the argument composer once per entry. Cost includes those composer calls and resident-key string/JSON bytes; the current composer serializes the full plugin manifest separately for every configured check. Returned storage scales with selected entries and their argument/key bytes.
+ * @evidence contracts/performance.md#reuse-equivalent-work Equivalent resident startup selections receive the same key; the session additionally requires stable execution context and resets topology before reuse.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Plans describe process selection but acquire no sidecars or retained requests themselves.
+ */
+function planResidentCheckEntries(plugins, createArgs, 
+// Part of the process identity even though it never appears in argv: the
+// forwarded tsgo payload rides the environment, and a resident process holds
+// the compiler options it was started with. Two cycles that forward different
+// flags must not share one warm Program.
+tsgoArgs, compilerArgsCwd) {
+    return plugins
+        .filter((candidate) => candidate.stage === "check")
+        .map((plugin, entryIndex) => {
+        const args = createArgs(plugin);
+        return {
+            args,
+            entryIndex,
+            key: plugin.capabilities?.residentCheck === true
+                ? residentCheckProcessKey(plugin, args, tsgoArgs, compilerArgsCwd)
+                : undefined,
+            plugin,
+        };
+    });
+}
+function residentCheckProcessKey(plugin, args, tsgoArgs, compilerArgsCwd) {
+    return `${plugin.binary}\0${plugin.name}\0${JSON.stringify(args)}\0${tsgoArgs ?? ""}\0${compilerArgsCwd ?? ""}`;
+}
+//# sourceMappingURL=planResidentCheckEntries.js.map

package/lib/compiler/internal/build/planResidentCheckEntries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planResidentCheckEntries.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/planResidentCheckEntries.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,kCACE,OAA2C,EAC3C,UAAyD;AACzD,yEAAyE;AACzE,6EAA6E;AAC7E,8EAA8E;AAC9E,yCAAyC;AACzC,QAAiB,EACjB,eAAwB;IAExB,OAAO,OAAO;SACX,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,KAAK,OAAO,CAAC;SAClD,GAAG,CAAC,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE;QAC1B,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;QAChC,OAAO;YACL,IAAI;YACJ,UAAU;YACV,GAAG,EACD,MAAM,CAAC,YAAY,EAAE,aAAa,KAAK,IAAI;gBACzC,CAAC,CAAC,uBAAuB,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,CAAC;gBAClE,CAAC,CAAC,SAAS;YACf,MAAM;SACP,CAAC;IACJ,CAAC,CAAC,CAAC;AACP,CAAC;AAED,SAAS,uBAAuB,CAC9B,MAA+B,EAC/B,IAAuB,EACvB,QAAiB,EACjB,eAAwB;IAExB,OAAO,GAAG,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,QAAQ,IAAI,EAAE,KAAK,eAAe,IAAI,EAAE,EAAE,CAAC;AAClH,CAAC"}

package/lib/compiler/internal/build/privateRuntimeRootDir.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Select the layout root for JavaScript written only to a runtime-owned emit
+ * directory. Explicit roots and composite-project containment remain compiler
+ * policy. An ordinary project without a root uses its native volume root so
+ * adding private output does not reject same-volume imports outside the config
+ * directory. A different Windows volume still cannot fit this one output root
+ * and remains subject to the compiler's cross-volume layout diagnostics. This
+ * changes only private output coordinates, not the program's input set. Actual
+ * emitted-source provenance remains required before serving any file.
+ *
+ * @evidence contracts/common.md#principled-implementation Runtime-injected output has a separate layout root without widening an explicit or composite root or changing source membership and type options.
+ * @evidence contracts/common.md#clear-and-simple-design One path policy is shared by compiler arguments and runtime ownership metadata.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No extra compiler pass, filename-derived emit authority or unchecked execution substitutes for the selected project and its actual output provenance.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes private output coordinates, explicit containment and actual source membership.
+ * @evidence contracts/portability.md#os-neutral-implementation Node's native path parser preserves drive and UNC volume roots; explicit relative roots resolve against their declaring project. This selects lexical layout and makes no filesystem identity or case-policy observation.
+ * @evidence contracts/performance.md#efficient-algorithms A fixed branch sequence delegates path parsing or resolution whose work and temporary strings scale with the supplied path text; no filesystem enumeration or compiler execution occurs.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This path policy caches no completed or in-flight producer; callers own runtime generation reuse.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only a returned path string transfers to the caller; no handle, generation or history is retained.
+ */
+export declare function privateRuntimeRootDir(projectRoot: string, rootDir: unknown, composite: unknown): string;

package/lib/compiler/internal/build/privateRuntimeRootDir.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.privateRuntimeRootDir = privateRuntimeRootDir;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Select the layout root for JavaScript written only to a runtime-owned emit
+ * directory. Explicit roots and composite-project containment remain compiler
+ * policy. An ordinary project without a root uses its native volume root so
+ * adding private output does not reject same-volume imports outside the config
+ * directory. A different Windows volume still cannot fit this one output root
+ * and remains subject to the compiler's cross-volume layout diagnostics. This
+ * changes only private output coordinates, not the program's input set. Actual
+ * emitted-source provenance remains required before serving any file.
+ *
+ * @evidence contracts/common.md#principled-implementation Runtime-injected output has a separate layout root without widening an explicit or composite root or changing source membership and type options.
+ * @evidence contracts/common.md#clear-and-simple-design One path policy is shared by compiler arguments and runtime ownership metadata.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No extra compiler pass, filename-derived emit authority or unchecked execution substitutes for the selected project and its actual output provenance.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes private output coordinates, explicit containment and actual source membership.
+ * @evidence contracts/portability.md#os-neutral-implementation Node's native path parser preserves drive and UNC volume roots; explicit relative roots resolve against their declaring project. This selects lexical layout and makes no filesystem identity or case-policy observation.
+ * @evidence contracts/performance.md#efficient-algorithms A fixed branch sequence delegates path parsing or resolution whose work and temporary strings scale with the supplied path text; no filesystem enumeration or compiler execution occurs.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This path policy caches no completed or in-flight producer; callers own runtime generation reuse.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only a returned path string transfers to the caller; no handle, generation or history is retained.
+ */
+function privateRuntimeRootDir(projectRoot, rootDir, composite) {
+    if (typeof rootDir === "string") {
+        return node_path_1.default.isAbsolute(rootDir)
+            ? rootDir
+            : node_path_1.default.resolve(projectRoot, rootDir);
+    }
+    return composite === true ? projectRoot : node_path_1.default.parse(projectRoot).root;
+}
+//# sourceMappingURL=privateRuntimeRootDir.js.map

package/lib/compiler/internal/build/privateRuntimeRootDir.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"privateRuntimeRootDir.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/privateRuntimeRootDir.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAE7B;;;;;;;;;;;;;;;;;;GAkBG;AACH,+BACE,WAAmB,EACnB,OAAgB,EAChB,SAAkB;IAElB,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,OAAO,mBAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YAC7B,CAAC,CAAC,OAAO;YACT,CAAC,CAAC,mBAAI,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,SAAS,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,mBAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC;AACzE,CAAC"}

package/lib/compiler/internal/build/residentCheckRequest.d.ts

@@ -0,0 +1,22 @@
+import { type ResidentCheckRequest } from "../ResidentCheckRequest";
+import type { ResidentCheckWatchChange } from "./ResidentCheckWatchChange";
+/**
+ * Translate one watch change into a resident check request payload. The process
+ * owner serializes this record into the sidecar's line protocol.
+ *
+ * Paths are resolved against `cwd`, deduplicated, and sorted, so two cycles
+ * that observed the same edits in a different order send identical requests.
+ * `reload` is not part of the wire protocol: the session handles it by
+ * discarding its processes before any request is sent.
+ *
+ * @evidence contracts/common.md#principled-implementation Resolving and sorting sets gives order-independent wire paths; invalidation remains explicit and coordinator-only reload is omitted from the sidecar payload.
+ * @evidence contracts/common.md#clear-and-simple-design One local normalizer serves changed and external lists, while the result literal exposes which nonempty wire fields are present.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Only protocol-defined fields are emitted; reload is handled by the session rather than faked as a special changed filename.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish canonical path order from reload's separate session effect.
+ * @evidence contracts/portability.md#os-neutral-implementation node:path resolves native spellings against the supplied cwd and collapses dot segments; it preserves case and does not resolve symlink targets or certify physical filesystem identity.
+ * @evidence contracts/performance.md#efficient-algorithms Each supplied path is resolved directly into a set without an intermediate mapped array. Resolution and set membership include path-string work; sorting U distinct paths uses O(U log U) string comparisons, and temporary storage holds distinct path bytes plus returned references.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This converts one change event without coordinating a persistent producer; process reuse belongs to the session.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local sets become returned arrays and this converter owns no retained watch buffer or sidecar.
+ */
+export declare function residentCheckRequest(change: ResidentCheckWatchChange, cwd: string): ResidentCheckRequest;

package/lib/compiler/internal/build/residentCheckRequest.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.residentCheckRequest = residentCheckRequest;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Translate one watch change into a resident check request payload. The process
+ * owner serializes this record into the sidecar's line protocol.
+ *
+ * Paths are resolved against `cwd`, deduplicated, and sorted, so two cycles
+ * that observed the same edits in a different order send identical requests.
+ * `reload` is not part of the wire protocol: the session handles it by
+ * discarding its processes before any request is sent.
+ *
+ * @evidence contracts/common.md#principled-implementation Resolving and sorting sets gives order-independent wire paths; invalidation remains explicit and coordinator-only reload is omitted from the sidecar payload.
+ * @evidence contracts/common.md#clear-and-simple-design One local normalizer serves changed and external lists, while the result literal exposes which nonempty wire fields are present.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Only protocol-defined fields are emitted; reload is handled by the session rather than faked as a special changed filename.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish canonical path order from reload's separate session effect.
+ * @evidence contracts/portability.md#os-neutral-implementation node:path resolves native spellings against the supplied cwd and collapses dot segments; it preserves case and does not resolve symlink targets or certify physical filesystem identity.
+ * @evidence contracts/performance.md#efficient-algorithms Each supplied path is resolved directly into a set without an intermediate mapped array. Resolution and set membership include path-string work; sorting U distinct paths uses O(U log U) string comparisons, and temporary storage holds distinct path bytes plus returned references.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This converts one change event without coordinating a persistent producer; process reuse belongs to the session.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local sets become returned arrays and this converter owns no retained watch buffer or sidecar.
+ */
+function residentCheckRequest(change, cwd) {
+    const normalize = (values) => {
+        const paths = new Set();
+        for (const value of values ?? [])
+            paths.add(node_path_1.default.resolve(cwd, value));
+        return [...paths].sort();
+    };
+    const changed = normalize(change.changed);
+    const external = normalize(change.external);
+    return {
+        ...(change.invalidate === true ? { invalidate: true } : {}),
+        ...(changed.length === 0 ? {} : { changed }),
+        ...(external.length === 0 ? {} : { external }),
+    };
+}
+//# sourceMappingURL=residentCheckRequest.js.map

package/lib/compiler/internal/build/residentCheckRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"residentCheckRequest.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/residentCheckRequest.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAK7B;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BACE,MAAgC,EAChC,GAAW;IAEX,MAAM,SAAS,GAAG,CAAC,MAAqC,EAAY,EAAE;QACpE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;QAChC,KAAK,MAAM,KAAK,IAAI,MAAM,IAAI,EAAE;YAAE,KAAK,CAAC,GAAG,CAAC,mBAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;QACtE,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC,CAAC;IACF,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC5C,OAAO;QACL,GAAG,CAAC,MAAM,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3D,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;QAC5C,GAAG,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC;KAC/C,CAAC;AACJ,CAAC"}

package/lib/compiler/internal/build/runBuild.d.ts

@@ -0,0 +1,22 @@
+import type { TtscBuildResult } from "../../../structures/internal/TtscBuildResult";
+import type { RunBuildOptions } from "./RunBuildOptions";
+/**
+ * Run `ttsc` against a tsconfig. Returns once the binary exits so the CLI can
+ * decide how to surface diagnostics. Non-zero process exit is returned as a
+ * result; configuration resolution and process-launch failures may throw.
+ *
+ * Project-free terminal flags bypass project/plugin setup when applicable.
+ * Required emit provenance preserves compiler selection and exposes unknown
+ * ownership when the selected producer cannot establish the requested
+ * relation.
+ *
+ * @evidence contracts/common.md#principled-implementation Shared preparation selects project and plugins before execution, while project-free terminal requests take their supported direct compiler path; timing is appended after the resulting build phase.
+ * @evidence contracts/common.md#clear-and-simple-design The public synchronous entry owns timing and delegates setup/execution to BuildExecution, keeping the same build policy available to watch sessions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Terminal bypass follows compiler flag semantics and plugin failures remain visible; no retry hides configuration or spawn errors.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes returned exit failures from thrown setup/launch errors and explains the project-free branch.
+ * @evidence contracts/portability.md#os-neutral-implementation Execution selection and spawning use the shared native path/process boundaries with cwd and separate argv, rather than constructing a shell command here.
+ * @evidence contracts/performance.md#efficient-algorithms Timing creation and terminal selection make their own flag projections before the selected preparation/execution path. Delegated configuration, plugin, native/provenance and diagnostic work follows its actual input/report sizes; timing formatting scans ledger labels and output. No measured dominance or duration/output ceiling is established by this wrapper.
+ * @evidence contracts/performance.md#reuse-equivalent-work A resolved execution context is carried through preparation and execution, so this build does not reload its plugin selection between phases.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The ledger and execution state are build-owned, while returned output/proof/diagnostic records transfer to the caller; no resident handle or historical build is stored here. Delegated native/probe/artifact acquisition and cleanup may be best effort, and thrown setup can precede some cleanup boundaries. This wrapper supplies no duration/output bound or descendant-release certification.
+ */
+export declare function runBuild(options?: RunBuildOptions): TtscBuildResult;

package/lib/compiler/internal/build/runBuild.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBuild = runBuild;
+const BuildExecution_1 = require("./BuildExecution");
+const BuildTiming_1 = require("./BuildTiming");
+/**
+ * Run `ttsc` against a tsconfig. Returns once the binary exits so the CLI can
+ * decide how to surface diagnostics. Non-zero process exit is returned as a
+ * result; configuration resolution and process-launch failures may throw.
+ *
+ * Project-free terminal flags bypass project/plugin setup when applicable.
+ * Required emit provenance preserves compiler selection and exposes unknown
+ * ownership when the selected producer cannot establish the requested
+ * relation.
+ *
+ * @evidence contracts/common.md#principled-implementation Shared preparation selects project and plugins before execution, while project-free terminal requests take their supported direct compiler path; timing is appended after the resulting build phase.
+ * @evidence contracts/common.md#clear-and-simple-design The public synchronous entry owns timing and delegates setup/execution to BuildExecution, keeping the same build policy available to watch sessions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Terminal bypass follows compiler flag semantics and plugin failures remain visible; no retry hides configuration or spawn errors.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes returned exit failures from thrown setup/launch errors and explains the project-free branch.
+ * @evidence contracts/portability.md#os-neutral-implementation Execution selection and spawning use the shared native path/process boundaries with cwd and separate argv, rather than constructing a shell command here.
+ * @evidence contracts/performance.md#efficient-algorithms Timing creation and terminal selection make their own flag projections before the selected preparation/execution path. Delegated configuration, plugin, native/provenance and diagnostic work follows its actual input/report sizes; timing formatting scans ledger labels and output. No measured dominance or duration/output ceiling is established by this wrapper.
+ * @evidence contracts/performance.md#reuse-equivalent-work A resolved execution context is carried through preparation and execution, so this build does not reload its plugin selection between phases.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The ledger and execution state are build-owned, while returned output/proof/diagnostic records transfer to the caller; no resident handle or historical build is stored here. Delegated native/probe/artifact acquisition and cleanup may be best effort, and thrown setup can precede some cleanup boundaries. This wrapper supplies no duration/output bound or descendant-release certification.
+ */
+function runBuild(options = {}) {
+    const timing = BuildTiming_1.BuildTiming.createBuildTiming(options);
+    const result = runBuildTimed(options, timing);
+    return BuildTiming_1.BuildTiming.appendTimingOutput(result, timing);
+}
+function runBuildTimed(options, timing) {
+    const projectFree = BuildExecution_1.BuildExecution.runProjectFreeTerminalFlag(options);
+    if (projectFree !== null)
+        return projectFree;
+    const setupStartedAt = process.hrtime.bigint();
+    const execution = BuildExecution_1.BuildExecution.resolveExecutionContext(options);
+    return runBuildWithExecution(options, timing, execution, setupStartedAt);
+}
+function runBuildWithExecution(options, timing, execution, setupStartedAt) {
+    const prepared = BuildExecution_1.BuildExecution.prepareBuildExecution(options, timing, execution, setupStartedAt);
+    if (prepared.result !== undefined)
+        return prepared.result;
+    return BuildExecution_1.BuildExecution.runPreparedBuild(options, timing, execution, prepared.buildOptions);
+}
+//# sourceMappingURL=runBuild.js.map

package/lib/compiler/internal/build/runBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runBuild.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/runBuild.ts"],"names":[],"mappings":";;;AACA,qDAAkD;AAClD,+CAA4C;AAG5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,kBAAyB,OAAO,GAAoB,EAAE;IACpD,MAAM,MAAM,GAAG,yBAAW,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACtD,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC9C,OAAO,yBAAW,CAAC,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AACxD,CAAC;AAED,SAAS,aAAa,CACpB,OAAwB,EACxB,MAA+B;IAE/B,MAAM,WAAW,GAAG,+BAAc,CAAC,0BAA0B,CAAC,OAAO,CAAC,CAAC;IACvE,IAAI,WAAW,KAAK,IAAI;QAAE,OAAO,WAAW,CAAC;IAC7C,MAAM,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;IAC/C,MAAM,SAAS,GAAG,+BAAc,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;IAClE,OAAO,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;AAC3E,CAAC;AAED,SAAS,qBAAqB,CAC5B,OAAwB,EACxB,MAA+B,EAC/B,SAAoE,EACpE,cAAsB;IAEtB,MAAM,QAAQ,GAAG,+BAAc,CAAC,qBAAqB,CACnD,OAAO,EACP,MAAM,EACN,SAAS,EACT,cAAc,CACf,CAAC;IACF,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC,MAAM,CAAC;IAC1D,OAAO,+BAAc,CAAC,gBAAgB,CACpC,OAAO,EACP,MAAM,EACN,SAAS,EACT,QAAQ,CAAC,YAAY,CACtB,CAAC;AACJ,CAAC"}

package/lib/compiler/internal/build/runExternalEmitProvenance.d.ts

@@ -0,0 +1,61 @@
+import type { TtscBuildResult } from "../../../structures/internal/TtscBuildResult";
+/**
+ * Observe emitted-source ownership around the selected external compiler. The
+ * callback runs the original producer once, with file-list reporting added only
+ * when its read-only option and source probes succeeded. Compiler status,
+ * diagnostics and user-requested file-list display remain owned by that run.
+ *
+ * Admission requires stable effective options, identical source selection and
+ * stable physical paths, file identities and bytes before and after emission,
+ * including response files and the selected executable itself. Response
+ * inspection preserves native argument-frame boundaries and operand positions;
+ * the producer and its probes receive the original argv. The executable's
+ * change time is excluded from cross-command equality because that metadata
+ * changed in real executions without changing the executable object or bytes;
+ * source change times remain proof premises and each read brackets its full
+ * metadata. This is an external observation, not an atomic compiler-generation
+ * ledger; a concurrent change restored between observations can remain
+ * invisible. Unsupported layouts and ambiguous outputs carry an empty ownership
+ * list.
+ *
+ * A nonzero compiler status can still carry proved writes for an unchecked
+ * consumer. Ownership metadata never changes that status or its diagnostics.
+ * Profiling and tracing options suppress probes so their artifacts remain owned
+ * by the emitting run. TSFILE rows are the selected producer's write reports,
+ * not output-file byte observations. Admission assumes that producer uses the
+ * supported upstream naming subset; this adapter does not certify arbitrary
+ * compiler behavior.
+ *
+ * Normally reported ownerless outputs carry their actual failed proof boundary
+ * in emittedSourceProofFailures. These explanations preserve compiler streams
+ * and status; they do not replace missing ownership with a successful claim.
+ *
+ * @evidence contracts/common.md#principled-implementation Actual TSFILE writes are matched against the supported upstream per-source extension and explicit-root layout under matching compiler-selected inputs and stable physical/content observations. No emitted filename alone establishes ownership; observation gaps remain documented.
+ * @evidence contracts/common.md#clear-and-simple-design One adapter owns read-only compiler probes, the single delegated emission and admission; private helpers isolate option parsing, physical observation and path prediction.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The selected executable and original arguments remain authoritative. Unknown layouts are reported unknown instead of switching compilers, guessing same-stem ownership or consulting source maps.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain producer preservation, unknown states and the non-atomic observation limitation; the investigation record documents the supported upstream naming subset.
+ * @evidence contracts/portability.md#os-neutral-implementation Native node:path and filesystem realpath/stat separate writer spelling from physical source identity. Executables receive separate argv entries through spawnNative, without a shell or OS-based case folding.
+ * @evidence contracts/performance.md#efficient-algorithms Source and output indexes avoid cross-product matching. Response inspection uses an iterative frame stack and active physical-path set. Repeated response/source/executable observations read and hash complete files; showConfig text, source/output lists, signature JSON, candidate path components and byte buffers are processed at their actual sizes alongside native probes/path operations. No native duration or report-size ceiling follows from using one index.
+ * @evidence contracts/performance.md#reuse-equivalent-work Each source observation and predicted output index is shared by all outputs in this invocation. Cross-build reuse is unavailable because arbitrary external producer and filesystem dependencies have no invalidation contract.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Response/config/source tokens and predicted owner sets live for this invocation; returned provenance/refusal records transfer to the caller. Retained bytes grow with complete reports, expanded arguments, paths and observations, while individual file reads allocate full file buffers. Probe capture cleanup is delegated and may be best effort; no timeout, output ceiling or descendant-release certification is provided here.
+ */
+export declare function runExternalEmitProvenance(options: {
+    /** Complete original compiler argv, including project selection. */
+    args: readonly string[];
+    /** Selected external executable; provenance never substitutes a producer. */
+    binary: string;
+    /** Native working directory shared by probes and the emitting command. */
+    cwd: string;
+    /** Same child environment used by the emitting command. */
+    env: NodeJS.ProcessEnv;
+    /**
+     * Execute the single emitting command, preserving raw output and whether the
+     * child exited normally rather than being killed during reporting.
+     */
+    run: (args: readonly string[]) => {
+        /** Original process facts and diagnostics, without status reinterpretation. */
+        result: TtscBuildResult;
+        /** Native status was present and no terminating signal truncated reporting. */
+        completedNormally: boolean;
+    };
+}): TtscBuildResult;