fix(tsconfig): detect cycles when walking project references

A pair of project references that point at each other (a → b → a)
previously caused infinite recursion when `references: "auto"`
recursively loaded the graph, blowing the test thread's stack.

Add a `visited` set threaded through `load_references`. Each tsconfig
inserts its own path before walking its references. When a candidate
reference's loaded path is already in the chain, the cycle edge is
cut: the reference is still attached so its own `paths` are honored,
but its nested references are not walked.

Includes a `references-cycle` fixture (a ↔ b) and a `cyclic_references`
test that asserts resolution succeeds from both sides without stack
overflow.

Direct self-reference (A → A) detection via the existing equality
check inside the cache callback is preserved.

Author: stormslowly

fixtures/tsconfig/cases/references-cycle/a/src/index.ts

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

fixtures/tsconfig/cases/references-cycle/a/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "baseUrl": "./",
+    "paths": {
+      "@a/*": ["src/*"]
+    }
+  },
+  "references": [{ "path": "../b" }]
+}

fixtures/tsconfig/cases/references-cycle/b/src/index.ts

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

fixtures/tsconfig/cases/references-cycle/b/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "baseUrl": "./",
+    "paths": {
+      "@b/*": ["src/*"]
+    }
+  },
+  "references": [{ "path": "../a" }]
+}

src/lib.rs

@@ -1495,7 +1495,8 @@ impl<Fs: FileSystem + Send + Sync> ResolverGeneric<Fs> {
                 .collect();
             }
           }
-          self.load_references(&mut tsconfig).await?;
+          let mut visited = FxHashSet::default();
+          self.load_references(&mut tsconfig, &mut visited).await?;
 
           Ok(tsconfig)
         })
@@ -1509,20 +1510,28 @@ impl<Fs: FileSystem + Send + Sync> ResolverGeneric<Fs> {
   // 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.
+  // `visited` carries the canonical paths of tsconfigs already being loaded
+  // along the current chain. When a reference points back into the chain,
+  // the cycle edge is cut: the reference is still attached with its own
+  // `paths` honored, but its nested references are not walked.
   fn load_references<'a>(
     &'a self,
     tsconfig: &'a mut TsConfig,
+    visited: &'a mut FxHashSet<PathBuf>,
   ) -> 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();
+      visited.insert(current_path.clone());
       for reference in &mut tsconfig.references {
         let reference_tsconfig_path = directory.normalize_with(&reference.path);
+        // Reborrow so the closure below can capture `&mut FxHashSet` across
+        // multiple iterations of this loop. Without the reborrow, the first
+        // iteration would consume the original `&mut visited` binding.
+        let visited: &mut FxHashSet<PathBuf> = &mut *visited;
         let reference_tsconfig = self
           .cache
           .tsconfig(
@@ -1536,13 +1545,21 @@ impl<Fs: FileSystem + Send + Sync> ResolverGeneric<Fs> {
                     reference_tsconfig.path.clone(),
                   ));
                 }
+                // Cut the cycle: if this reference is already part of the
+                // ongoing load chain, return it without walking its own
+                // references. Its `paths` are still attached to the parent.
+                if visited.contains(&reference_tsconfig.path) {
+                  return Ok(reference_tsconfig);
+                }
                 // 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?;
+                self
+                  .load_references(&mut reference_tsconfig, visited)
+                  .await?;
                 Ok(reference_tsconfig)
               }
             },

src/tests/tsconfig_project_references.rs

@@ -261,3 +261,33 @@ async fn references_with_extends() {
     .map(|p| p.full_path());
   assert_eq!(resolved_path, Ok(f.join("app/aliased/index.ts")));
 }
+
+// A pair of project references that form a cycle (a → b → a) must not
+// cause infinite recursion / stack overflow when `references: "auto"`
+// recursively walks the graph. Each project's own `paths` should still
+// be honored from within its own directory.
+#[tokio::test]
+async fn cyclic_references() {
+  let f = super::fixture_root().join("tsconfig/cases/references-cycle");
+
+  let resolver = Resolver::new(ResolveOptions {
+    extensions: vec![".ts".into()],
+    tsconfig: Some(TsconfigOptions {
+      config_file: f.join("a"),
+      references: TsconfigReferences::Auto,
+    }),
+    ..ResolveOptions::default()
+  });
+
+  let resolved_path = resolver
+    .resolve(&f.join("a"), "@a/index")
+    .await
+    .map(|p| p.full_path());
+  assert_eq!(resolved_path, Ok(f.join("a/src/index.ts")));
+
+  let resolved_path = resolver
+    .resolve(&f.join("b"), "@b/index")
+    .await
+    .map(|p| p.full_path());
+  assert_eq!(resolved_path, Ok(f.join("b/src/index.ts")));
+}