@akanjs/devkit 3.0.0-beta.9 → 3.0.0

package/transforms/barrelImportsPlugin.ts

@@ -3,17 +3,12 @@ import type { BunPlugin } from "bun";
 import ts from "typescript";
 import type { App } from "../commandDecorators";
 import { BarrelAnalyzer, type BarrelExportMap, type PackageEntry } from "./barrelAnalyzer";
+import { loaderFor, type NamedItem, parseNamedList } from "./moduleSyntax";
 
 export interface BarrelImportsPluginOptions {
-  /** Absolute paths whose content should be returned unchanged (e.g. node_modules). */
+  /** Absolute paths whose content is returned unchanged (e.g. node_modules). */
   skipPath?: (absPath: string) => boolean;
-  /**
-   * Optional transform applied after the barrel rewrite in the same onLoad
-   * pass. Useful to chain further transforms (e.g. `"use client"` stubbing)
-   * that would otherwise be blocked — Bun's `onLoad` cannot fall through to a
-   * second plugin once a response is returned.
-   * Return the transformed source, or `null` to indicate no change.
-   */
+  /** Runs after the rewrite in the same onLoad (Bun's onLoad cannot fall through); null means no change. */
   pipeAfter?: (source: string, args: { path: string }) => string | Promise<string | null> | null;
 }
 
@@ -30,13 +25,8 @@ export const createBarrelImportsPlugin = async (
   return {
     name: "barrel-imports",
     setup(build) {
-      // Exclude third-party node_modules, but keep node_modules/akanjs in generated
-      // workspaces so framework `"use client"` modules are still stubbed for RSC.
-      //
-      // The optional `(\?v=\d+)?` tail lets the filter match paths that HMR
-      // has version-tagged (`./_index.tsx?v=3`). We strip the query before
-      // reading and normalize it away from the path we pass downstream so
-      // only the cache-bust `pipeAfter` step (if any) knows about it.
+      // node_modules/akanjs stays in: framework `"use client"` modules still need RSC stubbing in generated workspaces.
+      // The optional `?v=N` tail matches HMR cache-busted paths; it is stripped before reading.
       build.onLoad(
         {
           filter:
@@ -45,27 +35,12 @@ export const createBarrelImportsPlugin = async (
         async (args) => {
           const realPath = args.path.replace(/\?v=\d+$/, "");
           const loader = loaderFor(realPath);
-          if (skipPath(realPath)) {
-            const raw = await Bun.file(realPath).text();
-            return { contents: raw, loader };
-          }
-
           let source = await Bun.file(realPath).text();
+          if (skipPath(realPath)) return { contents: source, loader };
 
-          // Bun's macro evaluator has a race condition when the plugin returns
-          // rewritten source for a module that also contains
-          // `with { type: "macro" }` imports *and* another macro-host file is
-          // being evaluated concurrently in the same graph: one of the macro
-          // identifiers ends up undefined at runtime (e.g. `getSerializedSignal
-          // is not defined`). Returning the unmodified source for macro hosts
-          // sidesteps the race. The trade-off is that a handful of `useClient`-
-          // style files keep their original barrel imports; the rest of the
-          // tree still benefits from flattening.
-          const hasMacroAttr = MACRO_ATTR_RE.test(source);
-
-          if (!hasMacroAttr && barrels.length > 0) {
-            // The pre-check that used to live here — "does this file mention a barrel at all" — now
-            // lives inside `rewriteBarrelImports`, so every caller gets it rather than just this one.
+          // Bun's macro evaluator races when a rewritten module holds `with { type: "macro" }` imports while another
+          // macro host evaluates (a macro identifier ends up undefined), so macro hosts keep their barrel imports.
+          if (!MACRO_ATTR_RE.test(source) && barrels.length > 0) {
             const rewritten = await rewriteBarrelImports(source, barrels, analyzer);
             if (rewritten !== null) source = rewritten;
           }
@@ -82,24 +57,16 @@ export const createBarrelImportsPlugin = async (
   };
 };
 
-/**
- * Build a `resolvePackage` that maps a package specifier (like `akanjs/ui`)
- * to its barrel entry file using the workspace tsconfig `paths`. If no direct
- * mapping exists, falls back to node_modules resolution.
- */
+/** Resolves a package specifier to its barrel entry via tsconfig `paths`, falling back to node_modules. */
 export const createTsconfigPackageResolver = async (
   app: App,
 ): Promise<(pkgName: string) => Promise<PackageEntry | null>> => {
   const tsconfig = await app.getTsConfig();
   const tsconfigPaths = tsconfig.compilerOptions.paths ?? {};
-  // Pre-compute wildcard entries so we don't walk the full map per lookup.
-  // Longer prefixes sort first so `@libs/util/*` wins over `@libs/*`.
+  // Longest prefix first so `@libs/util/*` wins over `@libs/*`.
   const wildcardEntries = Object.entries(tsconfigPaths)
     .filter(([k]) => k.endsWith("/*"))
-    .map(([k, v]) => ({
-      prefix: k.slice(0, -1), // keep trailing `/`
-      replacements: v,
-    }))
+    .map(([k, v]) => ({ prefix: k.slice(0, -1), replacements: v }))
     .sort((a, b) => b.prefix.length - a.prefix.length);
 
   return async (pkgName) => {
@@ -109,34 +76,16 @@ export const createTsconfigPackageResolver = async (
       if (!raw) return null;
       const entryFile = path.resolve(app.workspace.workspaceRoot, raw);
       if (!(await Bun.file(entryFile).exists())) return null;
-      // Detect "facet" barrels: specifiers like `@libs/util/server` whose entry
-      // file is a sibling inside the parent directory (`libs/util/server.ts`)
-      // rather than an `index.*` inside a dedicated package directory
-      // (`libs/util/server/index.ts`). For facets, the subpath the analyzer
-      // generates for a leaf like `libs/util/lib/sig.ts` must be computed
-      // against the parent package (`@libs/util`) so that the rewritten
-      // import resolves via the workspace's `@libs/*` tsconfig wildcard
-      // (`libs/util/lib/sig`). Using the raw `pkgName` (`@libs/util/server`)
-      // would generate `@libs/util/server/lib/sig`, a path that does not exist
-      // on disk and cannot be imported.
+      // A facet barrel (`@libs/util/server` -> `libs/util/server.ts`) takes subpaths from its parent package, so a leaf
+      // rewrites to `@libs/util/lib/sig` (resolvable via `@libs/*`), not the missing `@libs/util/server/lib/sig`.
       const parsed = path.parse(entryFile);
       const lastSlash = pkgName.lastIndexOf("/");
-      if (parsed.name !== "index" && lastSlash !== -1) {
-        const facet = pkgName.slice(lastSlash + 1);
-        const parentSpec = pkgName.slice(0, lastSlash);
-        if (facet === parsed.name && parentSpec.length > 0) {
-          return { pkgName: parentSpec, entryFile, pkgDir: parsed.dir };
-        }
-      }
+      if (parsed.name !== "index" && lastSlash > 0 && pkgName.slice(lastSlash + 1) === parsed.name)
+        return { pkgName: pkgName.slice(0, lastSlash), entryFile, pkgDir: parsed.dir };
       return { pkgName, entryFile, pkgDir: path.dirname(entryFile) };
     }
 
-    // Wildcard fallback: tsconfig entries like `@libs/*` → `./libs/*` map a
-    // whole family of specifiers to workspace directories. Without this,
-    // barrels such as `@libs/util/ui` or `@apps/minimal/client` never resolve
-    // to an entry file — the analyzer returns `null`, the plugin skips them,
-    // and the consumer falls back to Bun's default resolution which loads the
-    // full barrel (pulling the entire transitive macro / side-effect graph).
+    // Without the wildcard fallback `@libs/util/ui`-style barrels never resolve and load whole, macro graph included.
     for (const { prefix, replacements } of wildcardEntries) {
       if (!pkgName.startsWith(prefix)) continue;
       const suffix = pkgName.slice(prefix.length);
@@ -144,41 +93,25 @@ export const createTsconfigPackageResolver = async (
         if (!repl) continue;
         const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
         const candidate = path.resolve(app.workspace.workspaceRoot, replPath + suffix);
-        // Try `candidate.<ext>` first (facet-barrel: sibling file like
-        // `apps/minimal/client.ts`). If it exists we treat the PARENT directory
-        // as `pkgDir` and the PARENT specifier (`@apps/minimal`) as `pkgName`
-        // so a leaf at `apps/minimal/lib/useClient.ts` rewrites to
-        // `@apps/minimal/lib/useClient` and resolves via the same `@apps/*`
-        // wildcard. Using the raw `pkgName` would yield
-        // `@apps/minimal/client/lib/useClient`, a path that does not exist.
+        // A sibling file (`apps/minimal/client.ts`) is a facet barrel too: parent specifier, as above.
         for (const ext of CANDIDATE_EXTS) {
           const file = `${candidate}${ext}`;
           if (await Bun.file(file).exists()) {
             const lastSlash = pkgName.lastIndexOf("/");
-            if (lastSlash !== -1) {
-              const parentSpec = pkgName.slice(0, lastSlash);
-              if (parentSpec.length > 0) {
-                return { pkgName: parentSpec, entryFile: file, pkgDir: path.dirname(file) };
-              }
-            }
-            return { pkgName, entryFile: file, pkgDir: path.dirname(file) };
+            const parentSpec = lastSlash > 0 ? pkgName.slice(0, lastSlash) : pkgName;
+            return { pkgName: parentSpec, entryFile: file, pkgDir: path.dirname(file) };
           }
         }
         for (const ext of CANDIDATE_EXTS) {
           const file = path.join(candidate, `index${ext}`);
-          if (await Bun.file(file).exists()) {
-            return { pkgName, entryFile: file, pkgDir: candidate };
-          }
+          if (await Bun.file(file).exists()) return { pkgName, entryFile: file, pkgDir: candidate };
         }
       }
-      // A prefix matched but nothing on disk — stop so a shorter, less specific
-      // prefix doesn't accidentally resolve to an unrelated location.
+      // A matched prefix with nothing on disk stops here, so a shorter prefix cannot resolve somewhere unrelated.
       return null;
     }
 
-    // Fallback: resolve package exports from node_modules. This supports
-    // single-package subpaths such as `akanjs/ui`, whose package.json lives at
-    // node_modules/akanjs/package.json rather than node_modules/akanjs/ui.
+    // `akanjs/ui` resolves through node_modules/akanjs/package.json exports, not node_modules/akanjs/ui.
     const exported = await resolveNodePackageExport(app.workspace.workspaceRoot, pkgName);
     if (exported) return exported;
 
@@ -226,8 +159,7 @@ const resolveNodePackageExport = async (workspaceRoot: string, specifier: string
     if (!rel?.startsWith(".")) return null;
     const entryFile = await resolveFileCandidate(path.resolve(pkgDir, rel));
     if (!entryFile) return null;
-    const pkgEntryName = specifier;
-    return { pkgName: pkgEntryName, entryFile, pkgDir: path.dirname(entryFile), preserveFilePath: true };
+    return { pkgName: specifier, entryFile, pkgDir: path.dirname(entryFile), preserveFilePath: true };
   } catch {
     return null;
   }
@@ -290,22 +222,14 @@ const resolveFileCandidate = async (candidate: string): Promise<string | null> =
   return null;
 };
 
-// Matches `with { type: "macro" }` import attributes (single or double quotes,
-// tolerant of whitespace). Used to detect macro-host modules so the plugin
-// can leave their source untouched.
 const MACRO_ATTR_RE = /with\s*\{\s*type\s*:\s*["']macro["']\s*\}/;
 
-/** Exposed for testing. */
 export const rewriteBarrelImports = async (
   source: string,
   barrels: string[],
   analyzer: BarrelAnalyzer,
 ): Promise<string | null> => {
-  // Establish there is something to rewrite before the TypeScript parser is involved. This runs on
-  // every source file of every dev rebuild, and parsing was by far the most expensive thing in one:
-  // measured across 1189 files here, 299ms and 161MB of RSS, of which **63% of files import no barrel
-  // at all**. A static import cannot name a specifier without that specifier appearing literally in the
-  // text, so a substring test is a sound filter and costs 4ms for the whole corpus.
+  // Sound pre-filter before the costly parse: a static import cannot name a specifier absent from the text.
   if (!barrels.some((barrel) => source.includes(barrel))) return null;
   const statements = findImportStatements(source);
   if (statements.length === 0) return null;
@@ -332,15 +256,11 @@ interface ImportStatement {
   end: number;
   clause: string;
   specifier: string;
-  trailingSemicolon: boolean;
-  raw: string;
 }
 
 const findImportStatements = (source: string): ImportStatement[] => {
   const statements: ImportStatement[] = [];
-  // `setParentNodes: false`: nothing below reads `node.parent`, and every position comes from
-  // `getStart(sourceFile)`, which takes the file explicitly. Building the parent links cost 132ms and
-  // 143MB of RSS across 1189 files for no reader.
+  // `setParentNodes: false` holds only while nothing reads `node.parent` and positions use `getStart(sourceFile)`.
   const sourceFile = ts.createSourceFile(
     "barrel-imports.tsx",
     source,
@@ -353,31 +273,20 @@ const findImportStatements = (source: string): ImportStatement[] => {
     if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
     const importClause = statement.importClause;
     if (!importClause) continue;
-    const statementStart = statement.getStart(sourceFile);
-    const statementEnd = statement.end;
     statements.push({
-      start: statementStart,
-      end: statementEnd,
+      start: statement.getStart(sourceFile),
+      end: statement.end,
       clause: source.slice(importClause.getStart(sourceFile), importClause.end).trim(),
       specifier: statement.moduleSpecifier.text,
-      trailingSemicolon: source.slice(statement.moduleSpecifier.end, statement.end).includes(";"),
-      raw: source.slice(statementStart, statementEnd),
     });
   }
   return statements;
 };
 
-interface NamedImportItem {
-  imported: string;
-  local: string;
-  isType: boolean;
-}
-
 interface ParsedClause {
   defaultImport?: string;
   namespaceImport?: string;
-  named?: NamedImportItem[];
-  /** Whole clause is `import type { ... } from "..."`. */
+  named?: NamedItem[];
   typeOnly: boolean;
 }
 
@@ -389,7 +298,6 @@ const parseImportClause = (clause: string): ParsedClause | null => {
     rest = rest.slice(5).trim();
   }
   const parsed: ParsedClause = { typeOnly };
-  // Try pattern: default + rest
   const commaMatch = /^(\w+)\s*,\s*(.+)$/.exec(rest);
   if (commaMatch) {
     parsed.defaultImport = commaMatch[1];
@@ -407,36 +315,11 @@ const parseImportClause = (clause: string): ParsedClause | null => {
   if (rest.startsWith("{")) {
     const close = rest.indexOf("}");
     if (close === -1) return null;
-    const inner = rest.slice(1, close);
-    parsed.named = parseNamedImportList(inner);
-    return parsed;
+    parsed.named = parseNamedList(rest.slice(1, close));
   }
   return parsed;
 };
 
-const parseNamedImportList = (body: string): NamedImportItem[] => {
-  const out: NamedImportItem[] = [];
-  for (const raw of body.split(",")) {
-    const s = raw.trim();
-    if (!s) continue;
-    let isType = false;
-    let rest = s;
-    if (rest.startsWith("type ")) {
-      isType = true;
-      rest = rest.slice(5).trim();
-    }
-    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
-    if (asMatch) {
-      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
-      continue;
-    }
-    if (/^\w+$/.test(rest)) {
-      out.push({ imported: rest, local: rest, isType });
-    }
-  }
-  return out;
-};
-
 const rewriteSingleStatement = (stmt: ImportStatement, map: BarrelExportMap): string | null => {
   const clause = parseImportClause(stmt.clause);
   if (!clause) return null;
@@ -444,13 +327,10 @@ const rewriteSingleStatement = (stmt: ImportStatement, map: BarrelExportMap): st
   if (clause.namespaceImport) return null;
   // Pure type imports are erased at build; leave them alone.
   if (clause.typeOnly && !clause.defaultImport) return null;
-  if (!clause.named || clause.named.length === 0) {
-    // Only default import — nothing to split.
-    return null;
-  }
+  if (!clause.named?.length) return null;
 
-  const remaining: NamedImportItem[] = [];
-  const rewrites = new Map<string, NamedImportItem[]>();
+  const remaining: NamedItem[] = [];
+  const rewrites = new Map<string, NamedItem[]>();
   for (const item of clause.named) {
     if (item.isType) {
       remaining.push(item);
@@ -462,7 +342,6 @@ const rewriteSingleStatement = (stmt: ImportStatement, map: BarrelExportMap): st
       continue;
     }
     const list = rewrites.get(target.subpath) ?? [];
-    // Use the leaf's original name, keeping the consumer's local alias.
     list.push({ imported: target.originalName, local: item.local, isType: false });
     rewrites.set(target.subpath, list);
   }
@@ -470,26 +349,17 @@ const rewriteSingleStatement = (stmt: ImportStatement, map: BarrelExportMap): st
   if (rewrites.size === 0) return null;
 
   const lines: string[] = [];
-  // Always emit trailing semicolons; safe even when the source omitted them.
-  const tail = ";";
+  if (shouldPreserveBarrelSideEffects(stmt.specifier)) lines.push(`import "${stmt.specifier}";`);
 
-  if (shouldPreserveBarrelSideEffects(stmt.specifier)) {
-    lines.push(`import "${stmt.specifier}"${tail}`);
-  }
-
-  // Re-emit an import from the original barrel that carries whatever we could
-  // not flatten (default import, type-only items, unknown names).
   if (clause.defaultImport || remaining.length > 0) {
     const parts: string[] = [];
     if (clause.defaultImport) parts.push(clause.defaultImport);
-    if (remaining.length > 0) {
-      parts.push(`{ ${remaining.map(serializeNamedItem).join(", ")} }`);
-    }
-    lines.push(`import ${parts.join(", ")} from "${stmt.specifier}"${tail}`);
+    if (remaining.length > 0) parts.push(`{ ${remaining.map(serializeNamedItem).join(", ")} }`);
+    lines.push(`import ${parts.join(", ")} from "${stmt.specifier}";`);
   }
 
   for (const [subpath, items] of rewrites) {
-    lines.push(`import { ${items.map(serializeNamedItem).join(", ")} } from "${subpath}"${tail}`);
+    lines.push(`import { ${items.map(serializeNamedItem).join(", ")} } from "${subpath}";`);
   }
 
   return lines.join("\n");
@@ -497,15 +367,8 @@ const rewriteSingleStatement = (stmt: ImportStatement, map: BarrelExportMap): st
 
 const shouldPreserveBarrelSideEffects = (specifier: string): boolean => /^@(apps|libs)\/[^/]+\/client$/.test(specifier);
 
-const serializeNamedItem = (item: NamedImportItem): string => {
+const serializeNamedItem = (item: NamedItem): string => {
   const prefix = item.isType ? "type " : "";
   if (item.imported === item.local) return `${prefix}${item.imported}`;
   return `${prefix}${item.imported} as ${item.local}`;
 };
-
-const loaderFor = (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";
-};

package/transforms/externalizeFrameworkPlugin.test.ts

@@ -1,70 +1,46 @@
-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 { createExternalizeFrameworkPlugin } from "./externalizeFrameworkPlugin";
 
-const tempRoots: string[] = [];
+const makeTempRoot = tempDirs("akan-devkit-externalize-");
 
-const makeTempRoot = async () => {
-  const root = await mkdtemp(path.join(os.tmpdir(), "akan-devkit-externalize-"));
-  tempRoots.push(root);
-  return root;
+const akanServerPaths = {
+  akanjs: ["./pkgs/akanjs/index.ts"],
+  "akanjs/*": ["./pkgs/akanjs/*"],
+  "akanjs/server": ["./pkgs/akanjs/server/index.ts"],
+  "akanjs/server/*": ["./pkgs/akanjs/server/*"],
 };
 
-const write = async (filePath: string, content: string) => {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, content);
+const bundle = async (root: string, paths: Record<string, string[]>, entryLines: string[]) => {
+  const entry = path.join(root, "entry.ts");
+  await write(entry, [...entryLines, ""].join("\n"));
+  const plugin = await createExternalizeFrameworkPlugin({
+    app: { workspace: { workspaceRoot: root }, getTsConfig: async () => ({ compilerOptions: { paths } }) } as never,
+  });
+  const result = await Bun.build({
+    entrypoints: [entry],
+    outdir: path.join(root, "out"),
+    target: "bun",
+    format: "esm",
+    plugins: [plugin],
+  });
+  expect(result.success).toBe(true);
+  return await result.outputs.find((artifact) => artifact.kind === "entry-point")?.text();
 };
 
-afterEach(async () => {
-  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
-});
-
 describe("createExternalizeFrameworkPlugin", () => {
   test("bundles akanjs/server workspace sources into production pages artifacts", async () => {
     const root = await makeTempRoot();
-    const entry = path.join(root, "entry.ts");
-    const outdir = path.join(root, "out");
-    await write(
-      entry,
-      [
-        'import { optionMarker } from "akanjs/server";',
-        'import { tryMarker } from "akanjs/server/decorators";',
-        'import { jsx } from "react/jsx-runtime";',
-        "export const markers = [optionMarker, tryMarker, jsx];",
-        "",
-      ].join("\n"),
-    );
     await write(path.join(root, "pkgs/akanjs/server/index.ts"), 'export const optionMarker = "akan-option";\n');
     await write(path.join(root, "pkgs/akanjs/server/decorators.ts"), 'export const tryMarker = "akan-try";\n');
 
-    const plugin = await createExternalizeFrameworkPlugin({
-      app: {
-        workspace: { workspaceRoot: root },
-        getTsConfig: async () => ({
-          compilerOptions: {
-            paths: {
-              akanjs: ["./pkgs/akanjs/index.ts"],
-              "akanjs/*": ["./pkgs/akanjs/*"],
-              "akanjs/server": ["./pkgs/akanjs/server/index.ts"],
-              "akanjs/server/*": ["./pkgs/akanjs/server/*"],
-            },
-          },
-        }),
-      } as never,
-    });
-
-    const result = await Bun.build({
-      entrypoints: [entry],
-      outdir,
-      target: "bun",
-      format: "esm",
-      plugins: [plugin],
-    });
-
-    expect(result.success).toBe(true);
-    const output = await result.outputs.find((artifact) => artifact.kind === "entry-point")?.text();
+    const output = await bundle(root, akanServerPaths, [
+      'import { optionMarker } from "akanjs/server";',
+      'import { tryMarker } from "akanjs/server/decorators";',
+      'import { jsx } from "react/jsx-runtime";',
+      "export const markers = [optionMarker, tryMarker, jsx];",
+    ]);
     expect(output).toContain("akan-option");
     expect(output).toContain("akan-try");
     expect(output).not.toMatch(/from\s+["']akanjs\/server(?:\/decorators)?["']/);
@@ -73,17 +49,6 @@ describe("createExternalizeFrameworkPlugin", () => {
 
   test("externalizes optional backend dependencies reached through bundled akanjs/server sources", async () => {
     const root = await makeTempRoot();
-    const entry = path.join(root, "entry.ts");
-    const outdir = path.join(root, "out");
-    await write(
-      entry,
-      [
-        'import { optionMarker, redisLoader } from "akanjs/server";',
-        "export const marker = optionMarker;",
-        "export const loader = redisLoader;",
-        "",
-      ].join("\n"),
-    );
     await write(
       path.join(root, "pkgs/akanjs/server/index.ts"),
       [
@@ -99,32 +64,11 @@ describe("createExternalizeFrameworkPlugin", () => {
       'export const loadRedis = async () => import("ioredis");\n',
     );
 
-    const plugin = await createExternalizeFrameworkPlugin({
-      app: {
-        workspace: { workspaceRoot: root },
-        getTsConfig: async () => ({
-          compilerOptions: {
-            paths: {
-              akanjs: ["./pkgs/akanjs/index.ts"],
-              "akanjs/*": ["./pkgs/akanjs/*"],
-              "akanjs/server": ["./pkgs/akanjs/server/index.ts"],
-              "akanjs/server/*": ["./pkgs/akanjs/server/*"],
-            },
-          },
-        }),
-      } as never,
-    });
-
-    const result = await Bun.build({
-      entrypoints: [entry],
-      outdir,
-      target: "bun",
-      format: "esm",
-      plugins: [plugin],
-    });
-
-    expect(result.success).toBe(true);
-    const output = await result.outputs.find((artifact) => artifact.kind === "entry-point")?.text();
+    const output = await bundle(root, akanServerPaths, [
+      'import { optionMarker, redisLoader } from "akanjs/server";',
+      "export const marker = optionMarker;",
+      "export const loader = redisLoader;",
+    ]);
     expect(output).toContain("akan-option");
     expect(output).toContain("ioredis");
     expect(output).not.toMatch(/from\s+["']akanjs\/(?:server|service)["']/);
@@ -132,17 +76,6 @@ describe("createExternalizeFrameworkPlugin", () => {
 
   test("lets published akanjs package exports resolve when workspace paths are absent", async () => {
     const root = await makeTempRoot();
-    const entry = path.join(root, "entry.ts");
-    const outdir = path.join(root, "out");
-    await write(
-      entry,
-      [
-        'import { optionMarker } from "akanjs/server";',
-        'import { jsx } from "react/jsx-runtime";',
-        "export const markers = [optionMarker, jsx];",
-        "",
-      ].join("\n"),
-    );
     await write(
       path.join(root, "node_modules/akanjs/package.json"),
       JSON.stringify({
@@ -161,23 +94,11 @@ describe("createExternalizeFrameworkPlugin", () => {
       'export const optionMarker = "published-option";\n',
     );
 
-    const plugin = await createExternalizeFrameworkPlugin({
-      app: {
-        workspace: { workspaceRoot: root },
-        getTsConfig: async () => ({ compilerOptions: { paths: {} } }),
-      } as never,
-    });
-
-    const result = await Bun.build({
-      entrypoints: [entry],
-      outdir,
-      target: "bun",
-      format: "esm",
-      plugins: [plugin],
-    });
-
-    expect(result.success).toBe(true);
-    const output = await result.outputs.find((artifact) => artifact.kind === "entry-point")?.text();
+    const output = await bundle(root, {}, [
+      'import { optionMarker } from "akanjs/server";',
+      'import { jsx } from "react/jsx-runtime";',
+      "export const markers = [optionMarker, jsx];",
+    ]);
     expect(output).toContain("published-option");
     expect(output).not.toMatch(/from\s+["']akanjs\/server["']/);
     expect(output).toContain("react/jsx-runtime");