ttsc 0.30.4 → 0.31.0

package/lib/compiler/internal/CompilerArgumentsInspection.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompilerArgumentsInspection = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const readCompilerOptionOccurrence_1 = require("../../flags/readCompilerOptionOccurrence");
+/**
+ * Inspect compiler argument frames without replacing the emitting producer.
+ * Response identity and content are observed; native occurrence widths keep
+ * dash and @ operands with their options. Unknown or incomplete inspection
+ * requests fail before a reporting flag can become a missing scalar value.
+ *
+ * @evidence contracts/common.md#principled-implementation Shared native occurrence widths preserve option operands and response-frame boundaries; bracketed physical metadata and hashes establish observations without inventing compiler ownership.
+ * @evidence contracts/common.md#clear-and-simple-design The namespace owns argument inspection and its file observation representation; callers retain executable selection, native validation and emission.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Existing native response tokenization and metadata are retained, with generated occurrence consumption rather than independent option arity guesses or foreign method replacement.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains refusal, observation limits and producer ownership; members document transferred response observations and physical file signatures.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The grouping owns no independent native representation; its inspection and observation members describe their filesystem boundaries.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The grouping has no independent computation; the selected members own scans and hashing.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work No namespace cache or shared task is retained.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Invocation-local inspection and synchronous file operations have member owners.
+ */
+var CompilerArgumentsInspection;
+(function (CompilerArgumentsInspection) {
+    /**
+     * Expand observed response frames while preserving native operand positions.
+     * Throws when read-only reporting cannot safely extend the original frame.
+     * The producer still receives the caller's original argv and owns
+     * diagnostics. Response text is read separately between two hashed
+     * observations; equality does not establish an atomic snapshot or detect a
+     * change restored in between.
+     *
+     * @evidence contracts/common.md#principled-implementation A stack preserves each response frame and occurrence widths skip scalar operands; bare booleans receive an explicit value only in the inspection projection so parent tokens cannot bind across frames.
+     * @evidence contracts/common.md#clear-and-simple-design One cursor per frame and one active physical-path set distinguish ordered reuse from cycles, returning projected argv and the observations needed by the emission owner.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts This is conservative inspection admission, not a second native option validator; unknown or unsafe frames throw without rewriting the actual producer request.
+     * @evidence contracts/common.md#meaningful-documentation The comment describes projected argv, refusal and retained native diagnostic ownership.
+     * @evidence contracts/portability.md#os-neutral-implementation Native real paths and bigint file metadata identify response files; UTF-8 and BOM-selected UTF-16 decoding preserve the existing native filesystem text boundary.
+     * @evidence contracts/performance.md#efficient-algorithms Cursors advance through expanded occurrences; each response expansion performs two hashed file observations and a separate decoded read, plus native path resolution and tokenization. Cost follows all reread bytes, expanded argument text and path/metadata work; repeated frames and expansion depth have no fixed cap.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Response files are reread for each invocation because bytes and identity may change; no earlier request establishes continued validity.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Synchronous reads retain no handles; active paths leave the set as frames close, and projected arguments and observations transfer to the caller. Stack, decoded buffers and output follow the uncapped expanded invocation; failures leave only call-local state for collection.
+     */
+    function inspect(args, cwd) {
+        const observations = new Map();
+        const projected = [];
+        const active = new Set();
+        const frames = [{ args, index: 0 }];
+        while (frames.length !== 0) {
+            const frame = frames[frames.length - 1];
+            if (frame.index === frame.args.length) {
+                if (frame.physical !== undefined)
+                    active.delete(frame.physical);
+                frames.pop();
+                continue;
+            }
+            const index = frame.index;
+            const token = frame.args[index];
+            if (token.startsWith("@")) {
+                frame.index++;
+                const file = node_path_1.default.resolve(cwd, token.slice(1));
+                const before = observeInputFile(file);
+                const physical = JSON.parse(before)[0];
+                if (active.has(physical))
+                    throw new Error(`Cyclic compiler response file: ${file}`);
+                const text = responseText(node_fs_1.default.readFileSync(file));
+                if (observeInputFile(file) !== before)
+                    throw new Error(`Compiler response file changed during reading: ${file}`);
+                const previous = observations.get(file);
+                if (previous !== undefined && previous !== before)
+                    throw new Error(`Compiler response file changed between reads: ${file}`);
+                observations.set(file, before);
+                active.add(physical);
+                frames.push({ args: responseTokens(text), index: 0, physical });
+                continue;
+            }
+            const occurrence = (0, readCompilerOptionOccurrence_1.readCompilerOptionOccurrence)(frame.args, index);
+            if (token.startsWith("-")) {
+                const option = occurrence.option;
+                if (option === undefined ||
+                    token.includes("=") ||
+                    (option.kind !== "boolean" &&
+                        option.kind !== "list" &&
+                        occurrence.width === 1) ||
+                    (option.kind === "boolean" && occurrence.booleanValue === undefined))
+                    throw new Error(`Unsupported or incomplete compiler inspection option: ${token}`);
+            }
+            projected.push(...frame.args.slice(index, index + occurrence.width));
+            if (occurrence.option?.kind === "boolean" && occurrence.width === 1)
+                projected.push(occurrence.booleanValue === true ? "true" : "false");
+            frame.index += occurrence.width;
+        }
+        return { args: projected, observations };
+    }
+    CompilerArgumentsInspection.inspect = inspect;
+    /**
+     * Bracket a regular file read with physical identity and bigint metadata.
+     * Executable cross-command observations omit ctime; source observations keep
+     * it. A change restored between observations can remain invisible.
+     *
+     * @evidence contracts/common.md#principled-implementation Real paths, object metadata and SHA256 bytes describe the actual observed file; before/after equality rejects an unstable read, with executable ctime omitted only from the returned cross-command signature.
+     * @evidence contracts/common.md#clear-and-simple-design One serialized signature is shared by source, executable and response observation consumers.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No path spelling, same-stem output or version label substitutes for observed physical identity and bytes; the documented gap is not claimed atomic.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains metadata bracketing, executable ctime and the observation gap.
+     * @evidence contracts/portability.md#os-neutral-implementation Native realpath and bigint stat values represent physical objects without assuming platform case policy or inode precision in JavaScript numbers.
+     * @evidence contracts/performance.md#efficient-algorithms One file read and SHA256 hash scan the file bytes; two native realpath resolutions and two bigint stats also contribute filesystem cost. Signature construction, comparisons and JSON serialization follow path and metadata text, with a transient file-sized buffer and returned signature.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work A current observation cannot reuse earlier bytes without validating the same current identity and contents; no history is cached here.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Synchronous readFile and stat operations retain no open handle; the signature transfers to its caller.
+     */
+    function observeInputFile(source, kind = "source") {
+        const physical = node_fs_1.default.realpathSync.native(source);
+        const before = node_fs_1.default.statSync(source, { bigint: true });
+        if (!before.isFile())
+            throw new Error("Observed compiler input is not a regular file.");
+        const hash = (0, node_crypto_1.createHash)("sha256")
+            .update(node_fs_1.default.readFileSync(source))
+            .digest("hex");
+        const after = node_fs_1.default.statSync(source, { bigint: true });
+        const fullSignature = (stat) => [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
+        if (fullSignature(before) !== fullSignature(after) ||
+            node_fs_1.default.realpathSync.native(source) !== physical)
+            throw new Error("Compiler input changed during observation.");
+        const signature = kind === "source"
+            ? fullSignature(after)
+            : [after.dev, after.ino, after.size, after.mtimeNs].join(":");
+        return JSON.stringify([physical, signature, hash]);
+    }
+    CompilerArgumentsInspection.observeInputFile = observeInputFile;
+})(CompilerArgumentsInspection || (exports.CompilerArgumentsInspection = CompilerArgumentsInspection = {}));
+/** Native filesystem decoding strips UTF-8/UTF-16 BOMs before tokenization. */
+function responseText(bytes) {
+    if (bytes.length >= 2) {
+        const littleEndian = bytes[0] === 0xff && bytes[1] === 0xfe;
+        const bigEndian = bytes[0] === 0xfe && bytes[1] === 0xff;
+        if (littleEndian || bigEndian) {
+            if (bytes.length % 2 !== 0)
+                throw new Error("Incomplete UTF-16 compiler response text.");
+            return new node_util_1.TextDecoder(littleEndian ? "utf-16le" : "utf-16be", {
+                ignoreBOM: true,
+            }).decode(bytes.subarray(2));
+        }
+    }
+    const start = bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf ? 3 : 0;
+    return bytes.subarray(start).toString("utf8");
+}
+/** Native response grammar: ASCII control/space separators and whole quotes. */
+function responseTokens(text) {
+    const args = [];
+    let position = 0;
+    while (position < text.length) {
+        while (position < text.length && text.charCodeAt(position) <= 32)
+            position++;
+        if (position === text.length)
+            break;
+        if (text[position] === '"') {
+            const end = text.indexOf('"', position + 1);
+            if (end === -1)
+                throw new Error("Unterminated compiler response quote.");
+            args.push(text.slice(position + 1, end));
+            position = end + 1;
+        }
+        else {
+            const start = position;
+            while (position < text.length && text.charCodeAt(position) > 32)
+                position++;
+            args.push(text.slice(start, position));
+        }
+    }
+    return args;
+}
+//# sourceMappingURL=CompilerArgumentsInspection.js.map

package/lib/compiler/internal/CompilerArgumentsInspection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompilerArgumentsInspection.js","sourceRoot":"","sources":["../../../src/compiler/internal/CompilerArgumentsInspection.ts"],"names":[],"mappings":"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"}

package/lib/compiler/internal/EmitOwnershipIndex.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Match a source to actual compiler-written JavaScript using producer
+ * provenance.
+ *
+ * Keys are absolute writer paths. Source arrays contain physical coordinates
+ * established by the producer owner, not lexical names resolved again after
+ * compilation. Native hosts use their input ledger; external compiler adapters
+ * own their observed-program, output-rule and stability premises. Empty source
+ * arrays and multiple owners are unknown ownership. A missing record is
+ * legacy/unavailable; an authoritative empty record means no outputs. Neither
+ * filename layout nor source maps supply missing proof.
+ *
+ * Source-content freshness belongs to the generation owner. An owned output
+ * that disappears remains owned, so its reader reports that failure by name.
+ * Output coordinates use one native identity transaction to compare actual
+ * writer aliases; captured source coordinates are never resolved again.
+ *
+ * @evidence contracts/common.md#principled-implementation The producer owner associates its eligible sources with actual writes under its documented observation premises; captured physical coordinates establish ownership independently of filename precedence or source-map settings.
+ * @evidence contracts/common.md#clear-and-simple-design One source index replaces forward layout, inverse filename buckets and map parsing with the actual producing build's associations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing, incomplete or ambiguous provenance cannot be converted to ownership by extension order, matching names or newer source-map content.
+ * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs define writer/source coordinates, empty and missing states, and freshness ownership; properties carry only native documentation.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms Construction processes recorded output/source associations, normalizes source coordinate text, resolves output identities and builds source/output Sets. Native identity capability observations and proof-gap formatting remain costs of construction; queries reuse those maps instead of rescanning output trees.
+ * @evidence contracts/performance.md#reuse-equivalent-work One constructed index shares captured associations across queries, while each query resolves its current source target. Continued source-content/generation validity remains the producing build owner's responsibility, and a new build needs a new index.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The instance retains source/output Sets, root strings and proof-gap reasons until its caller discards it. Population and bytes grow with captured associations and path/reason text without a configured byte ceiling; construction-local identity memo state is not stored on the instance, and no query history or independently held native descriptor is acquired.
+ *
+ * @evidence contracts/portability.md#os-neutral-implementation Output writer aliases use the shared native filesystem identity resolver, preserving sensitive or unknown missing names; captured physical source coordinates remain distinct from later lexical aliases and normalize only Windows volume-root spelling.
+ */
+export declare class EmitOwnershipIndex {
+    /** Absolute native directory containing this build's isolated outputs. */
+    readonly emitDir: string;
+    /** Source root retained as build context, without inferring output ownership. */
+    readonly rootDir: string;
+    private readonly bySource;
+    /** Concrete proof gaps retained for actionable lookup failures. */
+    private readonly unavailableReasons;
+    /**
+     * Index one completed build's source associations, detached from input
+     * arrays. Sources are already physical coordinates: resolving them again
+     * could adopt a retargeted alias as if it produced the earlier output. The
+     * optional output record checks complete coverage before runtime user files
+     * enter the tree.
+     */
+    constructor(props: {
+        /** Native isolated output directory owned by the build. */
+        emitDir: string;
+        /** Native source-root context of the completed invocation. */
+        rootDir: string;
+        /** Complete relative JavaScript output record, captured before layout links. */
+        outputs?: readonly string[];
+        /** Absolute written output to captured physical source paths; [] is unknown. */
+        emittedSources?: Readonly<Record<string, readonly string[]>>;
+        /** Observed producer refusal reasons; these never establish ownership. */
+        emittedSourceProofFailures?: Readonly<Record<string, string>>;
+    });
+    /**
+     * List ordinary JavaScript outputs before virtual-layout user files are
+     * added. Paths are relative to emitDir with slash-separated protocol
+     * spelling. Links are not followed and enumeration failure propagates; this
+     * list checks coverage but cannot independently establish source ownership.
+     *
+     * @evidence contracts/common.md#principled-implementation Nonfollowing enumeration records ordinary JavaScript outputs and propagates failure rather than certifying an incomplete record as absence.
+     * @evidence contracts/common.md#clear-and-simple-design An explicit stack supplies one sorted path list without content parsing or source inference.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable subtrees are not silently omitted and later linked user files cannot become compiler output through a late snapshot.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states capture timing, returned spelling, link handling and the coverage-versus-ownership distinction before tags.
+     * @evidence contracts/performance.md#efficient-algorithms One traversal visits E entries, performs native directory reads and converts relative path text; J output paths are sorted with path-text comparison costs. It reads no output content, but entry/path storage grows with the enumeration.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This enumeration owns no cross-call sharing or validity protocol; every call observes the current tree. A build owner may retain the returned record for consumers under its capture-timing premise.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The path list transfers to the build owner; no retained handle or cache is acquired.
+     *
+     * @evidence contracts/portability.md#os-neutral-implementation Node directory kinds and relative-path grammar own native behavior; only returned protocol paths normalize separators.
+     */
+    static listOutputs(emitDir: string): string[];
+    /**
+     * Return the unique output actually written for this current physical source.
+     * Complete provenance excluding it returns null. Missing, incomplete or
+     * ambiguous ownership throws an error naming the source, output directory and
+     * concrete proof gaps. Query aliases are resolved afresh so a retargeted
+     * spelling cannot reuse an earlier ownership answer. Failure to observe the
+     * current physical target propagates.
+     *
+     * @evidence contracts/common.md#principled-implementation Fresh query identity is compared with captured physical source coordinates; only one written output answers and complete exclusion alone permits null.
+     * @evidence contracts/common.md#clear-and-simple-design One source lookup replaces filename inference; unavailable proof is explicit rather than a hidden fallback policy.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Legacy and unknown records cannot gain a unique owner through extension order or a lexical source alias resolved after compilation.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes exact, absent and error outcomes, plus fresh alias observation from source-content freshness; errors distinguish missing producer metadata, ownerless or ambiguous rows and uncovered written outputs with their native coordinates.
+     * @evidence contracts/performance.md#efficient-algorithms Construction indexes associations and resolves output coordinates in one memoized native identity transaction, including native capability queries where required; path normalization, alias merging and proof-gap text costs accompany it. Missing suffixes can add ancestor and case-observation work. A successful query resolves source identity and performs one map lookup without scanning outputs or source maps; unavailable errors format retained reason text rather than rereading the output tree.
+     * @evidence contracts/performance.md#reuse-equivalent-work A completed build's captured associations serve all queries while aliases stay fresh; another build requires a new index.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Index storage grows with captured associations and proof-gap path bytes, with no query history or retained native handle; each successful query finishes its native realpath observation synchronously.
+     * @evidence contracts/portability.md#os-neutral-implementation Native realpath resolves current aliases to physical spelling; exact captured names remain distinct when directory case policy changes, without OS-wide lowercase assumptions.
+     */
+    find(source: string): string | null;
+}

package/lib/compiler/internal/EmitOwnershipIndex.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmitOwnershipIndex = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const createFilesystemPathIdentityContext_1 = require("../../internal/pathIdentity/createFilesystemPathIdentityContext");
+const isOutsideRelativePath_1 = require("./isOutsideRelativePath");
+/**
+ * Match a source to actual compiler-written JavaScript using producer
+ * provenance.
+ *
+ * Keys are absolute writer paths. Source arrays contain physical coordinates
+ * established by the producer owner, not lexical names resolved again after
+ * compilation. Native hosts use their input ledger; external compiler adapters
+ * own their observed-program, output-rule and stability premises. Empty source
+ * arrays and multiple owners are unknown ownership. A missing record is
+ * legacy/unavailable; an authoritative empty record means no outputs. Neither
+ * filename layout nor source maps supply missing proof.
+ *
+ * Source-content freshness belongs to the generation owner. An owned output
+ * that disappears remains owned, so its reader reports that failure by name.
+ * Output coordinates use one native identity transaction to compare actual
+ * writer aliases; captured source coordinates are never resolved again.
+ *
+ * @evidence contracts/common.md#principled-implementation The producer owner associates its eligible sources with actual writes under its documented observation premises; captured physical coordinates establish ownership independently of filename precedence or source-map settings.
+ * @evidence contracts/common.md#clear-and-simple-design One source index replaces forward layout, inverse filename buckets and map parsing with the actual producing build's associations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing, incomplete or ambiguous provenance cannot be converted to ownership by extension order, matching names or newer source-map content.
+ * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs define writer/source coordinates, empty and missing states, and freshness ownership; properties carry only native documentation.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms Construction processes recorded output/source associations, normalizes source coordinate text, resolves output identities and builds source/output Sets. Native identity capability observations and proof-gap formatting remain costs of construction; queries reuse those maps instead of rescanning output trees.
+ * @evidence contracts/performance.md#reuse-equivalent-work One constructed index shares captured associations across queries, while each query resolves its current source target. Continued source-content/generation validity remains the producing build owner's responsibility, and a new build needs a new index.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The instance retains source/output Sets, root strings and proof-gap reasons until its caller discards it. Population and bytes grow with captured associations and path/reason text without a configured byte ceiling; construction-local identity memo state is not stored on the instance, and no query history or independently held native descriptor is acquired.
+ *
+ * @evidence contracts/portability.md#os-neutral-implementation Output writer aliases use the shared native filesystem identity resolver, preserving sensitive or unknown missing names; captured physical source coordinates remain distinct from later lexical aliases and normalize only Windows volume-root spelling.
+ */
+class EmitOwnershipIndex {
+    /** Absolute native directory containing this build's isolated outputs. */
+    emitDir;
+    /** Source root retained as build context, without inferring output ownership. */
+    rootDir;
+    bySource = new Map();
+    /** Concrete proof gaps retained for actionable lookup failures. */
+    unavailableReasons;
+    /**
+     * Index one completed build's source associations, detached from input
+     * arrays. Sources are already physical coordinates: resolving them again
+     * could adopt a retargeted alias as if it produced the earlier output. The
+     * optional output record checks complete coverage before runtime user files
+     * enter the tree.
+     */
+    constructor(props) {
+        // Output spelling is not provenance: the same native writer file can be
+        // named through a case, short-name or directory-link alias. Resolve only
+        // output coordinates here; captured source coordinates stay untouched.
+        const outputIdentity = (0, createFilesystemPathIdentityContext_1.createFilesystemPathIdentityContext)();
+        this.emitDir = outputIdentity.resolve(node_path_1.default.resolve(props.emitDir)).path;
+        this.rootDir = node_path_1.default.resolve(props.rootDir);
+        if (props.emittedSources !== undefined &&
+            (typeof props.emittedSources !== "object" ||
+                props.emittedSources === null ||
+                Array.isArray(props.emittedSources))) {
+            throw new Error("ttsc: invalid emitted-source provenance record");
+        }
+        const unavailableReasons = props.emittedSources === undefined
+            ? ["the emitting producer supplied no provenance record"]
+            : [];
+        const recorded = props.outputs === undefined
+            ? undefined
+            : new Set(props.outputs.map((file) => outputIdentity.resolve(node_path_1.default.resolve(this.emitDir, file)).key));
+        const accounted = new Set();
+        const ownersByOutput = new Map();
+        for (const [output, sources] of Object.entries(props.emittedSources ?? {})) {
+            if (!node_path_1.default.isAbsolute(output) || !Array.isArray(sources)) {
+                throw new Error("ttsc: invalid emitted-source provenance record");
+            }
+            const identity = outputIdentity.resolve(node_path_1.default.resolve(output));
+            const location = identity.path;
+            if (!isJavaScriptOutput(location))
+                continue;
+            const relative = node_path_1.default.relative(this.emitDir, location);
+            if (relative === "" || (0, isOutsideRelativePath_1.isOutsideRelativePath)(relative)) {
+                throw new Error("ttsc: emitted-source provenance escapes its output directory");
+            }
+            if (recorded !== undefined && !recorded.has(identity.key)) {
+                throw new Error("ttsc: emitted-source provenance names an unrecorded output");
+            }
+            accounted.add(identity.key);
+            const keys = new Set();
+            for (const source of sources) {
+                if (typeof source !== "string" || !node_path_1.default.isAbsolute(source)) {
+                    throw new Error("ttsc: invalid physical source in emitted-source provenance");
+                }
+                keys.add(physicalSourceKey(source));
+            }
+            const previousOwners = ownersByOutput.get(identity.key);
+            if (previousOwners === undefined) {
+                ownersByOutput.set(identity.key, new Set(keys));
+            }
+            else {
+                const previousSize = previousOwners.size;
+                for (const key of keys)
+                    previousOwners.add(key);
+                if (previousSize <= 1 && previousOwners.size > 1) {
+                    unavailableReasons.push(`multiple source owners were established across output aliases for ${JSON.stringify(location)}: ${JSON.stringify([...previousOwners])}`);
+                }
+            }
+            if (keys.size !== 1) {
+                const reason = props.emittedSourceProofFailures?.[output];
+                unavailableReasons.push(keys.size === 0
+                    ? `no source owner was established for ${JSON.stringify(location)}${typeof reason === "string" ? `: ${reason}` : ""}`
+                    : `multiple source owners were established for ${JSON.stringify(location)}: ${JSON.stringify([...keys])}`);
+                continue;
+            }
+            const key = keys.values().next().value;
+            let outputs = this.bySource.get(key);
+            if (outputs === undefined) {
+                outputs = new Set();
+                this.bySource.set(key, outputs);
+            }
+            outputs.add(location);
+        }
+        if (recorded !== undefined) {
+            for (const output of recorded) {
+                if (isJavaScriptOutput(output) && !accounted.has(output))
+                    unavailableReasons.push(`written output has no provenance entry: ${JSON.stringify(output)}`);
+            }
+        }
+        this.unavailableReasons = unavailableReasons;
+    }
+    /**
+     * List ordinary JavaScript outputs before virtual-layout user files are
+     * added. Paths are relative to emitDir with slash-separated protocol
+     * spelling. Links are not followed and enumeration failure propagates; this
+     * list checks coverage but cannot independently establish source ownership.
+     *
+     * @evidence contracts/common.md#principled-implementation Nonfollowing enumeration records ordinary JavaScript outputs and propagates failure rather than certifying an incomplete record as absence.
+     * @evidence contracts/common.md#clear-and-simple-design An explicit stack supplies one sorted path list without content parsing or source inference.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable subtrees are not silently omitted and later linked user files cannot become compiler output through a late snapshot.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states capture timing, returned spelling, link handling and the coverage-versus-ownership distinction before tags.
+     * @evidence contracts/performance.md#efficient-algorithms One traversal visits E entries, performs native directory reads and converts relative path text; J output paths are sorted with path-text comparison costs. It reads no output content, but entry/path storage grows with the enumeration.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This enumeration owns no cross-call sharing or validity protocol; every call observes the current tree. A build owner may retain the returned record for consumers under its capture-timing premise.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The path list transfers to the build owner; no retained handle or cache is acquired.
+     *
+     * @evidence contracts/portability.md#os-neutral-implementation Node directory kinds and relative-path grammar own native behavior; only returned protocol paths normalize separators.
+     */
+    static listOutputs(emitDir) {
+        const root = node_path_1.default.resolve(emitDir);
+        const outputs = [];
+        const stack = [root];
+        while (stack.length !== 0) {
+            const directory = stack.pop();
+            for (const entry of node_fs_1.default.readdirSync(directory, { withFileTypes: true })) {
+                const location = node_path_1.default.join(directory, entry.name);
+                if (entry.isDirectory())
+                    stack.push(location);
+                else if (entry.isFile() && isJavaScriptOutput(location)) {
+                    outputs.push(node_path_1.default.relative(root, location).split(node_path_1.default.sep).join("/"));
+                }
+            }
+        }
+        return outputs.sort();
+    }
+    /**
+     * Return the unique output actually written for this current physical source.
+     * Complete provenance excluding it returns null. Missing, incomplete or
+     * ambiguous ownership throws an error naming the source, output directory and
+     * concrete proof gaps. Query aliases are resolved afresh so a retargeted
+     * spelling cannot reuse an earlier ownership answer. Failure to observe the
+     * current physical target propagates.
+     *
+     * @evidence contracts/common.md#principled-implementation Fresh query identity is compared with captured physical source coordinates; only one written output answers and complete exclusion alone permits null.
+     * @evidence contracts/common.md#clear-and-simple-design One source lookup replaces filename inference; unavailable proof is explicit rather than a hidden fallback policy.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Legacy and unknown records cannot gain a unique owner through extension order or a lexical source alias resolved after compilation.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes exact, absent and error outcomes, plus fresh alias observation from source-content freshness; errors distinguish missing producer metadata, ownerless or ambiguous rows and uncovered written outputs with their native coordinates.
+     * @evidence contracts/performance.md#efficient-algorithms Construction indexes associations and resolves output coordinates in one memoized native identity transaction, including native capability queries where required; path normalization, alias merging and proof-gap text costs accompany it. Missing suffixes can add ancestor and case-observation work. A successful query resolves source identity and performs one map lookup without scanning outputs or source maps; unavailable errors format retained reason text rather than rereading the output tree.
+     * @evidence contracts/performance.md#reuse-equivalent-work A completed build's captured associations serve all queries while aliases stay fresh; another build requires a new index.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Index storage grows with captured associations and proof-gap path bytes, with no query history or retained native handle; each successful query finishes its native realpath observation synchronously.
+     * @evidence contracts/portability.md#os-neutral-implementation Native realpath resolves current aliases to physical spelling; exact captured names remain distinct when directory case policy changes, without OS-wide lowercase assumptions.
+     */
+    find(source) {
+        if (this.unavailableReasons.length !== 0) {
+            throw new Error(`ttsc: exact emitted-source ownership is unavailable for ${JSON.stringify(node_path_1.default.resolve(source))} in ${JSON.stringify(this.emitDir)}; ${this.unavailableReasons.join("; ")}. Rebuild with supported emit provenance`);
+        }
+        const physical = node_fs_1.default.realpathSync.native(node_path_1.default.resolve(source));
+        const outputs = this.bySource.get(physicalSourceKey(physical));
+        if (outputs === undefined)
+            return null;
+        if (outputs.size !== 1) {
+            throw new Error(`ttsc: emitted-source ownership is ambiguous for ${JSON.stringify(physical)}: ${JSON.stringify([...outputs])}`);
+        }
+        return outputs.values().next().value;
+    }
+}
+exports.EmitOwnershipIndex = EmitOwnershipIndex;
+/** JavaScript-bearing outputs, excluding maps and declaration artifacts. */
+function isJavaScriptOutput(file) {
+    return [".js", ".jsx", ".mjs", ".cjs"].includes(node_path_1.default.extname(file).toLowerCase());
+}
+/**
+ * Key an already physical coordinate without revisiting its alias or folding
+ * directory-sensitive names. Only Windows volume-root spelling is normalized,
+ * matching the native identity resolver's root convention.
+ */
+function physicalSourceKey(file) {
+    const location = node_path_1.default.normalize(file);
+    if (process.platform !== "win32")
+        return location;
+    const root = node_path_1.default.parse(location).root;
+    return root.toLowerCase() + location.slice(root.length);
+}
+//# sourceMappingURL=EmitOwnershipIndex.js.map

package/lib/compiler/internal/EmitOwnershipIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmitOwnershipIndex.js","sourceRoot":"","sources":["../../../src/compiler/internal/EmitOwnershipIndex.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,0DAA6B;AAE7B,yHAAsH;AACtH,mEAAgE;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IACE,0EAA0E;IAC1D,OAAO,CAAS;IAEhC,iFAAiF;IACjE,OAAO,CAAS;IAEf,QAAQ,GAAG,IAAI,GAAG,EAAuB,CAAC;IAC3D,mEAAmE;IAClD,kBAAkB,CAAW;IAE9C;;;;;;OAMG;IACH,YAAmB,KAelB;QACC,wEAAwE;QACxE,yEAAyE;QACzE,uEAAuE;QACvE,MAAM,cAAc,GAAG,IAAA,yEAAmC,GAAE,CAAC;QAC7D,IAAI,CAAC,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,mBAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;QACxE,IAAI,CAAC,OAAO,GAAG,mBAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC3C,IACE,KAAK,CAAC,cAAc,KAAK,SAAS;YAClC,CAAC,OAAO,KAAK,CAAC,cAAc,KAAK,QAAQ;gBACvC,KAAK,CAAC,cAAc,KAAK,IAAI;gBAC7B,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,EACtC,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACpE,CAAC;QACD,MAAM,kBAAkB,GACtB,KAAK,CAAC,cAAc,KAAK,SAAS;YAChC,CAAC,CAAC,CAAC,qDAAqD,CAAC;YACzD,CAAC,CAAC,EAAE,CAAC;QACT,MAAM,QAAQ,GACZ,KAAK,CAAC,OAAO,KAAK,SAAS;YACzB,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,IAAI,GAAG,CACL,KAAK,CAAC,OAAO,CAAC,GAAG,CACf,CAAC,IAAI,EAAE,EAAE,CACP,cAAc,CAAC,OAAO,CAAC,mBAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAC/D,CACF,CAAC;QACR,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;QACpC,MAAM,cAAc,GAAG,IAAI,GAAG,EAAuB,CAAC;QACtD,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAC5C,KAAK,CAAC,cAAc,IAAI,EAAE,CAC3B,EAAE,CAAC;YACF,IAAI,CAAC,mBAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACxD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;YACpE,CAAC;YACD,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,mBAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;YAC9D,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC;YAC/B,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC;gBAAE,SAAS;YAC5C,MAAM,QAAQ,GAAG,mBAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YACvD,IAAI,QAAQ,KAAK,EAAE,IAAI,IAAA,6CAAqB,EAAC,QAAQ,CAAC,EAAE,CAAC;gBACvD,MAAM,IAAI,KAAK,CACb,8DAA8D,CAC/D,CAAC;YACJ,CAAC;YACD,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC1D,MAAM,IAAI,KAAK,CACb,4DAA4D,CAC7D,CAAC;YACJ,CAAC;YACD,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC5B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;YAC/B,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;gBAC7B,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,mBAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC3D,MAAM,IAAI,KAAK,CACb,4DAA4D,CAC7D,CAAC;gBACJ,CAAC;gBACD,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC;YACtC,CAAC;YACD,MAAM,cAAc,GAAG,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YACxD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;gBACjC,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;YAClD,CAAC;iBAAM,CAAC;gBACN,MAAM,YAAY,GAAG,cAAc,CAAC,IAAI,CAAC;gBACzC,KAAK,MAAM,GAAG,IAAI,IAAI;oBAAE,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAChD,IAAI,YAAY,IAAI,CAAC,IAAI,cAAc,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;oBACjD,kBAAkB,CAAC,IAAI,CACrB,qEAAqE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,EAAE,CACxI,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;gBACpB,MAAM,MAAM,GAAG,KAAK,CAAC,0BAA0B,EAAE,CAAC,MAAM,CAAC,CAAC;gBAC1D,kBAAkB,CAAC,IAAI,CACrB,IAAI,CAAC,IAAI,KAAK,CAAC;oBACb,CAAC,CAAC,uCAAuC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;oBACrH,CAAC,CAAC,+CAA+C,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAC5G,CAAC;gBACF,SAAS;YACX,CAAC;YACD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAM,CAAC;YACxC,IAAI,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACrC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;gBACpB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;YAClC,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACxB,CAAC;QACD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,KAAK,MAAM,MAAM,IAAI,QAAQ,EAAE,CAAC;gBAC9B,IAAI,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC;oBACtD,kBAAkB,CAAC,IAAI,CACrB,2CAA2C,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CACpE,CAAC;YACN,CAAC;QACH,CAAC;QACD,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;IAC/C,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,CAAC,WAAW,CAAC,OAAe;QACvC,MAAM,IAAI,GAAG,mBAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACnC,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,CAAC;QACrB,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,SAAS,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;YAC/B,KAAK,MAAM,KAAK,IAAI,iBAAE,CAAC,WAAW,CAAC,SAAS,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;gBACvE,MAAM,QAAQ,GAAG,mBAAI,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;gBAClD,IAAI,KAAK,CAAC,WAAW,EAAE;oBAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;qBACzC,IAAI,KAAK,CAAC,MAAM,EAAE,IAAI,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACxD,OAAO,CAAC,IAAI,CAAC,mBAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,mBAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;gBACxE,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAC,IAAI,EAAE,CAAC;IACxB,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACI,IAAI,CAAC,MAAc;QACxB,IAAI,IAAI,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CACb,2DAA2D,IAAI,CAAC,SAAS,CAAC,mBAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,0CAA0C,CACpN,CAAC;QACJ,CAAC;QACD,MAAM,QAAQ,GAAG,iBAAE,CAAC,YAAY,CAAC,MAAM,CAAC,mBAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QAC9D,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC/D,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QACvC,IAAI,OAAO,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CACb,mDAAmD,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAC/G,CAAC;QACJ,CAAC;QACD,OAAO,OAAO,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAM,CAAC;IACxC,CAAC;CACF;;AAED,4EAA4E;AAC5E,SAAS,kBAAkB,CAAC,IAAY;IACtC,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,QAAQ,CAC7C,mBAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CACjC,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,iBAAiB,CAAC,IAAY;IACrC,MAAM,QAAQ,GAAG,mBAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,QAAQ,CAAC;IAClD,MAAM,IAAI,GAAG,mBAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC;IACvC,OAAO,IAAI,CAAC,WAAW,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC1D,CAAC"}

package/lib/compiler/internal/PrivateCompilerOutput.d.ts

@@ -0,0 +1,67 @@
+import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscParsedProjectConfig";
+import type { RunBuildOptions } from "./build/RunBuildOptions";
+/**
+ * Compiler destinations and artifact translation for a single in-memory API
+ * request. Native options retain distinct JavaScript, declaration, bundle and
+ * incremental coordinates while all actual writes belong to one private tree.
+ *
+ * @evidence contracts/common.md#principled-implementation Destination translation and returned-artifact translation share one inverse mapping, preserving original public paths while native writes use private paths.
+ * @evidence contracts/common.md#clear-and-simple-design This namespace groups one API output policy; shared build execution consumes its destination record without owning API artifact keys.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Compiler-supported destinations are used instead of foreign filesystem interception or deleting caller artifacts after a write.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes private actual writes from public artifact locations; operation comments document relative map and incremental path ownership.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The namespace groups operations; its path-owning members document the native boundary.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace chooses no processing strategy independent of its members.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace retains no shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The API call owns the private directory lifetime.
+ */
+export declare namespace PrivateCompilerOutput {
+    /**
+     * Relocate each compiler destination independently. Directory mappings retain
+     * the compiler's per-source layout; exact mappings keep bundle and
+     * incremental names independent of that layout. A private explicit build-info
+     * path avoids inferred paths above outDir for deeply nested rootDir values.
+     * Independent checks use another state file so diagnostic recovery cannot
+     * overwrite or masquerade as an emitted API artifact. Only a newly added
+     * outDir needs private root pinning. Relocating a configured outDir retains
+     * native inferred layout and its configuration diagnostics.
+     *
+     * @evidence contracts/common.md#principled-implementation Separate native destinations have inverse mappings to original artifact locations. Only originally source-adjacent emission receives root pinning; configured outDir retains native inferred layout and diagnostics. Inferred state follows pinned outputpaths.GetBuildInfoFileName config/rootDir/outDir rules; explicit private state prevents upward escapes and independent checks use a separate non-artifact destination.
+     * @evidence contracts/common.md#clear-and-simple-design One request-local mapping joins destination selection and artifact translation, preserving bundle/declaration distinctions at the API boundary.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Output destination options preserve incremental checking and separate bundle/declaration output instead of disabling them or cleaning caller paths after publication.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains path ownership, independent output kinds and why inferred incremental metadata needs an explicit private location.
+     * @evidence contracts/portability.md#os-neutral-implementation Node path resolution and relative paths preserve native volume boundaries and separators; protocol text normalizes host separators only.
+     * @evidence contracts/performance.md#efficient-algorithms At most four destination mappings are allocated. Native path resolution, root-relative inference and each inverse lookup operate on a bounded number of path strings and cost their actual text lengths; no caller tree is traversed.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each request observes new compiler input and owns its output; no cross-request result cache is introduced.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Mapping and returned text are request-local data; compileProjectInMemory owns acquisition and finally removal of the private tree.
+     */
+    function create(project: ITtscParsedProjectConfig, directory: string): {
+        /** Compiler destinations used only within the owning temporary tree. */
+        destinations: NonNullable<RunBuildOptions["privateOutputDestinations"]>;
+        /** Pin layout only when adding an outDir to an originally adjacent emit. */
+        pinInferredRootDir: boolean;
+        /** Map a captured native output path back to its original artifact location. */
+        originalPath: (file: string) => string;
+    };
+    /**
+     * Return all captured compiler artifacts at their original API keys. Source
+     * maps without compiler-owned sourceRoot/mapRoot need their relative sources
+     * re-based from the private destination to the original destination. Explicit
+     * roots already give sources their independent compiler-defined base. Only
+     * the final compiler map trailer is translated; similar authored text inside
+     * a multiline literal remains source text.
+     *
+     * Build information is identified by its selected path, including arbitrary
+     * extensions. Recovery-only state is excluded by path; actual emitted state
+     * remains an artifact even when the compiler also reports errors.
+     *
+     * @evidence contracts/common.md#principled-implementation Inverse destination mapping restores original keys as own data properties, including names inherited from Object.prototype. Maps without explicit sourceRoot/mapRoot rebase source paths through their private and original directories, preserving remote URLs and the pinned native generator's raw file-URL convention for different Windows roots without percent decoding filename data. Build-info source/option paths rebase similarly while special library names remain compiler identifiers. Only the separate check/recovery state is omitted; actual emission state and partial outputs remain captured.
+     * @evidence contracts/common.md#clear-and-simple-design One request-local mapping joins destination selection and artifact translation, preserving bundle/declaration distinctions at the API boundary.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Output destination options preserve incremental checking and separate bundle/declaration output instead of disabling them or cleaning caller paths after publication.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains path ownership, independent output kinds and why inferred incremental metadata needs an explicit private location.
+     * @evidence contracts/portability.md#os-neutral-implementation Node path resolution and relative paths preserve native volume boundaries and separators; protocol text normalizes host separators only.
+     * @evidence contracts/performance.md#efficient-algorithms The iterative walk visits E private directory entries, sorts F file paths with path-text comparison costs and reads B emitted bytes once. Map/state JSON parsing, translation and serialization cost their actual text and record sizes; retained output grows with B and the path keys.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each request observes new compiler input and owns its output; no cross-request result cache is introduced.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Mapping and returned text are request-local data; compileProjectInMemory owns acquisition and finally removal of the private tree.
+     */
+    function read(project: ITtscParsedProjectConfig, directory: string, originalPath: (file: string) => string, buildInfoFile?: string, diagnosticState?: string): Record<string, string>;
+}