@akanjs/devkit 3.0.0-beta.25 → 3.0.0-beta.27

package/frontendBuild/clientEntryDiscovery.ts

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import { SOURCE_EXTS } from "../akanApp/devHostPolicy";
 import type { App } from "../commandDecorators";
@@ -17,6 +18,21 @@ interface FileFacts {
   imports: ScannedImport[];
 }
 
+interface Lookup<T> {
+  epoch: number;
+  promise: Promise<T>;
+  found?: boolean;
+}
+
+interface DiscoveryWalk {
+  visiting: Set<string>;
+  //? Walked below a file the walk was already inside (an import cycle): their result lacks what that file reaches.
+  partial: Set<string>;
+  //? Every file's result within this walk, partial ones included: the file the cycle went back to is an ancestor here
+  //? and brings the rest itself, and re-walking each path through a dense cycle grows exponentially.
+  memo: Map<string, Set<string>>;
+}
+
 const shouldSkipNodeModule = (absPath: string) => NODE_MODULES_RE.test(absPath) && !AKANJS_NODE_MODULE_RE.test(absPath);
 
 /** `"use client"` discovery over the import graph (dynamic imports included), flattening barrels as the bundler does. */
@@ -25,15 +41,13 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
   #resolvePackage: PackageResolver;
   #analyzer: BarrelAnalyzer;
   #tsTranspiler = new Bun.Transpiler({ loader: "tsx" });
-  #fileExistsCache = new Map<string, Promise<boolean>>();
+  #fileExistsCache = new Map<string, Lookup<boolean>>();
   // Facts, never source text: this instance lives as long as the builder process, so texts would pin every file walked.
   #factsCache = new Map<string, Promise<FileFacts | null>>();
-  #resolvedFileCache = new Map<string, Promise<string | null>>();
-  #resolvedSpecifierCache = new Map<string, Promise<string | null>>();
+  #resolvedFileCache = new Map<string, Lookup<string | null>>();
+  #resolvedSpecifierCache = new Map<string, Lookup<string | null>>();
   #reachableEntriesCache = new Map<string, Set<string>>();
-  #missingFiles = new Set<string>();
-  #unresolvedPaths = new Set<string>();
-  #unresolvedSpecifiers = new Set<string>();
+  #readFiles = new Set<string>();
   //? Bumped by every invalidation: a walk that began before one computed from facts it may have read stale, so it
   //? answers its caller but caches nothing (a registry check walks this instance beside the slow lane's route builds).
   #epoch = 0;
@@ -51,48 +65,61 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
   async discover(seeds: string[]): Promise<string[]> {
     const entries = new Set<string>();
     for (const seed of seeds) {
-      for (const entry of await this.#discoverFromFile(seed, new Set())) entries.add(entry);
+      const walk: DiscoveryWalk = { visiting: new Set(), partial: new Set(), memo: new Map() };
+      for (const entry of await this.#discoverFromFile(seed, walk)) entries.add(entry);
     }
     return Array.from(entries).sort();
   }
 
   invalidate(files: string[]): void {
+    if (files.length === 0) return;
+    let moved = false;
     for (const file of files) {
       const absPath = path.resolve(file);
+      const exists = fs.existsSync(absPath);
+      if (exists !== this.#readFiles.has(absPath)) moved = true;
+      if (!exists) this.#readFiles.delete(absPath);
       this.#factsCache.delete(absPath);
       this.#fileExistsCache.delete(absPath);
-      this.#reachableEntriesCache.delete(absPath);
     }
-    if (files.length === 0) return;
     this.#epoch += 1;
     // Reachable-entry results are transitive, so a changed child invalidates every ancestor.
     this.#reachableEntriesCache.clear();
-    this.#forgetMissing();
+    //? A file gone, or one never read, can leave a found resolution on its old target (`Chart.tsx` to
+    //? `Chart/index.tsx`), so a move drops them all; a save of a file already read keeps them (a walk re-resolving
+    //? every package cost 3x). Misses lapse with the epoch on their own (#lookup).
+    if (!moved) return;
+    this.#fileExistsCache.clear();
+    this.#resolvedFileCache.clear();
+    this.#resolvedSpecifierCache.clear();
   }
 
-  // Negatives are keyed by extension-less path or `dir\0specifier`, which a new file's path cannot reach, so all go.
-  #forgetMissing(): void {
-    for (const key of this.#missingFiles) this.#fileExistsCache.delete(key);
-    for (const key of this.#unresolvedPaths) this.#resolvedFileCache.delete(key);
-    for (const key of this.#unresolvedSpecifiers) this.#resolvedSpecifierCache.delete(key);
-    this.#missingFiles.clear();
-    this.#unresolvedPaths.clear();
-    this.#unresolvedSpecifiers.clear();
+  //? A found answer outlives later epochs; a miss, or a lookup still in flight, answers only walks of its own epoch, so
+  //? a file created meanwhile is looked up again.
+  #lookup<T>(cache: Map<string, Lookup<T>>, key: string, run: () => Promise<T>, isFound: (value: T) => boolean) {
+    const cached = cache.get(key);
+    if (cached && (cached.found || cached.epoch === this.#epoch)) return cached.promise;
+    const entry: Lookup<T> = { epoch: this.#epoch, promise: run() };
+    entry.promise.then(
+      (value) => {
+        entry.found = isFound(value);
+      },
+      () => {
+        entry.found = false;
+      },
+    );
+    cache.set(key, entry);
+    return entry.promise;
   }
 
   async #fileExists(p: string): Promise<boolean> {
     const absPath = path.resolve(p);
-    let cached = this.#fileExistsCache.get(absPath);
-    if (!cached) {
-      cached = Bun.file(absPath)
-        .exists()
-        .then((exists) => {
-          if (!exists) this.#missingFiles.add(absPath);
-          return exists;
-        });
-      this.#fileExistsCache.set(absPath, cached);
-    }
-    return cached;
+    return await this.#lookup(
+      this.#fileExistsCache,
+      absPath,
+      () => Bun.file(absPath).exists(),
+      (exists) => exists,
+    );
   }
 
   #facts(file: string): Promise<FileFacts | null> {
@@ -104,6 +131,7 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
           .text()
           .catch(() => null);
         if (content === null) return null;
+        this.#readFiles.add(absPath);
         if (USE_CLIENT_RE.test(content)) return { isClientEntry: true, imports: [] };
         return { isClientEntry: false, imports: this.#scanImports(await this.#rewrite(content)) };
       })();
@@ -131,58 +159,71 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
 
   async #resolveFileCandidate(absPathNoExt: string): Promise<string | null> {
     const cacheKey = path.resolve(absPathNoExt);
-    let cached = this.#resolvedFileCache.get(cacheKey);
-    if (cached) return cached;
-    cached = (async () => {
-      if (await this.#fileExists(cacheKey)) return cacheKey;
-      for (const ext of SOURCE_EXTS) {
-        const f = `${cacheKey}${ext}`;
-        if (await this.#fileExists(f)) return f;
-      }
-      for (const ext of SOURCE_EXTS) {
-        const f = path.join(cacheKey, `index${ext}`);
-        if (await this.#fileExists(f)) return f;
-      }
-      this.#unresolvedPaths.add(cacheKey);
-      return null;
-    })();
-    this.#resolvedFileCache.set(cacheKey, cached);
-    return cached;
+    return await this.#lookup(
+      this.#resolvedFileCache,
+      cacheKey,
+      async () => {
+        if (await this.#fileExists(cacheKey)) return cacheKey;
+        for (const ext of SOURCE_EXTS) {
+          const f = `${cacheKey}${ext}`;
+          if (await this.#fileExists(f)) return f;
+        }
+        for (const ext of SOURCE_EXTS) {
+          const f = path.join(cacheKey, `index${ext}`);
+          if (await this.#fileExists(f)) return f;
+        }
+        return null;
+      },
+      (file) => file !== null,
+    );
   }
 
   async #resolveSpecifier(spec: string, importerDir: string): Promise<string | null> {
     const cacheKey = `${importerDir}\0${spec}`;
-    let cached = this.#resolvedSpecifierCache.get(cacheKey);
-    if (cached) return cached;
-    cached = (async () => {
-      if (spec.startsWith(".") || spec.startsWith("/")) {
-        const abs = spec.startsWith("/") ? spec : path.resolve(importerDir, spec);
-        return this.#resolveFileCandidate(abs);
-      }
-      const pkg = await this.#resolvePackage(spec);
-      if (pkg) return pkg.entryFile;
-      this.#unresolvedSpecifiers.add(cacheKey);
-      return null;
-    })();
-    this.#resolvedSpecifierCache.set(cacheKey, cached);
-    return cached;
+    return await this.#lookup(
+      this.#resolvedSpecifierCache,
+      cacheKey,
+      async () => {
+        if (spec.startsWith(".") || spec.startsWith("/")) {
+          const abs = spec.startsWith("/") ? spec : path.resolve(importerDir, spec);
+          return await this.#resolveFileCandidate(abs);
+        }
+        const pkg = await this.#resolvePackage(spec);
+        return pkg ? pkg.entryFile : null;
+      },
+      (file) => file !== null,
+    );
   }
 
-  async #discoverFromFile(file: string, visiting: Set<string>): Promise<Set<string>> {
+  async #discoverFromFile(file: string, walk: DiscoveryWalk): Promise<Set<string>> {
     const epoch = this.#epoch;
     const absPath = path.resolve(file);
     const cached = this.#reachableEntriesCache.get(absPath);
     if (cached) return new Set(cached);
-    if (visiting.has(absPath) || shouldSkipNodeModule(absPath)) return new Set();
+    const memo = walk.memo.get(absPath);
+    if (memo) {
+      //? Reused from another path: whatever this path is walking now inherits its gap and stays out of the cache.
+      if (walk.partial.has(absPath)) for (const onPath of walk.visiting) walk.partial.add(onPath);
+      return new Set(memo);
+    }
+    if (walk.visiting.has(absPath)) {
+      let below = false;
+      for (const onPath of walk.visiting) {
+        if (below) walk.partial.add(onPath);
+        else below = onPath === absPath;
+      }
+      return new Set();
+    }
+    if (shouldSkipNodeModule(absPath)) return new Set();
 
-    visiting.add(absPath);
+    walk.visiting.add(absPath);
     const entries = new Set<string>();
     const facts = await this.#facts(absPath);
-    if (!facts) return this.#finishDiscovery(absPath, visiting, entries, epoch);
+    if (!facts) return this.#finishDiscovery(absPath, walk, entries, epoch);
 
     if (facts.isClientEntry) {
       entries.add(absPath);
-      return this.#finishDiscovery(absPath, visiting, entries, epoch);
+      return this.#finishDiscovery(absPath, walk, entries, epoch);
     }
 
     const importerDir = path.dirname(absPath);
@@ -193,15 +234,16 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
       const resolved = await this.#resolveSpecifier(spec, importerDir);
       if (!resolved) continue;
       if (shouldSkipNodeModule(resolved)) continue;
-      for (const entry of await this.#discoverFromFile(resolved, visiting)) entries.add(entry);
+      for (const entry of await this.#discoverFromFile(resolved, walk)) entries.add(entry);
     }
 
-    return this.#finishDiscovery(absPath, visiting, entries, epoch);
+    return this.#finishDiscovery(absPath, walk, entries, epoch);
   }
 
-  #finishDiscovery(absPath: string, visiting: Set<string>, entries: Set<string>, epoch: number): Set<string> {
-    visiting.delete(absPath);
-    if (epoch === this.#epoch) this.#reachableEntriesCache.set(absPath, entries);
+  #finishDiscovery(absPath: string, walk: DiscoveryWalk, entries: Set<string>, epoch: number): Set<string> {
+    walk.visiting.delete(absPath);
+    walk.memo.set(absPath, entries);
+    if (epoch === this.#epoch && !walk.partial.has(absPath)) this.#reachableEntriesCache.set(absPath, entries);
     return new Set(entries);
   }
 }

package/frontendBuild/csrDevArtifactWriter.test.ts

@@ -76,6 +76,14 @@ describe("CsrDevArtifactWriter", () => {
     expect(existsSync(path.join(dir, "graph.json"))).toBe(true);
   });
 
+  test("a module a package's browser field turns off is written empty, and a Node built-in still throws", async () => {
+    const { writer, graph, dir } = await makeWriter();
+    graph.modules["a.ts"] = { vendor: false, mtimeMs: 0, hash: "", deps: ["stub:empty:fs", "stub:path"] };
+    const vendor = readFileSync(path.join(dir, await writer.writeVendor(graph)), "utf8");
+    expect(vendor).toContain('__akan.define("stub:empty:fs", function () {});');
+    expect(vendor).toContain("[akan-csr] path is a Node built-in the browser does not have");
+  });
+
   test("rewrites an app.js a crash left behind the manifest's generation", async () => {
     const { writer, graph, read } = await makeWriter();
     await writer.writeApp(graph, { generation: 5, vendorFile: "v.js" });

package/frontendBuild/csrDevArtifactWriter.ts

@@ -114,6 +114,10 @@ export class CsrDevArtifactWriter {
     const stubs = new Set(Object.values(graph.modules).flatMap((module) => module.deps.filter(CsrDevPaths.isStub)));
     const lines = [await this.#helperDefinitions(graph, ids), ...(await this.#defineLines(ids))];
     for (const stub of [...stubs].sort()) {
+      if (stub.startsWith(CsrDevPaths.emptyStubPrefix)) {
+        lines.push(`__akan.define(${JSON.stringify(stub)}, function () {});\n`);
+        continue;
+      }
       const message = `[akan-csr] ${stub.slice(CsrDevPaths.stubPrefix.length)} is a Node built-in the browser does not have`;
       lines.push(
         `__akan.define(${JSON.stringify(stub)}, function () {\n  throw new Error(${JSON.stringify(message)});\n});\n`,

package/frontendBuild/csrDevBundler.ts

@@ -13,7 +13,7 @@ import { PagesEntrySourceGenerator } from "./pagesEntrySourceGenerator";
 
 //* Dev-only CSR as a module registry, under `.akan/artifact/csr-dev`: one entry per basePath boots every page.
 export class CsrDevBundler extends DevRegistryBundler {
-  static readonly #formatVersion = 3;
+  static readonly #formatVersion = 4;
   readonly reloadsOnEntryChange = true;
   //? Detecting a page's async default parses it with TypeScript: on apps/akan every page each save cost ~100ms.
   readonly #asyncDefaults = new Map<string, { mtimeMs: number; detected: Promise<boolean> }>();

package/frontendBuild/csrDevFactoryCheck.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { CsrDevFactoryCheck } from "./csrDevFactoryCheck";
+
+const factoryOf = (body: string) =>
+  `function (require, module, exports, $RefreshReg$, $RefreshSig$, __akanImport) {\n${body}\n}`;
+
+describe("CsrDevFactoryCheck", () => {
+  test("a factory that parses as a classic script has no problem, twice over", () => {
+    const factory = factoryOf('var a = require("akan-module:x");\nmodule.exports = { a, label: "import.meta" };');
+    expect(CsrDevFactoryCheck.problemOf(factory)).toBeNull();
+    expect(CsrDevFactoryCheck.problemOf(factory)).toBeNull();
+  });
+
+  test("an import.meta left in a factory is named with its compiled line", () => {
+    const problem = CsrDevFactoryCheck.problemOf(factoryOf("var a = 1;\nvar url = import.meta.url;"));
+    expect(problem).toStartWith("import.meta is left in it (compiled line 2), which a classic script cannot hold");
+  });
+
+  test("a top-level await left in a factory is named as one", () => {
+    const problem = CsrDevFactoryCheck.problemOf(factoryOf("var a = await Promise.resolve(1);"));
+    expect(problem).toStartWith("a top-level await is left in it, which a CommonJS factory cannot wait on");
+  });
+
+  test("any other syntax error answers the parser's message, and a broken helper preamble counts too", () => {
+    expect(CsrDevFactoryCheck.problemOf(factoryOf("var = ;"))).toBeString();
+    expect(CsrDevFactoryCheck.problemOf(factoryOf("module.exports = 1;"), "var { a } = ;\n")).toBeString();
+  });
+
+  test("the stand-in for a module left out throws its id and the reason", () => {
+    const thrower = new Function(`return (${CsrDevFactoryCheck.thrower("node_modules/x/index.js", "why")});`)();
+    expect(() => thrower()).toThrow("[akan-csr] node_modules/x/index.js was left out of the dev registry: why");
+  });
+});

package/frontendBuild/csrDevFactoryCheck.ts

@@ -0,0 +1,39 @@
+//* A module factory runs inside one classic script with every module written beside it, so a factory that does not
+//* parse as a script drops them all, far from the cause. Each is parsed once, as the page will, before it is written.
+export class CsrDevFactoryCheck {
+  static readonly #parsed = new Set<number | bigint>();
+
+  /** Why the page could not parse `factory` after `helperDefinition`, or null when it can. */
+  static problemOf(factory: string, helperDefinition = ""): string | null {
+    const key = Bun.hash(`${helperDefinition}\0${factory}`);
+    if (CsrDevFactoryCheck.#parsed.has(key)) return null;
+    const problem = CsrDevFactoryCheck.#syntaxError(`${helperDefinition}return (${factory});`);
+    if (problem === null) {
+      CsrDevFactoryCheck.#parsed.add(key);
+      return null;
+    }
+    if (problem.includes("import.meta")) {
+      //? JSC's own line is the caller's, not the factory's; the factory's line N is line N of Bun's output.
+      const line = factory.split("\n").findIndex((text) => /(?<![\w$.])import\.meta\b/.test(text));
+      return `import.meta is left in it${line > 0 ? ` (compiled line ${line})` : ""}, which a classic script cannot hold: ${problem}`;
+    }
+    if (CsrDevFactoryCheck.#syntaxError(`${helperDefinition}return (async ${factory});`) === null)
+      return `a top-level await is left in it, which a CommonJS factory cannot wait on: ${problem}`;
+    return problem;
+  }
+
+  /** Stands in for a module left out of the registry: the page runs, and requiring the module says why. */
+  static thrower(id: string, problem: string): string {
+    const message = `[akan-csr] ${id} was left out of the dev registry: ${problem}`;
+    return `function () {\n  throw new Error(${JSON.stringify(message)});\n}`;
+  }
+
+  static #syntaxError(source: string): string | null {
+    try {
+      new Function(source);
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error.message : String(error);
+    }
+  }
+}

package/frontendBuild/csrDevModuleCompiler.test.ts

@@ -0,0 +1,261 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { App } from "../commandDecorators";
+import { CsrDevModuleCompiler } from "./csrDevModuleCompiler";
+import { CsrDevPaths } from "./csrDevPaths";
+import { CsrDevResolver } from "./csrDevResolver";
+import type { CsrDevCompiledModule, CsrDevContext } from "./csrDevTypes";
+
+const context: CsrDevContext = {
+  pageEntries: [],
+  basePaths: [],
+  htmlBasePaths: [],
+  define: {},
+  optimizeImports: [],
+  configKey: "key",
+  refreshFile: null,
+};
+
+//? esbuild's own interop helpers, as a pre-bundled chunk ships them (@mermaid-js/parser's dist/chunks).
+const prebundled = `var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var parts = {};
+__reExport(parts, { a: 1 });
+var wrapped = __toESM({ b: 2 });
+export { parts, wrapped };
+`;
+
+//? The development checks jotai's and zustand's ESM builds ship, as written in jotai/esm/vanilla.mjs.
+const jotai = `let keyCount = 0;
+export function atom(read) {
+  const key = \`atom\${++keyCount}\`;
+  return {
+    read,
+    toString() {
+      return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
+    },
+  };
+}
+`;
+const zustand = `export const devtools = (fn) => (import.meta.env ? import.meta.env.MODE : void 0) !== "production" ? "dev" : fn;
+`;
+
+describe("CsrDevModuleCompiler", () => {
+  let root: string;
+  const origin = "http://localhost:8283";
+  const file = (relative: string) => path.join(root, relative);
+  const logged: string[] = [];
+  const compile = async (relative: string | string[], { prepass = false }: { prepass?: boolean } = {}) => {
+    const files = (Array.isArray(relative) ? relative : [relative]).map(file);
+    const paths = new CsrDevPaths(root);
+    const resolver = new CsrDevResolver({ paths, context, entryFiles: prepass ? files : [] });
+    if (prepass) await resolver.prepass();
+    const compiler = new CsrDevModuleCompiler({
+      app: { verbose: () => undefined, logger: { error: (message: string) => logged.push(message) } } as unknown as App,
+      paths,
+      resolver,
+      context,
+      outDir: file("out"),
+      routePrefix: "/_akan/registry/",
+    });
+    return { resolver, ...(await compiler.compile(files, new Set())) };
+  };
+  //? As the page runs a factory: a classic script whose only globals are the runtime and the window.
+  const run = (module: CsrDevCompiledModule | undefined) => {
+    const helpers = new Map<string, Record<string, unknown>>();
+    const akan = {
+      defineHelpers: (hash: string, define: () => Record<string, unknown>) => helpers.set(hash, define()),
+      helpers: (hash: string) => helpers.get(hash),
+    };
+    if (module?.helpers) new Function("__akan", module.helpers.definition)(akan);
+    const factory = new Function("__akan", "self", `return (${module?.factory});`)(akan, {
+      location: { href: `${origin}/en/dashboard` },
+    });
+    const record = { exports: {} as Record<string, unknown> };
+    factory.call(
+      record.exports,
+      () => ({}),
+      record,
+      record.exports,
+      () => undefined,
+      () => (type: unknown) => type,
+      async () => ({}),
+    );
+    return record.exports;
+  };
+
+  beforeAll(async () => {
+    root = CsrDevPaths.realpath(await mkdtemp(path.join(os.tmpdir(), "akan-csr-dev-compiler-")));
+    await Bun.write(file("node_modules/prebundled/chunk.mjs"), prebundled);
+    await Bun.write(file("node_modules/bare-reexport/index.mjs"), "export const parts = __reExport({}, { a: 1 });\n");
+    await Bun.write(file("node_modules/bare-toesm/index.mjs"), "export const wrapped = __toESM({ b: 2 });\n");
+    await Bun.write(file("node_modules/jotai/esm/vanilla.mjs"), jotai);
+    await Bun.write(file("node_modules/zustand/esm/middleware.mjs"), zustand);
+    await Bun.write(
+      file("apps/demo/ui/meta.ts"),
+      [
+        "export const url = import.meta.url;",
+        "export const env = import.meta.env;",
+        'export const asset = new URL("./x.wasm", import.meta.url).href;',
+        'export const label = "import.meta.env";',
+        "",
+      ].join("\n"),
+    );
+    await Bun.write(file("node_modules/with-bin/index.mjs"), "#!/usr/bin/env node\nexport const a = 1;\n");
+    await Bun.write(file("node_modules/awaits/index.mjs"), "export const a = await Promise.resolve(1);\n");
+    await Bun.write(file("apps/demo/ui/awaits.ts"), "export const a = await Promise.resolve(1);\n");
+    await Bun.write(
+      file("node_modules/barrel/package.json"),
+      JSON.stringify({
+        name: "barrel",
+        type: "module",
+        main: "index.js",
+        sideEffects: false,
+        imports: {
+          "#where": { node: "./where.node.js", default: "./where.browser.js" },
+          "#other": { node: "./other.node.js", default: "./other.browser.js" },
+        },
+      }),
+    );
+    await Bun.write(
+      file("node_modules/barrel/index.js"),
+      'export { used } from "./used.js";\nexport { unused } from "./unused.js";\nexport { other } from "#other";\n',
+    );
+    await Bun.write(file("node_modules/barrel/used.js"), "export const used = 1;\n");
+    await Bun.write(
+      file("node_modules/barrel/unused.js"),
+      'import { where } from "#where";\nexport const unused = where;\n',
+    );
+    await Bun.write(
+      file("node_modules/barrel/where.node.js"),
+      'import path from "node:path";\nexport const where = path.sep;\n',
+    );
+    await Bun.write(file("node_modules/barrel/where.browser.js"), 'export const where = "browser";\n');
+    await Bun.write(
+      file("node_modules/barrel/other.node.js"),
+      'import path from "node:path";\nexport const other = path.sep;\n',
+    );
+    await Bun.write(file("node_modules/barrel/other.browser.js"), 'export const other = "browser";\n');
+    await Bun.write(file("apps/demo/entry.ts"), 'import { used } from "barrel";\nexport const run = used;\n');
+    await Bun.write(
+      file("node_modules/inspectish/package.json"),
+      JSON.stringify({ name: "inspectish", main: "index.js", browser: { "./util.inspect.js": false, fs: false } }),
+    );
+    await Bun.write(
+      file("node_modules/inspectish/index.js"),
+      'var inspect = require("./util.inspect");\nvar fs = require("fs");\nmodule.exports = { inspect, fs };\n',
+    );
+    await Bun.write(file("node_modules/inspectish/util.inspect.js"), 'module.exports = require("util").inspect;\n');
+  });
+
+  afterAll(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  test("a pre-bundled file keeps its own __reExport and __toESM, which Bun leaves in place of its own", async () => {
+    const { modules } = await compile("node_modules/prebundled/chunk.mjs");
+    const [module] = modules;
+    expect(module?.id).toBe("node_modules/prebundled/chunk.mjs");
+    const factory = module?.factory ?? "";
+    expect(factory).toContain("var __reExport = (target, mod, secondTarget) => (");
+    expect(factory).toContain("var __toESM = (mod, isNodeMode, target) => (");
+    expect(factory).not.toContain("__akan.reExport");
+    expect(factory).not.toContain("__akan.toESM");
+    expect(factory).not.toContain("__akanMeta");
+    expect(run(module)).toMatchObject({ parts: { a: 1 }, wrapped: { b: 2 } });
+  });
+
+  test.each([
+    ["__reExport", "node_modules/bare-reexport/index.mjs"],
+    ["__toESM", "node_modules/bare-toesm/index.mjs"],
+  ])("a %s call with no definition anywhere still stops the build", async (name, relative) => {
+    await expect(compile(relative)).rejects.toThrow(`Bun's ${name} helper no longer reads`);
+  });
+
+  test("jotai's and zustand's import.meta.env checks run as a classic script and take the ESM bundle's branch", async () => {
+    const [{ modules: jotaiModules }, { modules: zustandModules }] = await Promise.all([
+      compile("node_modules/jotai/esm/vanilla.mjs"),
+      compile("node_modules/zustand/esm/middleware.mjs"),
+    ]);
+    const [jotaiModule] = jotaiModules;
+    const [zustandModule] = zustandModules;
+    expect(jotaiModule?.factory).not.toContain("import.meta");
+    expect(zustandModule?.factory).not.toContain("import.meta");
+    const labeled = Object.assign((run(jotaiModule).atom as (read: unknown) => object)(null), { debugLabel: "count" });
+    expect(String(labeled)).toBe("atom1:count");
+    expect((run(zustandModule).devtools as (fn: unknown) => unknown)("prod")).toBe("dev");
+  });
+
+  test("an app module reads import.meta as a browser module does, on its own path and with no env", async () => {
+    const [module] = (await compile("apps/demo/ui/meta.ts")).modules;
+    expect(module?.factory).not.toContain("file://");
+    expect(run(module)).toEqual({
+      url: `${origin}/apps/demo/ui/meta.ts`,
+      env: undefined,
+      asset: `${origin}/apps/demo/ui/x.wasm`,
+      label: "import.meta.env",
+    });
+  });
+
+  test("a file or re-export the browser build tree-shook away resolves with the browser condition", async () => {
+    const { modules, resolver } = await compile("apps/demo/entry.ts", { prepass: true });
+    const ids = modules.map((module) => module.id);
+    expect(ids).toContain("node_modules/barrel/unused.js");
+    expect(ids).toContain("node_modules/barrel/where.browser.js");
+    expect(ids).not.toContain("node_modules/barrel/where.node.js");
+    expect(ids).toContain("node_modules/barrel/other.browser.js");
+    expect(ids).not.toContain("node_modules/barrel/other.node.js");
+    expect([...resolver.fallbacks]).toEqual([]);
+  });
+
+  test("what a package's browser field maps to false is an empty stub, not the file or the Node built-in", async () => {
+    const { modules } = await compile("node_modules/inspectish/index.js");
+    expect(modules.map((module) => module.id)).toEqual(["node_modules/inspectish/index.js"]);
+    expect(modules[0]?.deps.sort()).toEqual(["stub:empty:fs", "stub:empty:node_modules/inspectish/util.inspect.js"]);
+  });
+
+  test("a package's #! line is a comment in its factory, so the package loads", async () => {
+    const [module] = (await compile("node_modules/with-bin/index.mjs")).modules;
+    expect(module?.factory).not.toContain("#!");
+    expect(run(module)).toEqual({ a: 1 });
+  });
+
+  test("a package file Bun cannot build as CommonJS is left out, named in the log, and the rest still builds", async () => {
+    logged.length = 0;
+    const { modules } = await compile(["node_modules/awaits/index.mjs", "node_modules/zustand/esm/middleware.mjs"]);
+    const left = modules.find((module) => module.id === "node_modules/awaits/index.mjs");
+    expect(modules.map((module) => module.id)).toContain("node_modules/zustand/esm/middleware.mjs");
+    expect(left?.deps).toEqual([]);
+    expect(() => run(left)).toThrow(
+      "[akan-csr] node_modules/awaits/index.mjs was left out of the dev registry: a top-level await",
+    );
+    expect(logged).toEqual([
+      expect.stringContaining(
+        "[csr-dev] node_modules/awaits/index.mjs is left out of the dev registry: a top-level await",
+      ),
+    ]);
+    expect(logged[0]).toContain("(node_modules/awaits/index.mjs:1)");
+  });
+
+  test("app code Bun cannot build as CommonJS still fails the build with Bun's messages", async () => {
+    const failure = await compile("apps/demo/ui/awaits.ts").catch((error: unknown) => error);
+    expect(failure).toBeInstanceOf(AggregateError);
+    expect(String((failure as AggregateError).errors[0])).toContain('"await" can only be used');
+  });
+});