@akanjs/cli 3.0.0-alpha.8 → 3.0.0-alpha.81

package/{index-vg0sj9nc.js → index-k1n0h7dk.js}

@@ -1,13 +1,74 @@
 // @bun
-import {
-  Spinner
-} from "./index-mxvakhsm.js";
 import {
   FileSys
-} from "./index-67546d0j.js";
+} from "./index-ayy5ecax.js";
 import {
-  __require
-} from "./index-r24hmh0q.js";
+  getDirname2
+} from "./index-6wwzs1bc.js";
+
+// 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 {
@@ -19,17 +80,18 @@ import { readFileSync as readFileSync2 } from "fs";
 import {
   copyFile,
   cp as cpEntry,
-  mkdir,
+  mkdir as mkdir2,
   readdir as readDirEntries,
   realpath,
   rm as rm2,
   stat,
   symlink
 } from "fs/promises";
-import path5 from "path";
+import path7 from "path";
 import { pathToFileURL } from "url";
 import {
   capitalize,
+  getPageSourceFileViolation,
   isRouteSourceFile,
   Logger,
   parseRouteModuleKey,
@@ -41,9 +103,24 @@ 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 ";
+var stampBlockVersion = (block, version) => `${AGENT_VERSION_PREFIX}${version} -->
+
+${block}`;
+var extractBlockVersion = (content) => content.match(/<!-- akan:agent:version ([^\s]+) -->/)?.[1] ?? null;
+var readDevkitVersion = async () => {
+  const { readFile } = await import("fs/promises");
+  const { getDirname } = await import("./getDirname-dr3jz1xg.js");
+  try {
+    const raw = await readFile(`${getDirname(import.meta.url)}/package.json`, "utf-8");
+    return JSON.parse(raw).version ?? null;
+  } catch {
+    return null;
+  }
+};
 var upsertAgentBlock = (existing, block) => {
   const managed = `${AGENT_BLOCK_START}
 ${block}
@@ -137,9 +214,29 @@ ${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
@@ -181,9 +278,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",
@@ -212,8 +308,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()
 ]);
@@ -228,7 +322,8 @@ 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();
@@ -275,12 +370,28 @@ 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;
@@ -290,6 +401,7 @@ class AkanAppConfig {
   mobile;
   hasMobileConfig;
   secrets;
+  assets;
   syncPageLibs;
   baseDevEnv;
   libs;
@@ -298,7 +410,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;
@@ -306,7 +418,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}`),
@@ -320,10 +432,25 @@ class AkanAppConfig {
     process.env.AKAN_PUBLIC_LOCALES = this.i18n.locales.join(",");
     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 {
@@ -433,23 +560,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(`
 `)}
@@ -470,15 +605,9 @@ ${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_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 } = {}) {
@@ -495,7 +624,22 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
     ]);
     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];
@@ -505,13 +649,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]];
@@ -599,14 +737,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 ?? []);
@@ -627,42 +769,436 @@ var decreaseBuildNum = async (app) => {
   const akanConfigContent = akanConfig.replace(`buildNum: ${appConfig.mobile.buildNum}`, `buildNum: ${appConfig.mobile.buildNum - 1}`);
   fs.writeFileSync(akanConfigPath, akanConfigContent);
 };
-// pkgs/@akanjs/devkit/getDirname.ts
+// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
+import { mkdir } from "fs/promises";
+import path3 from "path";
+
+// pkgs/@akanjs/devkit/transforms/asyncDefaultExportDetector.ts
+import fs2 from "fs";
 import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var getDirname = (url) => path2.dirname(fileURLToPath2(url));
+
+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(path2.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(path3.join(appCwdPath, "lib", "st.ts")).exists();
+}
+var IMPLICIT_LAYOUT_DIR = path3.join(".akan", "generated", "root-layouts");
+var IMPLICIT_DICT_DIR = path3.join(".akan", "generated", "dict");
+var IMPLICIT_OVERRIDES_DIR = path3.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 = path3.join(path3.resolve(opts.appCwdPath), IMPLICIT_OVERRIDES_DIR, filename);
+  const userRel = path3.relative(path3.dirname(absPath), opts.userAbsPath).split(path3.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 path3.join(path3.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
+}
+function implicitDictionaryMacroAbsPath(appCwdPath) {
+  return path3.join(path3.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: path3.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 ? path3.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 = path3.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 mkdir(path3.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 mkdir(path3.dirname(absPath), { recursive: true });
+  const dictMacroRel = dictMacroAbsPath ? path3.relative(path3.dirname(absPath), dictMacroAbsPath).split(path3.sep).join("/") : null;
+  const dictMacroSpecifier = dictMacroRel ? dictMacroRel.startsWith(".") ? dictMacroRel : `./${dictMacroRel}` : null;
+  const sourceRel = opts.boundary.sourceAbsPath ? path3.relative(path3.dirname(absPath), opts.boundary.sourceAbsPath).split(path3.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 ? path3.relative(path3.dirname(absPath), inheritedSourceAbsPath).split(path3.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 = path3.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 = path3.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 path3 from "path";
+import path4 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 = path3.join(this.lintRoot, "node_modules/.bin/biome");
+    this.configPath = Linter.#configPathIn(this.lintRoot) ?? path4.join(this.lintRoot, "biome.json");
+    const localBiomeBin = path4.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 = path4.join(dir, fileName);
+      if (existsSync(configPath))
+        return configPath;
+    }
+    return null;
+  }
   #findBiomeRootPath(dir) {
-    const configPath = path3.join(dir, "biome.json");
-    if (existsSync(configPath))
+    if (Linter.#configPathIn(dir))
       return dir;
-    const parentDir = path3.dirname(dir);
+    const parentDir = path4.dirname(dir);
     if (parentDir === dir)
       throw new Error(`biome.json not found from ${dir}`);
     return this.#findBiomeRootPath(parentDir);
   }
   #toBiomePath(filePath) {
-    const relativePath = path3.relative(this.lintRoot, filePath);
-    if (!relativePath.startsWith("..") && !path3.isAbsolute(relativePath))
+    const relativePath = path4.relative(this.lintRoot, filePath);
+    if (!relativePath.startsWith("..") && !path4.isAbsolute(relativePath))
       return relativePath;
     return filePath;
   }
   #resolveFilePath(filePath) {
-    return path3.isAbsolute(filePath) ? filePath : path3.join(this.lintRoot, filePath);
+    return path4.isAbsolute(filePath) ? filePath : path4.join(this.lintRoot, filePath);
   }
   async#runBiome(args, input) {
     return await new Promise((resolve, reject) => {
@@ -683,18 +1219,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 path3.isAbsolute(diagnosticPath) ? diagnosticPath : path3.join(this.lintRoot, diagnosticPath);
+    return path4.isAbsolute(diagnosticPath) ? diagnosticPath : path4.join(this.lintRoot, diagnosticPath);
   }
   #createLintMessage(diagnostic) {
     const start = diagnostic.location?.start;
@@ -759,10 +1288,10 @@ class Linter {
       "--max-diagnostics=none",
       "--no-errors-on-unmatched",
       "--config-path",
-      path3.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;
@@ -880,22 +1409,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",
-      path3.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(path3.join(this.lintRoot, "biome.json"), "utf8"));
+    return JSON.parse(readFileSync(this.configPath, "utf8"));
   }
   async getProblematicRules(filePath) {
     const { results } = await this.lintFile(filePath);
@@ -910,9 +1451,34 @@ ${errorText}, ${warningText} found`];
   }
 }
 
+// pkgs/@akanjs/devkit/repoIdentity.ts
+import { execFileSync } from "child_process";
+import path5 from "path";
+var resolved = new Map;
+var readRemoteName = (workspaceRoot) => {
+  try {
+    const url = execFileSync("git", ["config", "--get", "remote.origin.url"], {
+      cwd: workspaceRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return url.replace(/\.git$/, "").split(/[/:]/).pop() || null;
+  } catch {
+    return null;
+  }
+};
+var resolveRepoName = (workspaceRoot) => {
+  const cached = resolved.get(workspaceRoot);
+  if (cached)
+    return cached;
+  const repoName = readRemoteName(workspaceRoot) ?? path5.basename(workspaceRoot);
+  resolved.set(workspaceRoot, repoName);
+  return repoName;
+};
+
 // pkgs/@akanjs/devkit/scanInfo.ts
 import { rm } from "fs/promises";
-import path4 from "path";
+import path6 from "path";
 
 // pkgs/@akanjs/devkit/workspaceLayout.ts
 var appRootAllowedFiles = new Set([
@@ -946,6 +1512,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",
@@ -957,7 +1551,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 = [
@@ -986,18 +1582,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-c64m6fxp.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) => path6.posix.join(`${exec.type}s`, exec.name, relativePath.split(path6.sep).join("/"));
 async function clearGeneratedRootCapacitorConfigs(exec) {
   if (exec.type !== "app")
     return;
   await Promise.all(generatedRootCapacitorConfigFiles.map((filename) => rm(exec.getPath(filename), { force: true })));
 }
 var getModuleNameFromPath = (kind, modulePath) => {
-  const dirname = path4.basename(modulePath);
+  const dirname = path6.basename(modulePath);
   return kind === "service" ? dirname.replace(/^_+/, "") : dirname;
 };
 async function assertScanConvention(exec, libRoot) {
@@ -1006,28 +1600,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(path6.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(path6.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", path6.join("lib", dirname))),
+    ...serviceDirs.map((dirname) => validateModuleFiles(exec, violations, "service", path6.join("lib", dirname))),
+    ...scalarDirs.map((dirname) => validateModuleFiles(exec, violations, "scalar", path6.join("lib/__scalar", dirname)))
   ]);
   if (violations.length > 0) {
     throw new Error(`[scan-convention]
@@ -1039,11 +1636,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, path6.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 = path6.join(modulePath, filename);
     if (filename === "index.ts" || filename === "index.tsx" || isAllowedTestFile(filename))
       return;
     if (filename === `${moduleName}.abstract.md`)
@@ -1087,7 +1684,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(),
@@ -1123,7 +1720,7 @@ class ScanInfo {
     });
     await Promise.all([
       ...databaseDirs.map(async (name) => {
-        const filenames = await exec.readdir(path4.join("lib", name));
+        const filenames = await exec.readdir(path6.join("lib", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constant.databases.push(name);
@@ -1151,7 +1748,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(path6.join("lib", dirname));
         filenames.forEach((filename) => {
           if (filename.endsWith(".dictionary.ts"))
             files.dictionary.services.push(name);
@@ -1174,7 +1771,7 @@ class ScanInfo {
         });
       }),
       ...scalarDirs.map(async (name) => {
-        const filenames = await exec.readdir(path4.join("lib/__scalar", name));
+        const filenames = await exec.readdir(path6.join("lib/__scalar", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constant.scalars.push(name);
@@ -1196,12 +1793,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(path6.join(exec.workspace.workspaceRoot, ".env")).serveDomain,
       files,
       libDeps,
       pkgDeps,
@@ -1209,6 +1805,7 @@ class ScanInfo {
       devDependencies: npmDevDeps.filter((dep) => !isAkanFrameworkDependency(dep)),
       routes
     };
+    const scanResult = akanConfig instanceof AkanAppConfig ? { ...common, akanConfig } : { ...common, akanConfig };
     return scanResult;
   }
   constructor(scanResult) {
@@ -1402,16 +1999,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,
@@ -1433,10 +2030,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;
   }
 }
 
@@ -1634,7 +2231,7 @@ class Executor {
         }));
       });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal)
+        if (code || signal)
           reject(new CommandExecutionError({
             command,
             cwd,
@@ -1732,7 +2329,7 @@ class Executor {
         }));
       });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal)
+        if (code || signal)
           reject(new CommandExecutionError({
             command: modulePath,
             args,
@@ -1748,10 +2345,10 @@ class Executor {
     });
   }
   getPath(filePath) {
-    if (path5.isAbsolute(filePath))
+    if (path7.isAbsolute(filePath))
       return filePath;
     if (filePath.startsWith("."))
-      return path5.join(this.cwdPath, filePath);
+      return path7.join(this.cwdPath, filePath);
     const baseParts = this.cwdPath.split(/[\\/]/).filter(Boolean);
     const targetParts = filePath.split(/[\\/]/).filter(Boolean);
     let overlapLength = 0;
@@ -1765,12 +2362,12 @@ class Executor {
       if (isOverlap)
         overlapLength = i;
     }
-    return path5.join(this.cwdPath, ...targetParts.slice(overlapLength));
+    return path7.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 mkdir2(writePath, { recursive: true });
     this.logger.verbose(`Make directory ${writePath}`);
     return this;
   }
@@ -1808,7 +2405,7 @@ class Executor {
     return this;
   }
   async removeDir(dirPath) {
-    const readPath = path5.join(this.getPath(dirPath), ".");
+    const readPath = path7.join(this.getPath(dirPath), ".");
     if (await FileSys.entryExists(readPath))
       await rm2(readPath, { recursive: true, force: true });
     this.logger.verbose(`Remove directory ${readPath}`);
@@ -1816,10 +2413,11 @@ class Executor {
   }
   async writeFile(filePath, content, { overwrite = true, silent = false } = {}) {
     const writePath = this.getPath(filePath);
-    const dir = path5.dirname(writePath);
+    const dir = path7.dirname(writePath);
     if (!await FileSys.dirExists(dir))
-      await mkdir(dir, { recursive: true });
-    let contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+      await mkdir2(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) {
@@ -1841,7 +2439,7 @@ class Executor {
     await this.writeFile(filePath, content);
   }
   async getLocalFile(targetPath) {
-    const filePath = path5.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
+    const filePath = path7.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
     const content = await this.readFile(filePath);
     return { filePath, content };
   }
@@ -1860,7 +2458,7 @@ class Executor {
       return;
     const isDirectory = (await stat(src)).isDirectory();
     if (!await FileSys.exists(dest) && isDirectory)
-      await mkdir(dest, { recursive: true });
+      await mkdir2(dest, { recursive: true });
     if (dereference)
       await cpEntry(src, dest, { recursive: isDirectory, dereference: true, force: true });
     else
@@ -1938,26 +2536,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 : path7.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 = path7.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(path7.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 = path7.dirname(writePath);
       if (!await FileSys.dirExists(dirname))
-        await mkdir(dirname, { recursive: true });
+        await mkdir2(dirname, { recursive: true });
       await copyFile(templatePath, writePath);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return { filePath: writePath, content: "" };
@@ -1976,10 +2574,10 @@ class Executor {
     const templatePath = `${templateRoot}${template ? `/${template}` : ""}`;
     const prefixTemplatePath = templatePath;
     if ((await stat(prefixTemplatePath)).isFile()) {
-      const filename = path5.basename(prefixTemplatePath);
+      const filename = path7.basename(prefixTemplatePath);
       const fileContent = await this.#applyTemplateFile({
         templatePath: prefixTemplatePath,
-        targetPath: path5.join(basePath, filename),
+        targetPath: path7.join(basePath, filename),
         scanInfo,
         overwrite
       }, dict, options);
@@ -1987,19 +2585,19 @@ class Executor {
     } else {
       const subdirs = await readDirEntries(templatePath);
       const fileContents = (await Promise.all(subdirs.map(async (subdir) => {
-        const subpath = path5.join(templatePath, subdir);
+        const subpath = path7.join(templatePath, subdir);
         if ((await stat(subpath)).isFile()) {
           const fileContent = await this.#applyTemplateFile({
             templatePath: subpath,
-            targetPath: path5.join(basePath, subdir),
+            targetPath: path7.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: path7.join(basePath, subdir),
+            template: path7.join(template, subdir),
             scanInfo,
             dict,
             overwrite,
@@ -2011,8 +2609,8 @@ class Executor {
   }
   async#resolveTemplateRoot() {
     const candidates = [
-      path5.resolve(getDirname(import.meta.url), "templates"),
-      path5.resolve(getDirname(import.meta.url), "../cli/templates")
+      path7.resolve(getDirname2(import.meta.url), "templates"),
+      path7.resolve(getDirname2(import.meta.url), "../cli/templates")
     ];
     for (const candidate of candidates) {
       if (await FileSys.dirExists(candidate))
@@ -2025,29 +2623,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"
@@ -2068,13 +2680,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")
+      path7.join(process.cwd(), "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path7.join(process.cwd(), "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path7.join(dirname, "typecheck/typecheck.proc.ts"),
+      path7.join(dirname, "typecheck.proc.js"),
+      path7.join(dirname, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -2086,9 +2698,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
     });
@@ -2109,7 +2721,7 @@ class WorkspaceExecutor extends Executor {
   static #execs = new Map;
   static fromRoot({
     workspaceRoot = process.cwd(),
-    repoName = path5.basename(process.cwd())
+    repoName = resolveRepoName(workspaceRoot)
   } = {}) {
     return WorkspaceExecutor.#execs.get(repoName) ?? new WorkspaceExecutor({ workspaceRoot, repoName });
   }
@@ -2201,7 +2813,7 @@ 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);
+        const dirPath = path7.join(dirname, dir);
         if ((await stat(dirPath)).isDirectory()) {
           results.push(`${prefix}${dir}`);
           if (maxDepth > 0)
@@ -2214,10 +2826,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"];
@@ -2226,9 +2848,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 = path7.join(dirname, dir);
         if (await FileSys.dirExists(dirPath)) {
-          const hasTargetFile = await FileSys.fileExists(path5.join(dirPath, targetFilename));
+          const hasTargetFile = await FileSys.fileExists(path7.join(dirPath, targetFilename));
           if (hasTargetFile)
             results.push(`${prefix}${dir}`);
           if (maxDepth > 0)
@@ -2294,8 +2916,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(path7.sep).join("/");
+      const reason = getPageSourceFileViolation(relativePath);
+      if (reason)
+        violations.push({ relativePath: `page/${relativePath}`, reason });
+    }
+    return violations;
   }
   #scanInfo = null;
   hasScanInfo() {
@@ -2399,7 +3033,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 = path7.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
     const content = await this.workspace.readFile(filePath);
     return { filePath, content };
   }
@@ -2485,7 +3119,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;
@@ -2496,9 +3130,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
@@ -2534,25 +3168,29 @@ 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_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,
@@ -2600,7 +3238,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;
@@ -2614,16 +3252,16 @@ class AppExecutor extends SysExecutor {
         absolute: false,
         onlyFiles: true
       })) {
-        const segments = rel.split(path5.sep);
+        const segments = rel.split(path7.sep);
         if (segments.some((s) => s === "node_modules"))
           continue;
         const posix = `${root.keyPrefix}${segments.join("/")}`;
-        const absPath = path5.join(root.dir, ...segments);
+        const absPath = path7.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
         });
@@ -2641,7 +3279,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")
@@ -2672,10 +3311,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()) {
@@ -2696,9 +3335,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(() => []);
@@ -2756,12 +3395,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 : path7.relative(path7.dirname(linkPath), targetPath);
       await symlink(target, linkPath, isWindows ? "junction" : "dir");
     } catch (error) {
       if (!isWindows)
         throw error;
-      await mkdir(linkPath, { recursive: true });
+      await mkdir2(linkPath, { recursive: true });
       await cpEntry(targetPath, linkPath, { recursive: true, dereference: true, force: true });
     }
   }
@@ -2798,7 +3437,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 = path7.join(this.cwdPath, "env", "env.client.ts");
         if (!await FileSys.fileExists(envClientPath))
           return null;
         try {
@@ -2857,9 +3496,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
@@ -2869,7 +3508,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;
   }
 }
@@ -2908,7 +3547,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(path7.join(this.workspace.workspaceRoot, packageJsonPath)).exists())
         return;
       const packageJson = await this.workspace.readJson(packageJsonPath);
       if (packageJson.name === dep)
@@ -2966,7 +3605,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)]);
@@ -3009,4 +3648,4 @@ class ModuleExecutor extends Executor {
   }
 }
 
-export { AGENT_BLOCK_START, AGENT_BLOCK_END, upsertAgentBlock, extractAgentBlock, renderRecipeEntries, collectScopeRecipeSources, renderScopeAgentBlock, getDirname, 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, rootAllowedFiles, rootAllowedDirs, isAllowedLibFacetRootFile, isScannedRootEntry, AppInfo, Spinner, CommandExecutionError, Executor, WorkspaceExecutor, SysExecutor, AppExecutor, LibExecutor, PkgExecutor, ModuleExecutor };