@akanjs/devkit 3.0.0-alpha.4 → 3.0.0-alpha.5

package/akanContext.ts

@@ -14,6 +14,7 @@ import {
   workflowRunArtifactPath,
   workflowSyncDir,
 } from "./workflow";
+import { appRootAllowedDirs, appRootAllowedFiles, isScannedAppRootEntry } from "./workspaceLayout";
 
 export type AkanContextFormat = "json" | "markdown";
 export type AkanModuleKind = "domain" | "service" | "scalar";
@@ -313,36 +314,6 @@ const moduleShapeFiles = (module: AkanModuleContext) => {
 const constantFieldNames = (content: string) =>
   [...content.matchAll(/\b([A-Za-z_$][\w$]*)\s*:\s*field\(/g)].map((match) => match[1]).filter(Boolean);
 
-const appRootAllowFiles = new Set([
-  // 스코프 에이전트 가이드 — scan(write) 이 유지 (agentsIndex.ts); scanInfo.ts 의 appRootAllowedFiles 와 동기
-  "AGENTS.md",
-  "CLAUDE.md",
-  "akan.app.json",
-  "akan.config.ts",
-  "capacitor.config.ts",
-  "client.ts",
-  "main.ts",
-  "package.json",
-  "server.ts",
-  "tsconfig.json",
-]);
-
-const appRootAllowDirs = new Set([
-  ".akan",
-  "android",
-  "common",
-  "env",
-  "ios",
-  "lib",
-  "page",
-  "private",
-  "public",
-  "script",
-  "srvkit",
-  "ui",
-  "webkit",
-]);
-
 const safeReadDir = async (dirPath: string) => {
   try {
     return (await readdir(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
@@ -671,7 +642,8 @@ export class AkanContextAnalyzer {
     for (const app of context.apps) {
       const appPath = path.join(workspace.workspaceRoot, app.path);
       for (const entry of await safeReadDir(appPath)) {
-        const allowed = entry.isDirectory() ? appRootAllowDirs.has(entry.name) : appRootAllowFiles.has(entry.name);
+        if (!isScannedAppRootEntry(entry.name)) continue;
+        const allowed = entry.isDirectory() ? appRootAllowedDirs.has(entry.name) : appRootAllowedFiles.has(entry.name);
         if (!allowed) {
           const action = repairAction(
             "module-shape",

package/applicationBuildRunner.ts

@@ -112,7 +112,7 @@ export class ApplicationBuildRunner {
       () => precompressArtifacts(this.#app),
       (result) =>
         result.files > 0
-          ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> ${ApplicationBuildRunner.formatBytes(result.outputBytes)}`
+          ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> gzip ${ApplicationBuildRunner.formatBytes(result.outputBytes)} / br ${ApplicationBuildRunner.formatBytes(result.brotliBytes)}`
           : "no files",
       phaseOptions,
     );

package/capacitorApp.test.ts

@@ -11,7 +11,6 @@ import {
   clearRootCapacitorConfigs,
   formatAndroidReleaseSigningError,
   getAdbDeviceStateIssues,
-  getAndroidLocalServerHost,
   getMissingAndroidReleaseSigningKeys,
   isPlaceholderAppId,
   materializeCapacitorConfig,
@@ -340,13 +339,6 @@ 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,9 +24,7 @@ interface RunIosConfig extends RunConfig {
   iosDeviceId?: string;
 }
 
-interface PrepareConfig extends RunConfig {
-  iosRunTargetKind?: IosRunTargetKind;
-}
+interface PrepareConfig extends RunConfig {}
 
 type MobileCommandEnv = Record<string, string | undefined>;
 
@@ -121,11 +119,10 @@ interface MaterializeCapacitorConfigOptions {
   localServerUrl?: string;
   localIp?: string;
 }
-type MobilePlatform = "ios" | "android";
 
 export interface LocalDevHostResolution {
   host: string;
-  source: "override" | "detected" | "loopback" | "platform";
+  source: "override" | "detected" | "loopback";
   candidates: { name: string; address: string }[];
 }
 
@@ -568,16 +565,6 @@ 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+)/);
@@ -761,7 +748,7 @@ export class CapacitorApp {
   async save() {
     await this.project.commit();
   }
-  async #prepareIos({ operation, env, regenerate = false, iosRunTargetKind }: PrepareConfig) {
+  async #prepareIos({ operation, env, regenerate = false }: PrepareConfig) {
     await this.init({ platform: "ios", operation, env, regenerate });
     await this.#prepareTargetAssets();
     await this.#prepareExternalFiles("ios");
@@ -770,10 +757,9 @@ 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 }, { iosRunTargetKind });
+    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation, env });
     this.app.verbose(`sync completed.`);
   }
   async buildIos({ env = "debug", regenerate = false }: { env?: RunConfig["env"]; regenerate?: boolean } = {}) {
@@ -791,14 +777,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, "--no-sync"],
+        ["cap", "run", "ios", "--target", runTarget.id],
         { operation, env },
-        { stdio: "inherit", platform: "ios", iosRunTargetKind: runTarget.kind },
+        { stdio: "inherit" },
       );
       return;
     }
@@ -892,10 +878,7 @@ export class CapacitorApp {
     noAllowProvisioningUpdates: boolean;
   }) {
     const mobileEnv = sanitizeIosNativeRunEnv(await this.#commandEnv(operation, env));
-    const configContent = await this.#writeCapacitorConfig(
-      { operation, platform: "ios", iosRunTargetKind: runTarget.kind },
-      mobileEnv,
-    );
+    const configContent = await this.#writeCapacitorConfig({ operation }, mobileEnv);
     await this.#writeRootCapacitorConfig(configContent);
     const scheme = this.#iosScheme();
     const command = buildIosNativeRunCommand({
@@ -960,7 +943,6 @@ 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();
@@ -1028,24 +1010,6 @@ 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 });
   }
@@ -1136,19 +1100,12 @@ export class CapacitorApp {
     if (html.includes("window.__AKAN_MOBILE_TARGET__")) return html;
     return html.replace(/<\/head\s*>/i, `${script}\n</head>`);
   }
-  async #writeCapacitorConfig(
-    {
-      operation,
-      platform,
-      iosRunTargetKind,
-    }: Pick<RunConfig, "operation"> & { platform?: MobilePlatform; iosRunTargetKind?: IosRunTargetKind },
-    commandEnv: MobileCommandEnv,
-  ) {
+  async #writeCapacitorConfig({ operation }: Pick<RunConfig, "operation">, 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 = await this.#resolveLocalDevHost({ override, platform, iosRunTargetKind });
+      const resolution = selectLocalDevHost(os.networkInterfaces(), { override });
       localIp = resolution.host;
       this.#logDevHostResolution(resolution, commandEnv);
     }
@@ -1161,36 +1118,11 @@ 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" || resolution.source === "platform") return;
+    if (resolution.source === "override") 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;
@@ -1400,29 +1332,20 @@ export class CapacitorApp {
     command: string,
     args: string[] = [],
     { operation, env }: Pick<RunConfig, "operation" | "env">,
-    options: SpawnMobileOptions = {},
+    options: Parameters<AppExecutor["spawn"]>[2] = {},
   ) {
-    const { iosRunTargetKind, platform, ...spawnOptions } = options;
     const mobileEnv = { ...(await this.#commandEnv(operation, env)), ...options.env };
-    const configContent = await this.#writeCapacitorConfig(
-      { operation, platform: platform ?? this.#inferMobilePlatform(args), iosRunTargetKind },
-      mobileEnv,
-    );
+    const configContent = await this.#writeCapacitorConfig({ operation }, mobileEnv);
     await this.#writeRootCapacitorConfig(configContent);
     try {
       return await this.#spawn(command, args, {
-        ...spawnOptions,
+        ...options,
         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.",
@@ -1523,31 +1446,14 @@ export class CapacitorApp {
       let end = index;
       while (end < lines.length && !/^\s*\};\s*$/.test(lines[end] ?? "")) end++;
       const settings = lines.slice(start, end + 1);
-      const configName = lines.slice(end + 1, end + 8).find((setting) => setting.includes("name = ")) ?? "";
+      if (settings.some((setting) => setting.includes("CODE_SIGN_ENTITLEMENTS"))) continue;
       const indent = line.match(/^\s*/)?.[0] ?? "";
-      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;
-      }
+      lines.splice(index, 0, `${indent}CODE_SIGN_ENTITLEMENTS = ${entitlementsRelPath};`);
+      index++;
+      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/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/cssCandidateCache.ts

@@ -1,12 +1,7 @@
 import { stat } from "node:fs/promises";
 
-/**
- * Every identifier-ish token in a source file is a potential tailwind class. The leading alternation
- * matters: an arbitrary variant starts with `[` (`[&_td]:px-3`, `[&>*]:gap-2`), and a pattern anchored
- * on a word character tears it into `_td` plus `px-3` instead — both meaningless, so the rule compiles
- * to nothing and the element silently renders unstyled.
- */
-const CANDIDATE_RE = /-?(?:[\w@]|\[[^\]]+\])[\w:/.-]*(?:\[[^\]]+\][\w:/.-]*)*/g;
+/** Every identifier-ish token in a source file is a potential tailwind class. */
+const CANDIDATE_RE = /-?[\w@][\w:/.-]*(?:\[[^\]]+\][\w:/.-]*)*/g;
 
 interface CachedFile {
   mtimeMs: number;
@@ -32,7 +27,7 @@ interface CacheFile {
  */
 export class CssCandidateCache {
   /** Bump when the token regex or the entry shape changes, so stale extractions are not reused. */
-  static readonly #version = 2;
+  static readonly #version = 1;
   readonly #path: string;
   readonly #entries = new Map<string, CachedFile>();
   #dirty = false;

package/frontendBuild/precompressArtifacts.ts

@@ -1,26 +1,41 @@
 import fs from "node:fs";
 import path from "node:path";
+import zlib from "node:zlib";
 import type { App } from "../commandDecorators";
 
 const COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
 const MIN_COMPRESS_BYTES = 1024;
+/**
+ * Quality 11 is roughly 100x slower than gzip, so it is spent only where it pays: there is one CSS asset
+ * per basePath and it is the largest single file the app ships, worth ~20% over gzip for ~0.2s. Raising the
+ * several hundred JS chunks from 9 to 11 costs ~12s of build time to save a few hundred KB, so they stay at 9.
+ */
+const BROTLI_QUALITY_BY_EXT = { ".css": 11 } as const;
+const DEFAULT_BROTLI_QUALITY = 9;
+const GZIP_LEVEL = 9;
 
 export interface PrecompressArtifactsResult {
   files: number;
   inputBytes: number;
   outputBytes: number;
+  brotliBytes: number;
 }
 
 export async function precompressArtifacts(app: App): Promise<PrecompressArtifactsResult> {
-  const roots = [path.join(app.dist.cwdPath, ".akan/artifact/client")];
-  const result: PrecompressArtifactsResult = { files: 0, inputBytes: 0, outputBytes: 0 };
+  //* styles too: WebRouter serves both prefixes through the same sidecar-aware #fileResponse, and the
+  //* one CSS asset per basePath is the largest uncompressed payload the app ships.
+  const roots = [
+    path.join(app.dist.cwdPath, ".akan/artifact/client"),
+    path.join(app.dist.cwdPath, ".akan/artifact/styles"),
+  ];
+  const result: PrecompressArtifactsResult = { files: 0, inputBytes: 0, outputBytes: 0, brotliBytes: 0 };
 
   await Promise.all(roots.map((root) => precompressRoot(root, result)));
   if (result.files > 0) {
     app.verbose(
-      `[precompress] wrote ${result.files} gzip sidecars (${formatBytes(result.inputBytes)} -> ${formatBytes(
+      `[precompress] wrote ${result.files} sidecars (${formatBytes(result.inputBytes)} -> gzip ${formatBytes(
         result.outputBytes,
-      )})`,
+      )} / br ${formatBytes(result.brotliBytes)})`,
     );
   }
   return result;
@@ -32,16 +47,29 @@ async function precompressRoot(root: string, result: PrecompressArtifactsResult)
   for await (const filePath of glob.scan({ cwd: root, absolute: true })) {
     if (!(await shouldPrecompress(filePath))) continue;
     const bytes = await Bun.file(filePath).bytes();
-    const gz = Bun.gzipSync(toArrayBuffer(bytes));
-    await Bun.write(`${filePath}.gz`, gz);
+    const buffer = toArrayBuffer(bytes);
+    const gz = Bun.gzipSync(buffer, { level: GZIP_LEVEL });
+    const br = brotliCompress(buffer, path.extname(filePath).toLowerCase());
+    await Promise.all([Bun.write(`${filePath}.gz`, gz), Bun.write(`${filePath}.br`, br)]);
     result.files += 1;
     result.inputBytes += bytes.byteLength;
     result.outputBytes += gz.byteLength;
+    result.brotliBytes += br.byteLength;
   }
 }
 
+function brotliCompress(buffer: ArrayBuffer, ext: string): Buffer {
+  const quality = BROTLI_QUALITY_BY_EXT[ext as keyof typeof BROTLI_QUALITY_BY_EXT] ?? DEFAULT_BROTLI_QUALITY;
+  return zlib.brotliCompressSync(buffer, {
+    params: {
+      [zlib.constants.BROTLI_PARAM_QUALITY]: quality,
+      [zlib.constants.BROTLI_PARAM_SIZE_HINT]: buffer.byteLength,
+    },
+  });
+}
+
 async function shouldPrecompress(filePath: string): Promise<boolean> {
-  if (filePath.endsWith(".gz")) return false;
+  if (filePath.endsWith(".gz") || filePath.endsWith(".br")) return false;
   if (!COMPRESSIBLE_EXTS.has(path.extname(filePath).toLowerCase())) return false;
   const file = Bun.file(filePath);
   if (!(await file.exists())) return false;

package/frontendBuild/routeClientBuilder.ts

@@ -33,6 +33,15 @@ export interface BuildRouteClientOptions {
   routeId?: string;
   command?: "build" | "start";
   discovery?: ClientEntryDiscovery;
+  /**
+   * Client entries resolved by the caller, which skips discovery and bundles exactly this list.
+   *
+   * `AllRoutesBuilder` passes every route's entries at once so they share one `Bun.build`. Chunk
+   * splitting is scoped to a single invocation, so a dependency reachable from entries spread across
+   * several invocations is emitted once per invocation — mermaid landed in `apps/akan` four times that
+   * way. Dev keeps one build per route and leaves this unset.
+   */
+  entries?: string[];
 }
 
 export interface BuildRouteClientResult {
@@ -61,6 +70,7 @@ export class RouteClientBuilder {
   #knownEntries: Set<string>;
   #command: "build" | "start";
   #discovery?: ClientEntryDiscovery;
+  #entries?: string[];
 
   constructor(options: BuildRouteClientOptions) {
     this.#app = options.app;
@@ -68,11 +78,13 @@ export class RouteClientBuilder {
     this.#knownEntries = options.knownEntries ?? new Set<string>();
     this.#command = options.command ?? "start";
     this.#discovery = options.discovery;
+    this.#entries = options.entries;
   }
 
   async build(): Promise<BuildRouteClientResult> {
-    const discovery = this.#discovery ?? (await GraphClientEntryDiscovery.create(this.#app));
-    const discovered = await discovery.discover(this.#seeds);
+    const discovered =
+      this.#entries ??
+      (await (this.#discovery ?? (await GraphClientEntryDiscovery.create(this.#app))).discover(this.#seeds));
     const entries = discovered.filter((e) => !this.#knownEntries.has(e));
     if (entries.length === 0) return this.#emptyResult(discovered);
 

package/integration/devResourceProbe.ts

@@ -285,9 +285,14 @@ export class DevResourceProbe {
       "rscWorkerRecycleCount",
       "httpFullSsrCount",
     ];
-    const rssMb = (Number(child.rssBytes ?? 0) / 1024 / 1024).toFixed(0);
+    // `rssBytes` is the replica's own; the RSC worker is a separate process reporting under
+    // `rscWorker*`. These used to be the same field, because the worker's report shadowed the
+    // replica's — so this line printed the worker's RSS labelled as the child's.
+    const toMb = (bytes: unknown) => (Number(bytes ?? 0) / 1024 / 1024).toFixed(0);
     const parts = keys.map((key) => `${key}=${child[key] ?? "?"}`);
-    console.info(`[metrics ${label}] rsc rss=${rssMb}MB ${parts.join(" ")}`);
+    console.info(
+      `[metrics ${label}] replicaRss=${toMb(child.rssBytes)}MB rscWorkerRss=${toMb(child.rscWorkerRssBytes)}MB ${parts.join(" ")}`,
+    );
   }
 
   async #waitForLog(pattern: RegExp, timeoutMs: number): Promise<boolean> {