fix(tsconfig): apply extends to project references before recursing

When a project reference uses `extends` to inherit its `baseUrl`/`paths`
from a shared base config, those fields must be merged before the
reference is consulted for resolution. The previous flow loaded each
reference through `cache.tsconfig` and only ran the extends-merging
logic on the entry tsconfig, so a transitively-referenced project
whose aliases live in an extended base file would resolve as if it had
no aliases at all.

This was a pre-existing latent bug at depth 1 — direct references with
`extends` did not inherit their aliases either — that the new
transitive-references support made easier to hit.

Changes:
- Extract `merge_tsconfig_extends` from `load_tsconfig` and call it
  from `load_references`' inner callback after the self-reference
  check, before recursing into nested references.
- Update the `references-transitive` fixture: `project_c` now reads its
  `paths` from a sibling `tsconfig.base.json` via `extends`. The
  existing `transitive_references` test fails before this fix
  (NotFound) and passes after.

Detected via Codex review of #213.

Author: stormslowly

fixtures/tsconfig/cases/references-transitive/project_c/tsconfig.json

@@ -1,9 +1,7 @@
 {
+  "extends": "../tsconfig.base.json",
   "compilerOptions": {
     "composite": true,
-    "baseUrl": "./",
-    "paths": {
-      "@/*": ["./aliased/*"]
-    }
+    "baseUrl": "./"
   }
 }

fixtures/tsconfig/cases/references-transitive/tsconfig.base.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./aliased/*"]
+    }
+  }
+}

src/lib.rs

@@ -1475,35 +1475,9 @@ impl<Fs: FileSystem + Send + Sync> ResolverGeneric<Fs> {
           tracing::trace!(tsconfig = ?tsconfig, "load_tsconfig");
 
           // Extend tsconfig
-          if let Some(extends) = &tsconfig.extends {
-            let extended_tsconfig_paths = match extends {
-              ExtendsField::Single(s) => {
-                vec![
-                  self
-                    .get_extended_tsconfig_path(&directory, &tsconfig, s)
-                    .await?,
-                ]
-              }
-              ExtendsField::Multiple(specifiers) => {
-                try_join_all(
-                  specifiers
-                    .iter()
-                    .map(|s| self.get_extended_tsconfig_path(&directory, &tsconfig, s)),
-                )
-                .await?
-              }
-            };
-            for extended_tsconfig_path in extended_tsconfig_paths {
-              let extended_tsconfig = self
-                .load_tsconfig(
-                  /* root */ false,
-                  &extended_tsconfig_path,
-                  &TsconfigReferences::Disabled,
-                )
-                .await?;
-              tsconfig.extend_tsconfig(&extended_tsconfig);
-            }
-          }
+          self
+            .merge_tsconfig_extends(&mut tsconfig, &directory)
+            .await?;
 
           // Load project references
           match references {
@@ -1562,6 +1536,12 @@ impl<Fs: FileSystem + Send + Sync> ResolverGeneric<Fs> {
                     reference_tsconfig.path.clone(),
                   ));
                 }
+                // Apply `extends` so the reference inherits its base config's
+                // `baseUrl`/`paths` before its own references are walked.
+                let directory = self.cache.value(reference_tsconfig.directory());
+                self
+                  .merge_tsconfig_extends(&mut reference_tsconfig, &directory)
+                  .await?;
                 self.load_references(&mut reference_tsconfig).await?;
                 Ok(reference_tsconfig)
               }
@@ -1577,6 +1557,44 @@ impl<Fs: FileSystem + Send + Sync> ResolverGeneric<Fs> {
     })
   }
 
+  async fn merge_tsconfig_extends(
+    &self,
+    tsconfig: &mut TsConfig,
+    directory: &CachedPath,
+  ) -> Result<(), ResolveError> {
+    let Some(extends) = &tsconfig.extends else {
+      return Ok(());
+    };
+    let extended_tsconfig_paths = match extends {
+      ExtendsField::Single(s) => {
+        vec![
+          self
+            .get_extended_tsconfig_path(directory, tsconfig, s)
+            .await?,
+        ]
+      }
+      ExtendsField::Multiple(specifiers) => {
+        try_join_all(
+          specifiers
+            .iter()
+            .map(|s| self.get_extended_tsconfig_path(directory, tsconfig, s)),
+        )
+        .await?
+      }
+    };
+    for extended_tsconfig_path in extended_tsconfig_paths {
+      let extended_tsconfig = self
+        .load_tsconfig(
+          /* root */ false,
+          &extended_tsconfig_path,
+          &TsconfigReferences::Disabled,
+        )
+        .await?;
+      tsconfig.extend_tsconfig(&extended_tsconfig);
+    }
+    Ok(())
+  }
+
   async fn get_extended_tsconfig_path(
     &self,
     directory: &CachedPath,