@akanjs/cli 3.0.0-alpha.9 → 3.0.0-alpha.90

package/{index-z8ptfkzv.js → index-q8sn827n.js}

@@ -1,16 +1,189 @@
 // @bun
-import {
-  Spinner
-} from "./index-mxvakhsm.js";
-import {
-  getDirname
-} from "./index-1577bej2.js";
 import {
   FileSys
-} from "./index-67546d0j.js";
+} from "./index-q0y2jq9j.js";
 import {
-  __require
-} from "./index-r24hmh0q.js";
+  getDirname2
+} from "./index-6wwzs1bc.js";
+
+// pkgs/@akanjs/devkit/codegenLock.ts
+import { mkdir, open, readFile, rm, stat } from "fs/promises";
+import path from "path";
+import { Logger } from "akanjs/common";
+
+class CodegenLock {
+  static fileName = "codegen.lock";
+  static waitTimeoutMs = 1e4;
+  static unknownHolderStaleMs = 60000;
+  static #pollMs = 25;
+  static #logger = new Logger("CodegenLock");
+  static #queue = Promise.resolve();
+  static pathIn(workspaceRoot) {
+    return path.join(workspaceRoot, "local", ".akan", CodegenLock.fileName);
+  }
+  static async run(workspaceRoot, label, fn) {
+    const ahead = CodegenLock.#queue;
+    let done;
+    CodegenLock.#queue = new Promise((resolve) => {
+      done = resolve;
+    });
+    try {
+      await CodegenLock.#waitForQueue(ahead, label);
+      return await CodegenLock.#withFileLock(workspaceRoot, label, fn);
+    } finally {
+      done();
+    }
+  }
+  static async#waitForQueue(ahead, label) {
+    let timer = null;
+    const expired = new Promise((resolve) => {
+      timer = setTimeout(() => resolve("expired"), CodegenLock.waitTimeoutMs);
+    });
+    try {
+      if (await Promise.race([ahead.then(() => "done"), expired]) === "expired")
+        CodegenLock.#logger.warn(`codegen lock queued past ${CodegenLock.waitTimeoutMs}ms in this process; continuing without waiting (${label})`);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  static async#withFileLock(workspaceRoot, label, fn) {
+    const lockPath = CodegenLock.pathIn(workspaceRoot);
+    await mkdir(path.dirname(lockPath), { recursive: true }).catch(() => {
+      return;
+    });
+    const held = await CodegenLock.#acquire(lockPath, label);
+    try {
+      return await fn();
+    } finally {
+      if (held)
+        await rm(lockPath, { force: true }).catch(() => {
+          return;
+        });
+    }
+  }
+  static async#acquire(lockPath, label) {
+    const deadline = Date.now() + CodegenLock.waitTimeoutMs;
+    for (;; ) {
+      const handle = await open(lockPath, "wx").catch(() => null);
+      if (handle) {
+        await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now(), label })).catch(() => {
+          return;
+        });
+        await handle.close().catch(() => {
+          return;
+        });
+        return true;
+      }
+      if (await CodegenLock.#reclaimIfAbandoned(lockPath))
+        continue;
+      if (Date.now() >= deadline) {
+        CodegenLock.#logger.warn(`codegen lock at ${lockPath} held past ${CodegenLock.waitTimeoutMs}ms; continuing without it (${label})`);
+        return false;
+      }
+      await Bun.sleep(CodegenLock.#pollMs);
+    }
+  }
+  static async#reclaimIfAbandoned(lockPath) {
+    const info = await stat(lockPath).catch(() => null);
+    if (!info)
+      return true;
+    const holder = CodegenLock.#parseHolder(await readFile(lockPath, "utf8").catch(() => ""));
+    if (holder) {
+      if (CodegenLock.#isAlive(holder.pid))
+        return false;
+    } else if (Date.now() - info.mtimeMs < CodegenLock.unknownHolderStaleMs)
+      return false;
+    await rm(lockPath, { force: true }).catch(() => {
+      return;
+    });
+    return true;
+  }
+  static #parseHolder(raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.pid !== "number" || typeof parsed.at !== "number")
+        return null;
+      return { pid: parsed.pid, at: parsed.at, label: typeof parsed.label === "string" ? parsed.label : "" };
+    } catch {
+      return null;
+    }
+  }
+  static #isAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+      return false;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/spinner.ts
+import ora from "ora";
+
+class Spinner {
+  static padding = 12;
+  static oraOptions = { discardStdin: false };
+  static canAnimate(stream = process.stderr) {
+    return !stream.isTTY || stream.columns > 0;
+  }
+  spinner;
+  stopWatch = null;
+  startAt = new Date;
+  prefix;
+  message;
+  enableSpin;
+  constructor(message, { prefix = "", indent = 0, enableSpin = true } = {}) {
+    Spinner.padding = Math.max(Spinner.padding, prefix.length);
+    this.prefix = prefix;
+    this.message = message;
+    this.spinner = ora({ ...Spinner.oraOptions, text: message });
+    this.spinner.prefixText = prefix.padStart(Spinner.padding, " ");
+    this.spinner.indent = indent;
+    this.enableSpin = enableSpin && Spinner.canAnimate();
+  }
+  start() {
+    this.startAt = new Date;
+    if (this.enableSpin) {
+      this.spinner.start();
+      this.stopWatch = setInterval(() => {
+        this.spinner.prefixText = this.prefix.padStart(Spinner.padding, " ");
+        this.spinner.text = `${this.message} (${this.#getElapsedTimeStr({ floor: true })})`;
+      }, 1000);
+    } else
+      this.spinner.info();
+    return this;
+  }
+  succeed(message) {
+    this.spinner.succeed(`${message} (${this.#getElapsedTimeStr()})`);
+    this.#reset();
+  }
+  fail(message) {
+    this.spinner.fail(`${message} (${this.#getElapsedTimeStr()})`);
+    this.#reset();
+  }
+  isSpinning() {
+    return this.spinner.isSpinning;
+  }
+  #reset() {
+    if (this.stopWatch)
+      clearInterval(this.stopWatch);
+    this.stopWatch = null;
+  }
+  #getElapsedTimeStr({ floor = false } = {}) {
+    const ms = Date.now() - this.startAt.getTime();
+    if (ms < 1000)
+      return `${ms}ms`;
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+      return `${floor ? Math.floor(ms / 1000) : Math.floor(ms / 100) / 10}s`;
+    const m = Math.floor(s / 60);
+    return `${m}m ${s % 60}s`;
+  }
+}
 
 // pkgs/@akanjs/devkit/executors.ts
 import {
@@ -22,19 +195,20 @@ import { readFileSync as readFileSync2 } from "fs";
 import {
   copyFile,
   cp as cpEntry,
-  mkdir,
+  mkdir as mkdir3,
   readdir as readDirEntries,
   realpath,
-  rm as rm2,
-  stat,
+  rm as rm3,
+  stat as stat2,
   symlink
 } from "fs/promises";
-import path5 from "path";
+import path8 from "path";
 import { pathToFileURL } from "url";
 import {
   capitalize,
+  getPageSourceFileViolation,
   isRouteSourceFile,
-  Logger,
+  Logger as Logger2,
   parseRouteModuleKey,
   validatePageSourceFile,
   validateSubRoutePageKey
@@ -44,7 +218,7 @@ import chalk2 from "chalk";
 
 // pkgs/@akanjs/devkit/agentsIndex.ts
 var recipeScannerLoad = null;
-var loadRecipeScanner = () => recipeScannerLoad ??= import("./recipeScanner-tghkzrrt.js");
+var loadRecipeScanner = () => recipeScannerLoad ??= import("./recipeScanner-fpagtgc1.js");
 var AGENT_BLOCK_START = "<!-- akan:agent:start -->";
 var AGENT_BLOCK_END = "<!-- akan:agent:end -->";
 var AGENT_VERSION_PREFIX = "<!-- akan:agent:version ";
@@ -54,9 +228,9 @@ ${block}`;
 var extractBlockVersion = (content) => content.match(/<!-- akan:agent:version ([^\s]+) -->/)?.[1] ?? null;
 var readDevkitVersion = async () => {
   const { readFile } = await import("fs/promises");
-  const { getDirname: getDirname2 } = await import("./getDirname-m9s0cmhq.js");
+  const { getDirname } = await import("./getDirname-dr3jz1xg.js");
   try {
-    const raw = await readFile(`${getDirname2(import.meta.url)}/package.json`, "utf-8");
+    const raw = await readFile(`${getDirname(import.meta.url)}/package.json`, "utf-8");
     return JSON.parse(raw).version ?? null;
   } catch {
     return null;
@@ -155,15 +329,36 @@ ${AGENT_BLOCK_START}
 ${block}
 ${AGENT_BLOCK_END}
 `;
+var CLAUDE_COMMENT_RULE = `## Comments \u2014 Overrides Your Default
+
+Write **no comments** unless the comment passes the test below. This is the rule agents break most often here, so it
+is repeated outside the guide: a diff that adds a comment the test rejects is a diff to redo.
+
+Before typing \`//\`, \`/*\`, or a doc block, ask \u2014 **does this sentence carry a fact that is nowhere in the code?**
+
+- Restates the identifier, the signature, or the line under it \u2192 delete it.
+- Labels a section (\`// helpers\`, \`// state\`) or narrates a step (\`// fetch the user\`, \`// then save\`) \u2192 delete it.
+- JSDoc on an ordinary function, or a why/how preamble on ordinary logic \u2192 delete it.
+- Explains the edit you just made, for whoever reads the diff \u2192 say it in your reply, not in the file.
+- Names a vendor or protocol quirk, an infrastructure constraint, a library gotcha, security reasoning, a math
+  derivation, a domain field's business meaning, a state transition, or why an obvious alternative was rejected \u2192
+  keep it, one line.
+
+That keep-list is exact \u2014 \`Comments\` in the guide is the full version. "It aids readability" and "this logic is
+subtle" are not on it: rename or split the code instead. When you edit an existing file, match its density; if the
+surrounding code carries none, your diff carries none.`;
 var renderScopeClaudeMd = (scope) => `# ${scope.name} \u2014 Claude Code Guide
 
 @AGENTS.md
+
+${CLAUDE_COMMENT_RULE}
 `;
 
 // pkgs/@akanjs/devkit/akanConfig/akanConfig.ts
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 import { fileURLToPath } from "url";
+import { normalizeRoutePrefix } from "akanjs/base";
 import { resolveAkanI18nConfig } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/akanConfig/types.ts
@@ -199,9 +394,8 @@ var DEFAULT_OPTIMIZE_IMPORTS = [
   "react-icons/*"
 ];
 var WORKSPACE_BARREL_FACETS = ["ui", "webkit", "common", "client", "server"];
+var DEFAULT_DOCKER_IMAGE = "oven/bun:1-slim";
 var SSR_RUNTIME_PACKAGES = ["react", "react-dom", "react-server-dom-webpack"];
-var NATIVE_RUNTIME_PACKAGES = ["sharp"];
-var DEFAULT_BACKEND_RUNTIME_PACKAGES = ["croner"];
 var MOBILE_RUNTIME_PACKAGES = [
   "@capacitor/cli",
   "@capacitor/core",
@@ -230,8 +424,6 @@ var DATABASE_MODE_RUNTIME_PACKAGES = {
 };
 var AKAN_RUNTIME_PACKAGES = new Set([
   ...SSR_RUNTIME_PACKAGES,
-  ...NATIVE_RUNTIME_PACKAGES,
-  ...DEFAULT_BACKEND_RUNTIME_PACKAGES,
   ...MOBILE_RUNTIME_PACKAGES,
   ...Object.values(DATABASE_MODE_RUNTIME_PACKAGES).flat()
 ]);
@@ -246,14 +438,15 @@ var DEFAULT_AKAN_IMAGE_CONFIG = {
   dangerouslyAllowSVG: false,
   maximumRedirects: 3,
   fetchTimeoutMs: 7000,
-  maxRemoteBytes: 25 * 1024 * 1024
+  maxRemoteBytes: 25 * 1024 * 1024,
+  maxConcurrency: 0
 };
 var normalizeIndexPath = (indexPath) => {
   const normalized = indexPath?.trim();
   if (!normalized)
     return;
-  const path2 = `/${normalized.replace(/^\/+|\/+$/g, "")}`;
-  return path2 === "/" ? "/" : path2;
+  const path = `/${normalized.replace(/^\/+|\/+$/g, "")}`;
+  return path === "/" ? "/" : path;
 };
 var normalizeStringList = (values) => {
   const normalized = values?.map((value) => value.trim()).filter(Boolean) ?? [];
@@ -293,21 +486,39 @@ var normalizeDeepLinks = (deepLinks) => {
     ...sha256CertFingerprints ? { android: { sha256CertFingerprints } } : {}
   };
 };
+var emptyLibContributions = () => ({
+  externalLibs: [],
+  docker: { preRuns: [], postRuns: [] },
+  keepFonts: []
+});
+var normalizeKeepFonts = (keepFonts) => [
+  ...new Set((keepFonts ?? []).map((glob) => glob.trim().replace(/^\/+/, "")).filter(Boolean))
+];
+var dedupeDockerRuns = (runs) => {
+  const byKey = new Map;
+  for (const run of runs)
+    byKey.set(typeof run === "string" ? run : JSON.stringify(run), run);
+  return [...byKey.values()];
+};
 
 class AkanAppConfig {
   app;
   rootPackageJson;
   docker;
+  dockerfile;
   defaultDatabaseMode;
+  web;
   externalLibs;
   barrelImports;
   optimizeImports;
   images;
   i18n;
+  api;
   publicEnv;
   mobile;
   hasMobileConfig;
   secrets;
+  assets;
   syncPageLibs;
   baseDevEnv;
   libs;
@@ -316,7 +527,7 @@ class AkanAppConfig {
   subRoutes = new Map;
   basePaths = new Set;
   branches = new Set(["debug", "develop", "main"]);
-  constructor(app, libs, rootPackageJson, config, baseDevEnv, plugins = []) {
+  constructor(app, libs, rootPackageJson, config, baseDevEnv, plugins = [], libContributions = emptyLibContributions()) {
     this.app = app;
     this.rootPackageJson = rootPackageJson;
     this.libs = libs;
@@ -324,7 +535,7 @@ class AkanAppConfig {
     this.plugins = plugins;
     this.#applyRoutes(config?.routes);
     this.defaultDatabaseMode = config?.defaultDatabaseMode ?? "single";
-    this.externalLibs = config?.externalLibs ?? [];
+    this.externalLibs = [...new Set([...config?.externalLibs ?? [], ...libContributions.externalLibs])];
     this.barrelImports = [
       ...DEFAULT_BARREL_IMPORTS,
       ...WORKSPACE_BARREL_FACETS.map((facet) => `@apps/${app.name}/${facet}`),
@@ -336,12 +547,33 @@ class AkanAppConfig {
     this.i18n = resolveAkanI18nConfig(config?.i18n);
     process.env.AKAN_PUBLIC_DEFAULT_LOCALE = this.i18n.defaultLocale;
     process.env.AKAN_PUBLIC_LOCALES = this.i18n.locales.join(",");
+    this.api = {
+      prefix: normalizeRoutePrefix(config?.api?.prefix) ?? "/api",
+      websocketPrefix: normalizeRoutePrefix(config?.api?.websocketPrefix) ?? "/ws"
+    };
+    process.env.AKAN_PUBLIC_API_PREFIX = this.api.prefix;
+    process.env.AKAN_PUBLIC_WS_PREFIX = this.api.websocketPrefix;
     this.publicEnv = config?.publicEnv ?? [];
     this.secrets = config?.secrets ?? [];
+    this.assets = {
+      pruneFonts: config?.assets?.pruneFonts ?? true,
+      keepFonts: [
+        ...normalizeKeepFonts(config?.assets?.keepFonts),
+        ...libContributions.keepFonts ?? []
+      ]
+    };
     this.syncPageLibs = config?.syncPageLibs ?? false;
     this.hasMobileConfig = Boolean(config.mobile);
     this.mobile = this.#resolveMobileConfig(config.mobile);
-    this.docker = this.#makeDockerContent(config?.docker ?? {});
+    this.web = this.#resolveWebConfig(config.web);
+    this.docker = AkanAppConfig.#resolveDocker(config.docker, libContributions.docker);
+    this.dockerfile = this.#makeDockerfile();
+  }
+  #resolveWebConfig(web) {
+    const resolved = typeof web === "object" ? { ssr: true, csr: web.csr } : { ssr: web ?? true, csr: web ?? true };
+    if (!resolved.csr && this.hasMobileConfig)
+      throw new Error(`apps/${this.app.name}/akan.config.ts turns the CSR bundle off but declares mobile targets; the Capacitor build ships that bundle. Drop the mobile section or leave CSR on.`);
+    return resolved;
   }
   #resolveMobileConfig(mobile) {
     const {
@@ -451,23 +683,31 @@ class AkanAppConfig {
       return archs.map((arch) => `FROM ${image[arch] ?? defaultImage} AS ${arch}`).join(`
 `);
   }
-  #makeDockerContent(docker) {
-    if (docker.content)
-      return {
-        content: docker.content,
-        image: {},
-        preRuns: [],
-        postRuns: [],
-        command: []
-      };
-    const preRunScripts = this.#getDockerRunScripts(docker.preRuns ?? []);
-    const postRunScripts = this.#getDockerRunScripts(docker.postRuns ?? []);
-    const imageScript = docker.image ? this.#getDockerImageScript(docker.image, "oven/bun:1-slim") : "FROM oven/bun:1-slim";
-    const command = docker.command ?? ["bun", "main.js"];
-    const content = `${imageScript}
+  static #resolveDocker(docker, libDocker) {
+    if (typeof docker === "string")
+      return docker;
+    return {
+      image: docker?.image ?? DEFAULT_DOCKER_IMAGE,
+      preRuns: dedupeDockerRuns([...libDocker.preRuns, ...docker?.preRuns ?? []]),
+      postRuns: dedupeDockerRuns([...libDocker.postRuns, ...docker?.postRuns ?? []]),
+      command: docker?.command ?? ["bun", "main.js"]
+    };
+  }
+  #makeDockerfile() {
+    if (typeof this.docker === "string")
+      return this.docker;
+    const { image, preRuns, postRuns, command } = this.docker;
+    const preRunScripts = this.#getDockerRunScripts(preRuns);
+    const postRunScripts = this.#getDockerRunScripts(postRuns);
+    const imageScript = this.#getDockerImageScript(image, DEFAULT_DOCKER_IMAGE);
+    const webEnvLines = [
+      ...this.web.ssr ? [] : ["ENV AKAN_SSR=false"],
+      ...this.web.csr ? [] : ["ENV AKAN_CSR=false"]
+    ].join(`
+`);
+    return `${imageScript}
+RUN apt-get update && apt-get upgrade -y && apt-get install -y --no-install-recommends ca-certificates tzdata && rm -rf /var/lib/apt/lists/*
 RUN ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
-RUN apt-get update && apt-get upgrade -y
-RUN apt-get install -y --no-install-recommends git redis build-essential python3 ca-certificates fonts-liberation libappindicator3-1 libasound2 libatk-bridge2.0-0 libatk1.0-0 libc6 libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 libgbm1 libgcc1 libglib2.0-0 libgtk-3-0 libnspr4 libnss3 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 libx11-xcb1 libxcb1 libxcomposite1 libxcursor1 libxdamage1 libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 libxtst6 lsb-release wget xdg-utils udev ffmpeg
 ARG TARGETARCH
 ${preRunScripts.join(`
 `)}
@@ -487,16 +727,12 @@ ENV AKAN_PUBLIC_ENV=${this.baseDevEnv.env}
 ${this.basePaths.size ? `ENV AKAN_PUBLIC_BASE_PATHS=${[...this.basePaths].join(",")}` : ""}
 ENV AKAN_PUBLIC_DEFAULT_LOCALE=${this.i18n.defaultLocale}
 ENV AKAN_PUBLIC_LOCALES=${this.i18n.locales.join(",")}
+ENV AKAN_PUBLIC_API_PREFIX=${this.api.prefix}
+ENV AKAN_PUBLIC_WS_PREFIX=${this.api.websocketPrefix}
 ENV AKAN_PUBLIC_OPERATION_MODE=cloud
-
+ENV AKAN_LOG_TO_FILE=0
+${webEnvLines}
 CMD [${command.map((c) => `"${c}"`).join(",")}]`;
-    return {
-      content,
-      image: imageScript,
-      preRuns: docker.preRuns ?? [],
-      postRuns: docker.postRuns ?? [],
-      command
-    };
   }
   static #importGeneration = 0;
   static async importConfigModule(cwdPath, { bustImportCache = false } = {}) {
@@ -507,13 +743,28 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
   static async from(app, { bustImportCache = false } = {}) {
     const [configImp, baseDevEnv, libs, rootPackageJson] = await Promise.all([
       AkanAppConfig.importConfigModule(app.cwdPath, { bustImportCache }),
-      WorkspaceExecutor.getBaseDevEnv(path.join(app.workspace.workspaceRoot, ".env")),
+      WorkspaceExecutor.getBaseDevEnv(path2.join(app.workspace.workspaceRoot, ".env")),
       app.workspace.getLibs(),
       app.workspace.getPackageJson()
     ]);
     const resolved = typeof configImp === "function" ? configImp(app) : configImp;
     const { plugins, ...config } = resolved ?? {};
-    return new AkanAppConfig(app, libs, rootPackageJson, config, baseDevEnv, plugins ?? []);
+    const libContributions = await AkanAppConfig.#collectLibContributions(app, libs, bustImportCache);
+    return new AkanAppConfig(app, libs, rootPackageJson, config, baseDevEnv, plugins ?? [], libContributions);
+  }
+  static async#collectLibContributions(app, libs, bustImportCache) {
+    const libConfigs = await Promise.all(libs.map(async (libName) => LibExecutor.from(app, libName).getConfig({ refresh: bustImportCache }).catch((error) => {
+      app.logger.warn(`Skipped libs/${libName}/akan.config.ts contributions: ${String(error)}`);
+      return null;
+    })));
+    return {
+      externalLibs: libConfigs.flatMap((libConfig) => libConfig?.externalLibs ?? []),
+      docker: {
+        preRuns: libConfigs.flatMap((libConfig) => libConfig?.docker.preRuns ?? []),
+        postRuns: libConfigs.flatMap((libConfig) => libConfig?.docker.postRuns ?? [])
+      },
+      keepFonts: libConfigs.flatMap((libConfig) => (libConfig?.assets.keepFonts ?? []).map((glob) => `libs/${libConfig?.lib.name}/${glob}`))
+    };
   }
   #resolveProductionDependencyVersion(lib) {
     const rootVersion = this.rootPackageJson.dependencies?.[lib] ?? this.rootPackageJson.devDependencies?.[lib];
@@ -523,13 +774,7 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
     return akanPackageJson.dependencies?.[lib] ?? akanPackageJson.peerDependencies?.[lib];
   }
   #getProductionRuntimePackages() {
-    return [
-      ...this.externalLibs,
-      ...SSR_RUNTIME_PACKAGES,
-      ...NATIVE_RUNTIME_PACKAGES,
-      ...DEFAULT_BACKEND_RUNTIME_PACKAGES,
-      ...this.getDatabaseModeRuntimePackages()
-    ];
+    return [...this.externalLibs, ...SSR_RUNTIME_PACKAGES, ...this.getDatabaseModeRuntimePackages()];
   }
   getDatabaseModeRuntimePackages(databaseMode = this.defaultDatabaseMode) {
     return [...DATABASE_MODE_RUNTIME_PACKAGES[databaseMode]];
@@ -578,11 +823,11 @@ var akanPackageJson = null;
 function getAkanPackageJson() {
   if (akanPackageJson)
     return akanPackageJson;
-  const sourceDir = path.dirname(fileURLToPath(import.meta.url));
+  const sourceDir = path2.dirname(fileURLToPath(import.meta.url));
   const packageJsonPaths = [
-    path.join(sourceDir, "../../../akanjs/package.json"),
-    path.join(process.cwd(), "pkgs/akanjs/package.json"),
-    path.join(path.dirname(Bun.main), "node_modules/akanjs/package.json")
+    path2.join(sourceDir, "../../../akanjs/package.json"),
+    path2.join(process.cwd(), "pkgs/akanjs/package.json"),
+    path2.join(path2.dirname(Bun.main), "node_modules/akanjs/package.json")
   ];
   try {
     packageJsonPaths.unshift(Bun.resolveSync("akanjs/package.json", sourceDir));
@@ -617,14 +862,18 @@ function mergeImageConfig(config = {}) {
 class AkanLibConfig {
   lib;
   externalLibs;
+  docker;
+  assets;
   plugins;
   constructor(lib, config, plugins = []) {
     this.lib = lib;
     this.externalLibs = config?.externalLibs ?? [];
+    this.docker = { preRuns: config?.docker?.preRuns ?? [], postRuns: config?.docker?.postRuns ?? [] };
+    this.assets = { keepFonts: normalizeKeepFonts(config?.assets?.keepFonts) };
     this.plugins = plugins;
   }
-  static async from(lib) {
-    const [configImp] = await Promise.all([import(`${lib.cwdPath}/akan.config.ts`).then((mod) => mod.default)]);
+  static async from(lib, { bustImportCache = false } = {}) {
+    const configImp = await AkanAppConfig.importConfigModule(lib.cwdPath, { bustImportCache });
     const resolved = typeof configImp === "function" ? configImp(lib) : configImp;
     const { plugins, ...config } = resolved ?? {};
     return new AkanLibConfig(lib, config, plugins ?? []);
@@ -633,49 +882,448 @@ class AkanLibConfig {
 //! need to refactor
 var increaseBuildNum = async (app) => {
   const appConfig = await AkanAppConfig.from(app);
-  const akanConfigPath = path.join(app.cwdPath, "akan.config.ts");
+  const akanConfigPath = path2.join(app.cwdPath, "akan.config.ts");
   const akanConfig = fs.readFileSync(akanConfigPath, "utf8");
   const akanConfigContent = akanConfig.replace(`buildNum: ${appConfig.mobile.buildNum}`, `buildNum: ${appConfig.mobile.buildNum + 1}`);
   fs.writeFileSync(akanConfigPath, akanConfigContent);
 };
 var decreaseBuildNum = async (app) => {
   const appConfig = await AkanAppConfig.from(app);
-  const akanConfigPath = path.join(app.cwdPath, "akan.config.ts");
+  const akanConfigPath = path2.join(app.cwdPath, "akan.config.ts");
   const akanConfig = fs.readFileSync(akanConfigPath, "utf8");
   const akanConfigContent = akanConfig.replace(`buildNum: ${appConfig.mobile.buildNum}`, `buildNum: ${appConfig.mobile.buildNum - 1}`);
   fs.writeFileSync(akanConfigPath, akanConfigContent);
 };
+// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import path4 from "path";
+
+// pkgs/@akanjs/devkit/transforms/asyncDefaultExportDetector.ts
+import fs2 from "fs";
+import path3 from "path";
+
+class AsyncDefaultExportDetector {
+  static #typescriptLoad;
+  static #loadTypescript() {
+    AsyncDefaultExportDetector.#typescriptLoad ??= import("typescript").then((mod) => mod.default ?? mod);
+    return AsyncDefaultExportDetector.#typescriptLoad;
+  }
+  static async detect(moduleAbsPath) {
+    try {
+      const typescript = await AsyncDefaultExportDetector.#loadTypescript();
+      const source = fs2.readFileSync(path3.resolve(moduleAbsPath), "utf8");
+      const sourceFile = typescript.createSourceFile(moduleAbsPath, source, typescript.ScriptTarget.Latest, true, AsyncDefaultExportDetector.#scriptKind(typescript, moduleAbsPath));
+      return new AsyncDefaultExportDetector(typescript).detectInSourceFile(sourceFile);
+    } catch {
+      return false;
+    }
+  }
+  #ts;
+  constructor(typescript) {
+    this.#ts = typescript;
+  }
+  detectInSourceFile(sourceFile) {
+    const ts = this.#ts;
+    const asyncBindings = new Map;
+    let defaultIdentifier = null;
+    for (const statement of sourceFile.statements) {
+      if (ts.isFunctionDeclaration(statement)) {
+        if (this.#hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+          return this.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword);
+        }
+        if (statement.name) {
+          asyncBindings.set(statement.name.text, this.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword));
+        }
+        continue;
+      }
+      if (ts.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+          if (!ts.isIdentifier(declaration.name))
+            continue;
+          asyncBindings.set(declaration.name.text, this.#isAsyncFunctionExpression(declaration.initializer));
+        }
+        continue;
+      }
+      if (ts.isExportAssignment(statement)) {
+        if (this.#isAsyncFunctionExpression(statement.expression))
+          return true;
+        if (ts.isIdentifier(statement.expression))
+          defaultIdentifier = statement.expression.text;
+        continue;
+      }
+      if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        const exportClause = statement.exportClause;
+        for (const specifier of exportClause.elements) {
+          if (specifier.name.text !== "default")
+            continue;
+          defaultIdentifier = specifier.propertyName?.text ?? specifier.name.text;
+        }
+      }
+    }
+    return defaultIdentifier ? asyncBindings.get(defaultIdentifier) === true : false;
+  }
+  #hasModifier(node, kind) {
+    const ts = this.#ts;
+    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+  }
+  #isAsyncFunctionExpression(node) {
+    const ts = this.#ts;
+    return Boolean(node && (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && this.#hasModifier(node, ts.SyntaxKind.AsyncKeyword));
+  }
+  static #scriptKind(typescript, moduleAbsPath) {
+    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? typescript.ScriptKind.TSX : typescript.ScriptKind.TS;
+  }
+}
+
+// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
+var LAYOUT_KEY_RE = /^\.\/(.+\/)?_layout\.(tsx|ts|jsx|js)$/;
+async function appHasStModule(appCwdPath) {
+  return Bun.file(path4.join(appCwdPath, "lib", "st.ts")).exists();
+}
+var IMPLICIT_LAYOUT_DIR = path4.join(".akan", "generated", "root-layouts");
+var IMPLICIT_DICT_DIR = path4.join(".akan", "generated", "dict");
+var IMPLICIT_OVERRIDES_DIR = path4.join(".akan", "generated", "overrides");
+var OVERRIDES_KEY_RE = /^\.\/(.+\/)?_overrides\.(tsx|ts|jsx|js)$/;
+async function writeGeneratedOverridesLayoutFile(opts) {
+  const filename = `${opts.key.replace(/^\.\//, "").replace(/[^a-zA-Z0-9]+/g, "_")}.tsx`;
+  const absPath = path4.join(path4.resolve(opts.appCwdPath), IMPLICIT_OVERRIDES_DIR, filename);
+  const userRel = path4.relative(path4.dirname(absPath), opts.userAbsPath).split(path4.sep).join("/");
+  const userSpecifier = userRel.startsWith(".") ? userRel : `./${userRel}`;
+  const source = `"use client";
+import { UiOverrideProvider } from "akanjs/ui";
+import { createElement, type ReactNode } from "react";
+import value from ${JSON.stringify(userSpecifier)};
+
+export default function AkanUiOverridesLayout({ children }: { children?: ReactNode }) {
+  return createElement(UiOverrideProvider, { value }, children);
+}
+`;
+  await Bun.write(absPath, source);
+  return absPath;
+}
+function getRootBoundarySegments(key) {
+  const match = LAYOUT_KEY_RE.exec(key);
+  if (!match)
+    return null;
+  const prefix = match[1]?.replace(/\/$/, "");
+  if (!prefix)
+    return [];
+  return prefix.split("/").filter(Boolean);
+}
+function implicitRootLayoutKey(segments) {
+  return `./${[...segments, "__root_layout"].join("/")}.tsx`;
+}
+function implicitRootLayoutAbsPath(appCwdPath, segments) {
+  const filename = segments.length ? `${segments.join("__")}__root_layout.tsx` : "__root_layout.tsx";
+  return path4.join(path4.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
+}
+function implicitDictionaryMacroAbsPath(appCwdPath) {
+  return path4.join(path4.resolve(appCwdPath), IMPLICIT_DICT_DIR, "useDict.ts");
+}
+function isRootBoundarySegments(segments, basePaths) {
+  const firstVisibleIndex = segments.findIndex((segment) => !/^\(.+\)$/.test(segment));
+  if (firstVisibleIndex === -1)
+    return segments.length <= 1;
+  if (segments.slice(firstVisibleIndex + 1).some((segment) => /^\(.+\)$/.test(segment)))
+    return false;
+  const visible = segments.slice(firstVisibleIndex);
+  const allowedBasePaths = new Set([...basePaths].map((basePath) => basePath.trim()).filter(Boolean));
+  return visible.length === 1 && (firstVisibleIndex > 0 || allowedBasePaths.has(visible[0] ?? ""));
+}
+function findRootBoundaries(pageKeys, appCwdPath, basePaths) {
+  const boundaries = new Map;
+  for (const key of pageKeys) {
+    const segments = getRootBoundarySegments(key);
+    if (!segments)
+      continue;
+    if (!isRootBoundarySegments(segments, basePaths))
+      continue;
+    const id = segments.join("/");
+    boundaries.set(id, {
+      sourceKey: key,
+      sourceAbsPath: path4.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
+      segments
+    });
+  }
+  const hasExplicitRootBoundary = [...boundaries.values()].some((boundary) => boundary.segments.length === 0);
+  if (!hasExplicitRootBoundary && boundaries.size === 0) {
+    boundaries.set("", { sourceKey: null, sourceAbsPath: null, segments: [] });
+  }
+  return [...boundaries.values()].sort((a, b) => a.segments.join("/").localeCompare(b.segments.join("/")));
+}
+function hasAncestorRootBoundary(boundary, boundaries) {
+  return boundaries.some((candidate) => candidate !== boundary && candidate.segments.length < boundary.segments.length && candidate.segments.every((segment, index) => boundary.segments[index] === segment));
+}
+function findExplicitRootLayoutAbsPath(pageKeys, appCwdPath) {
+  const rootLayoutKey = pageKeys.find((key) => {
+    const segments = getRootBoundarySegments(key);
+    return segments !== null && segments.length === 0;
+  });
+  return rootLayoutKey ? path4.resolve(appCwdPath, "page", rootLayoutKey.replace(/^\.\//, "")) : null;
+}
+function routePrefixForSegments(segments) {
+  const visible = segments.filter((segment) => !/^\(.+\)$/.test(segment));
+  return visible[0] ?? null;
+}
+async function assertEnvClientConvention(appCwdPath, appName) {
+  const envPath = path4.join(appCwdPath, "env", "env.client.ts");
+  if (!await Bun.file(envPath).exists()) {
+    throw new Error(`[route-convention] app "${appName}" must provide env/env.client.ts exporting "env" for generated System.Provider`);
+  }
+}
+async function writeGeneratedDictionaryMacroFile(appCwdPath, appName) {
+  const absPath = implicitDictionaryMacroAbsPath(appCwdPath);
+  await mkdir2(path4.dirname(absPath), { recursive: true });
+  await Bun.write(absPath, `import { getAllDictionary } from "@apps/${appName}/lib/dict" with { type: "macro" };
+
+export const allDictionary = getAllDictionary();
+`);
+  return absPath;
+}
+async function writeGeneratedRootLayoutFile(opts) {
+  await assertEnvClientConvention(opts.appCwdPath, opts.appName);
+  const dictMacroAbsPath = opts.includeSystemProvider ? await writeGeneratedDictionaryMacroFile(opts.appCwdPath, opts.appName) : null;
+  const absPath = implicitRootLayoutAbsPath(opts.appCwdPath, opts.boundary.segments);
+  await mkdir2(path4.dirname(absPath), { recursive: true });
+  const dictMacroRel = dictMacroAbsPath ? path4.relative(path4.dirname(absPath), dictMacroAbsPath).split(path4.sep).join("/") : null;
+  const dictMacroSpecifier = dictMacroRel ? dictMacroRel.startsWith(".") ? dictMacroRel : `./${dictMacroRel}` : null;
+  const sourceRel = opts.boundary.sourceAbsPath ? path4.relative(path4.dirname(absPath), opts.boundary.sourceAbsPath).split(path4.sep).join("/") : null;
+  const sourceSpecifier = sourceRel ? sourceRel.startsWith(".") ? sourceRel : `./${sourceRel}` : null;
+  const inheritedSourceAbsPath = opts.rootSourceAbsPath && opts.rootSourceAbsPath !== opts.boundary.sourceAbsPath ? opts.rootSourceAbsPath : null;
+  const inheritedSourceRel = inheritedSourceAbsPath ? path4.relative(path4.dirname(absPath), inheritedSourceAbsPath).split(path4.sep).join("/") : null;
+  const inheritedSourceSpecifier = inheritedSourceRel ? inheritedSourceRel.startsWith(".") ? inheritedSourceRel : `./${inheritedSourceRel}` : null;
+  const clientImport = opts.includeStInit ? `import { st } from "@apps/${opts.appName}/client";
+void st;
+` : `import "@apps/${opts.appName}/client";
+`;
+  const inheritedImport = inheritedSourceSpecifier ? `import * as inheritedLayout from ${JSON.stringify(inheritedSourceSpecifier)};
+` : `const inheritedLayout = {};
+`;
+  const prefix = routePrefixForSegments(opts.boundary.segments);
+  const userImport = sourceSpecifier ? `import UserLayout, * as userLayout from ${JSON.stringify(sourceSpecifier)};
+` : `const UserLayout = ({ children }) => children;
+const userLayout = {};
+`;
+  const isAsyncUserLayout = opts.boundary.sourceAbsPath ? await AsyncDefaultExportDetector.detect(opts.boundary.sourceAbsPath) : false;
+  const userLayoutElement = "<UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>";
+  const layoutSignature = isAsyncUserLayout ? "export default async function GeneratedLayout" : "export default function GeneratedLayout";
+  const layoutBinding = isAsyncUserLayout ? `  const layout =
+    process.env.AKAN_PUBLIC_RENDER_ENV === "csr"
+      ? await UserLayout({ params, searchParams, children })
+      : ${userLayoutElement};
+` : "";
+  const layoutChild = isAsyncUserLayout ? "{layout}" : userLayoutElement;
+  const layoutReturn = isAsyncUserLayout ? "layout" : userLayoutElement;
+  const source = opts.includeSystemProvider ? `import type { LayoutProps, PageProps } from "akanjs/client";
+import { loadFonts } from "akanjs/client";
+import { System } from "akanjs/ui";
+import { env } from "@apps/${opts.appName}/env/env.client";
+import { allDictionary } from ${JSON.stringify(dictMacroSpecifier)};
+${clientImport}${inheritedImport}${userImport}
+const userFonts = userLayout.fonts ?? inheritedLayout.fonts ?? [];
+const defaultFonts = userFonts.filter((font) => font.default);
+if (defaultFonts.length > 1) throw new Error("[route-convention] only one default font is allowed per root layout");
+const defaultFont = defaultFonts[0];
+const defaultFontClassName = defaultFont ? (defaultFont.className ?? \`font-\${defaultFont.name}\`) : undefined;
+
+export async function generateHead(props: PageProps) {
+  if (userLayout.generateHead) return userLayout.generateHead(props);
+  if (userLayout.head !== undefined) return userLayout.head;
+  if (inheritedLayout.generateHead) return inheritedLayout.generateHead(props);
+  return inheritedLayout.head;
+}
+
+export async function generateMetadata(props: PageProps) {
+  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
+  if (userLayout.metadata !== undefined) return userLayout.metadata;
+  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
+  return inheritedLayout.metadata;
+}
+
+export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
+export const Error = userLayout.Error ?? inheritedLayout.Error;
+export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
+
+${layoutSignature}({ children, params, searchParams }: LayoutProps) {
+${layoutBinding}  return (
+    <System.Provider
+      of={GeneratedLayout as never}
+      appName=${JSON.stringify(opts.appName)}
+      ${prefix ? `prefix=${JSON.stringify(prefix)}
+      ` : ""}params={params}
+      manifest={userLayout.manifest ?? inheritedLayout.manifest}
+      env={env}
+      theme={userLayout.theme ?? inheritedLayout.theme}
+      fonts={loadFonts(userFonts)}
+      className={defaultFontClassName}
+      gaTrackingId={userLayout.gaTrackingId ?? inheritedLayout.gaTrackingId}
+      layoutStyle={userLayout.layoutStyle ?? inheritedLayout.layoutStyle}
+      reconnect={userLayout.reconnect ?? inheritedLayout.reconnect ?? false}
+      wsConnect={userLayout.wsConnect ?? inheritedLayout.wsConnect ?? true}
+      allDictionary={process.env.AKAN_PUBLIC_RENDER_ENV === "ssr" ? allDictionary : undefined}
+    >
+      ${layoutChild}
+    </System.Provider>
+  );
+}
+` : `import type { LayoutProps, PageProps } from "akanjs/client";
+${inheritedImport}${userImport}
+export async function generateHead(props: PageProps) {
+  if (userLayout.generateHead) return userLayout.generateHead(props);
+  if (userLayout.head !== undefined) return userLayout.head;
+  if (inheritedLayout.generateHead) return inheritedLayout.generateHead(props);
+  return inheritedLayout.head;
+}
+
+export async function generateMetadata(props: PageProps) {
+  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
+  if (userLayout.metadata !== undefined) return userLayout.metadata;
+  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
+  return inheritedLayout.metadata;
+}
+
+export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
+export const Error = userLayout.Error ?? inheritedLayout.Error;
+export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
+
+${layoutSignature}({ children, params, searchParams }: LayoutProps) {
+${layoutBinding}  return ${layoutReturn};
+}
+`;
+  await Bun.write(absPath, source);
+  return absPath;
+}
+async function resolveSsrPageEntries(opts) {
+  const absPageDir = path4.resolve(opts.appCwdPath, "page");
+  const hasSt = await appHasStModule(opts.appCwdPath);
+  const basePaths = opts.basePaths ?? [];
+  const rootSourceAbsPath = findExplicitRootLayoutAbsPath(opts.pageKeys, opts.appCwdPath);
+  const rootBoundaries = findRootBoundaries(opts.pageKeys, opts.appCwdPath, basePaths);
+  const rootLayoutKeys = new Set(opts.pageKeys.filter((key) => {
+    const segments = getRootBoundarySegments(key);
+    return segments !== null && isRootBoundarySegments(segments, basePaths);
+  }));
+  const base = await Promise.all(opts.pageKeys.filter((key) => !rootLayoutKeys.has(key)).map(async (key) => {
+    const userAbsPath = path4.resolve(absPageDir, key);
+    if (OVERRIDES_KEY_RE.test(key)) {
+      const moduleAbsPath = await writeGeneratedOverridesLayoutFile({
+        appCwdPath: opts.appCwdPath,
+        key,
+        userAbsPath
+      });
+      return { key, moduleAbsPath, seedAbsPaths: [userAbsPath] };
+    }
+    return { key, moduleAbsPath: userAbsPath };
+  }));
+  const generated = await Promise.all(rootBoundaries.map(async (boundary) => ({
+    key: implicitRootLayoutKey(boundary.segments),
+    moduleAbsPath: await writeGeneratedRootLayoutFile({
+      appCwdPath: opts.appCwdPath,
+      appName: opts.appName,
+      boundary,
+      rootSourceAbsPath,
+      includeStInit: hasSt && boundary.segments.length === 0,
+      includeSystemProvider: !hasAncestorRootBoundary(boundary, rootBoundaries)
+    }),
+    seedAbsPaths: [...new Set([boundary.sourceAbsPath, rootSourceAbsPath].filter((absPath) => absPath !== null))]
+  })));
+  const entries = [...base, ...generated];
+  entries.sort((a, b) => a.key.localeCompare(b.key));
+  return entries;
+}
+async function resolveSsrPageEntriesForApp(app, pageKeys) {
+  const config = await app.getConfig();
+  return resolveSsrPageEntries({ appCwdPath: app.cwdPath, appName: app.name, pageKeys, basePaths: config.basePaths });
+}
+
 // pkgs/@akanjs/devkit/linter.ts
 import { spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
-import path2 from "path";
+import path5 from "path";
 import chalk from "chalk";
+var parseBiomeReport = (output) => {
+  for (let start = output.indexOf("{");start !== -1; start = output.indexOf("{", start + 1)) {
+    const end = objectEndAt(output, start);
+    if (end === -1)
+      break;
+    const report = asBiomeReport(output.slice(start, end + 1));
+    if (report)
+      return report;
+  }
+  throw new Error(output.trim() || "No Biome JSON output");
+};
+var objectEndAt = (output, start) => {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let idx = start;idx < output.length; idx += 1) {
+    const char = output[idx];
+    if (inString) {
+      if (escaped)
+        escaped = false;
+      else if (char === "\\")
+        escaped = true;
+      else if (char === '"')
+        inString = false;
+      continue;
+    }
+    if (char === '"')
+      inString = true;
+    else if (char === "{")
+      depth += 1;
+    else if (char === "}" && --depth === 0)
+      return idx;
+  }
+  return -1;
+};
+var asBiomeReport = (candidate) => {
+  try {
+    const parsed = JSON.parse(candidate);
+    if (!parsed || typeof parsed !== "object")
+      return null;
+    if (!("diagnostics" in parsed) && !("summary" in parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+var BIOME_CONFIG_FILES = ["biome.json", "biome.jsonc"];
 
 class Linter {
   lintRoot;
+  configPath;
   #biomeBin;
   constructor(cwdPath) {
     this.lintRoot = this.#findBiomeRootPath(cwdPath);
-    const localBiomeBin = path2.join(this.lintRoot, "node_modules/.bin/biome");
+    this.configPath = Linter.#configPathIn(this.lintRoot) ?? path5.join(this.lintRoot, "biome.json");
+    const localBiomeBin = path5.join(this.lintRoot, "node_modules/.bin/biome");
     this.#biomeBin = existsSync(localBiomeBin) ? localBiomeBin : "biome";
   }
+  static #configPathIn(dir) {
+    for (const fileName of BIOME_CONFIG_FILES) {
+      const configPath = path5.join(dir, fileName);
+      if (existsSync(configPath))
+        return configPath;
+    }
+    return null;
+  }
   #findBiomeRootPath(dir) {
-    const configPath = path2.join(dir, "biome.json");
-    if (existsSync(configPath))
+    if (Linter.#configPathIn(dir))
       return dir;
-    const parentDir = path2.dirname(dir);
+    const parentDir = path5.dirname(dir);
     if (parentDir === dir)
       throw new Error(`biome.json not found from ${dir}`);
     return this.#findBiomeRootPath(parentDir);
   }
   #toBiomePath(filePath) {
-    const relativePath = path2.relative(this.lintRoot, filePath);
-    if (!relativePath.startsWith("..") && !path2.isAbsolute(relativePath))
+    const relativePath = path5.relative(this.lintRoot, filePath);
+    if (!relativePath.startsWith("..") && !path5.isAbsolute(relativePath))
       return relativePath;
     return filePath;
   }
   #resolveFilePath(filePath) {
-    return path2.isAbsolute(filePath) ? filePath : path2.join(this.lintRoot, filePath);
+    return path5.isAbsolute(filePath) ? filePath : path5.join(this.lintRoot, filePath);
   }
   async#runBiome(args, input) {
     return await new Promise((resolve, reject) => {
@@ -696,18 +1344,11 @@ class Linter {
       proc.stdin.end(input);
     });
   }
-  #parseBiomeReport(output) {
-    const jsonStart = output.indexOf("{");
-    const jsonEnd = output.lastIndexOf("}");
-    if (jsonStart === -1 || jsonEnd === -1 || jsonEnd < jsonStart)
-      throw new Error(output.trim() || "No Biome JSON output");
-    return JSON.parse(output.slice(jsonStart, jsonEnd + 1));
-  }
   #diagnosticFilePath(diagnostic, fallbackFilePath) {
     const diagnosticPath = diagnostic.location?.path;
     if (!diagnosticPath)
       return fallbackFilePath;
-    return path2.isAbsolute(diagnosticPath) ? diagnosticPath : path2.join(this.lintRoot, diagnosticPath);
+    return path5.isAbsolute(diagnosticPath) ? diagnosticPath : path5.join(this.lintRoot, diagnosticPath);
   }
   #createLintMessage(diagnostic) {
     const start = diagnostic.location?.start;
@@ -772,10 +1413,10 @@ class Linter {
       "--max-diagnostics=none",
       "--no-errors-on-unmatched",
       "--config-path",
-      path2.join(this.lintRoot, "biome.json"),
+      this.configPath,
       this.#toBiomePath(filePath)
     ]);
-    const report = this.#parseBiomeReport(stdout || stderr);
+    const report = parseBiomeReport(stdout || stderr);
     const results = this.#toLintResults(report, filePath);
     const { errors, warnings } = this.#splitMessages(results);
     const output = write && existsSync(filePath) ? readFileSync(filePath, "utf8") : undefined;
@@ -893,22 +1534,34 @@ ${errorText}, ${warningText} found`];
     if (!dryRun)
       return await this.#checkFile(resolvedFilePath, { write: true });
     const source = readFileSync(resolvedFilePath, "utf8");
-    const { stdout } = await this.#runBiome([
+    const { stdout } = await this.#runBiome(["check", "--write", "--config-path", this.configPath, "--stdin-file-path", this.#toBiomePath(resolvedFilePath)], source);
+    const lintResult = await this.lintFile(resolvedFilePath);
+    return { ...lintResult, fixed: stdout !== source, output: stdout };
+  }
+  async fixFiles(filePaths) {
+    const resolved = filePaths.map((filePath) => this.#resolveFilePath(filePath)).filter(existsSync);
+    if (resolved.length === 0)
+      return { fixed: [] };
+    const before = new Map(resolved.map((filePath) => [filePath, readFileSync(filePath, "utf8")]));
+    await this.#runBiome([
       "check",
       "--write",
+      "--reporter=json",
+      "--max-diagnostics=none",
+      "--no-errors-on-unmatched",
       "--config-path",
-      path2.join(this.lintRoot, "biome.json"),
-      "--stdin-file-path",
-      this.#toBiomePath(resolvedFilePath)
-    ], source);
-    const lintResult = await this.lintFile(resolvedFilePath);
-    return { ...lintResult, fixed: stdout !== source, output: stdout };
+      this.configPath,
+      ...resolved.map((filePath) => this.#toBiomePath(filePath))
+    ]);
+    return {
+      fixed: resolved.filter((filePath) => readFileSync(filePath, "utf8") !== before.get(filePath))
+    };
   }
   async getConfigForFile(filePath) {
     const resolvedFilePath = this.#resolveFilePath(filePath);
     if (!existsSync(resolvedFilePath))
       throw new Error(`File not found: ${filePath}`);
-    return JSON.parse(readFileSync(path2.join(this.lintRoot, "biome.json"), "utf8"));
+    return JSON.parse(readFileSync(this.configPath, "utf8"));
   }
   async getProblematicRules(filePath) {
     const { results } = await this.lintFile(filePath);
@@ -925,7 +1578,7 @@ ${errorText}, ${warningText} found`];
 
 // pkgs/@akanjs/devkit/repoIdentity.ts
 import { execFileSync } from "child_process";
-import path3 from "path";
+import path6 from "path";
 var resolved = new Map;
 var readRemoteName = (workspaceRoot) => {
   try {
@@ -943,14 +1596,14 @@ var resolveRepoName = (workspaceRoot) => {
   const cached = resolved.get(workspaceRoot);
   if (cached)
     return cached;
-  const repoName = readRemoteName(workspaceRoot) ?? path3.basename(workspaceRoot);
+  const repoName = readRemoteName(workspaceRoot) ?? path6.basename(workspaceRoot);
   resolved.set(workspaceRoot, repoName);
   return repoName;
 };
 
 // pkgs/@akanjs/devkit/scanInfo.ts
-import { rm } from "fs/promises";
-import path4 from "path";
+import { rm as rm2 } from "fs/promises";
+import path7 from "path";
 
 // pkgs/@akanjs/devkit/workspaceLayout.ts
 var appRootAllowedFiles = new Set([
@@ -984,6 +1637,34 @@ var appRootAllowedDirs = new Set([
   "ui",
   "webkit"
 ]);
+var libRootAllowedFiles = new Set([
+  "AGENTS.md",
+  "CLAUDE.md",
+  "README.md",
+  "akan.config.ts",
+  "akan.lib.json",
+  "client.ts",
+  "index.ts",
+  "package.json",
+  "server.ts",
+  "tsconfig.json",
+  "tsconfig.spec.json",
+  "tsconfig.tsbuildinfo"
+]);
+var libRootAllowedDirs = new Set([
+  "common",
+  "env",
+  "lib",
+  "page",
+  "plugin",
+  "private",
+  "public",
+  "srvkit",
+  "ui",
+  "webkit"
+]);
+var rootAllowedFiles = { app: appRootAllowedFiles, lib: libRootAllowedFiles };
+var rootAllowedDirs = { app: appRootAllowedDirs, lib: libRootAllowedDirs };
 var libFacetRootAllowedFiles = new Set([
   "cnst.ts",
   "db.ts",
@@ -995,7 +1676,9 @@ var libFacetRootAllowedFiles = new Set([
   "useClient.ts",
   "useServer.ts"
 ]);
-var isScannedAppRootEntry = (name) => !name.startsWith(".") || appRootAllowedDirs.has(name);
+var libFacetRootTestPattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
+var isAllowedLibFacetRootFile = (filename) => libFacetRootAllowedFiles.has(filename) || libFacetRootTestPattern.test(filename);
+var isScannedRootEntry = (type, name) => !name.startsWith(".") || rootAllowedDirs[type].has(name);
 
 // pkgs/@akanjs/devkit/scanInfo.ts
 var databaseFileTypes = [
@@ -1024,18 +1707,16 @@ var moduleUiFileTypes = {
   scalar: new Set(["Template", "Unit"])
 };
 var testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
-var rootSignalTestFilePattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
-var createDependencyScanner = async (exec) => (await import("./dependencyScanner-f6grrep3.js")).TypeScriptDependencyScanner.from(exec);
+var createDependencyScanner = async (exec) => (await import("./dependencyScanner-shs82ynp.js")).TypeScriptDependencyScanner.from(exec);
 var isAllowedTestFile = (filename) => testFilePattern.test(filename);
-var isAllowedLibRootFile = (filename) => libFacetRootAllowedFiles.has(filename) || rootSignalTestFilePattern.test(filename);
-var getScanPath = (exec, relativePath) => path4.posix.join(`${exec.type}s`, exec.name, relativePath.split(path4.sep).join("/"));
+var getScanPath = (exec, relativePath) => path7.posix.join(`${exec.type}s`, exec.name, relativePath.split(path7.sep).join("/"));
 async function clearGeneratedRootCapacitorConfigs(exec) {
   if (exec.type !== "app")
     return;
-  await Promise.all(generatedRootCapacitorConfigFiles.map((filename) => rm(exec.getPath(filename), { force: true })));
+  await Promise.all(generatedRootCapacitorConfigFiles.map((filename) => rm2(exec.getPath(filename), { force: true })));
 }
 var getModuleNameFromPath = (kind, modulePath) => {
-  const dirname = path4.basename(modulePath);
+  const dirname = path7.basename(modulePath);
   return kind === "service" ? dirname.replace(/^_+/, "") : dirname;
 };
 async function assertScanConvention(exec, libRoot) {
@@ -1044,28 +1725,31 @@ async function assertScanConvention(exec, libRoot) {
   const addViolation = (relativePath, reason) => {
     violations.push(`${getScanPath(exec, relativePath)}: ${reason}`);
   };
-  if (exec.type === "app") {
-    const { files, dirs } = await exec.getFilesAndDirs(".");
-    files.filter((filename) => !appRootAllowedFiles.has(filename)).forEach((filename) => {
-      addViolation(filename, "unsupported app root file");
-    });
-    dirs.filter((dirname) => !appRootAllowedDirs.has(dirname)).forEach((dirname) => {
-      addViolation(dirname, "unsupported app root folder");
-    });
-  }
-  libRoot.files.filter((filename) => !isAllowedLibRootFile(filename)).forEach((filename) => {
-    addViolation(path4.join("lib", filename), "unsupported lib root file");
+  const allowedRootFiles = rootAllowedFiles[exec.type];
+  const allowedRootDirs = rootAllowedDirs[exec.type];
+  const { files, dirs } = await exec.getFilesAndDirs(".");
+  files.filter((filename) => !allowedRootFiles.has(filename)).forEach((filename) => {
+    addViolation(filename, `unsupported ${exec.type} root file`);
+  });
+  dirs.filter((dirname) => !allowedRootDirs.has(dirname)).forEach((dirname) => {
+    addViolation(dirname, `unsupported ${exec.type} root folder`);
+  });
+  if (exec.type === "lib")
+    for (const { relativePath, reason } of await exec.getPageConventionViolations())
+      addViolation(relativePath, reason);
+  libRoot.files.filter((filename) => !isAllowedLibFacetRootFile(filename)).forEach((filename) => {
+    addViolation(path7.join("lib", filename), "unsupported lib facet root file");
   });
   libRoot.dirs.filter((dirname) => dirname.startsWith("__") && !internalLibDirs.has(dirname)).forEach((dirname) => {
-    addViolation(path4.join("lib", dirname), "unsupported internal lib folder");
+    addViolation(path7.join("lib", dirname), "unsupported internal lib folder");
   });
   const databaseDirs = libRoot.dirs.filter((dirname) => !dirname.startsWith("_"));
   const serviceDirs = libRoot.dirs.filter((dirname) => dirname.startsWith("_") && !dirname.startsWith("__"));
   const scalarDirs = await exec.readdir("lib/__scalar");
   await Promise.all([
-    ...databaseDirs.map((dirname) => validateModuleFiles(exec, violations, "database", path4.join("lib", dirname))),
-    ...serviceDirs.map((dirname) => validateModuleFiles(exec, violations, "service", path4.join("lib", dirname))),
-    ...scalarDirs.map((dirname) => validateModuleFiles(exec, violations, "scalar", path4.join("lib/__scalar", dirname)))
+    ...databaseDirs.map((dirname) => validateModuleFiles(exec, violations, "database", path7.join("lib", dirname))),
+    ...serviceDirs.map((dirname) => validateModuleFiles(exec, violations, "service", path7.join("lib", dirname))),
+    ...scalarDirs.map((dirname) => validateModuleFiles(exec, violations, "scalar", path7.join("lib/__scalar", dirname)))
   ]);
   if (violations.length > 0) {
     throw new Error(`[scan-convention]
@@ -1077,11 +1761,11 @@ async function validateModuleFiles(exec, violations, kind, modulePath) {
   const { files, dirs } = await exec.getFilesAndDirs(modulePath);
   const moduleName = getModuleNameFromPath(kind, modulePath);
   dirs.forEach((dirname) => {
-    violations.push(`${getScanPath(exec, path4.join(modulePath, dirname))}: unsupported module folder`);
+    violations.push(`${getScanPath(exec, path7.join(modulePath, dirname))}: unsupported module folder`);
   });
   const uiModuleName = moduleName[0].toUpperCase() + moduleName.slice(1);
   files.forEach((filename) => {
-    const filePath = path4.join(modulePath, filename);
+    const filePath = path7.join(modulePath, filename);
     if (filename === "index.ts" || filename === "index.tsx" || isAllowedTestFile(filename))
       return;
     if (filename === `${moduleName}.abstract.md`)
@@ -1125,7 +1809,7 @@ class ScanInfo {
     { all: new Set, databases: new Set, services: new Set, scalars: new Set }
   ]));
   static async getScanResult(exec) {
-    const [akanConfig2, scanner, pkgs, libs] = await Promise.all([
+    const [akanConfig, scanner, pkgs, libs] = await Promise.all([
       exec.getConfig(),
       createDependencyScanner(exec),
       exec.workspace.getPkgs(),
@@ -1161,7 +1845,7 @@ class ScanInfo {
     });
     await Promise.all([
       ...databaseDirs.map(async (name) => {
-        const filenames = await exec.readdir(path4.join("lib", name));
+        const filenames = await exec.readdir(path7.join("lib", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constant.databases.push(name);
@@ -1189,7 +1873,7 @@ class ScanInfo {
       }),
       ...serviceDirs.map(async (dirname) => {
         const name = dirname.slice(1);
-        const filenames = await exec.readdir(path4.join("lib", dirname));
+        const filenames = await exec.readdir(path7.join("lib", dirname));
         filenames.forEach((filename) => {
           if (filename.endsWith(".dictionary.ts"))
             files.dictionary.services.push(name);
@@ -1212,7 +1896,7 @@ class ScanInfo {
         });
       }),
       ...scalarDirs.map(async (name) => {
-        const filenames = await exec.readdir(path4.join("lib/__scalar", name));
+        const filenames = await exec.readdir(path7.join("lib/__scalar", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constant.scalars.push(name);
@@ -1234,12 +1918,11 @@ class ScanInfo {
       })
     ]);
     const routes = exec.type === "lib" ? [] : await exec.getPageKeys();
-    const scanResult = {
+    const common = {
       name: exec.name,
       type: exec.type,
       repoName: exec.workspace.repoName,
-      serveDomain: WorkspaceExecutor.getBaseDevEnv(path4.join(exec.workspace.workspaceRoot, ".env")).serveDomain,
-      akanConfig: akanConfig2,
+      serveDomain: WorkspaceExecutor.getBaseDevEnv(path7.join(exec.workspace.workspaceRoot, ".env")).serveDomain,
       files,
       libDeps,
       pkgDeps,
@@ -1247,6 +1930,7 @@ class ScanInfo {
       devDependencies: npmDevDeps.filter((dep) => !isAkanFrameworkDependency(dep)),
       routes
     };
+    const scanResult = akanConfig instanceof AkanAppConfig ? { ...common, akanConfig } : { ...common, akanConfig };
     return scanResult;
   }
   constructor(scanResult) {
@@ -1440,16 +2124,16 @@ class LibInfo extends ScanInfo {
 class PkgInfo {
   exec;
   name;
-  scanResult;
+  #scanResult;
   static async scanExecutor(exec) {
     const [tsconfig, rootPackageJson] = await Promise.all([exec.getTsConfig(), exec.workspace.getPackageJson()]);
     const scanner = await createDependencyScanner(exec);
     const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
-    const pkgPathSet = new Set(Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path5) => tsconfig.compilerOptions.paths?.[path5]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path5) => path5.replace("/*", "")));
+    const pkgPathSet = new Set(Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path) => tsconfig.compilerOptions.paths?.[path]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path) => path.replace("/*", "")));
     const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
-    const pkgDeps = [...pkgPathDepSet].map((path5) => {
-      const pathSplitLength = path5.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path5]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+    const pkgDeps = [...pkgPathDepSet].map((path) => {
+      const pathSplitLength = path.split("/").length;
+      return (tsconfig.compilerOptions.paths?.[path]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
     }).filter((pkg) => pkg !== exec.name);
     const pkgScanResult = {
       name: exec.name,
@@ -1471,10 +2155,10 @@ class PkgInfo {
   constructor(exec, scanResult) {
     this.exec = exec;
     this.name = exec.name;
-    this.scanResult = scanResult;
+    this.#scanResult = scanResult;
   }
   getScanResult() {
-    return this.scanResult;
+    return this.#scanResult;
   }
 }
 
@@ -1635,16 +2319,16 @@ class Executor {
   linter = null;
   constructor(name, cwdPath) {
     this.name = name;
-    this.logger = new Logger(name);
+    this.logger = new Logger2(name);
     this.logs = [];
     this.cwdPath = cwdPath;
   }
   #stdout(data) {
     if (Executor.verbose)
-      Logger.raw(chalk2.dim(data.toString()));
+      Logger2.raw(chalk2.dim(data.toString()));
   }
   #stderr(data) {
-    Logger.raw(chalk2.red(data.toString()));
+    Logger2.raw(chalk2.red(data.toString()));
   }
   exec(command, options = {}) {
     const cwd = options.cwd?.toString() ?? this.cwdPath;
@@ -1672,7 +2356,7 @@ class Executor {
         }));
       });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal)
+        if (code || signal)
           reject(new CommandExecutionError({
             command,
             cwd,
@@ -1770,7 +2454,7 @@ class Executor {
         }));
       });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal)
+        if (code || signal)
           reject(new CommandExecutionError({
             command: modulePath,
             args,
@@ -1786,10 +2470,10 @@ class Executor {
     });
   }
   getPath(filePath) {
-    if (path5.isAbsolute(filePath))
+    if (path8.isAbsolute(filePath))
       return filePath;
     if (filePath.startsWith("."))
-      return path5.join(this.cwdPath, filePath);
+      return path8.join(this.cwdPath, filePath);
     const baseParts = this.cwdPath.split(/[\\/]/).filter(Boolean);
     const targetParts = filePath.split(/[\\/]/).filter(Boolean);
     let overlapLength = 0;
@@ -1803,12 +2487,12 @@ class Executor {
       if (isOverlap)
         overlapLength = i;
     }
-    return path5.join(this.cwdPath, ...targetParts.slice(overlapLength));
+    return path8.join(this.cwdPath, ...targetParts.slice(overlapLength));
   }
   async mkdir(dirPath) {
     const writePath = this.getPath(dirPath);
     if (!await FileSys.dirExists(writePath))
-      await mkdir(writePath, { recursive: true });
+      await mkdir3(writePath, { recursive: true });
     this.logger.verbose(`Make directory ${writePath}`);
     return this;
   }
@@ -1846,18 +2530,19 @@ class Executor {
     return this;
   }
   async removeDir(dirPath) {
-    const readPath = path5.join(this.getPath(dirPath), ".");
+    const readPath = path8.join(this.getPath(dirPath), ".");
     if (await FileSys.entryExists(readPath))
-      await rm2(readPath, { recursive: true, force: true });
+      await rm3(readPath, { recursive: true, force: true });
     this.logger.verbose(`Remove directory ${readPath}`);
     return this;
   }
   async writeFile(filePath, content, { overwrite = true, silent = false } = {}) {
     const writePath = this.getPath(filePath);
-    const dir = path5.dirname(writePath);
+    const dir = path8.dirname(writePath);
     if (!await FileSys.dirExists(dir))
-      await mkdir(dir, { recursive: true });
-    let contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+      await mkdir3(dir, { recursive: true });
+    let contentStr = typeof content === "string" ? content : `${JSON.stringify(content, null, 2)}
+`;
     if (await FileSys.fileExists(writePath)) {
       const currentContent = await FileSys.readText(writePath);
       if (currentContent === contentStr || !overwrite) {
@@ -1865,7 +2550,7 @@ class Executor {
         contentStr = currentContent;
       } else {
         await FileSys.writeText(writePath, contentStr);
-        if (Logger.isVerbose())
+        if (Logger2.isVerbose())
           this.logger.rawLog(chalk2.yellow(`File Update: ${filePath}`));
       }
     } else {
@@ -1879,7 +2564,7 @@ class Executor {
     await this.writeFile(filePath, content);
   }
   async getLocalFile(targetPath) {
-    const filePath = path5.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
+    const filePath = path8.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
     const content = await this.readFile(filePath);
     return { filePath, content };
   }
@@ -1896,9 +2581,9 @@ class Executor {
     const dest = this.getPath(destPath);
     if (!await FileSys.exists(src))
       return;
-    const isDirectory = (await stat(src)).isDirectory();
+    const isDirectory = (await stat2(src)).isDirectory();
     if (!await FileSys.exists(dest) && isDirectory)
-      await mkdir(dest, { recursive: true });
+      await mkdir3(dest, { recursive: true });
     if (dereference)
       await cpEntry(src, dest, { recursive: isDirectory, dereference: true, force: true });
     else
@@ -1976,26 +2661,26 @@ class Executor {
       const result = await getContent.default(scanInfo ?? null, dict, options);
       if (result === null)
         return null;
-      const filename = typeof result === "object" ? result.filename : path5.basename(targetPath).replace(".js", ".ts");
+      const filename = typeof result === "object" ? result.filename : path8.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
-      const dirname = path5.dirname(targetPath);
-      const convertedTargetPath = Object.entries(dict).reduce((path6, [key, value]) => path6.replace(new RegExp(`__${key}__`, "g"), value), `${dirname}/${filename}`);
+      const dirname = path8.dirname(targetPath);
+      const convertedTargetPath = Object.entries(dict).reduce((path, [key, value]) => path.replace(new RegExp(`__${key}__`, "g"), value), `${dirname}/${filename}`);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return this.writeFile(convertedTargetPath, content, { overwrite });
     } else if (targetPath.endsWith(".template")) {
       const content = await FileSys.readText(templatePath);
-      const convertedTargetPath = Object.entries(dict).reduce((path6, [key, value]) => path6.replace(new RegExp(`__${key}__`, "g"), value), targetPath.slice(0, -9));
+      const convertedTargetPath = Object.entries(dict).reduce((path, [key, value]) => path.replace(new RegExp(`__${key}__`, "g"), value), targetPath.slice(0, -9));
       const convertedContent = Object.entries(dict).reduce((data, [key, value]) => data.replace(new RegExp(`<%= ${key} %>`, "g"), value), content);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return this.writeFile(convertedTargetPath, convertedContent, {
         overwrite
       });
-    } else if (staticTemplateFileExtensions.has(path5.extname(targetPath).toLowerCase())) {
-      const convertedTargetPath = Object.entries(dict).reduce((path6, [key, value]) => path6.replace(new RegExp(`__${key}__`, "g"), value), targetPath);
+    } else if (staticTemplateFileExtensions.has(path8.extname(targetPath).toLowerCase())) {
+      const convertedTargetPath = Object.entries(dict).reduce((path, [key, value]) => path.replace(new RegExp(`__${key}__`, "g"), value), targetPath);
       const writePath = this.getPath(convertedTargetPath);
-      const dirname = path5.dirname(writePath);
+      const dirname = path8.dirname(writePath);
       if (!await FileSys.dirExists(dirname))
-        await mkdir(dirname, { recursive: true });
+        await mkdir3(dirname, { recursive: true });
       await copyFile(templatePath, writePath);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return { filePath: writePath, content: "" };
@@ -2013,11 +2698,11 @@ class Executor {
     const templateRoot = await this.#resolveTemplateRoot();
     const templatePath = `${templateRoot}${template ? `/${template}` : ""}`;
     const prefixTemplatePath = templatePath;
-    if ((await stat(prefixTemplatePath)).isFile()) {
-      const filename = path5.basename(prefixTemplatePath);
+    if ((await stat2(prefixTemplatePath)).isFile()) {
+      const filename = path8.basename(prefixTemplatePath);
       const fileContent = await this.#applyTemplateFile({
         templatePath: prefixTemplatePath,
-        targetPath: path5.join(basePath, filename),
+        targetPath: path8.join(basePath, filename),
         scanInfo,
         overwrite
       }, dict, options);
@@ -2025,19 +2710,19 @@ class Executor {
     } else {
       const subdirs = await readDirEntries(templatePath);
       const fileContents = (await Promise.all(subdirs.map(async (subdir) => {
-        const subpath = path5.join(templatePath, subdir);
-        if ((await stat(subpath)).isFile()) {
+        const subpath = path8.join(templatePath, subdir);
+        if ((await stat2(subpath)).isFile()) {
           const fileContent = await this.#applyTemplateFile({
             templatePath: subpath,
-            targetPath: path5.join(basePath, subdir),
+            targetPath: path8.join(basePath, subdir),
             scanInfo,
             overwrite
           }, dict, options);
           return fileContent ? [fileContent] : [];
         } else
           return await this._applyTemplate({
-            basePath: path5.join(basePath, subdir),
-            template: path5.join(template, subdir),
+            basePath: path8.join(basePath, subdir),
+            template: path8.join(template, subdir),
             scanInfo,
             dict,
             overwrite,
@@ -2049,8 +2734,8 @@ class Executor {
   }
   async#resolveTemplateRoot() {
     const candidates = [
-      path5.resolve(getDirname(import.meta.url), "templates"),
-      path5.resolve(getDirname(import.meta.url), "../cli/templates")
+      path8.resolve(getDirname2(import.meta.url), "templates"),
+      path8.resolve(getDirname2(import.meta.url), "../cli/templates")
     ];
     for (const candidate of candidates) {
       if (await FileSys.dirExists(candidate))
@@ -2063,29 +2748,43 @@ class Executor {
       ...options.dict ?? {},
       ...Object.fromEntries(Object.entries(options.dict ?? {}).map(([key, value]) => [capitalize(key), capitalize(value)]))
     };
-    return this._applyTemplate({ ...options, dict });
+    const fileContents = await this._applyTemplate({ ...options, dict });
+    await this.#formatAppliedTemplate(fileContents);
+    return fileContents;
+  }
+  async#formatAppliedTemplate(fileContents) {
+    const filePaths = fileContents.map((fileContent) => fileContent.filePath).filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
+    if (filePaths.length === 0)
+      return;
+    try {
+      const { fixed } = await this.getLinter().fixFiles(filePaths);
+      if (fixed.length > 0)
+        this.logger.verbose(`Formatted ${fixed.length} scaffolded file(s)`);
+    } catch (err) {
+      this.logger.verbose(`Skipped formatting scaffolded files: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
   async getTypeChecker() {
-    const { TypeChecker } = await import("./typeChecker-kravn7ns.js");
+    const { TypeChecker } = await import("./typeChecker-3xgrzc2v.js");
     this.typeChecker ??= new TypeChecker(this);
     return this.typeChecker;
   }
   async typeCheck(filePath) {
-    const path6 = this.getPath(filePath);
+    const path = this.getPath(filePath);
     const typeChecker = await this.getTypeChecker();
-    const { fileDiagnostics, fileErrors, fileWarnings } = typeChecker.check(path6);
+    const { fileDiagnostics, fileErrors, fileWarnings } = typeChecker.check(path);
     const message = typeChecker.formatDiagnostics(fileDiagnostics);
     return { fileDiagnostics, fileErrors, fileWarnings, message };
   }
   async typeCheckAsync(filePath) {
-    const path6 = this.getPath(filePath);
+    const path = this.getPath(filePath);
     const entry = await this.#resolveTypecheckWorkerEntry();
     const proc = Bun.spawn([process.execPath, entry], {
       cwd: this.cwdPath,
       env: {
         ...process.env,
         AKAN_TYPECHECK_CWD: this.cwdPath,
-        AKAN_TYPECHECK_FILE: path6
+        AKAN_TYPECHECK_FILE: path
       },
       stdout: "pipe",
       stderr: "pipe"
@@ -2106,13 +2805,13 @@ class Executor {
     };
   }
   async#resolveTypecheckWorkerEntry() {
-    const dirname = getDirname(import.meta.url);
+    const dirname = getDirname2(import.meta.url);
     const candidates = [
-      path5.join(process.cwd(), "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path5.join(process.cwd(), "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path5.join(dirname, "typecheck/typecheck.proc.ts"),
-      path5.join(dirname, "typecheck.proc.js"),
-      path5.join(dirname, "typecheck.proc.ts")
+      path8.join(process.cwd(), "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path8.join(process.cwd(), "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path8.join(dirname, "typecheck/typecheck.proc.ts"),
+      path8.join(dirname, "typecheck.proc.js"),
+      path8.join(dirname, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -2124,9 +2823,9 @@ class Executor {
     return this.linter;
   }
   async lint(filePath, { fix = false, dryRun = false } = {}) {
-    const path6 = this.getPath(filePath);
+    const path = this.getPath(filePath);
     const linter = this.getLinter();
-    const { results, errors, warnings } = await linter.lint(path6, {
+    const { results, errors, warnings } = await linter.lint(path, {
       fix,
       dryRun
     });
@@ -2239,8 +2938,8 @@ class WorkspaceExecutor extends Executor {
       await Promise.all(dirs.map(async (dir) => {
         if (dir.includes("_") || AVOID_DIRS.includes(dir))
           return;
-        const dirPath = path5.join(dirname, dir);
-        if ((await stat(dirPath)).isDirectory()) {
+        const dirPath = path8.join(dirname, dir);
+        if ((await stat2(dirPath)).isDirectory()) {
           results.push(`${prefix}${dir}`);
           if (maxDepth > 0)
             await getDirs(dirPath, maxDepth - 1, results, `${prefix}${dir}/`);
@@ -2252,10 +2951,20 @@ class WorkspaceExecutor extends Executor {
   }
   async commit(message, { init = false, add = true } = {}) {
     if (init)
-      await this.exec(`git init --quiet`);
+      await this.spawn("git", ["init", "--quiet"]);
     if (add)
-      await this.exec(`git add .`);
-    await this.exec(`git commit --quiet -m "${message}"`);
+      await this.spawn("git", ["add", "."]);
+    await this.spawn("git", ["commit", "--quiet", "-m", message]);
+  }
+  async hasChanges() {
+    return !!(await this.spawn("git", ["status", "--porcelain"])).trim();
+  }
+  async listGitFiles(paths, { untracked = false } = {}) {
+    if (!paths.length)
+      return [];
+    const mode = untracked ? ["--cached", "--others", "--exclude-standard"] : ["--cached"];
+    const stdout = await this.spawn("git", ["ls-files", "-z", ...mode, "--", ...paths]);
+    return stdout.split("\x00").filter((file) => !!file).sort();
   }
   async#getDirHasFile(basePath, targetFilename) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "webkit"];
@@ -2264,9 +2973,9 @@ class WorkspaceExecutor extends Executor {
       await Promise.all(dirs.map(async (dir) => {
         if (AVOID_DIRS.includes(dir))
           return;
-        const dirPath = path5.join(dirname, dir);
+        const dirPath = path8.join(dirname, dir);
         if (await FileSys.dirExists(dirPath)) {
-          const hasTargetFile = await FileSys.fileExists(path5.join(dirPath, targetFilename));
+          const hasTargetFile = await FileSys.fileExists(path8.join(dirPath, targetFilename));
           if (hasTargetFile)
             results.push(`${prefix}${dir}`);
           if (maxDepth > 0)
@@ -2332,8 +3041,20 @@ class SysExecutor extends Executor {
     return this.#akanConfig;
   }
   async getModules() {
-    const path6 = this.type === "app" ? `apps/${this.name}/lib` : `libs/${this.name}/lib`;
-    return await this.workspace.getDirInModule(path6, this.name);
+    const path = this.type === "app" ? `apps/${this.name}/lib` : `libs/${this.name}/lib`;
+    return await this.workspace.getDirInModule(path, this.name);
+  }
+  async getPageConventionViolations() {
+    if (!await this.exists("page"))
+      return [];
+    const violations = [];
+    for (const entry of await this.getAllFiles("**/*", { cwd: this.getPath("page") })) {
+      const relativePath = entry.split(path8.sep).join("/");
+      const reason = getPageSourceFileViolation(relativePath);
+      if (reason)
+        violations.push({ relativePath: `page/${relativePath}`, reason });
+    }
+    return violations;
   }
   #scanInfo = null;
   hasScanInfo() {
@@ -2391,18 +3112,19 @@ class SysExecutor extends Executor {
     }) : await LibInfo.fromExecutor(this, {
       refresh
     });
-    if (write) {
-      await Promise.all(this.#getScanTemplateTasks(scanInfo));
-      await this.writeJson(`akan.${this.type}.json`, scanInfo.getScanResult());
-      if (this.type === "lib")
-        this.#updateDependencies(scanInfo);
-      if (writeLib) {
-        const libInfos = [...scanInfo.getLibInfos().values()];
-        await this.#updateDependencies(scanInfo);
-        await Promise.all(libInfos.flatMap((libInfo) => libInfo.exec.#getScanTemplateTasks(libInfo)));
-      }
-      await this.syncAgentsIndex(scanInfo);
-    }
+    if (write)
+      await CodegenLock.run(this.workspace.workspaceRoot, `scan:${this.name}`, async () => {
+        await Promise.all(this.#getScanTemplateTasks(scanInfo));
+        await this.writeJson(`akan.${this.type}.json`, scanInfo.getScanResult());
+        if (this.type === "lib")
+          this.#updateDependencies(scanInfo);
+        if (writeLib) {
+          const libInfos = [...scanInfo.getLibInfos().values()];
+          await this.#updateDependencies(scanInfo);
+          await Promise.all(libInfos.flatMap((libInfo) => libInfo.exec.#getScanTemplateTasks(libInfo)));
+        }
+        await this.syncAgentsIndex(scanInfo);
+      });
     this.#scanInfo = scanInfo;
     return scanInfo;
   }
@@ -2437,7 +3159,7 @@ class SysExecutor extends Executor {
     await this.setPackageJson(libPkgJsonWithDeps);
   }
   async getLocalFile(targetPath) {
-    const filePath = path5.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
+    const filePath = path8.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
     const content = await this.workspace.readFile(filePath);
     return { filePath, content };
   }
@@ -2523,7 +3245,7 @@ class SysExecutor extends Executor {
 class AppExecutor extends SysExecutor {
   static #routeSourceValidator = null;
   static async#getRouteSourceValidator() {
-    AppExecutor.#routeSourceValidator ??= (await import("./routeSourceValidator-e4jmbfcx.js")).RouteSourceValidator;
+    AppExecutor.#routeSourceValidator ??= (await import("./routeSourceValidator-ze6x894c.js")).RouteSourceValidator;
     return AppExecutor.#routeSourceValidator;
   }
   dist;
@@ -2534,9 +3256,9 @@ class AppExecutor extends SysExecutor {
   }
   static #execs = new Map;
   static from(executor, name) {
-    const exec2 = AppExecutor.#execs.get(name);
-    if (exec2)
-      return exec2;
+    const exec = AppExecutor.#execs.get(name);
+    if (exec)
+      return exec;
     else if (executor instanceof WorkspaceExecutor)
       return new AppExecutor({ workspace: executor, name });
     else
@@ -2572,25 +3294,31 @@ class AppExecutor extends SysExecutor {
     };
   }
   async prepareCommand(type) {
-    const akanConfig2 = await this.getConfig();
-    const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig2.defaultDatabaseMode ?? "single";
+    const akanConfig = await this.getConfig();
+    const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
     const routeEnv = {
-      AKAN_PUBLIC_BASE_PATHS: [...akanConfig2.basePaths].join(","),
+      AKAN_PUBLIC_BASE_PATHS: [...akanConfig.basePaths].join(","),
+      AKAN_PUBLIC_API_PREFIX: akanConfig.api.prefix,
+      AKAN_PUBLIC_WS_PREFIX: akanConfig.api.websocketPrefix,
       AKAN_DATABASE_MODE: databaseMode
     };
     Object.assign(process.env, routeEnv);
     if (type === "build") {
       this.#excludeDevOnlyPages = true;
       this.#pageKeys = null;
-      if (await this.exists(this.dist.cwdPath))
-        await this.dist.exec(`rm -rf ${this.dist.cwdPath}`);
+      await this.dist.removeDir(this.dist.cwdPath);
       await Promise.all([this.dist.mkdir("private"), this.dist.mkdir("public")]);
       await Promise.all([
         this.cp("private", `${this.dist.cwdPath}/private`, { dereference: true }),
-        this.cp("public", `${this.dist.cwdPath}/public`, { dereference: true })
+        ...akanConfig.web.ssr ? [this.cp("public", `${this.dist.cwdPath}/public`, { dereference: true })] : []
       ]);
-    } else
+    } else {
       await this.removeDir(".akan");
+      if (!akanConfig.web.ssr || !akanConfig.web.csr)
+        this.logger.verbose(`akan.config.ts disables web.${!akanConfig.web.ssr ? "ssr" : "csr"}; \`akan start\` still serves it, \`akan build\` will not`);
+    }
+    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,
@@ -2638,7 +3366,7 @@ class AppExecutor extends SysExecutor {
   async getPageKeys({ refresh } = {}) {
     if (this.#pageKeys && !refresh)
       return this.#pageKeys;
-    const akanConfig2 = await this.getConfig();
+    const akanConfig = await this.getConfig();
     const glob = new Bun.Glob("**/*");
     const pageKeys = [];
     const owners = new Map;
@@ -2652,16 +3380,16 @@ class AppExecutor extends SysExecutor {
         absolute: false,
         onlyFiles: true
       })) {
-        const segments = rel.split(path5.sep);
+        const segments = rel.split(path8.sep);
         if (segments.some((s) => s === "node_modules"))
           continue;
         const posix = `${root.keyPrefix}${segments.join("/")}`;
-        const absPath = path5.join(root.dir, ...segments);
+        const absPath = path8.join(root.dir, ...segments);
         validatePageSourceFile(posix, { filePath: absPath });
         if (!isRouteSourceFile(posix))
           continue;
         const key = `./${posix}`;
-        validateSubRoutePageKey(key, akanConfig2.basePaths, {
+        validateSubRoutePageKey(key, akanConfig.basePaths, {
           appName: this.name,
           filePath: absPath
         });
@@ -2679,7 +3407,8 @@ class AppExecutor extends SysExecutor {
         }
         if (!owner)
           owners.set(routeId, { absPath, fromLib });
-        const isRootLayout = parsed.kind === "layout" && parsed.moduleSegments.at(-1) === "_layout";
+        const layoutSegments = getRootBoundarySegments(key);
+        const isRootLayout = layoutSegments !== null && isRootBoundarySegments(layoutSegments, akanConfig.basePaths);
         const routeSource = await Bun.file(absPath).text();
         const validator = await AppExecutor.#getRouteSourceValidator();
         if (parsed.kind === "overrides")
@@ -2710,10 +3439,10 @@ class AppExecutor extends SysExecutor {
     return pageKeys.filter((key) => !isDevOnly(key));
   }
   async getPageRoots() {
-    const akanConfig2 = await this.getConfig();
+    const akanConfig = await this.getConfig();
     const pageDir = `${this.cwdPath}/page`;
     const roots = [{ dir: pageDir, realDir: pageDir, keyPrefix: "" }];
-    for (const parent of AppExecutor.#pageLibParents(akanConfig2.basePaths)) {
+    for (const parent of AppExecutor.#pageLibParents(akanConfig.basePaths)) {
       const libsDir = `${pageDir}/${parent}${AppExecutor.#pageLibsDir}`;
       const entries = await readDirEntries(libsDir).catch(() => []);
       for (const entry of entries.sort()) {
@@ -2734,9 +3463,9 @@ class AppExecutor extends SysExecutor {
     return parents.length ? parents : [""];
   }
   async syncPages(libDeps) {
-    const akanConfig2 = await this.getConfig();
-    const parents = AppExecutor.#pageLibParents(akanConfig2.basePaths);
-    const libs = await this.#resolvePageLibs(akanConfig2.syncPageLibs, libDeps);
+    const akanConfig = await this.getConfig();
+    const parents = AppExecutor.#pageLibParents(akanConfig.basePaths);
+    const libs = await this.#resolvePageLibs(akanConfig.syncPageLibs, libDeps);
     const linked = (await Promise.all(parents.map(async (parent) => {
       const libsDir = `${this.cwdPath}/page/${parent}${AppExecutor.#pageLibsDir}`;
       const entries = await readDirEntries(libsDir).catch(() => []);
@@ -2794,12 +3523,12 @@ class AppExecutor extends SysExecutor {
   static async#linkLibAsset(targetPath, linkPath) {
     const isWindows = process.platform === "win32";
     try {
-      const target = isWindows ? targetPath : path5.relative(path5.dirname(linkPath), targetPath);
+      const target = isWindows ? targetPath : path8.relative(path8.dirname(linkPath), targetPath);
       await symlink(target, linkPath, isWindows ? "junction" : "dir");
     } catch (error) {
       if (!isWindows)
         throw error;
-      await mkdir(linkPath, { recursive: true });
+      await mkdir3(linkPath, { recursive: true });
       await cpEntry(targetPath, linkPath, { recursive: true, dereference: true, force: true });
     }
   }
@@ -2836,7 +3565,7 @@ class AppExecutor extends SysExecutor {
         await this.writeFile(rel, content, opts);
       },
       readEnvClient: async () => {
-        const envClientPath = path5.join(this.cwdPath, "env", "env.client.ts");
+        const envClientPath = path8.join(this.cwdPath, "env", "env.client.ts");
         if (!await FileSys.fileExists(envClientPath))
           return null;
         try {
@@ -2895,9 +3624,9 @@ class LibExecutor extends SysExecutor {
   }
   static #execs = new Map;
   static from(executor, name) {
-    const exec2 = LibExecutor.#execs.get(name);
-    if (exec2)
-      return exec2;
+    const exec = LibExecutor.#execs.get(name);
+    if (exec)
+      return exec;
     else if (executor instanceof WorkspaceExecutor)
       return new LibExecutor({ workspace: executor, name });
     else
@@ -2907,7 +3636,7 @@ class LibExecutor extends SysExecutor {
   async getConfig({ refresh } = {}) {
     if (this.#akanConfig && !refresh)
       return this.#akanConfig;
-    this.#akanConfig = await AkanLibConfig.from(this);
+    this.#akanConfig = await AkanLibConfig.from(this, { bustImportCache: refresh });
     return this.#akanConfig;
   }
 }
@@ -2946,7 +3675,7 @@ class PkgExecutor extends Executor {
       return rootVersion;
     try {
       const packageJsonPath = `pkgs/${dep}/package.json`;
-      if (!await Bun.file(path5.join(this.workspace.workspaceRoot, packageJsonPath)).exists())
+      if (!await Bun.file(path8.join(this.workspace.workspaceRoot, packageJsonPath)).exists())
         return;
       const packageJson = await this.workspace.readJson(packageJsonPath);
       if (packageJson.name === dep)
@@ -3004,7 +3733,7 @@ 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)]);
@@ -3047,4 +3776,4 @@ class ModuleExecutor extends Executor {
   }
 }
 
-export { AGENT_BLOCK_START, AGENT_BLOCK_END, stampBlockVersion, extractBlockVersion, readDevkitVersion, upsertAgentBlock, extractAgentBlock, renderRecipeEntries, collectScopeRecipeSources, renderScopeAgentBlock, appRootAllowedFiles, appRootAllowedDirs, libFacetRootAllowedFiles, isScannedAppRootEntry, CommandExecutionError, Executor, WorkspaceExecutor, SysExecutor, AppExecutor, LibExecutor, PkgExecutor, ModuleExecutor };
+export { AGENT_BLOCK_START, AGENT_BLOCK_END, stampBlockVersion, extractBlockVersion, readDevkitVersion, upsertAgentBlock, extractAgentBlock, renderRecipeEntries, collectScopeRecipeSources, renderScopeAgentBlock, CLAUDE_COMMENT_RULE, AsyncDefaultExportDetector, resolveSsrPageEntriesForApp, CodegenLock, rootAllowedFiles, rootAllowedDirs, isAllowedLibFacetRootFile, isScannedRootEntry, AppInfo, Spinner, CommandExecutionError, Executor, WorkspaceExecutor, SysExecutor, AppExecutor, LibExecutor, PkgExecutor, ModuleExecutor };