@ttsc/unplugin 0.19.3 → 0.20.1

package/src/core/transform.ts

@@ -53,7 +53,7 @@ export interface TtscTransformAlias {
 export interface TtscCachedProjectTransform {
   /**
    * SHA-256 hash of every input the compiler reported outside the project walk
-   * (keyed by absolute path), captured at the time of the transform.
+   * (keyed by filesystem identity), captured at the time of the transform.
    *
    * The project walk cannot see files outside the project root or under ignored
    * directories (`node_modules` declarations, monorepo sibling sources,
@@ -65,6 +65,12 @@ export interface TtscCachedProjectTransform {
    * `buildStart` and never replay across edits.
    */
   externalInputHashes?: Record<string, string>;
+  /**
+   * Original absolute spellings of {@link externalInputHashes} inputs. These
+   * stay separate from their identity keys so validation reads the paths the
+   * compiler reported rather than a normalized replacement spelling.
+   */
+  externalInputPaths?: string[];
   /**
    * SHA-256 hash of each project-relative input path at the time of the
    * transform.
@@ -101,22 +107,27 @@ export function createTtscTransformCache(): TtscTransformCache {
   return new Map();
 }
 
+/** 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 (currently the plugin-reported dependency list) reach the
- * bundler without leaking extra fields on the returned `TransformResult`.
+ * side-channels (plugin-reported dependencies and host resolution candidates)
+ * reach the bundler without leaking extra fields on the returned
+ * `TransformResult`.
  */
 export interface TtscTransformHooks {
   /**
    * Invoked once per absolute watch-input path derived for the transformed file
    * `F`: the plugin-reported `dependencies[F]` list unioned with the host-owned
    * reference graph's contribution — the reachability closure of `graph.edges`
-   * from `F`, the `graph.globals` files, and the `graph.configs` chain — or,
-   * for a file the envelope declared `dependenciesComplete`, only
-   * `dependencies[F]` and the universal `graph.configs` chain. Adapters forward
-   * this to the bundler's `addWatchFile` so type-only inputs participate in
-   * watch-mode and persistent-cache invalidation. See {@link selectWatchInputs}
-   * for the exact derivation.
+   * from `F`, the `graph.globals` files, the `graph.configs` chain, and missing
+   * higher-priority `graph.candidates` — or, for a file the envelope declared
+   * `dependenciesComplete`, only `dependencies[F]`, `graph.candidates`, and the
+   * universal `graph.configs` chain. Adapters forward this to the bundler's
+   * `addWatchFile` so type-only inputs participate in watch-mode and
+   * persistent-cache invalidation. See {@link selectWatchInputs} for the exact
+   * derivation.
    */
   addWatchFile?: (file: string) => void;
   /**
@@ -313,7 +324,7 @@ function evictGeneration(
  * Forward every derived watch input for `file` to the adapter's `addWatchFile`
  * hook: the plugin-reported `dependencies[file]` list unioned with the
  * host-owned reference graph's contribution (`reach(edges, file)`, `globals`,
- * `configs`).
+ * `configs`, and resolution candidates).
  *
  * Envelope keys mirror the `typescript` keys (project-relative); values may be
  * project-relative or absolute. Every path is absolutized against the project
@@ -344,7 +355,8 @@ function notifyWatchInputs(
  *
  * By default the derivation is a union: `dependencies[file] ∪ reach(edges,
  * file) ∪ globals ∪ configs`. The plugin-reported list can only widen the
- * host-owned language-semantic bound, never narrow it.
+ * host-owned language-semantic bound, never narrow it. Resolution candidates
+ * remain part of that host-owned bound in both modes.
  *
  * An envelope that lists `file` in `dependenciesComplete` narrows it to
  * `dependencies[file] ∪ configs`: the plugin declared its reported list the
@@ -368,8 +380,8 @@ function selectWatchInputs(props: {
   const seen = new Set<string>();
   const excluded = new Set(
     props.temporaryTsconfig === undefined
-      ? [props.file]
-      : [props.file, path.resolve(props.temporaryTsconfig)],
+      ? [pathIdentityKey(props.file)]
+      : [pathIdentityKey(props.file), pathIdentityKey(props.temporaryTsconfig)],
   );
   for (const absolute of [
     ...selectFileDependencies(props),
@@ -377,16 +389,56 @@ function selectWatchInputs(props: {
       ...props,
       complete: declaresCompleteDependencies(props) && !isVolatileFile(props),
     }),
+    ...selectResolutionCandidateInputs(props),
   ]) {
-    if (excluded.has(absolute) || seen.has(absolute)) {
+    const identity = pathIdentityKey(absolute);
+    if (excluded.has(identity) || seen.has(identity)) {
       continue;
     }
-    seen.add(absolute);
+    seen.add(identity);
     output.push(absolute);
   }
   return output;
 }
 
+/**
+ * Return the module-resolution paths that can supersede a currently resolved
+ * 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.
+ */
+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) {
+    return [];
+  }
+  const reachable = new Set(
+    selectReachableSources(props.projectRoot, props.file, graph).map(
+      pathIdentityKey,
+    ),
+  );
+  const output: string[] = [];
+  for (const [source, candidates] of Object.entries(graph.candidates)) {
+    if (
+      !reachable.has(
+        pathIdentityKey(path.resolve(props.projectRoot, source)),
+      ) ||
+      !Array.isArray(candidates)
+    ) {
+      continue;
+    }
+    output.push(...selectListedFiles(props.projectRoot, candidates));
+  }
+  return output;
+}
+
 /**
  * Flatten the host-owned reference graph for one file into absolute paths.
  *
@@ -438,26 +490,29 @@ function selectReachableEdges(
     if (!Array.isArray(targets)) {
       continue;
     }
-    edges.set(
-      path.resolve(projectRoot, source),
-      targets
+    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>([file]);
+  const visited = new Set<string>([pathIdentityKey(file)]);
   const queue = [file];
   while (queue.length !== 0) {
     const current = queue.pop()!;
-    for (const target of edges.get(current) ?? []) {
-      if (visited.has(target)) {
+    for (const target of edges.get(pathIdentityKey(current)) ?? []) {
+      const identity = pathIdentityKey(target);
+      if (visited.has(identity)) {
         continue;
       }
-      visited.add(target);
+      visited.add(identity);
       queue.push(target);
       output.push(target);
     }
@@ -465,6 +520,54 @@ function selectReachableEdges(
   return output;
 }
 
+/**
+ * Return the source files whose direct graph edges are reachable from `file`,
+ * including `file` itself. Resolution candidates belong to importers rather
+ * than targets, so this is intentionally distinct from selectReachableEdges.
+ */
+function selectReachableSources(
+  projectRoot: string,
+  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 queue = [file];
+  while (queue.length !== 0) {
+    const current = queue.pop()!;
+    for (const target of edges.get(pathIdentityKey(current)) ?? []) {
+      const identity = pathIdentityKey(target);
+      if (visited.has(identity)) {
+        continue;
+      }
+      visited.add(identity);
+      queue.push(target);
+      output.push(spellings.get(identity) ?? target);
+    }
+  }
+  return output;
+}
+
 /**
  * Absolutize one graph string list (`globals`, `configs`), skipping members a
  * malformed envelope section may carry. Duplicates survive; the caller
@@ -534,7 +637,8 @@ function declaresFile(
     (entry) =>
       typeof entry === "string" &&
       entry.length !== 0 &&
-      path.resolve(props.projectRoot, entry) === props.file,
+      pathIdentityKey(path.resolve(props.projectRoot, entry)) ===
+        pathIdentityKey(props.file),
   );
 }
 
@@ -560,7 +664,10 @@ function selectFileDependencies(props: {
   let entries = dependencies[key];
   if (entries === undefined) {
     for (const [candidate, candidateEntries] of Object.entries(dependencies)) {
-      if (path.resolve(props.projectRoot, candidate) === props.file) {
+      if (
+        pathIdentityKey(path.resolve(props.projectRoot, candidate)) ===
+        pathIdentityKey(props.file)
+      ) {
         entries = candidateEntries;
         break;
       }
@@ -576,10 +683,11 @@ function selectFileDependencies(props: {
       continue;
     }
     const absolute = path.resolve(props.projectRoot, entry);
-    if (absolute === props.file || seen.has(absolute)) {
+    const identity = pathIdentityKey(absolute);
+    if (identity === pathIdentityKey(props.file) || seen.has(identity)) {
       continue;
     }
-    seen.add(absolute);
+    seen.add(identity);
     output.push(absolute);
   }
   return output;
@@ -678,7 +786,9 @@ function matchesCachedSource(
   const externalHashes = cached.externalInputHashes ?? {};
   return sameHashes(
     externalHashes,
-    collectExternalInputHashes(Object.keys(externalHashes)),
+    collectExternalInputHashes(
+      cached.externalInputPaths ?? Object.keys(externalHashes),
+    ),
   );
 }
 
@@ -773,7 +883,7 @@ function listProjectInputFiles(root: string): string[] {
  * only the reference graph can prove relevant.
  */
 export function isProjectWalkPath(root: string, file: string): boolean {
-  const relative = path.relative(path.resolve(root), path.resolve(file));
+  const relative = path.relative(pathIdentityKey(root), pathIdentityKey(file));
   if (
     relative.length === 0 ||
     relative === ".." ||
@@ -789,20 +899,26 @@ export function isProjectWalkPath(root: string, file: string): boolean {
 
 /**
  * Hash a list of absolute out-of-walk input paths: content SHA-256 for a
- * readable file, a stable `missing` marker otherwise. The marker is state, not
- * an error — a recorded input disappearing (or reappearing) must change the
- * comparison exactly like a content edit. Exported so `@ttsc/metro` can re-hash
- * its recorded snapshot with identical semantics at cache-key time.
+ * readable file, a stable `missing` marker otherwise. Keys use filesystem
+ * identity so case-only spellings share one snapshot entry, while reads retain
+ * the original path supplied by the compiler. The marker is state, not an error
+ * — a recorded input disappearing (or reappearing) must change the comparison
+ * exactly like a content edit. Exported so `@ttsc/metro` can re-hash its
+ * recorded snapshot with identical semantics at cache-key time.
  */
 export function collectExternalInputHashes(
   paths: readonly string[],
 ): Record<string, string> {
   const hashes: Record<string, string> = {};
   for (const file of paths) {
+    const identity = pathIdentityKey(file);
+    if (identity in hashes) {
+      continue;
+    }
     try {
-      hashes[file] = hashText(fs.readFileSync(file));
+      hashes[identity] = hashText(fs.readFileSync(file));
     } catch {
-      hashes[file] = "missing";
+      hashes[identity] = "missing";
     }
   }
   return hashes;
@@ -813,7 +929,9 @@ export function collectExternalInputHashes(
  * union of every reference-graph member (edge keys and targets, globals, the
  * config chain) and every plugin-reported dependency, minus everything the
  * project walk already hashes and the disposed temp-dir tsconfig. These are the
- * inputs {@link matchesCachedSource}'s walk cannot see.
+ * inputs {@link matchesCachedSource}'s walk cannot see. Resolution candidates
+ * that are still missing remain in this set even under the project root: the
+ * first walk cannot hash a file that has not been created yet.
  *
  * A `dependenciesComplete` declaration deliberately does not narrow this set,
  * unlike the per-file watch derivation. This cache replays one whole envelope,
@@ -833,6 +951,7 @@ function selectExternalInputPaths(props: {
     return [];
   }
   const members: string[] = [];
+  const resolutionCandidates = new Set<string>();
   const graph = props.result.graph;
   if (graph !== undefined) {
     for (const [source, targets] of Object.entries(graph.edges ?? {})) {
@@ -846,6 +965,19 @@ function selectExternalInputPaths(props: {
         members.push(...listed);
       }
     }
+    for (const candidates of Object.values(graph.candidates ?? {})) {
+      if (!Array.isArray(candidates)) {
+        continue;
+      }
+      for (const candidate of candidates) {
+        if (typeof candidate !== "string" || candidate.length === 0) {
+          continue;
+        }
+        const absolute = path.resolve(props.projectRoot, candidate);
+        members.push(candidate);
+        resolutionCandidates.add(pathIdentityKey(absolute));
+      }
+    }
   }
   for (const entries of Object.values(props.result.dependencies ?? {})) {
     if (Array.isArray(entries)) {
@@ -855,7 +987,7 @@ function selectExternalInputPaths(props: {
   const excluded =
     props.temporaryTsconfig === undefined
       ? undefined
-      : path.resolve(props.temporaryTsconfig);
+      : pathIdentityKey(props.temporaryTsconfig);
   const output: string[] = [];
   const seen = new Set<string>();
   for (const member of members) {
@@ -863,14 +995,17 @@ function selectExternalInputPaths(props: {
       continue;
     }
     const absolute = path.resolve(props.projectRoot, member);
+    const identity = pathIdentityKey(absolute);
+    const missingCandidate =
+      resolutionCandidates.has(identity) && !fs.existsSync(absolute);
     if (
-      absolute === excluded ||
-      seen.has(absolute) ||
-      isProjectWalkPath(props.projectRoot, absolute)
+      identity === excluded ||
+      seen.has(identity) ||
+      (!missingCandidate && isProjectWalkPath(props.projectRoot, absolute))
     ) {
       continue;
     }
-    seen.add(absolute);
+    seen.add(identity);
     output.push(absolute);
   }
   output.sort();
@@ -939,13 +1074,17 @@ async function transformProject(props: {
     }).transform();
     const temporaryTsconfig =
       configured.path === props.tsconfig ? undefined : configured.path;
+    const externalInputPaths = selectExternalInputPaths({
+      projectRoot,
+      result,
+      temporaryTsconfig,
+    });
     return {
       // Capture the out-of-walk input hashes while the generation is fresh so
       // cache validation can re-check them; computed before dispose so the
       // exclusion of the temp-dir tsconfig is the only reason it never keys.
-      externalInputHashes: collectExternalInputHashes(
-        selectExternalInputPaths({ projectRoot, result, temporaryTsconfig }),
-      ),
+      externalInputHashes: collectExternalInputHashes(externalInputPaths),
+      externalInputPaths,
       inputHashes: collectInputHashes({
         currentFile: props.currentFile,
         currentSource: props.currentSource,
@@ -1181,7 +1320,7 @@ function createTransformCacheKey(props: {
     aliasPaths: props.aliasPaths,
     compilerOptions: props.compilerOptions,
     plugins: props.plugins,
-    tsconfig: path.resolve(props.tsconfig),
+    tsconfig: pathIdentityKey(props.tsconfig),
   });
 }
 
@@ -1257,7 +1396,10 @@ function selectTransformedSource(props: {
   }
   // Slow path: resolve each candidate to an absolute path for comparison.
   for (const [candidate, source] of Object.entries(props.result.typescript)) {
-    if (path.resolve(props.projectRoot, candidate) === props.file) {
+    if (
+      pathIdentityKey(path.resolve(props.projectRoot, candidate)) ===
+      pathIdentityKey(props.file)
+    ) {
       return source;
     }
   }
@@ -1357,7 +1499,65 @@ function resolveTsconfig(file: string, tsconfig?: string): string {
 }
 
 function toProjectKey(root: string, file: string): string {
-  return normalizePath(path.relative(root, file));
+  return normalizePath(
+    path.relative(pathIdentityKey(root), pathIdentityKey(file)),
+  );
+}
+
+/**
+ * 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.
+ */
+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;
 }
 
 function normalizePath(file: string): string {

package/src/core/tsconfigPaths.ts

@@ -130,10 +130,10 @@ function extendsSpecifiers(extended: unknown): string[] {
 
 /**
  * Resolve an `extends` specifier to an absolute config path using TypeScript's
- * rules: absolute paths and relative specifiers get `.json` /
- * `tsconfig.json`-directory fallbacks; bare specifiers go through Node's module
- * resolver scoped to the declaring config. Returns `null` instead of throwing;
- * the compiler reports unresolvable `extends` itself.
+ * rules: absolute paths and relative specifiers get an exact-file / `.json`
+ * fallback; bare specifiers go through Node's module resolver scoped to the
+ * declaring config. Returns `null` instead of throwing; the compiler reports
+ * unresolvable `extends` itself.
  */
 function resolveExtendsConfig(
   tsconfig: string,
@@ -221,22 +221,30 @@ function isBarePackageRoot(specifier: string): boolean {
 }
 
 /**
- * Try an on-disk `extends` location as-is, with `.json` appended, and as a
- * directory containing `tsconfig.json`. Returns the first existing match.
+ * Try an on-disk `extends` location as-is and, unless it already ends in
+ * `.json`, with that extension appended. A directory is never a config file and
+ * cannot be expanded to `tsconfig.json` or a double `.json` suffix.
  */
 function resolveExistingExtendsPath(location: string): string | null {
-  for (const candidate of new Set([
-    location,
-    `${location}.json`,
-    path.join(location, "tsconfig.json"),
-  ])) {
-    if (fs.existsSync(candidate)) {
+  const candidates = location.endsWith(".json")
+    ? [location]
+    : [location, `${location}.json`];
+  for (const candidate of candidates) {
+    if (isFile(candidate)) {
       return resolveRealPath(candidate);
     }
   }
   return null;
 }
 
+function isFile(location: string): boolean {
+  try {
+    return fs.statSync(location).isFile();
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Return true when `specifier` is a relative path reference: `.`, `..`, or a
  * string starting with `./`, `../`, `.\\`, or `..\\`.