@ttsc/unplugin 0.22.0 → 0.24.0

package/lib/core/transform.mjs

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { TtscCompiler } from 'ttsc';
+import { createFilesystemPathIdentityContext } from 'ttsc/path-identity';
 import { absolutizePathsTarget, readEffectiveTsconfigPaths } from './tsconfigPaths.mjs';
 
 /**
@@ -10,6 +11,11 @@ import { absolutizePathsTarget, readEffectiveTsconfigPaths } from './tsconfigPat
  * {@link beginTtscTransformBuild} before transforms begin.
  */
 const BUILD_SCOPED_TRANSFORM_CACHES = new WeakSet();
+function createHostPathIdentityContext() {
+    return createFilesystemPathIdentityContext({
+        throwOnRealpathError: false,
+    });
+}
 /** Create an empty persistent transform cache. */
 function createTtscTransformCache() {
     return new Map();
@@ -37,8 +43,6 @@ function resetTtscTransformCache(cache) {
     cache.clear();
     BUILD_SCOPED_TRANSFORM_CACHES.delete(cache);
 }
-/** Cached case-insensitivity probes for existing macOS filesystem locations. */
-const CASE_INSENSITIVE_FILESYSTEMS = new Map();
 /**
  * Apply the ttsc plugin transform to a single source file.
  *
@@ -98,7 +102,7 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
             // A file the plugin declared volatile must never be served from the
             // cache: its output depends on non-file inputs, so the input-hash
             // snapshot cannot prove freshness. Fall through to a fresh transform.
-            !isVolatileFile({
+            !isVolatileFile(envelopeDerivation(cached), {
                 file,
                 projectRoot: cached.projectRoot,
                 result: cached.result,
@@ -155,7 +159,7 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
         });
         notifyWatchInputs(hooks, { file, projectRoot, result, temporaryTsconfig });
         markCachedSourceServed(cached, file);
-        if (isVolatileFile({ file, projectRoot, result })) {
+        if (isVolatileFile(envelopeDerivation(cached), { file, projectRoot, result })) {
             hooks?.markVolatile?.();
         }
         return createTransformResult(source, code);
@@ -205,6 +209,105 @@ function evictGeneration(cache, key, generation) {
         cache.delete(key);
     }
 }
+/**
+ * Derivation states keyed by the compiler result object. One result object is
+ * produced by one compile against one project root, so the root captured at
+ * build time is the only root the state ever sees.
+ */
+const ENVELOPE_DERIVATIONS = new WeakMap();
+/** Return the derivation state of `props.result`, building it on first use. */
+function envelopeDerivation(props) {
+    const existing = ENVELOPE_DERIVATIONS.get(props.result);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const created = {
+        identityContext: createHostPathIdentityContext(),
+        identities: new Map(),
+        watchInputs: new Map(),
+    };
+    ENVELOPE_DERIVATIONS.set(props.result, created);
+    return created;
+}
+/**
+ * Build the reference-graph indexes of one envelope on first watch-input
+ * derivation. Malformed sections are dropped member by member, mirroring the
+ * historical per-delivery scan.
+ */
+function envelopeGraphIndexes(state, props) {
+    if (state.graph !== undefined) {
+        return state.graph;
+    }
+    const built = {
+        edges: new Map(),
+        spellings: new Map(),
+        candidates: [],
+        globals: [],
+        configs: [],
+    };
+    const graph = props.result.type === "exception" ? undefined : props.result.graph;
+    if (graph !== undefined) {
+        for (const [source, targets] of Object.entries(graph.edges ?? {})) {
+            if (!Array.isArray(targets)) {
+                continue;
+            }
+            const absolute = path.resolve(props.projectRoot, source);
+            const identity = derivationIdentity(state, absolute);
+            built.spellings.set(identity, absolute);
+            const entries = built.edges.get(identity) ?? [];
+            entries.push(...targets
+                .filter((target) => typeof target === "string" && target.length !== 0)
+                .map((target) => path.resolve(props.projectRoot, target)));
+            built.edges.set(identity, entries);
+        }
+        built.globals.push(...selectListedFiles(props.projectRoot, graph.globals));
+        built.configs.push(...selectListedFiles(props.projectRoot, graph.configs));
+        for (const [source, candidates] of Object.entries(graph.candidates ?? {})) {
+            if (!Array.isArray(candidates)) {
+                continue;
+            }
+            built.candidates.push({
+                source: derivationIdentity(state, path.resolve(props.projectRoot, source)),
+                files: selectListedFiles(props.projectRoot, candidates),
+            });
+        }
+    }
+    state.graph = built;
+    return built;
+}
+/**
+ * {@link pathIdentityKey} memoized inside one envelope's derivation state.
+ * Callers always pass already-resolved absolute paths, so the input string is a
+ * stable memo key.
+ */
+function derivationIdentity(state, file) {
+    const existing = state.identities.get(file);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const identity = pathIdentityKey(file, state.identityContext);
+    state.identities.set(file, identity);
+    return identity;
+}
+/**
+ * Fold one envelope member list (`volatile`, `dependenciesComplete`) into an
+ * identity set. Members are keyed like `typescript`, so a project-relative and
+ * an absolute spelling of the same file share one identity; a malformed member
+ * is ignored rather than fatal.
+ */
+function collectDeclaredIdentities(state, projectRoot, listed) {
+    const output = new Set();
+    if (!Array.isArray(listed)) {
+        return output;
+    }
+    for (const entry of listed) {
+        if (typeof entry !== "string" || entry.length === 0) {
+            continue;
+        }
+        output.add(derivationIdentity(state, path.resolve(projectRoot, entry)));
+    }
+    return output;
+}
 /**
  * Forward every derived watch input for `file` to the adapter's `addWatchFile`
  * hook: the plugin-reported `dependencies[file]` list unioned with the
@@ -244,23 +347,44 @@ function notifyWatchInputs(hooks, props) {
  * volatile keeps the baseline: the two declarations contradict, so the
  * conservative one wins.
  *
- * Returns an empty list on exceptions.
+ * The derived list is a pure function of the envelope and the file's filesystem
+ * identity, so it is computed at most once per generation per file: sibling and
+ * repeated deliveries replay the per-envelope memo ({@link envelopeDerivation})
+ * instead of re-walking the graph. Returns an empty list on exceptions.
  */
 function selectWatchInputs(props) {
+    if (props.result.type === "exception") {
+        return [];
+    }
+    const state = envelopeDerivation(props);
+    const fileIdentity = derivationIdentity(state, props.file);
+    const memoized = state.watchInputs.get(fileIdentity);
+    if (memoized !== undefined) {
+        return memoized;
+    }
+    const derived = deriveWatchInputs(state, props, fileIdentity);
+    state.watchInputs.set(fileIdentity, derived);
+    return derived;
+}
+/** Compute one file's watch-input list over the shared per-envelope state. */
+function deriveWatchInputs(state, props, fileIdentity) {
+    const graph = envelopeGraphIndexes(state, props);
     const output = [];
     const seen = new Set();
-    const excluded = new Set(props.temporaryTsconfig === undefined
-        ? [pathIdentityKey(props.file)]
-        : [pathIdentityKey(props.file), pathIdentityKey(props.temporaryTsconfig)]);
+    const excluded = new Set([fileIdentity]);
+    if (props.temporaryTsconfig !== undefined) {
+        excluded.add(derivationIdentity(state, props.temporaryTsconfig));
+    }
     for (const absolute of [
         ...selectFileDependencies(props),
-        ...selectGraphInputs({
+        ...selectGraphInputs(graph, state, {
             ...props,
-            complete: declaresCompleteDependencies(props) && !isVolatileFile(props),
+            complete: declaresCompleteDependencies(state, props) &&
+                !isVolatileFile(state, props),
         }),
-        ...selectResolutionCandidateInputs(props),
+        ...selectResolutionCandidateInputs(graph, state, props),
     ]) {
-        const identity = pathIdentityKey(absolute);
+        const identity = derivationIdentity(state, absolute);
         if (excluded.has(identity) || seen.has(identity)) {
             continue;
         }
@@ -274,23 +398,23 @@ function selectWatchInputs(props) {
  * module reachable from `file`. They remain host-owned even when a plugin
  * declares `dependenciesComplete`: plugin code cannot vouch for a compiler
  * resolution change that occurs without any plugin input changing.
+ *
+ * Candidate entries and their source identities come from the shared
+ * per-envelope state, so one delivery scans only the candidates themselves
+ * instead of re-resolving every candidate source.
  */
-function selectResolutionCandidateInputs(props) {
-    if (props.result.type === "exception") {
-        return [];
-    }
-    const graph = props.result.graph;
-    if (graph === undefined || graph.candidates === undefined) {
+function selectResolutionCandidateInputs(graph, state, props) {
+    if (props.result.type === "exception" ||
+        props.result.graph?.candidates === undefined) {
         return [];
     }
-    const reachable = new Set(selectReachableSources(props.projectRoot, props.file, graph).map(pathIdentityKey));
+    const reachable = new Set(selectReachableSources(graph, state, props.file).map((source) => derivationIdentity(state, source)));
     const output = [];
-    for (const [source, candidates] of Object.entries(graph.candidates)) {
-        if (!reachable.has(pathIdentityKey(path.resolve(props.projectRoot, source))) ||
-            !Array.isArray(candidates)) {
+    for (const entry of graph.candidates) {
+        if (!reachable.has(entry.source)) {
             continue;
         }
-        output.push(...selectListedFiles(props.projectRoot, candidates));
+        output.push(...entry.files);
     }
     return output;
 }
@@ -308,47 +432,33 @@ function selectResolutionCandidateInputs(props) {
  * `dependencies[file]` list the complete replacement for them. Returns an empty
  * list on exceptions or without a graph.
  */
-function selectGraphInputs(props) {
-    if (props.result.type === "exception") {
-        return [];
-    }
-    const graph = props.result.graph;
-    if (graph === undefined) {
+function selectGraphInputs(graph, state, props) {
+    if (props.result.type === "exception" || props.result.graph === undefined) {
         return [];
     }
     const output = [];
     if (!props.complete) {
-        output.push(...selectReachableEdges(props.projectRoot, props.file, graph));
-        output.push(...selectListedFiles(props.projectRoot, graph.globals));
+        output.push(...selectReachableEdges(graph, state, props.file));
+        output.push(...graph.globals);
     }
-    output.push(...selectListedFiles(props.projectRoot, graph.configs));
+    output.push(...graph.configs);
     return output;
 }
 /**
  * Walk the reachability closure of the graph's direct `edges` from `file`,
  * returning the absolute path of every file reached (the starting file itself
- * excluded, even when a cycle points back at it).
+ * excluded, even when a cycle points back at it). Reads the shared per-envelope
+ * edge index instead of rebuilding it per delivery.
  */
-function selectReachableEdges(projectRoot, file, graph) {
-    const edges = new Map();
-    for (const [source, targets] of Object.entries(graph.edges ?? {})) {
-        if (!Array.isArray(targets)) {
-            continue;
-        }
-        const identity = pathIdentityKey(path.resolve(projectRoot, source));
-        const entries = edges.get(identity) ?? [];
-        entries.push(...targets
-            .filter((target) => typeof target === "string" && target.length !== 0)
-            .map((target) => path.resolve(projectRoot, target)));
-        edges.set(identity, entries);
-    }
+function selectReachableEdges(graph, state, file) {
     const output = [];
-    const visited = new Set([pathIdentityKey(file)]);
+    const visited = new Set([derivationIdentity(state, file)]);
     const queue = [file];
     while (queue.length !== 0) {
         const current = queue.pop();
-        for (const target of edges.get(pathIdentityKey(current)) ?? []) {
-            const identity = pathIdentityKey(target);
+        for (const target of graph.edges.get(derivationIdentity(state, current)) ??
+            []) {
+            const identity = derivationIdentity(state, target);
             if (visited.has(identity)) {
                 continue;
             }
@@ -364,35 +474,21 @@ function selectReachableEdges(projectRoot, file, graph) {
  * including `file` itself. Resolution candidates belong to importers rather
  * than targets, so this is intentionally distinct from selectReachableEdges.
  */
-function selectReachableSources(projectRoot, file, graph) {
-    const edges = new Map();
-    const spellings = new Map();
-    for (const [source, targets] of Object.entries(graph.edges ?? {})) {
-        if (!Array.isArray(targets)) {
-            continue;
-        }
-        const absolute = path.resolve(projectRoot, source);
-        const identity = pathIdentityKey(absolute);
-        spellings.set(identity, absolute);
-        const entries = edges.get(identity) ?? [];
-        entries.push(...targets
-            .filter((target) => typeof target === "string" && target.length !== 0)
-            .map((target) => path.resolve(projectRoot, target)));
-        edges.set(identity, entries);
-    }
+function selectReachableSources(graph, state, file) {
     const output = [file];
-    const visited = new Set([pathIdentityKey(file)]);
+    const visited = new Set([derivationIdentity(state, file)]);
     const queue = [file];
     while (queue.length !== 0) {
         const current = queue.pop();
-        for (const target of edges.get(pathIdentityKey(current)) ?? []) {
-            const identity = pathIdentityKey(target);
+        for (const target of graph.edges.get(derivationIdentity(state, current)) ??
+            []) {
+            const identity = derivationIdentity(state, target);
             if (visited.has(identity)) {
                 continue;
             }
             visited.add(identity);
             queue.push(target);
-            output.push(spellings.get(identity) ?? target);
+            output.push(graph.spellings.get(identity) ?? target);
         }
     }
     return output;
@@ -418,13 +514,15 @@ function selectListedFiles(projectRoot, listed) {
 /**
  * Report whether the plugin declared `file` volatile: its output depends on
  * non-file inputs (environment, time, network), so neither the project
- * transform cache nor a bundler's persistent cache may replay it.
+ * transform cache nor a bundler's persistent cache may replay it. Reads the
+ * per-envelope identity set instead of rescanning the member list.
  */
-function isVolatileFile(props) {
+function isVolatileFile(state, props) {
     if (props.result.type === "exception") {
         return false;
     }
-    return declaresFile(props.result.volatile, props);
+    const declared = (state.volatileFiles ??= collectDeclaredIdentities(state, props.projectRoot, props.result.volatile));
+    return declared.has(derivationIdentity(state, props.file));
 }
 /**
  * Report whether the envelope declared `dependencies[file]` complete, i.e. the
@@ -432,32 +530,18 @@ function isVolatileFile(props) {
  * itself and the universal config chain. Callers must still keep the baseline
  * for a file the same envelope declared volatile.
  */
-function declaresCompleteDependencies(props) {
+function declaresCompleteDependencies(state, props) {
     if (props.result.type === "exception") {
         return false;
     }
-    return declaresFile(props.result.dependenciesComplete, props);
-}
-/**
- * Report whether one of the envelope's transformed-file lists (`volatile`,
- * `dependenciesComplete`) names `file`. Members are keyed like `typescript`, so
- * a project-relative and an absolute spelling of the same file both match; a
- * malformed member is ignored rather than fatal.
- */
-function declaresFile(listed, props) {
-    if (!Array.isArray(listed)) {
-        return false;
-    }
-    return listed.some((entry) => typeof entry === "string" &&
-        entry.length !== 0 &&
-        pathIdentityKey(path.resolve(props.projectRoot, entry)) ===
-            pathIdentityKey(props.file));
+    const declared = (state.dependenciesComplete ??= collectDeclaredIdentities(state, props.projectRoot, props.result.dependenciesComplete));
+    return declared.has(derivationIdentity(state, props.file));
 }
 /**
  * Extract the absolute, deduplicated dependency list for a single file from the
  * compiler result. Mirrors {@link selectTransformedSource}'s key lookup: fast
- * project-relative match first, then a resolve-based scan. Returns an empty
- * list on exceptions or when the plugin reported nothing.
+ * project-relative match first, then a per-envelope identity index. Returns an
+ * empty list on exceptions or when the plugin reported nothing.
  */
 function selectFileDependencies(props) {
     if (props.result.type === "exception") {
@@ -467,29 +551,26 @@ function selectFileDependencies(props) {
     if (dependencies === undefined) {
         return [];
     }
-    const key = toProjectKey(props.projectRoot, props.file);
+    const state = envelopeDerivation(props);
+    const key = toProjectKey(props.projectRoot, props.file, state.identityContext);
     let entries = dependencies[key];
     if (entries === undefined) {
-        for (const [candidate, candidateEntries] of Object.entries(dependencies)) {
-            if (pathIdentityKey(path.resolve(props.projectRoot, candidate)) ===
-                pathIdentityKey(props.file)) {
-                entries = candidateEntries;
-                break;
-            }
-        }
+        const index = (state.dependencyIndex ??= createEnvelopeKeyIndex(state, props.projectRoot, dependencies));
+        entries = index.get(derivationIdentity(state, props.file));
     }
     if (!Array.isArray(entries)) {
         return [];
     }
     const output = [];
     const seen = new Set();
+    const fileIdentity = derivationIdentity(state, props.file);
     for (const entry of entries) {
         if (typeof entry !== "string" || entry.length === 0) {
             continue;
         }
         const absolute = path.resolve(props.projectRoot, entry);
-        const identity = pathIdentityKey(absolute);
-        if (identity === pathIdentityKey(props.file) || seen.has(identity)) {
+        const identity = derivationIdentity(state, absolute);
+        if (identity === fileIdentity || seen.has(identity)) {
             continue;
         }
         seen.add(identity);
@@ -497,6 +578,21 @@ function selectFileDependencies(props) {
     }
     return output;
 }
+/**
+ * Build a first-match identity index over one envelope key map (`typescript`,
+ * `dependencies`), mirroring the historical per-delivery scan that returned the
+ * first entry whose resolved key matched by filesystem identity.
+ */
+function createEnvelopeKeyIndex(state, projectRoot, keyed) {
+    const index = new Map();
+    for (const [candidate, value] of Object.entries(keyed)) {
+        const identity = derivationIdentity(state, path.resolve(projectRoot, candidate));
+        if (!index.has(identity)) {
+            index.set(identity, value);
+        }
+    }
+    return index;
+}
 /**
  * Strip a query string or hash fragment from a bundler module id.
  *
@@ -552,14 +648,16 @@ function createTransformResult(source, code) {
  * agree on the key universe.
  */
 function matchesCachedSource(cached, file, source, buildScoped) {
-    const currentKey = toProjectKey(cached.projectRoot, file);
+    const identities = envelopeDerivation(cached).identityContext;
+    const currentKey = toProjectKey(cached.projectRoot, file, identities);
     if (cached.inputHashes[currentKey] !== hashText(source)) {
         return false;
     }
-    if (buildScoped && !cached.servedFiles?.has(pathIdentityKey(file))) {
+    if (buildScoped &&
+        !cached.servedFiles?.has(pathIdentityKey(file, identities))) {
         return true;
     }
-    const currentHashes = collectProjectInputHashes(cached.projectRoot);
+    const currentHashes = collectProjectInputHashes(cached.projectRoot, identities);
     currentHashes[currentKey] = hashText(source);
     if (!sameHashes(cached.inputHashes, currentHashes)) {
         return false;
@@ -577,7 +675,7 @@ function matchesCachedSource(cached, file, source, buildScoped) {
 }
 /** Record a successfully selected module as delivered by this generation. */
 function markCachedSourceServed(cached, file) {
-    (cached.servedFiles ??= new Set()).add(pathIdentityKey(file));
+    (cached.servedFiles ??= new Set()).add(pathIdentityKey(file, envelopeDerivation(cached).identityContext));
 }
 /**
  * Build the input-hash snapshot stored alongside a fresh compiler result.
@@ -593,9 +691,11 @@ function markCachedSourceServed(cached, file) {
  * them here would make every snapshot comparison fail and the cache never hit.
  */
 function collectInputHashes(props) {
-    const hashes = collectProjectInputHashes(props.projectRoot);
+    const identities = createHostPathIdentityContext();
+    const hashes = collectProjectInputHashes(props.projectRoot, identities);
     // Overlay the in-memory source so unsaved edits invalidate the cache.
-    hashes[toProjectKey(props.projectRoot, props.currentFile)] = hashText(props.currentSource);
+    hashes[toProjectKey(props.projectRoot, props.currentFile, identities)] =
+        hashText(props.currentSource);
     return hashes;
 }
 /**
@@ -604,11 +704,11 @@ function collectInputHashes(props) {
  * slash path. Exported so hosts without a per-build boundary (`@ttsc/metro`)
  * can fold the identical input universe into their own cache fingerprints.
  */
-function collectProjectInputHashes(projectRoot) {
+function collectProjectInputHashes(projectRoot, identities = createHostPathIdentityContext()) {
     const hashes = {};
     for (const file of listProjectInputFiles(projectRoot)) {
         try {
-            hashes[toProjectKey(projectRoot, file)] = hashText(fs.readFileSync(file));
+            hashes[toProjectKey(projectRoot, file, identities)] = hashText(fs.readFileSync(file));
         }
         catch {
             // File watchers may observe a transform while another process is moving
@@ -662,8 +762,13 @@ function listProjectInputFiles(root) {
  * Missing paths and files reached through symlinks or Windows junctions are
  * out-of-walk inputs that only the reference graph can prove relevant.
  */
-function isProjectWalkPath(root, file) {
-    const relative = path.relative(pathIdentityKey(root), pathIdentityKey(file));
+function isProjectWalkPath(root, file, identities = createHostPathIdentityContext()) {
+    if (!identities.isWithin(root, file)) {
+        return false;
+    }
+    const rootKey = pathIdentityKey(root, identities);
+    const fileKey = pathIdentityKey(file, identities);
+    const relative = fileKey.slice(rootKey.length).replace(/^[/\\]+/, "");
     if (relative.length === 0 ||
         relative === ".." ||
         relative.startsWith(`..${path.sep}`) ||
@@ -705,8 +810,9 @@ function isProjectWalkPath(root, file) {
  */
 function collectExternalInputHashes(paths) {
     const hashes = {};
+    const identities = createHostPathIdentityContext();
     for (const file of paths) {
-        const identity = pathIdentityKey(file);
+        const identity = pathIdentityKey(file, identities);
         if (identity in hashes) {
             continue;
         }
@@ -742,6 +848,7 @@ function selectExternalInputPaths(props) {
         return [];
     }
     const members = [];
+    const identities = createHostPathIdentityContext();
     const resolutionCandidates = new Set();
     const graph = props.result.graph;
     if (graph !== undefined) {
@@ -766,7 +873,7 @@ function selectExternalInputPaths(props) {
                 }
                 const absolute = path.resolve(props.projectRoot, candidate);
                 members.push(candidate);
-                resolutionCandidates.add(pathIdentityKey(absolute));
+                resolutionCandidates.add(pathIdentityKey(absolute, identities));
             }
         }
     }
@@ -777,7 +884,7 @@ function selectExternalInputPaths(props) {
     }
     const excluded = props.temporaryTsconfig === undefined
         ? undefined
-        : pathIdentityKey(props.temporaryTsconfig);
+        : pathIdentityKey(props.temporaryTsconfig, identities);
     const output = [];
     const seen = new Set();
     for (const member of members) {
@@ -785,11 +892,12 @@ function selectExternalInputPaths(props) {
             continue;
         }
         const absolute = path.resolve(props.projectRoot, member);
-        const identity = pathIdentityKey(absolute);
+        const identity = pathIdentityKey(absolute, identities);
         const missingCandidate = resolutionCandidates.has(identity) && !fs.existsSync(absolute);
         if (identity === excluded ||
             seen.has(identity) ||
-            (!missingCandidate && isProjectWalkPath(props.projectRoot, absolute))) {
+            (!missingCandidate &&
+                isProjectWalkPath(props.projectRoot, absolute, identities))) {
             continue;
         }
         seen.add(identity);
@@ -1097,17 +1205,18 @@ function selectTransformedSource(props) {
         throw new Error(formatDiagnostics(props.result.diagnostics));
     }
     // Fast path: the compiler key matches the normalised project-relative path.
-    const key = toProjectKey(props.projectRoot, props.file);
+    const state = envelopeDerivation(props);
+    const key = toProjectKey(props.projectRoot, props.file, state.identityContext);
     const direct = props.result.typescript[key];
     if (direct !== undefined) {
         return direct;
     }
-    // Slow path: resolve each candidate to an absolute path for comparison.
-    for (const [candidate, source] of Object.entries(props.result.typescript)) {
-        if (pathIdentityKey(path.resolve(props.projectRoot, candidate)) ===
-            pathIdentityKey(props.file)) {
-            return source;
-        }
+    // Slow path: the first-match identity index of the envelope's `typescript`
+    // keys, built once per generation instead of scanned per delivery.
+    const index = (state.outputIndex ??= createEnvelopeKeyIndex(state, props.projectRoot, props.result.typescript));
+    const source = index.get(derivationIdentity(state, props.file));
+    if (source !== undefined) {
+        return source;
     }
     throw new Error(`ttsc transform did not return output for ${props.file}`);
 }
@@ -1194,62 +1303,21 @@ function resolveTsconfig(file, tsconfig) {
     }
     return path.resolve(process.cwd(), "tsconfig.json");
 }
-function toProjectKey(root, file) {
-    return normalizePath(path.relative(pathIdentityKey(root), pathIdentityKey(file)));
+function toProjectKey(root, file, identities = createHostPathIdentityContext()) {
+    const rootKey = pathIdentityKey(root, identities);
+    const fileKey = pathIdentityKey(file, identities);
+    if (!identities.isWithin(root, file)) {
+        return normalizePath(fileKey);
+    }
+    return normalizePath(fileKey.slice(rootKey.length).replace(/^[/\\]+/, ""));
 }
 /**
  * Build a comparison key for a path without changing the spelling handed to a
  * filesystem or bundler. Windows is case-insensitive; macOS is probed per
  * existing filesystem location so case-sensitive volumes keep distinct paths.
  */
-function pathIdentityKey(file) {
-    const absolute = path.resolve(file);
-    return filesystemIsCaseInsensitive(absolute)
-        ? absolute.toLowerCase()
-        : absolute;
-}
-function filesystemIsCaseInsensitive(file) {
-    if (process.platform === "win32") {
-        return true;
-    }
-    if (process.platform !== "darwin") {
-        return false;
-    }
-    let existing = file;
-    while (!fs.existsSync(existing)) {
-        const parent = path.dirname(existing);
-        if (parent === existing) {
-            return false;
-        }
-        existing = parent;
-    }
-    let resolved;
-    try {
-        resolved = fs.realpathSync.native(existing);
-    }
-    catch {
-        return false;
-    }
-    const cached = CASE_INSENSITIVE_FILESYSTEMS.get(resolved);
-    if (cached !== undefined) {
-        return cached;
-    }
-    const alternate = togglePathCase(resolved);
-    const insensitive = alternate !== undefined && fs.existsSync(alternate);
-    CASE_INSENSITIVE_FILESYSTEMS.set(resolved, insensitive);
-    return insensitive;
-}
-function togglePathCase(file) {
-    for (let index = file.length - 1; index >= 0; --index) {
-        const character = file[index];
-        if (character >= "a" && character <= "z") {
-            return `${file.slice(0, index)}${character.toUpperCase()}${file.slice(index + 1)}`;
-        }
-        if (character >= "A" && character <= "Z") {
-            return `${file.slice(0, index)}${character.toLowerCase()}${file.slice(index + 1)}`;
-        }
-    }
-    return undefined;
+function pathIdentityKey(file, identities = createHostPathIdentityContext()) {
+    return identities.resolve(file).key;
 }
 function normalizePath(file) {
     return file.replace(/\\/g, "/");