@akanjs/devkit 3.0.0-beta.9 → 3.0.0

package/frontendBuild/buildRouteClient.test.ts

@@ -1,33 +1,17 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
+import { describe, expect, test } from "bun:test";
 import path from "node:path";
+import { tempDirs, writeText as write } from "../testHelpers";
 import { createTsconfigPackageResolver } from "../transforms/barrelImportsPlugin";
 import { CLIENT_BUNDLE_NAMING } from "./clientBuildTypes";
 import { ClientEntriesBundler } from "./clientEntriesBundler";
 import { GraphClientEntryDiscovery } from "./clientEntryDiscovery";
 import { RouteClientBuilder } from "./routeClientBuilder";
 
-const tempRoots: string[] = [];
-
-const makeTempRoot = async () => {
-  const root = await mkdtemp(path.join(os.tmpdir(), "akan-client-entry-"));
-  tempRoots.push(root);
-  return root;
-};
-
-const write = async (filePath: string, content: string) => {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, content);
-};
-
-afterEach(async () => {
-  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
-});
+const makeTempRoot = tempDirs("akan-client-entry-");
 
 describe("route client store bootstrap", () => {
   test("wraps client entries with app client bootstrap before re-exporting components", () => {
-    const original = "/repo/pkgs/akanjs/ui/Model/NewWrapper_Client.tsx";
+    const original = path.resolve("/repo/pkgs/akanjs/ui/Model/NewWrapper_Client.tsx");
     const source = RouteClientBuilder.createStoreBootstrapEntrySource({
       appName: "akan",
       originalEntry: original,
@@ -147,6 +131,58 @@ describe("route client store bootstrap", () => {
     );
   });
 
+  test("bundles every route's entries into one graph so a page never loads a module twice", async () => {
+    const root = await makeTempRoot();
+    const appDir = path.join(root, "apps/demo");
+    const pageA = path.join(appDir, "page/a.tsx");
+    const pageB = path.join(appDir, "page/b.tsx");
+    const entryA = path.join(appDir, "ui/A.tsx");
+    const entryB = path.join(appDir, "ui/B.tsx");
+    const shared = path.join(appDir, "common/shared.ts");
+    await write(pageA, 'import { A } from "../ui/A";\nexport default A;\n');
+    await write(pageB, 'import { B } from "../ui/B";\nexport default B;\n');
+    await write(entryA, '"use client";\nimport { mark } from "../common/shared";\nexport const A = () => mark;\n');
+    await write(entryB, '"use client";\nimport { mark } from "../common/shared";\nexport const B = () => mark;\n');
+    await write(shared, 'export const mark = "shared-module-marker";\n');
+    const app = {
+      name: "demo",
+      cwdPath: appDir,
+      dist: { cwdPath: path.join(root, "dist/apps/demo") },
+      workspace: { workspaceRoot: root },
+      getConfig: async () => ({ barrelImports: [], optimizeImports: [] }),
+      getTsConfig: async () => ({ compilerOptions: { paths: {} } }),
+      getPublicEnv: () => ({}),
+    } as never;
+    const discovery = new GraphClientEntryDiscovery({ barrelImports: [] }, async () => null);
+    const build = (seeds: string[], knownEntries: Set<string>) =>
+      new RouteClientBuilder({
+        app,
+        seeds,
+        graphSeeds: [pageA, pageB],
+        knownEntries,
+        discovery,
+        artifact: {} as never,
+        browser: "chunks",
+      }).build();
+
+    const first = await build([pageA], new Set());
+    const second = await build([pageB], new Set(first.newEntries));
+
+    expect(first.newEntries).toEqual([entryA, entryB]);
+    expect(first.discoveredEntries).toEqual([entryA]);
+    expect(first.clientDeps).not.toContain(entryB);
+    expect(Object.keys(first.clientDepsByEntry ?? {}).sort()).toEqual([entryA, entryB]);
+    expect(second.newEntries).toEqual([]);
+    expect(second.discoveredEntries).toEqual([entryB]);
+    expect(Object.keys(second.manifestDelta)).toEqual([]);
+    const clientOut = path.join(appDir, ".akan/artifact/client");
+    const outputs = [...new Bun.Glob("**/*.js").scanSync(clientOut)];
+    const carriers = await Promise.all(
+      outputs.map(async (file) => (await Bun.file(path.join(clientOut, file)).text()).includes("shared-module-marker")),
+    );
+    expect(carriers.filter(Boolean)).toHaveLength(1);
+  });
+
   test("discovers client entries from installed akanjs package sources", async () => {
     const root = await makeTempRoot();
     const seed = path.join(root, "apps/demo/page/_index.tsx");
@@ -159,24 +195,14 @@ describe("route client store bootstrap", () => {
     await write(uiEntry, 'export { ClientPathWrapper } from "./System/Client";\n');
     await write(clientEntry, '"use client";\nexport const ClientPathWrapper = () => null;\n');
 
+    const entryFiles = new Map([
+      ["akanjs/ui", uiEntry],
+      ["akanjs/ui/System/Client.tsx", clientEntry],
+    ]);
     const discovery = new GraphClientEntryDiscovery({ barrelImports: ["akanjs/ui"] }, async (specifier) => {
-      if (specifier === "akanjs/ui") {
-        return {
-          pkgName: "akanjs/ui",
-          entryFile: uiEntry,
-          pkgDir: path.dirname(uiEntry),
-          preserveFilePath: true,
-        };
-      }
-      if (specifier === "akanjs/ui/System/Client.tsx") {
-        return {
-          pkgName: "akanjs/ui/System/Client.tsx",
-          entryFile: clientEntry,
-          pkgDir: path.dirname(clientEntry),
-          preserveFilePath: true,
-        };
-      }
-      return null;
+      const entryFile = entryFiles.get(specifier);
+      if (!entryFile) return null;
+      return { pkgName: specifier, entryFile, pkgDir: path.dirname(entryFile), preserveFilePath: true };
     });
 
     expect(await discovery.discover([seed])).toEqual([clientEntry]);
@@ -209,3 +235,63 @@ describe("route client store bootstrap", () => {
     });
   });
 });
+
+describe("fast refresh named default function", () => {
+  test("hoists a named default function into a declaration plus a trailing default export", () => {
+    const source = `export default async function Page<T>(props: T) {\n  return null;\n}\n`;
+    const next = RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh(source, { path: "/app/page.tsx" });
+    expect(next).toBe(`async function Page<T>(props: T) {\n  return null;\n}\n\nexport default Page;\n`);
+  });
+
+  test("leaves code quoted in a template literal or a comment alone", () => {
+    const source = [
+      `import { page } from "akanjs/client";`,
+      `const snippet = \``,
+      `export default function Page() {`,
+      `  return <div />;`,
+      `}\`;`,
+      `/*`,
+      `export default function Commented() {}`,
+      `*/`,
+      `export default page().render(() => <pre>{snippet}</pre>);`,
+      "",
+    ].join("\n");
+    expect(
+      RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh(source, { path: "/app/page.tsx" }),
+    ).toBeNull();
+  });
+
+  test("rewrites only the real declaration when the same name is also quoted", () => {
+    const source = [
+      "const snippet = `",
+      "export default function Page() {}",
+      "`;",
+      "export default function Page() {",
+      "  return snippet;",
+      "}",
+      "",
+    ].join("\n");
+    const next = RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh(source, { path: "/app/page.tsx" });
+    expect(next).toBe(
+      [
+        "const snippet = `",
+        "export default function Page() {}",
+        "`;",
+        "function Page() {",
+        "  return snippet;",
+        "}",
+        "",
+        "export default Page;",
+        "",
+      ].join("\n"),
+    );
+  });
+
+  test("leaves a file it cannot parse to the bundler", () => {
+    expect(
+      RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh("export default function Page( {", {
+        path: "/app/page.tsx",
+      }),
+    ).toBeNull();
+  });
+});

package/frontendBuild/bundleDefine.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, test } from "bun:test";
+import type { App } from "../commandDecorators";
+import { bundleDefine } from "./bundleDefine";
+
+describe("bundleDefine", () => {
+  test("spells the public env in one order whatever order the process holds it in", () => {
+    const appWith = (env: Record<string, string>) => ({ getPublicEnv: () => env }) as unknown as App;
+    const builder = bundleDefine(appWith({ AKAN_PUBLIC_Z: "1", AKAN_PUBLIC_A: "2" }), "start", "ssr");
+    const worker = bundleDefine(appWith({ AKAN_PUBLIC_A: "2", AKAN_PUBLIC_Z: "1" }), "start", "ssr");
+    expect(JSON.stringify(builder)).toBe(JSON.stringify(worker));
+  });
+});

package/frontendBuild/bundleDefine.ts

@@ -0,0 +1,16 @@
+import type { App } from "../commandDecorators";
+
+export const bundleDefine = (app: App, command: "build" | "start", renderEnv: "ssr" | "csr") => {
+  const nodeEnv = command === "build" ? "production" : (process.env.NODE_ENV ?? "development");
+  return {
+    "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+    "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify(renderEnv),
+    //? Sorted: Windows hands a child its environment sorted, while keys the config sets at runtime trail the parent's,
+    //? and the dev registries hash this object to tell a worker's build from the builder's.
+    ...Object.fromEntries(
+      Object.entries(app.getPublicEnv())
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]),
+    ),
+  };
+};

package/frontendBuild/clientBuildTypes.ts

@@ -10,39 +10,14 @@ export interface BuildClientOptions {
   outputDir?: string;
   servePrefix?: string;
   mode?: "production" | "test";
-  /** Additional Bun plugins applied to the client bundle build. */
   plugins?: BunPlugin[];
-  /**
-   * Legacy fallback: additional directories to filesystem-scan for
-   * `"use client"` entry points. Only used when `workspaceRoot` /
-   * `tsconfigPaths` are not provided (in which case we fall back to the old
-   * filesystem-scan strategy). Prefer the graph-based discovery.
-   */
+  /** Legacy filesystem-scan roots, used only when `workspaceRoot` / `tsconfigPaths` are absent. */
   extraClientScanRoots?: string[];
-  /**
-   * Environment variables to inline into the browser bundle via `define`.
-   * Keys are the original `process.env` names. Each key is emitted as
-   * `process.env.<KEY>` so existing server/client shared code that reads
-   * `process.env.AKAN_PUBLIC_*` keeps working unchanged.
-   */
+  /** Inlined via `define` as `process.env.<KEY>`. */
   publicEnv?: Record<string, string>;
-  /**
-   * Workspace root used by the graph-based client-entry discovery to resolve
-   * tsconfig-aliased specifiers (`@libs/shared/ui`, `@apps/<name>/client`,
-   * ...). When provided together with `tsconfigPaths`, discovery traverses
-   * the import graph starting from `appDir` instead of doing a filesystem
-   * scan, so `"use client"` files that no route transitively imports (e.g.
-   * unused editor components in a shared UI package) stay out of the client
-   * bundle.
-   */
+  /** With `tsconfigPaths`, discovery walks the import graph from `appDir` instead of scanning the filesystem. */
   workspaceRoot?: string;
-  /** Workspace tsconfig `compilerOptions.paths`. See `workspaceRoot`. */
   tsconfigPaths?: Record<string, string[]>;
-  /**
-   * Barrel specifiers whose imports are flattened by `barrelImportsPlugin`.
-   * Discovery rewrites barrel imports with the same analyzer before scanning,
-   * so the traversal sees the same leaf files the bundler will see.
-   */
   barrelImports?: string[];
 }
 
@@ -73,10 +48,7 @@ export interface BundleClientEntriesOptions {
   entries: string[];
   plugins?: BunPlugin[];
   outputSubdir?: string;
-  /**
-   * Future Fast Refresh hook. Bun only injects the React Refresh transform;
-   * the browser runtime/update protocol still needs to be provided by Akan.
-   */
+  /** Bun only injects the React Refresh transform; the browser runtime and update protocol are Akan's. */
   reactFastRefresh?: boolean;
 }
 
@@ -92,13 +64,10 @@ export interface BundleClientEntriesInternalOptions extends BundleClientEntriesO
 export interface BundleClientEntriesResult {
   manifest: ClientManifest;
   ssrManifest: SsrManifest;
-  /** Absolute path → serve URL for every entry point we produced. */
   entryUrlsByAbsPath: Map<string, string>;
-  /** Absolute source entry path → emitted entry file absolute path. */
   entryOutputAbsByAbsPath: Map<string, string>;
-  /** Absolute source files that Bun included for each client entry bundle. */
   entryDepsByAbsPath: Map<string, string[]>;
-  /** Absolute source entry path → workspace-relative client reference id. */
+  /** Workspace-relative client reference id per absolute source entry. */
   clientReferenceIdByAbsPath: Map<string, string>;
 }
 

package/frontendBuild/clientEntriesBundler.ts

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import type { SsrManifest, SsrManifestEntry } from "akanjs/server";
 import type { BunPlugin } from "bun";
-import { toClientReferencePath } from "../transforms/rscUseClientTransform";
+import { scanUseClientExports, toClientReferencePath } from "../transforms/rscUseClientTransform";
+import { bundleDefine } from "./bundleDefine";
 import {
   type BundleClientEntriesInternalOptions,
   type BundleClientEntriesResult,
@@ -13,11 +14,6 @@ import {
   type OpaqueEntryAliases,
 } from "./clientBuildTypes";
 
-/**
- * Low-level primitive shared by the eager base build and the lazy per-route
- * builds. Takes a flat entrypoints list, runs `Bun.build`, and extracts a
- * `ClientManifest` / `SsrManifest` covering only those entries.
- */
 export class ClientEntriesBundler {
   #app: BundleClientEntriesInternalOptions["app"];
   #entries: string[];
@@ -29,7 +25,6 @@ export class ClientEntriesBundler {
   #target: ClientBundleTarget;
   #outputSubdir: string;
   #reactFastRefresh: boolean;
-  #artifactDir: string;
   #outdir: string;
   #servePrefix: string;
   #manifest: ClientManifest = {};
@@ -52,8 +47,8 @@ export class ClientEntriesBundler {
     this.#target = options.target ?? "browser";
     this.#outputSubdir = options.outputSubdir ?? "client";
     this.#reactFastRefresh = options.reactFastRefresh ?? false;
-    this.#artifactDir = `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
-    this.#outdir = `${this.#artifactDir}/${this.#outputSubdir}`;
+    const artifactDir = `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
+    this.#outdir = `${artifactDir}/${this.#outputSubdir}`;
     this.#servePrefix = `/_akan/${this.#outputSubdir}`;
   }
 
@@ -68,7 +63,7 @@ export class ClientEntriesBundler {
       format: "esm",
       naming: CLIENT_BUNDLE_NAMING,
       metafile: true,
-      define: this.#getDefine(),
+      define: bundleDefine(this.#app, this.#command, "ssr"),
       minify: this.#command === "build",
       optimizeImports: akanConfig.optimizeImports,
       reactFastRefresh: this.#command === "start" && this.#outputSubdir === "client" && this.#reactFastRefresh,
@@ -100,17 +95,6 @@ export class ClientEntriesBundler {
     };
   }
 
-  #getDefine(): Record<string, string> {
-    const nodeEnv = this.#command === "build" ? "production" : (process.env.NODE_ENV ?? "development");
-    return {
-      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
-      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("ssr"),
-      ...Object.fromEntries(
-        Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]),
-      ),
-    };
-  }
-
   async #createOpaqueEntryAliases(): Promise<OpaqueEntryAliases> {
     const aliasDir = path.join(this.#app.cwdPath, ".akan", "generated", "client-entry-alias", this.#outputSubdir);
     fs.mkdirSync(aliasDir, { recursive: true });
@@ -141,22 +125,10 @@ export class ClientEntriesBundler {
   }
 
   async #scanEntryExportNames(absEntry: string): Promise<string[]> {
-    const source = await Bun.file(absEntry).text();
-    const transpiler = new Bun.Transpiler({ loader: this.#loaderForEntry(absEntry) });
-    return transpiler.scan(source).exports;
+    return scanUseClientExports(await Bun.file(absEntry).text(), absEntry, this.#app.workspace.workspaceRoot);
   }
 
-  #loaderForEntry(absPath: string): "ts" | "tsx" | "js" | "jsx" {
-    if (absPath.endsWith(".tsx")) return "tsx";
-    if (absPath.endsWith(".jsx")) return "jsx";
-    if (absPath.endsWith(".ts")) return "ts";
-    return "js";
-  }
-
-  /**
-   * Build a BunPlugin that marks a fixed set of bare specifiers as external via `onResolve`,
-   * as opposed to `Bun.build({ external })`, so macro-time imports still resolve normally.
-   */
+  // `onResolve` rather than `Bun.build({ external })`, so macro-time imports still resolve normally.
   #createExternalSpecifiersPlugin(): BunPlugin {
     const set = new Set(this.#external);
     const subpathSet = new Set(this.#externalSubpaths);
@@ -182,11 +154,8 @@ export class ClientEntriesBundler {
     exactExternals: Set<string>,
     subpathExternals: Set<string>,
   ): boolean {
-    if (exactExternals.has(specifier)) return true;
-    if (subpathExternals.has(specifier)) return true;
-    for (const external of subpathExternals) {
-      if (specifier.startsWith(`${external}/`)) return true;
-    }
+    if (exactExternals.has(specifier) || subpathExternals.has(specifier)) return true;
+    for (const external of subpathExternals) if (specifier.startsWith(`${external}/`)) return true;
     return false;
   }
 

package/frontendBuild/clientEntryDiscovery.test.ts

@@ -0,0 +1,112 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { GraphClientEntryDiscovery } from "./clientEntryDiscovery";
+
+const dirs: string[] = [];
+
+afterAll(async () => {
+  await Promise.all(dirs.map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("GraphClientEntryDiscovery", () => {
+  test("a walk an invalidation overtook answers its caller but leaves nothing stale for the next one", async () => {
+    for (const yields of [0, 5, 10, 20, 40, 80]) {
+      const dir = await mkdtemp(path.join(os.tmpdir(), "akan-discovery-"));
+      dirs.push(dir);
+      const file = (name: string) => path.join(dir, name);
+      await Bun.write(file("S.tsx"), 'import "./A";\n');
+      await Bun.write(file("A.tsx"), 'import "./B";\nimport "./D";\n');
+      await Bun.write(file("B.tsx"), "export const b = 1;\n");
+      await Bun.write(file("C.tsx"), '"use client";\nexport const C = () => null;\n');
+      await Bun.write(file("D.tsx"), "export const d = 1;\n");
+      const discovery = new GraphClientEntryDiscovery({ barrelImports: [] }, (async () => null) as never);
+      expect(await discovery.discover([file("S.tsx")])).toEqual([]);
+
+      await Bun.write(file("B.tsx"), 'import "./C";\nexport const b = 1;\n');
+      await Bun.write(file("D.tsx"), "export const d = 2;\n");
+      discovery.invalidate([file("D.tsx")]);
+      const walk = discovery.discover([file("S.tsx")]);
+      for (let tick = 0; tick < yields; tick++) await Promise.resolve();
+      discovery.invalidate([file("B.tsx")]);
+      await walk;
+      expect(await discovery.discover([file("S.tsx")])).toEqual([file("C.tsx")]);
+    }
+  });
+
+  const tempDir = async () => {
+    const dir = await mkdtemp(path.join(os.tmpdir(), "akan-discovery-"));
+    dirs.push(dir);
+    return (name: string) => path.join(dir, name);
+  };
+
+  test("an entry moved into a folder, or to another extension, is found once the move is invalidated", async () => {
+    const file = await tempDir();
+    await Bun.write(file("S.tsx"), 'import "./ui/Chart";\nimport "./ui/Card";\n');
+    await Bun.write(file("ui/Chart.tsx"), '"use client";\nexport const Chart = () => null;\n');
+    await Bun.write(file("ui/Card.tsx"), '"use client";\nexport const Card = () => null;\n');
+    const discovery = new GraphClientEntryDiscovery({ barrelImports: [] }, (async () => null) as never);
+    expect(await discovery.discover([file("S.tsx")])).toEqual([file("ui/Card.tsx"), file("ui/Chart.tsx")]);
+
+    await rm(file("ui/Chart.tsx"));
+    await Bun.write(file("ui/Chart/index.tsx"), '"use client";\nexport const Chart = () => null;\n');
+    await rm(file("ui/Card.tsx"));
+    await Bun.write(file("ui/Card.ts"), '"use client";\nexport const Card = () => null;\n');
+    discovery.invalidate([file("ui/Chart.tsx"), file("ui/Chart/index.tsx"), file("ui/Card.tsx"), file("ui/Card.ts")]);
+    expect(await discovery.discover([file("S.tsx")])).toEqual([file("ui/Card.ts"), file("ui/Chart/index.tsx")]);
+  });
+
+  test("a resolution still in flight when its target appears is not what the next walk reads", async () => {
+    const file = await tempDir();
+    await Bun.write(file("S.tsx"), 'import "./B";\n');
+    await Bun.write(file("B.tsx"), 'import "@demo/C";\nexport const b = 1;\n');
+    const gate = Promise.withResolvers<void>();
+    const seen = Promise.withResolvers<void>();
+    let calls = 0;
+    const resolvePackage = async () => {
+      calls += 1;
+      const exists = await Bun.file(file("C.tsx")).exists();
+      if (calls === 1) {
+        seen.resolve();
+        await gate.promise;
+      }
+      return exists ? { entryFile: file("C.tsx") } : null;
+    };
+    const discovery = new GraphClientEntryDiscovery({ barrelImports: [] }, resolvePackage as never);
+    const walk = discovery.discover([file("S.tsx")]);
+    await seen.promise;
+    await Bun.write(file("C.tsx"), '"use client";\nexport const C = () => null;\n');
+    discovery.invalidate([file("C.tsx")]);
+    gate.resolve();
+    await walk;
+    expect(await discovery.discover([file("S.tsx")])).toEqual([file("C.tsx")]);
+  });
+
+  test("a dense import cycle is walked once per file, not once per path", async () => {
+    const file = await tempDir();
+    const names = Array.from({ length: 12 }, (_, idx) => `M${idx}.tsx`);
+    for (const name of names)
+      await Bun.write(file(name), names.map((other) => `import "./${other.replace(".tsx", "")}";\n`).join(""));
+    await Bun.write(file("C.tsx"), '"use client";\nexport const C = () => null;\n');
+    await Bun.write(
+      file("M11.tsx"),
+      `${names.map((other) => `import "./${other.replace(".tsx", "")}";\n`).join("")}import "./C";\n`,
+    );
+    const discovery = new GraphClientEntryDiscovery({ barrelImports: [] }, (async () => null) as never);
+    const started = performance.now();
+    expect(await discovery.discover([file("M0.tsx")])).toEqual([file("C.tsx")]);
+    expect(performance.now() - started).toBeLessThan(2_000);
+    expect(await discovery.discover([file("M5.tsx")])).toEqual([file("C.tsx")]);
+  });
+
+  test("a file walked inside an import cycle keeps no partial result for a walk that starts at it", async () => {
+    const file = await tempDir();
+    await Bun.write(file("A.tsx"), 'import "./B";\nimport "./C";\n');
+    await Bun.write(file("B.tsx"), 'import "./A";\n');
+    await Bun.write(file("C.tsx"), '"use client";\nexport const C = () => null;\n');
+    const discovery = new GraphClientEntryDiscovery({ barrelImports: [] }, (async () => null) as never);
+    expect(await discovery.discover([file("A.tsx")])).toEqual([file("C.tsx")]);
+    expect(await discovery.discover([file("B.tsx")])).toEqual([file("C.tsx")]);
+  });
+});