fix(tsconfig): honor transitive project references for paths resolution

When the entry tsconfig declares `references: [B]` and B declares
`references: [C]`, a file inside C should resolve via C's own `paths`,
matching `tsc`'s "nearest tsconfig wins" semantics and webpack's
recursive `references: "auto"` walk.

Previously, rspack-resolver loaded only the directly-listed references
(one level deep) and `TsConfig::resolve` only iterated those direct
references. As a result, requests from a transitively-referenced
project's directory would silently fall back to the entry tsconfig's
`paths` and resolve incorrectly.

Changes:
- `load_tsconfig` extracts `load_references` which recursively loads
  nested project references. Existing self-reference detection (A → A)
  is preserved; cycle detection across multiple levels is intentionally
  out of scope for this change.
- `TsConfig::resolve` recursively descends into nested references via
  `find_reference_paths`, returning the nearest reference whose
  `base_path` contains the requested path before falling back to the
  current tsconfig.

Author: stormslowly

fixtures/tsconfig/cases/references-transitive/app/aliased/index.ts

@@ -0,0 +1 @@
+export const from = "app";

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

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["./aliased/*"]
+    }
+  },
+  "references": [
+    { "path": "../project_b" }
+  ]
+}

fixtures/tsconfig/cases/references-transitive/project_b/src/aliased/index.ts

@@ -0,0 +1 @@
+export const from = "project_b";

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

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "baseUrl": "./src",
+    "paths": {
+      "@/*": ["./aliased/*"]
+    }
+  },
+  "references": [
+    { "path": "../project_c" }
+  ]
+}

fixtures/tsconfig/cases/references-transitive/project_c/aliased/index.ts

@@ -0,0 +1 @@
+export const from = "project_c";

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

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["./aliased/*"]
+    }
+  }
+}

src/lib.rs

@@ -1521,31 +1521,7 @@ impl<Fs: FileSystem + Send + Sync> ResolverGeneric<Fs> {
                 .collect();
             }
           }
-          if !tsconfig.references.is_empty() {
-            let directory = tsconfig.directory().to_path_buf();
-            for reference in &mut tsconfig.references {
-              let reference_tsconfig_path = directory.normalize_with(&reference.path);
-              let reference_tsconfig = self
-                .cache
-                .tsconfig(
-                  /* root */ true,
-                  &reference_tsconfig_path,
-                  |reference_tsconfig| async {
-                    if reference_tsconfig.path == tsconfig.path {
-                      return Err(ResolveError::TsconfigSelfReference(
-                        reference_tsconfig.path.clone(),
-                      ));
-                    }
-                    Ok(reference_tsconfig)
-                  },
-                )
-                .await?;
-              tsconfig
-                .file_dependencies
-                .extend(reference_tsconfig.file_dependencies.iter().cloned());
-              reference.tsconfig.replace(reference_tsconfig);
-            }
-          }
+          self.load_references(&mut tsconfig).await?;
 
           Ok(tsconfig)
         })
@@ -1554,6 +1530,53 @@ impl<Fs: FileSystem + Send + Sync> ResolverGeneric<Fs> {
     Box::pin(fut)
   }
 
+  // Walks `tsconfig.references` and loads each referenced tsconfig, recursing
+  // into nested references so that transitive `paths` (e.g. A → B → C) are
+  // honored — matching `tsc`'s "nearest tsconfig wins" behavior and
+  // `enhanced-resolve`'s recursive `references: "auto"` walk.
+  //
+  // The caller is expected to provide a DAG; cycle detection is intentionally
+  // not implemented here.
+  fn load_references<'a>(
+    &'a self,
+    tsconfig: &'a mut TsConfig,
+  ) -> BoxFuture<'a, Result<(), ResolveError>> {
+    Box::pin(async move {
+      if tsconfig.references.is_empty() {
+        return Ok(());
+      }
+      let directory = tsconfig.directory().to_path_buf();
+      let current_path = tsconfig.path.clone();
+      for reference in &mut tsconfig.references {
+        let reference_tsconfig_path = directory.normalize_with(&reference.path);
+        let reference_tsconfig = self
+          .cache
+          .tsconfig(
+            /* root */ true,
+            &reference_tsconfig_path,
+            |mut reference_tsconfig| {
+              let current_path = current_path.clone();
+              async move {
+                if reference_tsconfig.path == current_path {
+                  return Err(ResolveError::TsconfigSelfReference(
+                    reference_tsconfig.path.clone(),
+                  ));
+                }
+                self.load_references(&mut reference_tsconfig).await?;
+                Ok(reference_tsconfig)
+              }
+            },
+          )
+          .await?;
+        tsconfig
+          .file_dependencies
+          .extend(reference_tsconfig.file_dependencies.iter().cloned());
+        reference.tsconfig.replace(reference_tsconfig);
+      }
+      Ok(())
+    })
+  }
+
   async fn get_extended_tsconfig_path(
     &self,
     directory: &CachedPath,

src/tests/tsconfig_project_references.rs

@@ -184,3 +184,47 @@ async fn self_reference() {
     );
   }
 }
+
+// Transitive project references: A → B → C.
+// When the entry tsconfig (A) declares `references: [B]` and B declares
+// `references: [C]`, a file inside C must resolve via C's own `paths`
+// (matching tsc's "nearest tsconfig wins" behavior and webpack's
+// recursive `references: "auto"` walk).
+#[tokio::test]
+async fn transitive_references() {
+  let f = super::fixture_root().join("tsconfig/cases/references-transitive");
+
+  let resolver = Resolver::new(ResolveOptions {
+    tsconfig: Some(TsconfigOptions {
+      config_file: f.join("app"),
+      references: TsconfigReferences::Auto,
+    }),
+    ..ResolveOptions::default()
+  });
+
+  let cases = [
+    // Direct: file in app uses app's paths.
+    (f.join("app"), "@/index.ts", f.join("app/aliased/index.ts")),
+    // One level: file in project_b uses project_b's paths (baseUrl ./src).
+    (
+      f.join("project_b/src"),
+      "@/index.ts",
+      f.join("project_b/src/aliased/index.ts"),
+    ),
+    // Two levels: file in project_c (referenced by project_b which is
+    // referenced by app) uses project_c's paths.
+    (
+      f.join("project_c"),
+      "@/index.ts",
+      f.join("project_c/aliased/index.ts"),
+    ),
+  ];
+
+  for (path, request, expected) in cases {
+    let resolved_path = resolver
+      .resolve(&path, request)
+      .await
+      .map(|p| p.full_path());
+    assert_eq!(resolved_path, Ok(expected), "{request} from {path:?}");
+  }
+}

src/tsconfig.rs

@@ -170,17 +170,31 @@ impl TsConfig {
   }
 
   pub fn resolve(&self, path: &Path, specifier: &str) -> Vec<PathBuf> {
+    if let Some(matched) = self.find_reference_paths(path, specifier) {
+      return matched;
+    }
+    self.resolve_path_alias(specifier)
+  }
+
+  // Walks `references` recursively, returning the nearest reference whose
+  // `base_path` contains `path`. Used to honor transitive project references
+  // (A → B → C): a file inside C should resolve via C's own `paths` even
+  // when the entry tsconfig is A and only B is listed directly in A's
+  // references. Matches `tsc`'s "nearest tsconfig wins" semantics.
+  fn find_reference_paths(&self, path: &Path, specifier: &str) -> Option<Vec<PathBuf>> {
     for tsconfig in self
       .references
       .iter()
       .filter_map(|reference| reference.tsconfig.as_ref())
     {
+      if let Some(nested) = tsconfig.find_reference_paths(path, specifier) {
+        return Some(nested);
+      }
       if path.starts_with(tsconfig.base_path()) {
-        return tsconfig.resolve_path_alias(specifier);
+        return Some(tsconfig.resolve_path_alias(specifier));
       }
     }
-
-    self.resolve_path_alias(specifier)
+    None
   }
 
   // Copied from parcel