@akanjs/devkit 3.0.0-alpha.2 → 3.0.0-alpha.20

package/capacitorApp.test.ts

@@ -11,6 +11,7 @@ import {
   clearRootCapacitorConfigs,
   formatAndroidReleaseSigningError,
   getAdbDeviceStateIssues,
+  getAndroidLocalServerHost,
   getMissingAndroidReleaseSigningKeys,
   isPlaceholderAppId,
   materializeCapacitorConfig,
@@ -339,6 +340,13 @@ describe("Android signing diagnostics", () => {
       "Android device abc123 is unauthorized. Confirm USB debugging authorization on the device.",
       "Android device xyz is offline. Reconnect the device or restart adb.",
     ]);
+    expect(getAndroidLocalServerHost("List of devices attached\nemulator-5554 device\n", "192.168.0.5")).toBe(
+      "10.0.2.2",
+    );
+    expect(getAndroidLocalServerHost("List of devices attached\nabc123 device\n", "192.168.0.5")).toBe("192.168.0.5");
+    expect(
+      getAndroidLocalServerHost("List of devices attached\nemulator-5554 device\nabc123 device\n", "192.168.0.5"),
+    ).toBe("192.168.0.5");
   });
 });
 

package/capacitorApp.ts

@@ -24,7 +24,9 @@ interface RunIosConfig extends RunConfig {
   iosDeviceId?: string;
 }
 
-interface PrepareConfig extends RunConfig {}
+interface PrepareConfig extends RunConfig {
+  iosRunTargetKind?: IosRunTargetKind;
+}
 
 type MobileCommandEnv = Record<string, string | undefined>;
 
@@ -119,10 +121,11 @@ interface MaterializeCapacitorConfigOptions {
   localServerUrl?: string;
   localIp?: string;
 }
+type MobilePlatform = "ios" | "android";
 
 export interface LocalDevHostResolution {
   host: string;
-  source: "override" | "detected" | "loopback";
+  source: "override" | "detected" | "loopback" | "platform";
   candidates: { name: string; address: string }[];
 }
 
@@ -565,6 +568,16 @@ export function getAdbDeviceStateIssues(output: string) {
     });
 }
 
+export function getAndroidLocalServerHost(adbDevicesOutput: string | undefined, fallbackHost: string) {
+  const onlineDeviceIds =
+    adbDevicesOutput
+      ?.split(/\r?\n/)
+      .map((line) => line.trim().split(/\s+/))
+      .filter(([id, state]) => id && state === "device")
+      .map(([id]) => id) ?? [];
+  return onlineDeviceIds.length === 1 && onlineDeviceIds[0]?.startsWith("emulator-") ? "10.0.2.2" : fallbackHost;
+}
+
 export const ANDROID_MIN_SDK_VERSION = 26;
 export function raiseGradleMinSdkVersion(content: string, floor: number = ANDROID_MIN_SDK_VERSION): string | null {
   const match = content.match(/minSdkVersion\s*=\s*(\d+)/);
@@ -748,7 +761,7 @@ export class CapacitorApp {
   async save() {
     await this.project.commit();
   }
-  async #prepareIos({ operation, env, regenerate = false }: PrepareConfig) {
+  async #prepareIos({ operation, env, regenerate = false, iosRunTargetKind }: PrepareConfig) {
     await this.init({ platform: "ios", operation, env, regenerate });
     await this.#prepareTargetAssets();
     await this.#prepareExternalFiles("ios");
@@ -757,9 +770,10 @@ export class CapacitorApp {
     await this.#applyDeepLinks("ios", { operation, env });
     await this.#flushIosEntitlements();
     await this.project.commit();
+    await this.#setCodeSignEntitlementsInIosIfExists("App/App.entitlements");
     await this.#generateAssets({ operation, env });
     this.app.verbose(`syncing iOS`);
-    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation, env });
+    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation, env }, { iosRunTargetKind });
     this.app.verbose(`sync completed.`);
   }
   async buildIos({ env = "debug", regenerate = false }: { env?: RunConfig["env"]; regenerate?: boolean } = {}) {
@@ -777,14 +791,14 @@ export class CapacitorApp {
   }
   async runIos({ operation, env, regenerate = false, noAllowProvisioningUpdates = false, iosDeviceId }: RunIosConfig) {
     if (operation === "release") await this.prepareWww();
-    await this.#prepareIos({ operation, env, regenerate });
     const runTarget = await this.#selectIosRunTarget(iosDeviceId);
+    await this.#prepareIos({ operation, env, regenerate, iosRunTargetKind: runTarget.kind });
     if (runTarget.kind === "simulator") {
       await this.#spawnMobile(
         "npx",
-        ["cap", "run", "ios", "--target", runTarget.id],
+        ["cap", "run", "ios", "--target", runTarget.id, "--no-sync"],
         { operation, env },
-        { stdio: "inherit" },
+        { stdio: "inherit", platform: "ios", iosRunTargetKind: runTarget.kind },
       );
       return;
     }
@@ -878,7 +892,10 @@ export class CapacitorApp {
     noAllowProvisioningUpdates: boolean;
   }) {
     const mobileEnv = sanitizeIosNativeRunEnv(await this.#commandEnv(operation, env));
-    const configContent = await this.#writeCapacitorConfig({ operation }, mobileEnv);
+    const configContent = await this.#writeCapacitorConfig(
+      { operation, platform: "ios", iosRunTargetKind: runTarget.kind },
+      mobileEnv,
+    );
     await this.#writeRootCapacitorConfig(configContent);
     const scheme = this.#iosScheme();
     const command = buildIosNativeRunCommand({
@@ -943,6 +960,7 @@ export class CapacitorApp {
     await this.#applyAndroidMinSdkVersion();
     await this.#applyPermissions({ operation, env });
     await this.#applyDeepLinks("android", { operation, env });
+    await this.#disableNativeKeyboardResizeInAndroid();
     await this.project.commit();
     await this.#generateAssets({ operation, env });
     await this.#ensureAndroidAssetsDir();
@@ -1010,6 +1028,24 @@ export class CapacitorApp {
   async openAndroid() {
     await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
+  async #disableNativeKeyboardResizeInAndroid() {
+    const manifestPath = path.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
+    let manifest = await readFile(manifestPath, "utf8");
+    let changed = false;
+    manifest = manifest.replace(/<activity\b[^>]*android:name="\.MainActivity"[^>]*>/, (activityTag) => {
+      if (activityTag.includes("android:windowSoftInputMode=")) {
+        const nextTag = activityTag.replace(
+          /android:windowSoftInputMode="[^"]*"/,
+          'android:windowSoftInputMode="adjustNothing"',
+        );
+        changed ||= nextTag !== activityTag;
+        return nextTag;
+      }
+      changed = true;
+      return activityTag.replace(/>$/, '\n            android:windowSoftInputMode="adjustNothing">');
+    });
+    if (changed) await writeFile(manifestPath, manifest);
+  }
   async #ensureAndroidAssetsDir() {
     await mkdir(path.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
   }
@@ -1100,12 +1136,19 @@ export class CapacitorApp {
     if (html.includes("window.__AKAN_MOBILE_TARGET__")) return html;
     return html.replace(/<\/head\s*>/i, `${script}\n</head>`);
   }
-  async #writeCapacitorConfig({ operation }: Pick<RunConfig, "operation">, commandEnv: MobileCommandEnv) {
+  async #writeCapacitorConfig(
+    {
+      operation,
+      platform,
+      iosRunTargetKind,
+    }: Pick<RunConfig, "operation"> & { platform?: MobilePlatform; iosRunTargetKind?: IosRunTargetKind },
+    commandEnv: MobileCommandEnv,
+  ) {
     await mkdir(this.targetRoot, { recursive: true });
     let localIp: string | undefined;
     if (operation === "local") {
       const override = commandEnv.AKAN_PUBLIC_CLIENT_HOST ?? process.env.AKAN_PUBLIC_CLIENT_HOST;
-      const resolution = selectLocalDevHost(os.networkInterfaces(), { override });
+      const resolution = await this.#resolveLocalDevHost({ override, platform, iosRunTargetKind });
       localIp = resolution.host;
       this.#logDevHostResolution(resolution, commandEnv);
     }
@@ -1118,11 +1161,36 @@ export class CapacitorApp {
     await Bun.write(path.join(this.targetRoot, "capacitor.config.json"), content);
     return content;
   }
+  // An explicit override always wins; an emulator/simulator run reaches the host machine through a
+  // loopback alias (10.0.2.2 / localhost), so LAN detection only applies to physical-device runs.
+  async #resolveLocalDevHost({
+    override,
+    platform,
+    iosRunTargetKind,
+  }: {
+    override?: string;
+    platform?: MobilePlatform;
+    iosRunTargetKind?: IosRunTargetKind;
+  }): Promise<LocalDevHostResolution> {
+    const resolution = selectLocalDevHost(os.networkInterfaces(), { override });
+    if (resolution.source === "override") return resolution;
+    if (platform === "ios" && iosRunTargetKind === "simulator")
+      return { ...resolution, host: "localhost", source: "platform" };
+    if (platform === "android") {
+      try {
+        const host = getAndroidLocalServerHost(await this.#spawn("adb", ["devices"]), resolution.host);
+        return host === resolution.host ? resolution : { ...resolution, host, source: "platform" };
+      } catch {
+        return resolution;
+      }
+    }
+    return resolution;
+  }
   // Surface the live-reload URL a physical device must reach, and warn when auto-detection landed on
   // a likely-unreachable host so a blank WebView is not mistaken for an app bug.
   #logDevHostResolution(resolution: LocalDevHostResolution, commandEnv: MobileCommandEnv) {
     this.app.log(`Mobile live-reload server: ${this.#localCsrUrl(resolution.host, commandEnv)}`);
-    if (resolution.source === "override") return;
+    if (resolution.source === "override" || resolution.source === "platform") return;
     const suspicious = resolution.host === "127.0.0.1" || resolution.host.startsWith("169.254.");
     const alternatives = resolution.candidates.filter((candidate) => candidate.address !== resolution.host);
     if (!suspicious && alternatives.length === 0) return;
@@ -1332,20 +1400,29 @@ export class CapacitorApp {
     command: string,
     args: string[] = [],
     { operation, env }: Pick<RunConfig, "operation" | "env">,
-    options: Parameters<AppExecutor["spawn"]>[2] = {},
+    options: SpawnMobileOptions = {},
   ) {
+    const { iosRunTargetKind, platform, ...spawnOptions } = options;
     const mobileEnv = { ...(await this.#commandEnv(operation, env)), ...options.env };
-    const configContent = await this.#writeCapacitorConfig({ operation }, mobileEnv);
+    const configContent = await this.#writeCapacitorConfig(
+      { operation, platform: platform ?? this.#inferMobilePlatform(args), iosRunTargetKind },
+      mobileEnv,
+    );
     await this.#writeRootCapacitorConfig(configContent);
     try {
       return await this.#spawn(command, args, {
-        ...options,
+        ...spawnOptions,
         env: mobileEnv,
       });
     } finally {
       await this.#clearRootCapacitorConfigs();
     }
   }
+  #inferMobilePlatform(args: string[]): MobilePlatform | undefined {
+    if (args.includes("android")) return "android";
+    if (args.includes("ios")) return "ios";
+    return undefined;
+  }
   async addCamera() {
     await this.#setPermissionInIos({
       cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
@@ -1446,14 +1523,31 @@ export class CapacitorApp {
       let end = index;
       while (end < lines.length && !/^\s*\};\s*$/.test(lines[end] ?? "")) end++;
       const settings = lines.slice(start, end + 1);
-      if (settings.some((setting) => setting.includes("CODE_SIGN_ENTITLEMENTS"))) continue;
+      const configName = lines.slice(end + 1, end + 8).find((setting) => setting.includes("name = ")) ?? "";
       const indent = line.match(/^\s*/)?.[0] ?? "";
-      lines.splice(index, 0, `${indent}CODE_SIGN_ENTITLEMENTS = ${entitlementsRelPath};`);
-      index++;
-      changed = true;
+      const insertSettings = [];
+      if (!settings.some((setting) => setting.includes("CODE_SIGN_ENTITLEMENTS"))) {
+        insertSettings.push(`${indent}CODE_SIGN_ENTITLEMENTS = ${entitlementsRelPath};`);
+      }
+      if (
+        configName.includes("name = Debug;") &&
+        !settings.some((setting) => setting.includes("CODE_SIGN_ALLOW_ENTITLEMENTS_MODIFICATION"))
+      ) {
+        insertSettings.push(`${indent}CODE_SIGN_ALLOW_ENTITLEMENTS_MODIFICATION = YES;`);
+      }
+      if (insertSettings.length > 0) {
+        lines.splice(index, 0, ...insertSettings);
+        index += insertSettings.length;
+        changed = true;
+      }
     }
     if (changed) await writeFile(pbxprojPath, lines.join("\n"));
   }
+  async #setCodeSignEntitlementsInIosIfExists(entitlementsRelPath: string) {
+    const entitlementsPath = path.join(this.app.cwdPath, this.iosProjectPath, entitlementsRelPath);
+    if (!(await Bun.file(entitlementsPath).exists())) return;
+    await this.#setCodeSignEntitlementsInIos(entitlementsRelPath);
+  }
   async #setUrlSchemesInAndroid(schemes: string[]) {
     const manifestPath = path.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
     let manifest = await readFile(manifestPath, "utf8");

package/executors.test.ts

@@ -31,7 +31,6 @@ const rootPackageJson = (extra: Partial<PackageJson> = {}): PackageJson => ({
     react: "19.0.0",
     "react-dom": "19.0.0",
     "react-server-dom-webpack": "19.0.0",
-    sharp: "1.0.0",
     lodash: "4.0.0",
   },
   devDependencies: {
@@ -149,8 +148,10 @@ describe("Executor filesystem helpers", () => {
       "AI Development Guide",
     );
     expect(await readFile(path.join(root, "workspace/docs/GENERATED.md"), "utf8")).toContain("Generated Akan Files");
+    // Rules and their plugin registrations live in the package's base config, so a framework release reaches an
+    // existing workspace on `bun update` — the workspace file only extends it and scopes its own files.
     expect(await readFile(path.join(root, "workspace/biome.json"), "utf8")).toContain(
-      "./node_modules/@akanjs/devkit/lint/no-import-client-functions.grit",
+      '"extends": ["@akanjs/devkit/biome.base.json"]',
     );
   });
 
@@ -758,6 +759,29 @@ describe("Workspace and app executor environment contracts", () => {
     expect(offsetMinimalStart.env.AKAN_PUBLIC_CLIENT_PORT).toBe("8286");
     expect(offsetMinimalStart.env.AKAN_PUBLIC_SERVER_PORT).toBe("8286");
   });
+
+  test("pins the start command to development so an ambient NODE_ENV cannot pick the production router", async () => {
+    const root = await makeTempRoot();
+    process.env.AKAN_PUBLIC_REPO_NAME = "repo";
+    process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
+    process.env.AKAN_PUBLIC_ENV = "local";
+    await writeJson(path.join(root, "package.json"), rootPackageJson());
+    await mkdir(path.join(root, "apps/ambient"), { recursive: true });
+    await writeFile(path.join(root, "apps/ambient/akan.config.ts"), "export default {};\n");
+
+    const originalNodeEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = "production";
+    try {
+      const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
+      const started = await AppExecutor.from(workspace, "ambient").prepareCommand("start");
+      expect(started.env.NODE_ENV).toBe("development");
+      // The builder runs in this process and bakes NODE_ENV into the dev bundles it emits.
+      expect(process.env.NODE_ENV).toBe("development");
+    } finally {
+      if (originalNodeEnv === undefined) delete process.env.NODE_ENV;
+      else process.env.NODE_ENV = originalNodeEnv;
+    }
+  });
 });
 
 describe("PkgExecutor package generation", () => {
@@ -771,7 +795,7 @@ describe("PkgExecutor package generation", () => {
       exports: { "./extra": { import: "./extra.ts" } },
       peerDependencies: { react: "19.0.0" },
       peerDependenciesMeta: { react: { optional: true } },
-      optionalDependencies: { sharp: "1.0.0" },
+      optionalDependencies: { "@sample/native": "1.0.0" },
     });
 
     const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
@@ -781,12 +805,12 @@ describe("PkgExecutor package generation", () => {
     expect(distPackageJson).toMatchObject({
       name: "@sample/tool",
       type: "module",
-      engines: { bun: ">=1.3.13" },
+      engines: { bun: ">=1.4.0" },
       dependencies: { lodash: "4.0.0" },
       devDependencies: { typescript: "6.0.0" },
       peerDependencies: { react: "19.0.0" },
       peerDependenciesMeta: { react: { optional: true } },
-      optionalDependencies: { sharp: "1.0.0" },
+      optionalDependencies: { "@sample/native": "1.0.0" },
     });
     expect(distPackageJson.exports?.["."]).toEqual({
       import: "./index.ts",
@@ -855,3 +879,16 @@ describe("scan info construction", () => {
     expect(info.file.document.scalars.has("money")).toBe(true);
   });
 });
+
+describe("AppExecutor.shouldRelaunchForAppEnv", () => {
+  test("relaunches when the process was born without the app name, or with another app's", () => {
+    expect(AppExecutor.shouldRelaunchForAppEnv("sceny", undefined, undefined)).toBe(true);
+    expect(AppExecutor.shouldRelaunchForAppEnv("sceny", "other", undefined)).toBe(true);
+  });
+
+  test("runs in place when the name was present at birth, and never relaunches twice", () => {
+    expect(AppExecutor.shouldRelaunchForAppEnv("sceny", "sceny", undefined)).toBe(false);
+    expect(AppExecutor.shouldRelaunchForAppEnv("sceny", undefined, "1")).toBe(false);
+    expect(AppExecutor.shouldRelaunchForAppEnv("sceny", "other", "1")).toBe(false);
+  });
+});

package/executors.ts

@@ -42,6 +42,7 @@ import { AkanAppConfig, AkanLibConfig, decreaseBuildNum, increaseBuildNum } from
 import { FileSys } from "./fileSys";
 import { getDirname } from "./getDirname";
 import { Linter } from "./linter";
+import { resolveRepoName } from "./repoIdentity";
 import { AppInfo, LibInfo, PkgInfo, WorkspaceInfo } from "./scanInfo";
 import { Spinner } from "./spinner";
 // Type-only: the implementation is loaded on demand in `getTypeChecker` to keep `typescript` out of
@@ -232,7 +233,7 @@ export class Executor {
         );
       });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal)
+        if (code || signal)
           reject(
             new CommandExecutionError({
               command,
@@ -341,7 +342,7 @@ export class Executor {
         );
       });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal)
+        if (code || signal)
           reject(
             new CommandExecutionError({
               command: modulePath,
@@ -788,7 +789,7 @@ export class WorkspaceExecutor extends Executor {
   static #execs = new Map<string, WorkspaceExecutor>();
   static fromRoot({
     workspaceRoot = process.cwd(),
-    repoName = path.basename(process.cwd()),
+    repoName = resolveRepoName(workspaceRoot),
   }: {
     workspaceRoot?: string;
     repoName?: string;
@@ -1283,6 +1284,10 @@ interface AppExecutorOptions {
   workspace?: WorkspaceExecutor;
   name: string;
 }
+// Captured at module load, before the command dispatcher patches the resolved app name into `process.env` —
+// the relaunch guard below must judge what bundler macros will see, which is the env this process was born with.
+const bootAppName = process.env.AKAN_PUBLIC_APP_NAME;
+
 export class AppExecutor extends SysExecutor {
   // `typescript` costs ~65MB resident, so keep it out of the module graph of every process that only
   // ever imports an executor. Route validation is the sole consumer here and is already async.
@@ -1341,6 +1346,35 @@ export class AppExecutor extends SysExecutor {
       ...env,
     };
   }
+  /**
+   * Bun macros snapshot `process.env` at process start, so the env `prepareCommand` publishes later is invisible
+   * to them — and any hand-written `@libs/<lib>/server` import puts that lib's env files (module-scope `getEnv()`)
+   * into the `getSerializedSignal` macro graph. `AKAN_PUBLIC_APP_NAME` is the one required key no workspace root
+   * `.env` can carry, so the build relaunches itself once with it in place; the child sees it from birth.
+   *
+   * The decision compares the boot snapshot, never the live `process.env`: the command dispatcher writes the
+   * resolved app into `process.env.AKAN_PUBLIC_APP_NAME` before any command method runs, which satisfies runtime
+   * readers but not macros — trusting it is how this relaunch shipped once without ever firing.
+   */
+  static shouldRelaunchForAppEnv(
+    appName: string,
+    bootName: string | undefined = bootAppName,
+    marker: string | undefined = process.env.AKAN_BUILD_RELAUNCHED,
+  ) {
+    if (marker === "1") return false;
+    return bootName !== appName;
+  }
+  async relaunchWithAppEnv(): Promise<number | null> {
+    if (!AppExecutor.shouldRelaunchForAppEnv(this.name)) return null;
+    console.info(`Relaunching with AKAN_PUBLIC_APP_NAME=${this.name} so bundler macros see the app env.`);
+    const child = Bun.spawn([process.execPath, ...process.argv.slice(1)], {
+      env: { ...this.getCommandEnv(), AKAN_PUBLIC_APP_NAME: this.name, AKAN_BUILD_RELAUNCHED: "1" },
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    return await child.exited;
+  }
   async prepareCommand(type: "build" | "start") {
     const akanConfig = await this.getConfig();
     const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
@@ -1363,6 +1397,12 @@ export class AppExecutor extends SysExecutor {
         this.cp("public", `${this.dist.cwdPath}/public`, { dereference: true }),
       ]);
     } else await this.removeDir(".akan");
+    //? `akan start` is the dev server, and it must say so rather than inherit an answer. Bun auto-loads the
+    //? workspace `.env`, so NODE_ENV=production can reach this process without ever being exported in a shell —
+    //? and a dev server that believes it is production serves from the production route cache, whose every
+    //? route throws because a dev artifact carries no routes manifest. Written into `process.env` and not only
+    //? into the child env because the builder runs here and bakes NODE_ENV into the bundles it emits.
+    if (type === "start") process.env.NODE_ENV = "development";
     const devPort = type === "start" ? (await this.getDevPort()).toString() : undefined;
     const env = this.getCommandEnv({
       AKAN_COMMAND_TYPE: type,
@@ -1806,7 +1846,7 @@ export class PkgExecutor extends Executor {
           default: "./index.ts",
         },
       },
-      engines: { bun: ">=1.3.13" },
+      engines: { bun: ">=1.4.0" },
       ...dependencyMaps,
     };
     await Promise.all([this.dist.writeJson("package.json", distPkgJson), this.writeJson("package.json", distPkgJson)]);

package/frontendBuild/allRoutesBuilder.ts

@@ -47,11 +47,24 @@ export class AllRoutesBuilder {
     this.#app.verbose(`[build-all] discovered ${seedIndex.entries.length} routes`);
     this.#discovery = await GraphClientEntryDiscovery.create(this.#app);
 
+    // Discovery first, bundling second. Chunk splitting only dedupes within one `Bun.build`, so a
+    // dependency shared by entries from different routes was emitted once per route that reached it.
+    // Discovery is cached and does no bundling, so collecting every entry up front costs almost nothing.
+    const allEntries: string[] = [];
+    const seen = new Set<string>();
     for (const entry of seedIndex.entries) {
       const seeds = Array.from(new Set([...seedIndex.globalLayoutFiles, ...entry.seeds]));
-      const delta = await this.#buildRoute(entry.routeId, seeds);
-      this.#mergeRoute(entry.routeId, delta);
+      for (const discovered of await this.#discovery.discover(seeds)) {
+        if (seen.has(discovered)) continue;
+        seen.add(discovered);
+        allEntries.push(discovered);
+      }
+      this.#routeIds.push(entry.routeId);
     }
+    this.#app.verbose(`[build-all] ${allEntries.length} client entries across ${this.#routeIds.length} routes`);
+
+    const delta = await this.#buildEntries(allEntries);
+    this.#mergeDelta(delta);
     this.#merged.knownEntries = Array.from(this.#knownSet);
 
     const manifest: RoutesManifest = {
@@ -76,28 +89,34 @@ export class AllRoutesBuilder {
     return { manifest, manifestPath, seedIndex };
   }
 
-  async #buildRoute(routeId: string, seeds: string[]): Promise<BuildRouteClientResult> {
+  async #buildEntries(entries: string[]): Promise<BuildRouteClientResult> {
     if (!this.#discovery) throw new Error("[build-all] client entry discovery is not initialized");
+    if (entries.length === 0)
+      return {
+        manifestDelta: {},
+        ssrManifestDelta: { moduleLoading: null, moduleMap: {} },
+        newEntries: [],
+        clientDeps: [],
+      };
     const started = Date.now();
     const delta = await new RouteClientBuilder({
       app: this.#app,
-      routeId,
-      seeds,
+      seeds: [],
+      entries,
       artifact: this.#artifact,
       knownEntries: this.#knownSet,
       discovery: this.#discovery,
       command: this.#command,
     }).build();
-    this.#app.verbose(`[build-all] ${routeId} +${delta.newEntries.length} entries (${Date.now() - started}ms)`);
+    this.#app.verbose(`[build-all] bundled ${delta.newEntries.length} entries (${Date.now() - started}ms)`);
     return delta;
   }
 
-  #mergeRoute(routeId: string, delta: BuildRouteClientResult): void {
+  #mergeDelta(delta: BuildRouteClientResult): void {
     for (const [key, row] of Object.entries(delta.manifestDelta)) this.#merged.clientManifest[key] = row;
     for (const [url, byName] of Object.entries(delta.ssrManifestDelta.moduleMap)) {
       this.#merged.ssrManifest.moduleMap[url] = byName;
     }
     for (const abs of delta.newEntries) this.#knownSet.add(abs);
-    this.#routeIds.push(routeId);
   }
 }

package/frontendBuild/buildRouteClient.test.ts

@@ -82,16 +82,42 @@ describe("route client store bootstrap", () => {
   });
 
   test("bundles akan fetch into production SSR client chunks", () => {
-    expect(RouteClientBuilder.resolveSsrClientExternalOptions("start")).toMatchObject({
+    expect(RouteClientBuilder.resolveSsrClientBundleOptions("start")).toMatchObject({
       external: expect.arrayContaining(["akanjs/fetch"]),
       externalSubpaths: ["akanjs/fetch"],
     });
 
-    expect(RouteClientBuilder.resolveSsrClientExternalOptions("build")).toEqual({
+    expect(RouteClientBuilder.resolveSsrClientBundleOptions("build")).toEqual({
+      target: "bun",
       external: ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime"],
     });
   });
 
+  test("targets the server so SSR client chunks never resolve a browser export condition", async () => {
+    const root = await makeTempRoot();
+    const pkgDir = path.join(root, "node_modules/dom-conditioned-pkg");
+    await write(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({
+        name: "dom-conditioned-pkg",
+        type: "module",
+        exports: { ".": { browser: "./index.dom.js", default: "./index.js" } },
+      }),
+    );
+    await write(path.join(pkgDir, "index.dom.js"), 'export const element = document.createElement("i");\n');
+    await write(path.join(pkgDir, "index.js"), "export const element = null;\n");
+    const entry = path.join(root, "entry.ts");
+    await write(entry, 'export { element } from "dom-conditioned-pkg";\n');
+
+    for (const command of ["start", "build"] as const) {
+      const { target } = RouteClientBuilder.resolveSsrClientBundleOptions(command);
+      const built = await Bun.build({ entrypoints: [entry], target, format: "esm" });
+
+      expect(built.success).toBe(true);
+      expect(await built.outputs[0].text()).not.toContain("document.createElement");
+    }
+  });
+
   test("rewrites SSR external imports to runtime aliases", () => {
     const source = [
       'import React, { useState } from "react";',

package/frontendBuild/clientBuildTypes.ts

@@ -55,6 +55,8 @@ export interface BuildClientResult {
   rscClientUrl: string;
 }
 
+export type ClientBundleTarget = "browser" | "bun";
+
 export const CLIENT_BUNDLE_NAMING = {
   entry: "[name]-[hash].[ext]",
   chunk: "chunks/[hash].[ext]",
@@ -79,6 +81,8 @@ export interface BundleClientEntriesOptions {
 }
 
 export interface BundleClientEntriesInternalOptions extends BundleClientEntriesOptions {
+  /** Module-resolution target. `"bun"` for the server-executed `client-ssr` bundle, `"browser"` otherwise. */
+  target?: ClientBundleTarget;
   external?: readonly string[];
   externalSubpaths?: readonly string[];
   externalAliases?: Partial<Record<string, string>>;

package/frontendBuild/clientEntriesBundler.ts

@@ -7,6 +7,7 @@ import {
   type BundleClientEntriesInternalOptions,
   type BundleClientEntriesResult,
   CLIENT_BUNDLE_NAMING,
+  type ClientBundleTarget,
   type ClientManifest,
   type MetafileOutput,
   type OpaqueEntryAliases,
@@ -25,6 +26,7 @@ export class ClientEntriesBundler {
   #externalSubpaths: readonly string[];
   #externalAliases: Partial<Record<string, string>>;
   #command: "build" | "start";
+  #target: ClientBundleTarget;
   #outputSubdir: string;
   #reactFastRefresh: boolean;
   #artifactDir: string;
@@ -47,6 +49,7 @@ export class ClientEntriesBundler {
     this.#externalSubpaths = options.externalSubpaths ?? [];
     this.#externalAliases = options.externalAliases ?? {};
     this.#command = options.command ?? "start";
+    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`;
@@ -61,7 +64,7 @@ export class ClientEntriesBundler {
       entrypoints: this.#opaqueEntries.entries,
       outdir: this.#outdir,
       splitting: true,
-      target: "browser",
+      target: this.#target,
       format: "esm",
       naming: CLIENT_BUNDLE_NAMING,
       metafile: true,