@akanjs/devkit 3.2.0-rc.1 → 3.2.0-rc.3

package/frontendBuild/csrDevPatcher.ts

@@ -4,7 +4,7 @@ import { appGenerationOf, CSR_DEV_MANIFEST_FILE, type CsrDevManifest } from "aka
 import type { CsrDevCompileResult } from "./csrDevModuleCompiler";
 import { CsrDevPaths } from "./csrDevPaths";
 import { CsrDevResolver } from "./csrDevResolver";
-import type { CsrDevCode, CsrDevContext, CsrDevGraph } from "./csrDevTypes";
+import type { CsrDevBarrelStamp, CsrDevCode, CsrDevContext, CsrDevGraph } from "./csrDevTypes";
 import type { CsrDevUpdate, CsrDevUpdateOptions, DevRegistryBundler } from "./devRegistryBundler";
 
 interface CsrDevPatcherState {
@@ -109,6 +109,7 @@ export class CsrDevPatcher {
     const present = CsrDevPatcher.#presence(changedFiles);
     const forgotten = this.#forgetDeletedModules(state, present);
     const changed = onlyRoots ? new Set<string>() : await this.#changedModules(graph, changedFiles, present);
+    const restamped = onlyRoots ? null : await this.#renarrowed(context, graph, changedFiles, changed);
     for (const id of this.#withoutFactory(state, present)) changed.add(id);
     for (const file of entries.changed) changed.add(paths.idOf(file));
     const rootFiles = [...Object.values(entries.files), ...roots.filter((file) => fs.existsSync(file))];
@@ -121,6 +122,8 @@ export class CsrDevPatcher {
       this.#bundler.reloadsOnEntryChange &&
       (entries.changed.length > 0 || JSON.stringify(entryIds) !== JSON.stringify(graph.entries));
     if (changed.size === 0) {
+      //? No importer moved (none compiles), so the restamped barrels already hold.
+      if (restamped) graph.barrels = { ...graph.barrels, ...restamped };
       if (carried.length === 0) return { kind: "unchanged" };
       return await this.#retryCarried(context, state, carried, { announce, allowWholeAppBuilds });
     }
@@ -188,15 +191,11 @@ export class CsrDevPatcher {
       forgotten.push(id);
     }
     graph.pending = graph.pending.filter((id) => !orphans.includes(id));
-    this.#bundler.merge(graph, resolver, compiled);
+    this.#bundler.merge(graph, resolver, compiled, { ...restamped, ...result.barrels });
     if (!this.#resident) delete graph.failed;
     for (const module of compiled) this.#delegated.delete(module.id);
     graph.entries = entryIds;
-    for (const module of compiled) {
-      if (module.vendor || !code) continue;
-      code.modules.set(module.id, module.factory);
-      if (module.helpers) code.helpers.set(module.helpers.hash, module.helpers.definition);
-    }
+    if (code) CsrDevPatcher.#remember(code, compiled);
     const changedIds = compiled.filter((module) => !module.vendor).map((module) => module.id);
     const constantId = changedIds.find((id) => id.endsWith(".constant.ts"));
     // A model class swapped under live store state would mix old and new instances; reload instead.
@@ -359,6 +358,7 @@ export class CsrDevPatcher {
       modules: [...result.modules, ...more.modules],
       refusedVendors: [...result.refusedVendors, ...more.refusedVendors],
       unresolved: [...result.unresolved, ...more.unresolved],
+      barrels: { ...result.barrels, ...more.barrels },
     };
   }
 
@@ -508,6 +508,46 @@ export class CsrDevPatcher {
     return changed;
   }
 
+  //? The new stamps go into the graph with the compile that follows (`merge`), never ahead of it: a round that fails or
+  //? is handed back must leave the barrel stale for the next one.
+  async #renarrowed(
+    context: CsrDevContext,
+    graph: CsrDevGraph,
+    changedFiles: string[],
+    changed: Set<string>,
+  ): Promise<Record<string, CsrDevBarrelStamp>> {
+    const { paths } = this.#bundler;
+    const saved = new Set(changedFiles.map((file) => paths.idOf(file)));
+    const stale = Object.entries(graph.barrels ?? {})
+      .filter(([, { read }]) =>
+        Object.entries(read).some(
+          ([id, mtimeMs]) => saved.has(id) || CsrDevPaths.mtimeOf(paths.fileOf(id)) !== mtimeMs,
+        ),
+      )
+      .map(([barrel]) => barrel);
+    const barrelImports = stale.length > 0 ? await this.#bundler.barrelImports(context) : null;
+    if (!barrelImports) return {};
+    const barrels = await barrelImports.stamps(stale, (file) => paths.idOf(file));
+    const moved = stale.filter((barrel) => barrels[barrel]?.digest !== graph.barrels?.[barrel]?.digest);
+    for (const [id, module] of Object.entries(graph.modules)) {
+      for (const barrel of moved) {
+        const narrowed = module.narrowed?.[barrel];
+        if (!narrowed || (await barrelImports.fingerprint(barrel, narrowed.names)) === narrowed.hash) continue;
+        changed.add(id);
+        break;
+      }
+    }
+    return barrels;
+  }
+
+  static #remember(code: CsrDevCode, compiled: CsrDevCompileResult["modules"]) {
+    for (const module of compiled) {
+      if (module.vendor) continue;
+      code.modules.set(module.id, module.factory);
+      if (module.helpers) code.helpers.set(module.helpers.hash, module.helpers.definition);
+    }
+  }
+
   //? A new file can take over a relative import another module already resolved (`Foo.tsx` created beside
   //? `Foo/index.tsx`), with no change to that module's own text: it compiles again, and resolves against the disk.
   #shadowedImporters(graph: CsrDevGraph, changedFiles: string[]): string[] {

package/frontendBuild/csrDevTypes.ts

@@ -1,11 +1,24 @@
 import type { PageEntry } from "../artifact/implicitRootLayout";
 
+export interface CsrDevNarrowedImport {
+  names: string[];
+  hash: string;
+}
+
+export interface CsrDevBarrelStamp {
+  /** The mtime of each file and directory the barrel's analysis read, by id. */
+  read: Record<string, number>;
+  /** Each export name with the file it resolves to, hashed: what every importer's narrowing reads. */
+  digest: string;
+}
+
 export interface CsrDevGraphModule {
   vendor: boolean;
   mtimeMs: number;
   hash: string;
   deps: string[];
   helpers?: string;
+  narrowed?: Record<string, CsrDevNarrowedImport>;
 }
 
 export interface CsrDevGraph {
@@ -22,6 +35,7 @@ export interface CsrDevGraph {
   failed?: { roots: string[]; files: Record<string, string> };
   /** The stamp of the signal and dictionary sources the last whole build inlined; see `RegistryMetadataFingerprint`. */
   metadata?: string;
+  barrels?: Record<string, CsrDevBarrelStamp>;
 }
 
 export interface CsrDevContext {
@@ -35,6 +49,7 @@ export interface CsrDevContext {
   refreshFile: string | null;
   /** Bare specifiers the page already loads (an SSR page's import map): required as `vendor:<specifier>`, not compiled. */
   externals?: readonly string[];
+  barrelImports?: readonly string[];
 }
 
 export interface CsrDevSharedHelpers {
@@ -52,6 +67,7 @@ export interface CsrDevCompiledModule {
   deps: string[];
   mtimeMs: number;
   hash: string;
+  narrowed?: Record<string, CsrDevNarrowedImport>;
 }
 
 /** Module factories by id and helper definitions by hash, kept in memory so app.js is written without a pass over the disk. */

package/frontendBuild/cssCompiler.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, test } from "bun:test";
-import { declaredCustomProperties } from "./cssCompiler";
+import path from "node:path";
+import { tempDirs, writeText as write } from "../testHelpers";
+import { CssCompiler, declaredCustomProperties } from "./cssCompiler";
+
+const makeTempRoot = tempDirs("akan-css-compiler-");
 
 describe("declaredCustomProperties", () => {
   test("names what the regex-based version named", () => {
@@ -51,3 +55,61 @@ describe("declaredCustomProperties", () => {
     }
   });
 });
+
+describe("CssCompiler.discoverCssAndSources", () => {
+  test("scans the files a page reaches through a client barrel's narrowed imports, never the barrel's other modules", async () => {
+    const root = await makeTempRoot();
+    const paths = { "@apps/*": ["./apps/*"], "@libs/*": ["./libs/*"] };
+    const writeSys = async (dir: string, modules: string[]) => {
+      await write(
+        path.join(dir, "client.ts"),
+        [
+          'export * as cnst from "./lib/cnst";',
+          'export { msg, usePage } from "./lib/useClient";',
+          'export { st, RootStore } from "./lib/st";',
+          ...modules.map((name) => `export { ${name} } from "./lib/${name.toLowerCase()}";`),
+          "",
+        ].join("\n"),
+      );
+      await write(path.join(dir, "lib/cnst.ts"), "export const Sample = 1;\n");
+      await write(path.join(dir, "lib/useClient.ts"), "export const msg = 1;\nexport const usePage = () => msg;\n");
+      for (const name of modules) {
+        await write(
+          path.join(dir, `lib/${name.toLowerCase()}/index.ts`),
+          `import * as Zone from "./${name}.Zone";\nexport const ${name} = { Zone };\n`,
+        );
+        await write(path.join(dir, `lib/${name.toLowerCase()}/${name}.Zone.tsx`), 'export const Card = () => "p-4";\n');
+      }
+    };
+    const appDir = path.join(root, "apps/demo");
+    await writeSys(appDir, ["Memo", "Other"]);
+    await writeSys(path.join(root, "libs/kit"), ["Widget"]);
+    await write(path.join(root, "libs/kit/lib/st.ts"), "export class RootStore {}\nexport const st = {};\n");
+    await write(
+      path.join(appDir, "lib/st.ts"),
+      'import { RootStore as kit } from "@libs/kit/client";\nexport class RootStore {}\nexport const st = { kit };\n',
+    );
+    await write(
+      path.join(appDir, "page/_index.tsx"),
+      'import { Memo, st } from "@apps/demo/client";\nexport default function Page() { return [Memo, st]; }\n',
+    );
+    const app = {
+      cwdPath: appDir,
+      workspace: { workspaceRoot: root },
+      getTsConfig: async () => ({ compilerOptions: { paths } }),
+      getConfig: async () => ({ barrelImports: ["@apps/demo/client", "@libs/kit/client"] }),
+    };
+
+    const { sourcePaths } = await new CssCompiler(app as never).discoverCssAndSources({ pageKeys: ["_index.tsx"] });
+
+    expect(sourcePaths.map((file) => path.relative(root, file)).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))).toEqual([
+      "apps/demo/lib/memo/Memo.Zone.tsx",
+      "apps/demo/lib/memo/index.ts",
+      "apps/demo/lib/st.ts",
+      "apps/demo/lib/useClient.ts",
+      "apps/demo/page/_index.tsx",
+      "libs/kit/lib/st.ts",
+      "libs/kit/lib/useClient.ts",
+    ]);
+  });
+});

package/frontendBuild/devBarrelImports.ts

@@ -0,0 +1,132 @@
+import path from "node:path";
+import type { App } from "../commandDecorators";
+import { BarrelAnalyzer, type PackageEntry } from "../transforms/barrelAnalyzer";
+import { createTsconfigPackageResolver, rewriteBarrelImports } from "../transforms/barrelImportsPlugin";
+import { CsrDevPaths } from "./csrDevPaths";
+import type { CsrDevBarrelStamp, CsrDevNarrowedImport } from "./csrDevTypes";
+
+export interface DevBarrelRewrite {
+  contents: string | null;
+  narrowed: Record<string, CsrDevNarrowedImport>;
+}
+
+//* Targets are written as relative paths, which resolve against the disk with no resolution build: a save that adds a
+//* barrel import stays a patch.
+export class DevBarrelImports {
+  readonly #barrels: string[];
+  readonly #resolvePackage: (pkgName: string) => Promise<PackageEntry | null>;
+  readonly #analyzer: BarrelAnalyzer;
+  readonly #packages = new Map<string, Promise<PackageEntry | null>>();
+
+  constructor(barrels: readonly string[], resolvePackage: (pkgName: string) => Promise<PackageEntry | null>) {
+    this.#barrels = [...barrels];
+    this.#resolvePackage = resolvePackage;
+    this.#analyzer = new BarrelAnalyzer({ resolvePackage });
+  }
+
+  static async create(app: App, barrels: readonly string[]): Promise<DevBarrelImports | null> {
+    if (barrels.length === 0) return null;
+    return new DevBarrelImports(barrels, await createTsconfigPackageResolver(app));
+  }
+
+  async rewrite(source: string, importer: string): Promise<DevBarrelRewrite | null> {
+    const named = this.#barrels.filter((barrel) => source.includes(barrel));
+    if (named.length === 0) return null;
+    const packages = await this.#packagesOf(named);
+    const from = path.dirname(CsrDevPaths.realpath(importer));
+    const names = new Map<string, Set<string>>();
+    const contents = await rewriteBarrelImports(source, named, this.#analyzer, {
+      keepLines: true,
+      specifierOf: (subpath) => DevBarrelImports.#relative(subpath, from, packages),
+      onImport: (barrel, imported) => names.set(barrel, new Set([...(names.get(barrel) ?? []), ...imported])),
+    });
+    const narrowed = await Promise.all(
+      [...names].map(async ([barrel, set]) => {
+        const sorted = [...set].sort();
+        return [barrel, { names: sorted, hash: await this.fingerprint(barrel, sorted) }] as const;
+      }),
+    );
+    return { contents, narrowed: Object.fromEntries(narrowed) };
+  }
+
+  //? Hashes what an import of these names alone narrows to, with each target as the file it resolves to: the same
+  //? names in another importer narrow to the same files, and only a moved export or a moved file changes it.
+  async fingerprint(barrel: string, names: string[]): Promise<string> {
+    const packages = await this.#packagesOf([barrel]);
+    const aliased = names.map((name, index) => `${name} as _${index}`).join(", ");
+    const narrowed = await rewriteBarrelImports(
+      `import { ${aliased} } from ${JSON.stringify(barrel)};`,
+      [barrel],
+      this.#analyzer,
+      { specifierOf: (subpath) => DevBarrelImports.#fileOf(subpath, packages) ?? subpath },
+    );
+    return Bun.hash(narrowed ?? "").toString(36);
+  }
+
+  async stamps(barrels: Iterable<string>, idOf: (file: string) => string): Promise<Record<string, CsrDevBarrelStamp>> {
+    const stamped = await Promise.all(
+      [...barrels].map(async (barrel) => {
+        const files = await this.#analyzer.filesOf(barrel);
+        const read = [...new Set([...files, ...files.map((file) => path.dirname(file))])];
+        const stamp: CsrDevBarrelStamp = {
+          read: Object.fromEntries(read.map((file) => [idOf(file), CsrDevPaths.mtimeOf(file)])),
+          digest: await this.#digest(barrel),
+        };
+        return [barrel, stamp] as const;
+      }),
+    );
+    return Object.fromEntries(stamped);
+  }
+
+  //? Every input of an importer's fingerprint: an importer is hashed again only once this moves, so a save that
+  //? changes a component's body costs one analysis of its barrel, whatever the number of importers.
+  async #digest(barrel: string): Promise<string> {
+    const map = await this.#analyzer.analyze(barrel);
+    const packages = await this.#packagesOf([barrel]);
+    const files = new Map<string, string>();
+    const fileOf = (subpath: string) => {
+      let file = files.get(subpath);
+      if (file === undefined) {
+        file = DevBarrelImports.#fileOf(subpath, packages) ?? subpath;
+        files.set(subpath, file);
+      }
+      return file;
+    };
+    const exports = [...(map ?? [])]
+      .map(([name, target]) => [name, target.originalName, !!target.namespace, fileOf(target.subpath)] as const)
+      .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    return Bun.hash(JSON.stringify([fileOf(barrel), map === null, exports])).toString(36);
+  }
+
+  async #packagesOf(barrels: string[]): Promise<PackageEntry[]> {
+    return (await Promise.all(barrels.map((barrel) => this.#packageOf(barrel))))
+      .filter((pkg): pkg is PackageEntry => pkg !== null)
+      .sort((a, b) => b.pkgName.length - a.pkgName.length);
+  }
+
+  #packageOf(barrel: string): Promise<PackageEntry | null> {
+    let pkg = this.#packages.get(barrel);
+    if (!pkg) {
+      pkg = this.#resolvePackage(barrel);
+      this.#packages.set(barrel, pkg);
+    }
+    return pkg;
+  }
+
+  static #fileOf(subpath: string, packages: PackageEntry[]): string | null {
+    const pkg = packages.find(({ pkgName }) => subpath === pkgName || subpath.startsWith(`${pkgName}/`));
+    if (!pkg) return null;
+    const file = CsrDevPaths.resolveOnDisk(path.join(pkg.pkgDir, subpath.slice(pkg.pkgName.length)));
+    return file ? CsrDevPaths.realpath(file) : null;
+  }
+
+  static #relative(subpath: string, from: string, packages: PackageEntry[]): string {
+    const file = DevBarrelImports.#fileOf(subpath, packages);
+    if (!file) return subpath;
+    const relative = path.relative(from, file);
+    //? A target on another Windows drive has no relative path: `path.relative` returns it absolute.
+    if (path.isAbsolute(relative)) return file.split(path.sep).join("/");
+    const posix = relative.split(path.sep).join("/");
+    return posix.startsWith("../") ? posix : `./${posix}`;
+  }
+}

package/frontendBuild/devRegistryBundler.ts

@@ -7,7 +7,8 @@ import { CsrDevModuleCompiler } from "./csrDevModuleCompiler";
 import { CsrDevPatcher } from "./csrDevPatcher";
 import { CsrDevPaths } from "./csrDevPaths";
 import { CsrDevResolver } from "./csrDevResolver";
-import type { CsrDevCompiledModule, CsrDevContext, CsrDevGraph } from "./csrDevTypes";
+import type { CsrDevBarrelStamp, CsrDevCompiledModule, CsrDevContext, CsrDevGraph } from "./csrDevTypes";
+import { DevBarrelImports } from "./devBarrelImports";
 import { RegistryMetadataFingerprint } from "./registryMetadataFingerprint";
 import { WatchRootResolver } from "./watchRootResolver";
 
@@ -131,7 +132,7 @@ export abstract class DevRegistryBundler {
     const resolver = new CsrDevResolver({ paths: this.paths, context, entryFiles: roots });
     await resolver.prepass();
     const compiler = this.compiler(context, resolver);
-    const { modules: compiled } = await compiler.compile(
+    const { modules: compiled, barrels } = await compiler.compile(
       [...roots, ...(context.refreshFile ? [context.refreshFile] : [])],
       new Set(),
     );
@@ -147,7 +148,7 @@ export abstract class DevRegistryBundler {
       pending: [],
       metadata,
     };
-    this.merge(graph, resolver, compiled);
+    this.merge(graph, resolver, compiled, barrels);
     await this.writer.markBuilding();
     await this.writer.writeModules(compiled);
     const vendorFile = await this.writer.writeVendor(graph);
@@ -170,7 +171,16 @@ export abstract class DevRegistryBundler {
     });
   }
 
-  merge(graph: CsrDevGraph, resolver: CsrDevResolver, compiled: CsrDevCompiledModule[]): void {
+  async barrelImports(context: CsrDevContext): Promise<DevBarrelImports | null> {
+    return await DevBarrelImports.create(this.app, context.barrelImports ?? []);
+  }
+
+  merge(
+    graph: CsrDevGraph,
+    resolver: CsrDevResolver,
+    compiled: CsrDevCompiledModule[],
+    barrels: Record<string, CsrDevBarrelStamp> = {},
+  ): void {
     for (const module of compiled)
       graph.modules[module.id] = {
         vendor: module.vendor,
@@ -178,7 +188,12 @@ export abstract class DevRegistryBundler {
         hash: module.hash,
         deps: module.deps.map((dep) => (CsrDevPaths.isStub(dep) ? dep : this.paths.idOf(dep))),
         ...(module.helpers ? { helpers: module.helpers.hash } : {}),
+        ...(module.narrowed ? { narrowed: module.narrowed } : {}),
       };
+    const narrowing = new Set(Object.values(graph.modules).flatMap((module) => Object.keys(module.narrowed ?? {})));
+    graph.barrels = Object.fromEntries(
+      Object.entries({ ...graph.barrels, ...barrels }).filter(([barrel]) => narrowing.has(barrel)),
+    );
     //? Only what this round compiled leaves pending: a root another route's check failed on stays for its retry.
     const compiledIds = new Set(compiled.map((module) => module.id));
     graph.pending = graph.pending.filter((id) => !compiledIds.has(id));

package/frontendBuild/mcpAppViewBuilder.test.ts

@@ -177,6 +177,7 @@ describe("McpAppViewBuilder.build", () => {
       dist: { cwdPath: file("dist/apps/demo") },
       workspace: { workspaceRoot: root },
       getTsConfig: async () => ({ compilerOptions: {} }),
+      getConfig: async () => ({ barrelImports: [] }),
       getPublicEnv: () => ({}),
       logger: { warn: () => undefined },
     };
@@ -195,6 +196,72 @@ describe("McpAppViewBuilder.build", () => {
   });
 });
 
+describe("McpAppViewBuilder.build with an app barrel", () => {
+  test("narrows the app's client barrel to the module the trimmed page names, never another module's UI", async () => {
+    const root = await makeTempRoot();
+    const file = (rel: string) => path.join(root, rel);
+    const paths = { "@apps/*": ["./apps/*"] };
+    await write(file("tsconfig.json"), JSON.stringify({ compilerOptions: { baseUrl: ".", paths } }));
+    await write(
+      file("node_modules/akanjs/package.json"),
+      JSON.stringify({ name: "akanjs", exports: { "./webkit": "./webkit.ts" } }),
+    );
+    await write(
+      file("node_modules/akanjs/webkit.ts"),
+      "export const McpAppBoot = { run: (view: unknown) => console.info(view) };\n",
+    );
+    await write(
+      file("apps/demo/client.ts"),
+      [
+        'export { usePage } from "./lib/useClient";',
+        'export { st } from "./lib/st";',
+        'export { Memo } from "./lib/memo";',
+        'export { Report } from "./lib/report";',
+        "",
+      ].join("\n"),
+    );
+    await write(
+      file("apps/demo/lib/useClient.ts"),
+      'console.info("the client runtime loaded");\nexport const usePage = () => null;\n',
+    );
+    await write(file("apps/demo/lib/st.ts"), 'console.info("the store loaded");\nexport const st = null;\n');
+    await write(file("apps/demo/lib/memo/index.ts"), 'export const Memo = "a memo card";\n');
+    await write(
+      file("apps/demo/lib/report/index.ts"),
+      'console.info("the report module loaded");\nexport const Report = "a report card";\n',
+    );
+    await write(
+      file("apps/demo/page/home.tsx"),
+      [
+        'import { Memo, Report } from "@apps/demo/client";',
+        "const page = () => ({ app: (name: string, description: string, draw: () => unknown) => ({ render: (render: () => unknown) => [name, description, draw, render] }) });",
+        'export default page().app("showHome", "Show home.", () => Memo).render(() => Report);',
+      ].join("\n"),
+    );
+    const app = {
+      cwdPath: file("apps/demo"),
+      dist: { cwdPath: file("dist/apps/demo") },
+      workspace: { workspaceRoot: root },
+      getTsConfig: async () => ({ compilerOptions: { paths } }),
+      getConfig: async () => ({ barrelImports: ["@apps/demo/client"] }),
+      getPublicEnv: () => ({}),
+      logger: { warn: () => undefined },
+    };
+
+    await new McpAppViewBuilder(app as never, "build").build(
+      [{ key: "./home.tsx", moduleAbsPath: file("apps/demo/page/home.tsx") }],
+      { basePaths: [], cssAssets: {}, options: CsrArtifactBuilder.bundleOptions(app as never, "build") },
+    );
+
+    const view = await Bun.file(file("dist/apps/demo/mcp-apps/showHome.html")).text();
+    expect(view).toContain("a memo card");
+    expect(view).toContain("the client runtime loaded");
+    expect(view).toContain("the store loaded");
+    expect(view).not.toContain("a report card");
+    expect(view).not.toContain("the report module loaded");
+  });
+});
+
 describe("McpAppViewBuilder.entryOf", () => {
   test("boots the one app with its page, the root layout and overrides it sits under, by relative path", () => {
     const view = {

package/frontendBuild/ssrDevBundler.ts

@@ -5,6 +5,7 @@ import { resolveSsrPageEntriesForApp } from "../artifact/implicitRootLayout";
 import { computeRouteSeedIndex } from "../artifact/routeSeedIndex";
 import { StoreBootstrap } from "../artifact/storeBootstrap";
 import type { App } from "../commandDecorators";
+import { workspaceBarrels } from "../transforms/barrelImportsPlugin";
 import { bundleDefine } from "./bundleDefine";
 import type { ClientEntryDiscovery } from "./clientBuildTypes";
 import { GraphClientEntryDiscovery } from "./clientEntryDiscovery";
@@ -17,7 +18,7 @@ import { VENDOR_SPECIFIERS } from "./vendorSpecifiers";
 //* (the app's client runtime) and every `"use client"` entry; React and the akanjs vendor facets stay the import map's,
 //* so the page keeps one React and one store registry.
 export class SsrDevBundler extends DevRegistryBundler {
-  static readonly #formatVersion = 2;
+  static readonly #formatVersion = 4;
   static readonly bootstrapKey = "";
   readonly reloadsOnEntryChange = false;
   #discovery: ClientEntryDiscovery | null = null;
@@ -33,8 +34,17 @@ export class SsrDevBundler extends DevRegistryBundler {
     const akanConfig = await this.app.getConfig();
     const define = bundleDefine(this.app, "start", "ssr");
     const optimizeImports = [...akanConfig.optimizeImports];
+    const barrelImports = workspaceBarrels(akanConfig.barrelImports);
     const configKey = Bun.hash(
-      JSON.stringify(["ssr", SsrDevBundler.#formatVersion, Bun.version, define, optimizeImports, VENDOR_SPECIFIERS]),
+      JSON.stringify([
+        "ssr",
+        SsrDevBundler.#formatVersion,
+        Bun.version,
+        define,
+        optimizeImports,
+        VENDOR_SPECIFIERS,
+        barrelImports,
+      ]),
     ).toString(36);
     return {
       pageEntries: [],
@@ -45,6 +55,7 @@ export class SsrDevBundler extends DevRegistryBundler {
       configKey,
       refreshFile: null,
       externals: VENDOR_SPECIFIERS,
+      barrelImports,
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.2.0-rc.1",
+  "version": "3.2.0-rc.3",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -41,7 +41,7 @@
     "./*": "./*.ts"
   },
   "dependencies": {
-    "@akanjs/language": "3.2.0-rc.1",
+    "@akanjs/language": "3.2.0-rc.3",
     "@earendil-works/pi-agent-core": "1.3.0",
     "@earendil-works/pi-ai": "1.3.0",
     "@earendil-works/pi-codemode": "1.3.0",
@@ -50,7 +50,7 @@
     "@earendil-works/pi-tui": "1.3.0",
     "@inquirer/prompts": "^8.7.3",
     "@tailwindcss/node": "^4.3.3",
-    "akanjs": "3.2.0-rc.1",
+    "akanjs": "3.2.0-rc.3",
     "chalk": "^6.0.1",
     "commander": "^15.0.0",
     "dayjs": "^1.11.23",

package/preview/PreviewView.ts

@@ -80,12 +80,14 @@ export class PreviewView {
     const view = PreviewView.#open({ width, height, engine, onConsole: (line) => logs.push(line) });
     try {
       //? A browser that missed its start bound may still come up, so a later page retries it within only its own bound.
+      //? One that died or was closed instead is spawned afresh by the next view, which gets the full bound.
       const startMs = PreviewView.#stalled.has(engine) ? Math.min(startTimeoutMs, timeoutMs) : startTimeoutMs;
       const stalled = new Error(`Timed out starting the ${engine} browser after ${startMs / 1_000} s.`);
       await PreviewView.#within(view.navigate("about:blank"), Date.now() + startMs, stalled).then(
         () => PreviewView.#stalled.delete(engine),
         (error: unknown) => {
           if (error === stalled) PreviewView.#stalled.add(engine);
+          else PreviewView.#stalled.delete(engine);
           throw error;
         },
       );