@ttsc/unplugin 0.22.0 → 0.24.0

package/src/core/transform.ts

@@ -7,6 +7,10 @@ import type {
   ITtscCompilerTransformation,
 } from "ttsc";
 import { TtscCompiler } from "ttsc";
+import {
+  type FilesystemPathIdentityContext,
+  createFilesystemPathIdentityContext,
+} from "ttsc/path-identity";
 import type { TransformResult } from "unplugin";
 
 import type { ResolvedTtscUnpluginOptions } from "./options";
@@ -113,6 +117,12 @@ export type TtscTransformCache = Map<
  */
 const BUILD_SCOPED_TRANSFORM_CACHES = new WeakSet<TtscTransformCache>();
 
+function createHostPathIdentityContext(): FilesystemPathIdentityContext {
+  return createFilesystemPathIdentityContext({
+    throwOnRealpathError: false,
+  });
+}
+
 /** Create an empty persistent transform cache. */
 export function createTtscTransformCache(): TtscTransformCache {
   return new Map();
@@ -143,9 +153,6 @@ export function resetTtscTransformCache(cache: TtscTransformCache): void {
   BUILD_SCOPED_TRANSFORM_CACHES.delete(cache);
 }
 
-/** Cached case-insensitivity probes for existing macOS filesystem locations. */
-const CASE_INSENSITIVE_FILESYSTEMS = new Map<string, boolean>();
-
 /**
  * Hooks the bundler adapter passes into {@link transformTtsc} so transform
  * side-channels (plugin-reported dependencies and host resolution candidates)
@@ -244,7 +251,7 @@ export async function transformTtsc(
         // 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,
@@ -308,7 +315,9 @@ export async function transformTtsc(
     });
     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);
@@ -377,6 +386,211 @@ function evictGeneration(
   }
 }
 
+/**
+ * Per-envelope derivation state: every index the per-delivery paths need, built
+ * at most once and shared by all deliveries of one compiler result.
+ *
+ * Building the direct-edge index, the candidate entries, the declared-file
+ * identity sets, or the output/dependency key indexes per delivery costs
+ * O(envelope) `pathIdentityKey` computations per module — and each of those
+ * costs real path-resolution and case-semantics probes
+ * ({@link pathIdentityKey}). A graph-bearing envelope (typia >= 13.1.19) turned
+ * that into O(modules x edges) filesystem work per build, which is the
+ * samchon/ttsc#1007 stall. All deliveries of one generation share this state,
+ * so a delivery pays only its own reachability closure with memoized
+ * identities.
+ *
+ * Every index is lazy: a host that never wires `addWatchFile` and never misses
+ * a project-relative key pays nothing beyond the volatile/completeness
+ * membership sets, which are themselves built on first predicate use.
+ *
+ * Freshness matches the generation contract: every derivable path is a recorded
+ * project or external input, so persistent-mode validation already proves those
+ * paths unchanged on every non-build-scoped hit, and any change invalidates the
+ * generation — and this state with it. The `WeakMap` key is the envelope object
+ * itself, so the state dies when the generation does.
+ */
+interface TtscEnvelopeDerivation {
+  /** One filesystem snapshot for every identity comparison in this envelope. */
+  readonly identityContext: FilesystemPathIdentityContext;
+  /** Memoized {@link pathIdentityKey} results, keyed by the exact input. */
+  readonly identities: Map<string, string>;
+  /**
+   * Lazily built reference-graph indexes, `undefined` until the first
+   * watch-input derivation. A host without an `addWatchFile` hook never pays
+   * the O(edges) build.
+   */
+  graph?: TtscEnvelopeGraphIndexes;
+  /**
+   * Lazily collected identities of the envelope's `volatile` member files,
+   * `undefined` until the first volatility predicate.
+   */
+  volatileFiles?: Set<string>;
+  /**
+   * Lazily collected identities of the envelope's `dependenciesComplete` member
+   * files, `undefined` until the first completeness predicate.
+   */
+  dependenciesComplete?: Set<string>;
+  /**
+   * Lazily built identity -> output source index of the `typescript` map (first
+   * match wins, mirroring the historical scan). `undefined` until the first
+   * project-relative key miss.
+   */
+  outputIndex?: Map<string, string>;
+  /**
+   * Lazily built identity -> `dependencies` entries index (first match wins,
+   * mirroring the historical scan). `undefined` until the first key miss.
+   */
+  dependencyIndex?: Map<string, unknown>;
+  /** Per-file memo of the final derived watch-input list. */
+  readonly watchInputs: Map<string, string[]>;
+}
+
+/** Reference-graph indexes shared by every watch-input derivation. */
+interface TtscEnvelopeGraphIndexes {
+  /** Identity of each direct-edge source -> its resolved absolute targets. */
+  readonly edges: Map<string, string[]>;
+  /** Identity of each direct-edge source -> its absolute spelling. */
+  readonly spellings: Map<string, string>;
+  /** Resolution-candidate entries in envelope order, sources pre-identified. */
+  readonly candidates: { source: string; files: string[] }[];
+  /** Resolved absolute `graph.globals` and `graph.configs` members. */
+  readonly globals: string[];
+  readonly configs: string[];
+}
+
+/**
+ * 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<
+  ITtscCompilerTransformation,
+  TtscEnvelopeDerivation
+>();
+
+/** Return the derivation state of `props.result`, building it on first use. */
+function envelopeDerivation(props: {
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+}): TtscEnvelopeDerivation {
+  const existing = ENVELOPE_DERIVATIONS.get(props.result);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const created: TtscEnvelopeDerivation = {
+    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: TtscEnvelopeDerivation,
+  props: {
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+  },
+): TtscEnvelopeGraphIndexes {
+  if (state.graph !== undefined) {
+    return state.graph;
+  }
+  const built: TtscEnvelopeGraphIndexes = {
+    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): target is string =>
+              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: TtscEnvelopeDerivation,
+  file: string,
+): string {
+  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: TtscEnvelopeDerivation,
+  projectRoot: string,
+  listed: unknown,
+): Set<string> {
+  const output = new Set<string>();
+  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
@@ -425,7 +639,10 @@ function notifyWatchInputs(
  * 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: {
   file: string;
@@ -433,22 +650,49 @@ function selectWatchInputs(props: {
   result: ITtscCompilerTransformation;
   temporaryTsconfig?: string;
 }): string[] {
+  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: TtscEnvelopeDerivation,
+  props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+    temporaryTsconfig?: string;
+  },
+  fileIdentity: string,
+): string[] {
+  const graph = envelopeGraphIndexes(state, props);
   const output: string[] = [];
   const seen = new Set<string>();
-  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;
     }
@@ -463,35 +707,37 @@ 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: {
-  file: string;
-  projectRoot: string;
-  result: ITtscCompilerTransformation;
-}): string[] {
-  if (props.result.type === "exception") {
-    return [];
-  }
-  const graph = props.result.graph;
-  if (graph === undefined || graph.candidates === undefined) {
+function selectResolutionCandidateInputs(
+  graph: TtscEnvelopeGraphIndexes,
+  state: TtscEnvelopeDerivation,
+  props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+  },
+): string[] {
+  if (
+    props.result.type === "exception" ||
+    props.result.graph?.candidates === undefined
+  ) {
     return [];
   }
   const reachable = new Set(
-    selectReachableSources(props.projectRoot, props.file, graph).map(
-      pathIdentityKey,
+    selectReachableSources(graph, state, props.file).map((source) =>
+      derivationIdentity(state, source),
     ),
   );
   const output: string[] = [];
-  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;
 }
@@ -510,62 +756,47 @@ function selectResolutionCandidateInputs(props: {
  * `dependencies[file]` list the complete replacement for them. Returns an empty
  * list on exceptions or without a graph.
  */
-function selectGraphInputs(props: {
-  complete: boolean;
-  file: string;
-  projectRoot: string;
-  result: ITtscCompilerTransformation;
-}): string[] {
-  if (props.result.type === "exception") {
-    return [];
-  }
-  const graph = props.result.graph;
-  if (graph === undefined) {
+function selectGraphInputs(
+  graph: TtscEnvelopeGraphIndexes,
+  state: TtscEnvelopeDerivation,
+  props: {
+    complete: boolean;
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+  },
+): string[] {
+  if (props.result.type === "exception" || props.result.graph === undefined) {
     return [];
   }
   const output: string[] = [];
   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: string,
+  graph: TtscEnvelopeGraphIndexes,
+  state: TtscEnvelopeDerivation,
   file: string,
-  graph: ITtscCompilerTransformation.IReferenceGraph,
 ): string[] {
-  const edges = new Map<string, string[]>();
-  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): target is string =>
-            typeof target === "string" && target.length !== 0,
-        )
-        .map((target) => path.resolve(projectRoot, target)),
-    );
-    edges.set(identity, entries);
-  }
   const output: string[] = [];
-  const visited = new Set<string>([pathIdentityKey(file)]);
+  const visited = new Set<string>([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;
       }
@@ -583,43 +814,24 @@ function selectReachableEdges(
  * than targets, so this is intentionally distinct from selectReachableEdges.
  */
 function selectReachableSources(
-  projectRoot: string,
+  graph: TtscEnvelopeGraphIndexes,
+  state: TtscEnvelopeDerivation,
   file: string,
-  graph: ITtscCompilerTransformation.IReferenceGraph,
 ): string[] {
-  const edges = new Map<string, string[]>();
-  const spellings = new Map<string, string>();
-  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): target is string =>
-            typeof target === "string" && target.length !== 0,
-        )
-        .map((target) => path.resolve(projectRoot, target)),
-    );
-    edges.set(identity, entries);
-  }
   const output = [file];
-  const visited = new Set<string>([pathIdentityKey(file)]);
+  const visited = new Set<string>([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;
@@ -647,17 +859,26 @@ function selectListedFiles(projectRoot: string, listed: unknown): string[] {
 /**
  * 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: {
-  file: string;
-  projectRoot: string;
-  result: ITtscCompilerTransformation;
-}): boolean {
+function isVolatileFile(
+  state: TtscEnvelopeDerivation,
+  props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+  },
+): boolean {
   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));
 }
 
 /**
@@ -666,44 +887,30 @@ 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: {
-  file: string;
-  projectRoot: string;
-  result: ITtscCompilerTransformation;
-}): boolean {
-  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: unknown,
-  props: { file: string; projectRoot: string },
+function declaresCompleteDependencies(
+  state: TtscEnvelopeDerivation,
+  props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+  },
 ): boolean {
-  if (!Array.isArray(listed)) {
+  if (props.result.type === "exception") {
     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: {
   file: string;
@@ -717,31 +924,36 @@ 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)) as
+      | string[]
+      | undefined;
   }
   if (!Array.isArray(entries)) {
     return [];
   }
   const output: string[] = [];
   const seen = new Set<string>();
+  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);
@@ -750,6 +962,29 @@ 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<T>(
+  state: TtscEnvelopeDerivation,
+  projectRoot: string,
+  keyed: Record<string, T>,
+): Map<string, T> {
+  const index = new Map<string, T>();
+  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.
  *
@@ -819,14 +1054,21 @@ function matchesCachedSource(
   source: string,
   buildScoped: boolean,
 ): boolean {
-  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;
@@ -853,7 +1095,9 @@ function markCachedSourceServed(
   cached: TtscCachedProjectTransform,
   file: string,
 ): void {
-  (cached.servedFiles ??= new Set()).add(pathIdentityKey(file));
+  (cached.servedFiles ??= new Set()).add(
+    pathIdentityKey(file, envelopeDerivation(cached).identityContext),
+  );
 }
 
 /**
@@ -874,11 +1118,11 @@ function collectInputHashes(props: {
   currentSource: string;
   projectRoot: string;
 }): Record<string, string> {
-  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;
 }
 
@@ -890,11 +1134,14 @@ function collectInputHashes(props: {
  */
 export function collectProjectInputHashes(
   projectRoot: string,
+  identities: FilesystemPathIdentityContext = createHostPathIdentityContext(),
 ): Record<string, string> {
   const hashes: Record<string, string> = {};
   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
       // or deleting files. The missing key invalidates older cache entries.
@@ -947,8 +1194,17 @@ function listProjectInputFiles(root: string): string[] {
  * Missing paths and files reached through symlinks or Windows junctions are
  * out-of-walk inputs that only the reference graph can prove relevant.
  */
-export function isProjectWalkPath(root: string, file: string): boolean {
-  const relative = path.relative(pathIdentityKey(root), pathIdentityKey(file));
+export function isProjectWalkPath(
+  root: string,
+  file: string,
+  identities: FilesystemPathIdentityContext = createHostPathIdentityContext(),
+): boolean {
+  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 === ".." ||
@@ -994,8 +1250,9 @@ export function collectExternalInputHashes(
   paths: readonly string[],
 ): Record<string, string> {
   const hashes: Record<string, string> = {};
+  const identities = createHostPathIdentityContext();
   for (const file of paths) {
-    const identity = pathIdentityKey(file);
+    const identity = pathIdentityKey(file, identities);
     if (identity in hashes) {
       continue;
     }
@@ -1035,6 +1292,7 @@ function selectExternalInputPaths(props: {
     return [];
   }
   const members: string[] = [];
+  const identities = createHostPathIdentityContext();
   const resolutionCandidates = new Set<string>();
   const graph = props.result.graph;
   if (graph !== undefined) {
@@ -1059,7 +1317,7 @@ function selectExternalInputPaths(props: {
         }
         const absolute = path.resolve(props.projectRoot, candidate);
         members.push(candidate);
-        resolutionCandidates.add(pathIdentityKey(absolute));
+        resolutionCandidates.add(pathIdentityKey(absolute, identities));
       }
     }
   }
@@ -1071,7 +1329,7 @@ function selectExternalInputPaths(props: {
   const excluded =
     props.temporaryTsconfig === undefined
       ? undefined
-      : pathIdentityKey(props.temporaryTsconfig);
+      : pathIdentityKey(props.temporaryTsconfig, identities);
   const output: string[] = [];
   const seen = new Set<string>();
   for (const member of members) {
@@ -1079,13 +1337,14 @@ 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;
     }
@@ -1474,19 +1733,26 @@ function selectTransformedSource(props: {
   }
 
   // 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}`);
 }
@@ -1583,10 +1849,17 @@ function resolveTsconfig(file: string, tsconfig?: string): string {
   return path.resolve(process.cwd(), "tsconfig.json");
 }
 
-function toProjectKey(root: string, file: string): string {
-  return normalizePath(
-    path.relative(pathIdentityKey(root), pathIdentityKey(file)),
-  );
+function toProjectKey(
+  root: string,
+  file: string,
+  identities: FilesystemPathIdentityContext = createHostPathIdentityContext(),
+): string {
+  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(/^[/\\]+/, ""));
 }
 
 /**
@@ -1594,55 +1867,11 @@ function toProjectKey(root: string, file: string): string {
  * filesystem or bundler. Windows is case-insensitive; macOS is probed per
  * existing filesystem location so case-sensitive volumes keep distinct paths.
  */
-export function pathIdentityKey(file: string): string {
-  const absolute = path.resolve(file);
-  return filesystemIsCaseInsensitive(absolute)
-    ? absolute.toLowerCase()
-    : absolute;
-}
-
-function filesystemIsCaseInsensitive(file: string): boolean {
-  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: string;
-  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: string): string | undefined {
-  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;
+export function pathIdentityKey(
+  file: string,
+  identities: FilesystemPathIdentityContext = createHostPathIdentityContext(),
+): string {
+  return identities.resolve(file).key;
 }
 
 function normalizePath(file: string): string {