@akanjs/cli 3.0.0-beta.2 → 3.0.0-beta.21

package/{index-2tv3fdx4.js → index-ga6hygxr.js}

@@ -1,161 +1,474 @@
 // @bun
 import {
-  FileSys
-} from "./index-q0y2jq9j.js";
-import {
-  getDirname2
-} from "./index-6wwzs1bc.js";
+  getDirname2,
+  FileSys2
+} from "./index-5b6tavv3.js";
 
-// pkgs/@akanjs/devkit/codegenLock.ts
-import { mkdir, open, readFile, rm, stat } from "fs/promises";
+// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
+import { readdir, rm } from "fs/promises";
+import path2 from "path";
+
+// pkgs/@akanjs/devkit/transforms/asyncDefaultExportDetector.ts
+import fs from "fs";
 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();
-    }
+class AsyncDefaultExportDetector {
+  static #typescriptLoad;
+  static #loadTypescript() {
+    AsyncDefaultExportDetector.#typescriptLoad ??= import("typescript").then((mod) => mod.default ?? mod);
+    return AsyncDefaultExportDetector.#typescriptLoad;
   }
-  static async#waitForQueue(ahead, label) {
-    let timer = null;
-    const expired = new Promise((resolve) => {
-      timer = setTimeout(() => resolve("expired"), CodegenLock.waitTimeoutMs);
-    });
+  static async detect(moduleAbsPath) {
     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);
+      const typescript = await AsyncDefaultExportDetector.#loadTypescript();
+      const source = fs.readFileSync(path.resolve(moduleAbsPath), "utf8");
+      const sourceFile = typescript.createSourceFile(moduleAbsPath, source, typescript.ScriptTarget.Latest, true, /\.[tj]sx$/.test(moduleAbsPath) ? typescript.ScriptKind.TSX : typescript.ScriptKind.TS);
+      return new AsyncDefaultExportDetector(typescript).detectInSourceFile(sourceFile);
+    } catch {
+      return false;
     }
   }
-  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;
-        });
-    }
+  #ts;
+  constructor(typescript) {
+    this.#ts = typescript;
   }
-  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;
+  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 (await CodegenLock.#reclaimIfAbandoned(lockPath))
+      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 (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);
+      if (ts.isExportAssignment(statement)) {
+        if (this.#isAsyncFunctionExpression(statement.expression))
+          return true;
+        if (ts.isCallExpression(statement.expression))
+          return true;
+        if (ts.isIdentifier(statement.expression))
+          defaultIdentifier = statement.expression.text;
+        continue;
+      }
+      if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        for (const specifier of statement.exportClause.elements) {
+          if (specifier.name.text !== "default")
+            continue;
+          defaultIdentifier = specifier.propertyName?.text ?? specifier.name.text;
+        }
+      }
     }
+    return defaultIdentifier ? asyncBindings.get(defaultIdentifier) === true : false;
   }
-  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;
-    }
+  #hasModifier(node, kind) {
+    const ts = this.#ts;
+    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
   }
-  static #isAlive(pid) {
-    if (!Number.isInteger(pid) || pid <= 0)
-      return false;
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch (error) {
-      return error.code === "EPERM";
-    }
+  #isAsyncFunctionExpression(node) {
+    const ts = this.#ts;
+    return Boolean(node && (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && this.#hasModifier(node, ts.SyntaxKind.AsyncKeyword));
   }
 }
 
-// pkgs/@akanjs/devkit/spinner.ts
-import ora from "ora";
+// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
+var LAYOUT_KEY_RE = /^\.\/(.+\/)?_layout\.(tsx|ts|jsx|js)$/;
+var IMPLICIT_LAYOUT_DIR = path2.join(".akan", "generated", "root-layouts");
+var IMPLICIT_DICT_DIR = path2.join(".akan", "generated", "dict");
+var IMPLICIT_OVERRIDES_DIR = path2.join(".akan", "generated", "overrides");
+var OVERRIDES_KEY_RE = /^\.\/(.+\/)?_overrides\.(tsx|ts|jsx|js)$/;
+var importSpecifier = (fromAbsPath, toAbsPath) => {
+  const rel = path2.relative(path2.dirname(fromAbsPath), toAbsPath).split(path2.sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+};
+async function writeGeneratedOverridesLayoutFile(opts) {
+  const filename = `${opts.key.replace(/^\.\//, "").replace(/[^a-zA-Z0-9]+/g, "_")}.tsx`;
+  const absPath = path2.join(path2.resolve(opts.appCwdPath), IMPLICIT_OVERRIDES_DIR, filename);
+  const source = `"use client";
+import { UiOverrideProvider } from "akanjs/ui";
+import { createElement, type ReactNode } from "react";
+import value from ${JSON.stringify(importSpecifier(absPath, opts.userAbsPath))};
 
-class Spinner {
-  static padding = 12;
-  static oraOptions = { discardStdin: false };
-  static canAnimate(stream = process.stderr) {
-    return !stream.isTTY || stream.columns > 0;
+export default function AkanUiOverridesLayout({ children }: { children?: ReactNode }) {
+  return createElement(UiOverrideProvider, { value }, children);
+}
+`;
+  await Bun.write(absPath, source);
+  return absPath;
+}
+async function pruneGeneratedFiles(dirAbsPath, keepAbsPaths) {
+  const keep = new Set(keepAbsPaths);
+  const names = await readdir(dirAbsPath).catch(() => []);
+  await Promise.all(names.map((name) => path2.join(dirAbsPath, name)).filter((absPath) => !keep.has(absPath)).map((absPath) => rm(absPath, { force: true })));
+}
+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 path2.join(path2.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
+}
+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: path2.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
+      segments
+    });
   }
-  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();
+  if (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 ? path2.resolve(appCwdPath, "page", rootLayoutKey.replace(/^\.\//, "")) : null;
+}
+async function assertEnvClientConvention(appCwdPath, appName) {
+  const envPath = path2.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`);
   }
-  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;
+}
+async function writeGeneratedDictionaryMacroFile(appCwdPath, appName) {
+  const absPath = path2.join(path2.resolve(appCwdPath), IMPLICIT_DICT_DIR, "useDict.ts");
+  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);
+  const dictMacroSpecifier = dictMacroAbsPath ? importSpecifier(absPath, dictMacroAbsPath) : null;
+  const sourceSpecifier = opts.boundary.sourceAbsPath ? importSpecifier(absPath, opts.boundary.sourceAbsPath) : null;
+  const inheritedSourceAbsPath = opts.rootSourceAbsPath && opts.rootSourceAbsPath !== opts.boundary.sourceAbsPath ? opts.rootSourceAbsPath : null;
+  const inheritedSourceSpecifier = inheritedSourceAbsPath ? importSpecifier(absPath, inheritedSourceAbsPath) : null;
+  const clientImport = opts.includeStInit ? `import { st } from "@apps/${opts.appName}/client";
+void st;
+` : `import "@apps/${opts.appName}/client";
+`;
+  const inheritedLabel = inheritedSourceAbsPath ? path2.relative(opts.appCwdPath, inheritedSourceAbsPath) : "";
+  const inheritedImport = inheritedSourceSpecifier ? `import * as inheritedModule from ${JSON.stringify(inheritedSourceSpecifier)};
+const inheritedLayout = resolveRouteModule(inheritedModule as never, ${JSON.stringify(inheritedLabel)}).module as LayoutModule;
+` : `const inheritedLayout: LayoutModule = {};
+`;
+  const prefix = opts.boundary.segments.find((segment) => !/^\(.+\)$/.test(segment)) ?? null;
+  const userLabel = opts.boundary.sourceAbsPath ? path2.relative(opts.appCwdPath, opts.boundary.sourceAbsPath) : "";
+  const userImport = sourceSpecifier ? `import * as userModule from ${JSON.stringify(sourceSpecifier)};
+const userLayout = resolveRouteModule(userModule as never, ${JSON.stringify(userLabel)}).module as LayoutModule;
+const UserLayout = userLayout.default as (props: LayoutProps) => ReactNode | Promise<ReactNode>;
+` : `const UserLayout = ({ children }: LayoutProps) => children;
+const userLayout: LayoutModule = {};
+`;
+  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 layoutExports = `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 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 `;
+  const source = opts.includeSystemProvider ? `import type { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
+import { loadFonts, resolveRouteModule } from "akanjs/client";
+import type { ReactNode } from "react";
+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;
+
+${layoutExports}(
+    <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}
+      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 { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
+import { resolveRouteModule } from "akanjs/client";
+import type { ReactNode } from "react";
+${inheritedImport}${userImport}
+${layoutExports}${layoutReturn};
+}
+`;
+  await Bun.write(absPath, source);
+  return absPath;
+}
+async function resolveSsrPageEntries(opts) {
+  const absPageDir = path2.resolve(opts.appCwdPath, "page");
+  const hasSt = await Bun.file(path2.join(opts.appCwdPath, "lib", "st.ts")).exists();
+  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 = path2.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 appCwdAbsPath = path2.resolve(opts.appCwdPath);
+  await Promise.all([
+    pruneGeneratedFiles(path2.join(appCwdAbsPath, IMPLICIT_OVERRIDES_DIR), base.filter(({ key }) => OVERRIDES_KEY_RE.test(key)).map(({ moduleAbsPath }) => moduleAbsPath)),
+    pruneGeneratedFiles(path2.join(appCwdAbsPath, IMPLICIT_LAYOUT_DIR), generated.map(({ moduleAbsPath }) => moduleAbsPath))
+  ]);
+  return [...base, ...generated].sort((a, b) => a.key.localeCompare(b.key));
+}
+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/codegenLock.ts
+import { mkdir, open, readFile, rm as rm2, stat } from "fs/promises";
+import path3 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 path3.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(path3.dirname(lockPath), { recursive: true }).catch(() => {
+      return;
+    });
+    const held = await CodegenLock.#acquire(lockPath, label);
+    try {
+      return await fn();
+    } finally {
+      if (held)
+        await rm2(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 rm2(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()})`);
@@ -191,11 +504,12 @@ import {
   fork,
   spawn as spawn2
 } from "child_process";
-import { readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import {
   copyFile,
   cp as cpEntry,
-  mkdir as mkdir3,
+  lstat,
+  mkdir as mkdir2,
   readdir as readDirEntries,
   realpath,
   rm as rm3,
@@ -218,7 +532,7 @@ import chalk2 from "chalk";
 
 // pkgs/@akanjs/devkit/agentsIndex.ts
 var recipeScannerLoad = null;
-var loadRecipeScanner = () => recipeScannerLoad ??= import("./recipeScanner-fpagtgc1.js");
+var loadRecipeScanner = () => recipeScannerLoad ??= import("./recipeScanner-4b69ybe0.js");
 var AGENT_BLOCK_START = "<!-- akan:agent:start -->";
 var AGENT_BLOCK_END = "<!-- akan:agent:end -->";
 var AGENT_VERSION_PREFIX = "<!-- akan:agent:version ";
@@ -228,7 +542,7 @@ ${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");
+  const { getDirname } = await import("./fileSys-5ngz93ga.js");
   try {
     const raw = await readFile(`${getDirname(import.meta.url)}/package.json`, "utf-8");
     return JSON.parse(raw).version ?? null;
@@ -355,10 +669,10 @@ ${CLAUDE_COMMENT_RULE}
 `;
 
 // pkgs/@akanjs/devkit/akanConfig/akanConfig.ts
-import fs from "fs";
-import path2 from "path";
+import fs2 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
-import { normalizeRoutePrefix } from "akanjs/base";
+import { DatabaseModes, normalizeRoutePrefix } from "akanjs/base";
 import { resolveAkanI18nConfig } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/akanConfig/types.ts
@@ -367,66 +681,14 @@ import { archs } from "akanjs";
 // pkgs/@akanjs/devkit/akanConfig/akanConfig.ts
 var DEFAULT_BARREL_IMPORTS = ["akanjs/webkit", "akanjs/common", "akanjs/ui", "akanjs/server"];
 var DEFAULT_OPTIMIZE_IMPORTS = [
-  "lucide-react",
-  "date-fns",
-  "lodash-es",
-  "ramda",
-  "antd",
-  "react-bootstrap",
-  "ahooks",
-  "@ant-design/icons",
-  "@headlessui/react",
-  "@headlessui-float/react",
-  "@heroicons/react/20/solid",
-  "@heroicons/react/24/solid",
-  "@heroicons/react/24/outline",
-  "@visx/visx",
-  "@tremor/react",
-  "rxjs",
-  "@mui/material",
-  "@mui/icons-material",
-  "recharts",
-  "react-use",
-  "@material-ui/core",
-  "@material-ui/icons",
-  "@tabler/icons-react",
-  "mui-core",
-  "react-icons/*"
-];
+  "lucide-react date-fns lodash-es ramda antd react-bootstrap ahooks @ant-design/icons @headlessui/react",
+  "@headlessui-float/react @heroicons/react/20/solid @heroicons/react/24/solid @heroicons/react/24/outline",
+  "@visx/visx @tremor/react rxjs @mui/material @mui/icons-material recharts react-use @material-ui/core",
+  "@material-ui/icons @tabler/icons-react mui-core react-icons/*"
+].flatMap((line) => line.split(" "));
 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 MOBILE_RUNTIME_PACKAGES = [
-  "@capacitor/cli",
-  "@capacitor/core",
-  "@capacitor/ios",
-  "@capacitor/android",
-  "@capacitor/assets"
-];
-var MOBILE_APP_CAPACITOR_PLUGINS = [
-  "@capacitor/app",
-  "@capacitor/browser",
-  "@capacitor/camera",
-  "@capacitor/core",
-  "@capacitor/device",
-  "@capacitor/geolocation",
-  "@capacitor/haptics",
-  "@capacitor/inappbrowser",
-  "@capacitor/keyboard",
-  "@capacitor/preferences",
-  "@capacitor/push-notifications",
-  "capacitor-plugin-safe-area"
-];
-var DATABASE_MODE_RUNTIME_PACKAGES = {
-  single: [],
-  multiple: ["@libsql/client", "bullmq", "ioredis", "protobufjs"],
-  cluster: ["bullmq", "ioredis", "postgres", "protobufjs"]
-};
-var AKAN_RUNTIME_PACKAGES = new Set([
-  ...SSR_RUNTIME_PACKAGES,
-  ...MOBILE_RUNTIME_PACKAGES,
-  ...Object.values(DATABASE_MODE_RUNTIME_PACKAGES).flat()
-]);
 var DEFAULT_AKAN_IMAGE_CONFIG = {
   deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
   imageSizes: [32, 48, 64, 96, 128, 256, 384],
@@ -506,7 +768,7 @@ class AkanAppConfig {
   rootPackageJson;
   docker;
   dockerfile;
-  defaultDatabaseMode;
+  database;
   web;
   externalLibs;
   barrelImports;
@@ -534,7 +796,7 @@ class AkanAppConfig {
     this.baseDevEnv = baseDevEnv;
     this.plugins = plugins;
     this.#applyRoutes(config?.routes);
-    this.defaultDatabaseMode = config?.defaultDatabaseMode ?? "single";
+    this.database = AkanAppConfig.#database(app, config);
     this.externalLibs = [...new Set([...config?.externalLibs ?? [], ...libContributions.externalLibs])];
     this.barrelImports = [
       ...DEFAULT_BARREL_IMPORTS,
@@ -572,7 +834,7 @@ class AkanAppConfig {
   #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.`);
+      throw new Error(`apps/${this.app.name}/akan.config.ts turns the CSR bundle off but declares mobile targets; the mobile apps ship that bundle. Drop the mobile section or leave CSR on.`);
     return resolved;
   }
   #resolveMobileConfig(mobile) {
@@ -581,57 +843,113 @@ class AkanAppConfig {
       indexPath: _indexPath,
       ...rawMobile
     } = mobile ?? {};
+    const configPath = `apps/${this.app.name}/akan.config.ts`;
+    AkanAppConfig.#assertMobileKeys(rawMobile, AkanAppConfig.#mobileKeys, "mobile", configPath);
     const appName = rawMobile.appName ?? this.app.name;
     const appId = rawMobile.appId ?? deriveDefaultAppId(this.baseDevEnv.repoName, this.app.name);
     const version = rawMobile.version ?? "0.0.1";
     const buildNum = rawMobile.buildNum ?? 1;
+    const files = AkanAppConfig.#resolveMobileFiles(rawMobile.files, "mobile", configPath);
+    const native = rawMobile.native;
     const defaultTargetName = this.#defaultMobileTargetName(rawTargets);
     const targetEntries = Object.entries(rawTargets ?? {
       [defaultTargetName]: {}
     });
     const targets = Object.fromEntries(targetEntries.map(([name, rawTarget]) => {
-      const target = rawTarget;
+      const target = rawTarget ?? {};
+      const where = `mobile.targets.${name}`;
+      AkanAppConfig.#assertMobileKeys(target, AkanAppConfig.#targetKeys, where, configPath);
       const fallbackBasePath = !rawTargets && this.basePaths.has(name) ? name : undefined;
       const basePath = (target.basePath ?? fallbackBasePath)?.replace(/^\/+|\/+$/g, "") || undefined;
       const indexPath = normalizeIndexPath(target.indexPath);
       const deepLinks = normalizeDeepLinks(target.deepLinks);
       if (basePath && !this.basePaths.has(basePath)) {
-        throw new Error(`Mobile target '${name}' uses unknown basePath '${basePath}' in apps/${this.app.name}/akan.config.ts`);
+        throw new Error(`Mobile target '${name}' uses unknown basePath '${basePath}' in ${configPath}`);
       }
+      const targetFiles = AkanAppConfig.#resolveMobileFiles(target.files, where, configPath);
+      const fileName = target.fileName ?? rawMobile.fileName;
       const resolved = {
-        ...rawMobile,
-        ...target,
         name,
         basePath,
         indexPath,
         deepLinks,
         appName: target.appName ?? appName,
         appId: target.appId ?? appId,
+        ...fileName ? { fileName } : {},
         version: target.version ?? version,
         buildNum: target.buildNum ?? buildNum,
-        plugins: {
-          ...rawMobile.plugins,
-          ...target.plugins
-        },
-        android: {
-          ...rawMobile.android,
-          ...target.android
-        },
-        ios: {
-          ...rawMobile.ios,
-          ...target.ios
-        }
+        ...target.assets ? { assets: target.assets } : {},
+        ...target.permissions ? { permissions: target.permissions } : {},
+        ...files || targetFiles ? { files: { ...files, ...targetFiles } } : {},
+        ...native || target.native ? { native: AkanAppConfig.#mergeNative(native, target.native) } : {}
       };
       return [name, resolved];
     }));
     return {
-      ...rawMobile,
       appName,
       appId,
+      ...rawMobile.fileName ? { fileName: rawMobile.fileName } : {},
       version,
       buildNum,
-      targets,
-      plugins: rawMobile.plugins
+      ...files ? { files } : {},
+      ...native ? { native } : {},
+      targets
+    };
+  }
+  static #mobileKeys = ["appName", "appId", "fileName", "version", "buildNum", "files", "native"];
+  static #targetKeys = [
+    "basePath",
+    "indexPath",
+    "appName",
+    "appId",
+    "fileName",
+    "version",
+    "buildNum",
+    "assets",
+    "permissions",
+    "deepLinks",
+    "files",
+    "native"
+  ];
+  static #assertMobileKeys(section, known, where, configPath) {
+    for (const key of Object.keys(section)) {
+      if (known.includes(key))
+        continue;
+      if (key === "plugins" || key === "ios" || key === "android")
+        throw new Error(`${where}.${key} in ${configPath} is a Capacitor setting. The native runtime reads native.plugins, native.ios.{infoPlist,entitlements} and native.android.{manifest,application,activity,googleServices} instead.`);
+      throw new Error(`${where}.${key} in ${configPath} is not a mobile setting. Known: ${known.join(", ")}.`);
+    }
+  }
+  static #fileTargetPattern = /^(?:ios\/.+|android\/res\/[^/]+\/[^/]+|android\/assets\/.+)$/;
+  static #resolveMobileFiles(files, where, configPath) {
+    if (!files)
+      return;
+    for (const [to, from] of Object.entries(files)) {
+      if (typeof from !== "string")
+        throw new Error(`${where}.files in ${configPath} maps where a file lands to its source now, e.g. { "android/res/raw/chime.mp3": "assets/chime.mp3" }. google-services.json goes to native.android.googleServices, and GoogleService-Info.plist is no longer needed.`);
+      if (!AkanAppConfig.#fileTargetPattern.test(to))
+        throw new Error(`${where}.files["${to}"] in ${configPath} must land under ios/<path>, android/res/<type>/<file> or android/assets/<path>.`);
+    }
+    return files;
+  }
+  static #mergeNative(base, override) {
+    const plugins = [...new Set([...base?.plugins ?? [], ...override?.plugins ?? []])];
+    const ios = { ...base?.ios, ...override?.ios };
+    const android = {
+      ...base?.android,
+      ...override?.android
+    };
+    for (const key of ["manifest", "application", "activity"]) {
+      const merged = [...base?.android?.[key] ?? [], ...override?.android?.[key] ?? []];
+      if (merged.length)
+        android[key] = merged;
+      else
+        delete android[key];
+    }
+    return {
+      ...plugins.length ? { plugins } : {},
+      ...Object.keys(ios).length ? { ios } : {},
+      ...Object.keys(android).length ? { android } : {}
     };
   }
   #defaultMobileTargetName(rawTargets) {
@@ -641,22 +959,15 @@ class AkanAppConfig {
   }
   #applyRoutes(routes = []) {
     for (const route of routes) {
-      if (route.basePath) {
-        const basePath = route.basePath.replace(/^\/+|\/+$/g, "");
+      const basePath = route.basePath ? route.basePath.replace(/^\/+|\/+$/g, "") : null;
+      if (basePath !== null)
         this.basePaths.add(basePath);
-        const domains = this.subRoutes.getOrInsert(basePath, new Set);
-        Object.keys(route.domains).forEach((branch) => void this.branches.add(branch));
-        Object.values(route.domains).flat().forEach((domain) => {
-          if (domain)
-            domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
-        });
-      } else {
-        Object.keys(route.domains).forEach((branch) => void this.branches.add(branch));
-        Object.values(route.domains).flat().forEach((domain) => {
-          if (domain)
-            this.domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
-        });
-      }
+      const domains = basePath !== null ? this.subRoutes.getOrInsert(basePath, new Set) : this.domains;
+      for (const branch of Object.keys(route.domains))
+        this.branches.add(branch);
+      for (const domain of Object.values(route.domains).flat())
+        if (domain)
+          domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
     }
     const appName = this.app.name.toLowerCase();
     const serveDomain = this.baseDevEnv.serveDomain.toLowerCase();
@@ -730,6 +1041,7 @@ 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_DATABASE_MODES=${this.database.modes.join(",")}
 ENV AKAN_LOG_TO_FILE=0
 ${webEnvLines}
 CMD [${command.map((c) => `"${c}"`).join(",")}]`;
@@ -743,509 +1055,157 @@ 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(path2.join(app.workspace.workspaceRoot, ".env")),
+      WorkspaceExecutor.getBaseDevEnv(path4.join(app.workspace.workspaceRoot, ".env")),
       app.workspace.getLibs(),
       app.workspace.getPackageJson()
     ]);
-    const resolved = typeof configImp === "function" ? configImp(app) : configImp;
-    const { plugins, ...config } = resolved ?? {};
-    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];
-    if (rootVersion)
-      return rootVersion;
-    const akanPackageJson = getAkanPackageJson();
-    return akanPackageJson.dependencies?.[lib] ?? akanPackageJson.peerDependencies?.[lib];
-  }
-  #getProductionRuntimePackages() {
-    return [...this.externalLibs, ...SSR_RUNTIME_PACKAGES, ...this.getDatabaseModeRuntimePackages()];
-  }
-  getDatabaseModeRuntimePackages(databaseMode = this.defaultDatabaseMode) {
-    return [...DATABASE_MODE_RUNTIME_PACKAGES[databaseMode]];
-  }
-  getMissingDatabaseModeDependencySpecs(databaseMode = this.defaultDatabaseMode) {
-    return this.#getMissingDependencySpecs(this.getDatabaseModeRuntimePackages(databaseMode));
-  }
-  getMobileRuntimePackages() {
-    return [...new Set([...MOBILE_RUNTIME_PACKAGES, ...MOBILE_APP_CAPACITOR_PLUGINS])];
-  }
-  getMissingMobileDependencySpecs() {
-    return this.#getMissingDependencySpecs(this.getMobileRuntimePackages());
-  }
-  getMobileAppCapacitorPlugins() {
-    return [...MOBILE_APP_CAPACITOR_PLUGINS];
-  }
-  #getMissingDependencySpecs(libs) {
-    const rootDependencies = {
-      ...this.rootPackageJson.dependencies,
-      ...this.rootPackageJson.devDependencies
-    };
-    return libs.filter((lib) => !rootDependencies[lib]).map((lib) => {
-      const version = this.#resolveProductionDependencyVersion(lib);
-      if (!version)
-        throw new Error(`Dependency ${lib} not found in package.json`);
-      return `${lib}@${version}`;
-    });
-  }
-  getProductionPackageJson(data = {}) {
-    return {
-      name: this.app.name,
-      description: this.app.name,
-      version: "1.0.0",
-      main: "./main.js",
-      dependencies: Object.fromEntries([...new Set(this.#getProductionRuntimePackages())].map((lib) => {
-        const version = this.#resolveProductionDependencyVersion(lib);
-        if (!version)
-          throw new Error(`Dependency ${lib} not found in package.json`);
-        return [lib, version];
-      })),
-      ...data
-    };
-  }
-}
-var akanPackageJson = null;
-function getAkanPackageJson() {
-  if (akanPackageJson)
-    return akanPackageJson;
-  const sourceDir = path2.dirname(fileURLToPath(import.meta.url));
-  const packageJsonPaths = [
-    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));
-  } catch {}
-  for (const packageJsonPath of packageJsonPaths) {
-    try {
-      akanPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-      return akanPackageJson;
-    } catch {}
-  }
-  akanPackageJson = {
-    name: "akanjs",
-    version: "0.0.0",
-    description: "akanjs",
-    dependencies: {}
-  };
-  return akanPackageJson;
-}
-function mergeImageConfig(config = {}) {
-  return {
-    ...DEFAULT_AKAN_IMAGE_CONFIG,
-    ...config,
-    deviceSizes: config.deviceSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.deviceSizes,
-    imageSizes: config.imageSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.imageSizes,
-    formats: config.formats ?? DEFAULT_AKAN_IMAGE_CONFIG.formats,
-    qualities: config.qualities ?? DEFAULT_AKAN_IMAGE_CONFIG.qualities,
-    remotePatterns: config.remotePatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.remotePatterns,
-    localPatterns: config.localPatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.localPatterns
-  };
-}
-
-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, { 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 ?? []);
-  }
-}
-//! need to refactor
-var increaseBuildNum = async (app) => {
-  const appConfig = await AkanAppConfig.from(app);
-  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 = 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.isCallExpression(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;
+    const resolved = typeof configImp === "function" ? configImp(app) : configImp;
+    const { plugins, ...config } = resolved ?? {};
+    const libContributions = await AkanAppConfig.#collectLibContributions(app, libs, bustImportCache);
+    return new AkanAppConfig(app, libs, rootPackageJson, config, baseDevEnv, plugins ?? [], libContributions);
   }
-  #hasModifier(node, kind) {
-    const ts = this.#ts;
-    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+  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}`))
+    };
   }
-  #isAsyncFunctionExpression(node) {
-    const ts = this.#ts;
-    return Boolean(node && (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && this.#hasModifier(node, ts.SyntaxKind.AsyncKeyword));
+  #resolveProductionDependencyVersion(lib) {
+    const rootVersion = this.rootPackageJson.dependencies?.[lib] ?? this.rootPackageJson.devDependencies?.[lib];
+    if (rootVersion)
+      return rootVersion;
+    const akanPackageJson = getAkanPackageJson();
+    const version = akanPackageJson.dependencies?.[lib] ?? akanPackageJson.peerDependencies?.[lib];
+    if (!version)
+      throw new Error(`Dependency ${lib} not found in package.json`);
+    return version;
   }
-  static #scriptKind(typescript, moduleAbsPath) {
-    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? typescript.ScriptKind.TSX : typescript.ScriptKind.TS;
+  #getProductionRuntimePackages() {
+    return [
+      ...this.externalLibs,
+      ...SSR_RUNTIME_PACKAGES,
+      ...this.database.modes.flatMap((mode) => this.getDatabaseModeRuntimePackages(mode))
+    ];
   }
-}
-
-// 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
+  getDatabaseModeRuntimePackages(databaseMode) {
+    return [...DatabaseModes.drivers[databaseMode]];
+  }
+  getMissingDatabaseModeDependencySpecs(databaseMode) {
+    return this.#getMissingDependencySpecs(this.getDatabaseModeRuntimePackages(databaseMode));
+  }
+  resolveDatabaseMode() {
+    return DatabaseModes.resolve({
+      requested: process.env.AKAN_DATABASE_MODE,
+      declared: this.database.modes.join(","),
+      local: true
     });
   }
-  const hasExplicitRootBoundary = [...boundaries.values()].some((boundary) => boundary.segments.length === 0);
-  if (!hasExplicitRootBoundary && boundaries.size === 0) {
-    boundaries.set("", { sourceKey: null, sourceAbsPath: null, segments: [] });
+  static #database(app, config) {
+    const declared = config?.database?.modes?.filter((mode) => !!mode);
+    const modes = declared?.length ? declared : ["single"];
+    return { modes: DatabaseModes.parseList(modes.join(","), `database.modes in apps/${app.name}/akan.config.ts`) };
   }
-  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`);
+  #getMissingDependencySpecs(libs) {
+    const rootDependencies = {
+      ...this.rootPackageJson.dependencies,
+      ...this.rootPackageJson.devDependencies
+    };
+    return libs.filter((lib) => !rootDependencies[lib]).map((lib) => `${lib}@${this.#resolveProductionDependencyVersion(lib)}`);
+  }
+  get akanVersion() {
+    return getAkanPackageJson().version;
+  }
+  getProductionPackageJson(data = {}) {
+    return {
+      name: this.app.name,
+      description: this.app.name,
+      version: "1.0.0",
+      main: "./main.js",
+      dependencies: Object.fromEntries([...new Set(this.#getProductionRuntimePackages())].map((lib) => [
+        lib,
+        this.#resolveProductionDependencyVersion(lib)
+      ])),
+      ...data
+    };
   }
 }
-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 inheritedLabel = inheritedSourceAbsPath ? path4.relative(opts.appCwdPath, inheritedSourceAbsPath) : "";
-  const inheritedImport = inheritedSourceSpecifier ? `import * as inheritedModule from ${JSON.stringify(inheritedSourceSpecifier)};
-const inheritedLayout = resolveRouteModule(inheritedModule as never, ${JSON.stringify(inheritedLabel)}).module as LayoutModule;
-` : `const inheritedLayout: LayoutModule = {};
-`;
-  const prefix = routePrefixForSegments(opts.boundary.segments);
-  const userLabel = opts.boundary.sourceAbsPath ? path4.relative(opts.appCwdPath, opts.boundary.sourceAbsPath) : "";
-  const userImport = sourceSpecifier ? `import * as userModule from ${JSON.stringify(sourceSpecifier)};
-const userLayout = resolveRouteModule(userModule as never, ${JSON.stringify(userLabel)}).module as LayoutModule;
-const UserLayout = userLayout.default as (props: LayoutProps) => ReactNode | Promise<ReactNode>;
-` : `const UserLayout = ({ children }: LayoutProps) => children;
-const userLayout: LayoutModule = {};
-`;
-  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 { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
-import { loadFonts, resolveRouteModule } from "akanjs/client";
-import type { ReactNode } from "react";
-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 { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
-import { resolveRouteModule } from "akanjs/client";
-import type { ReactNode } from "react";
-${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 });
+var akanPackageJson = null;
+function getAkanPackageJson() {
+  if (akanPackageJson)
+    return akanPackageJson;
+  const sourceDir = path4.dirname(fileURLToPath(import.meta.url));
+  const packageJsonPaths = [
+    path4.join(sourceDir, "../../../akanjs/package.json"),
+    path4.join(process.cwd(), "pkgs/akanjs/package.json"),
+    path4.join(path4.dirname(Bun.main), "node_modules/akanjs/package.json")
+  ];
+  try {
+    packageJsonPaths.unshift(Bun.resolveSync("akanjs/package.json", sourceDir));
+  } catch {}
+  for (const packageJsonPath of packageJsonPaths) {
+    try {
+      akanPackageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+      return akanPackageJson;
+    } catch {}
+  }
+  akanPackageJson = {
+    name: "akanjs",
+    version: "0.0.0",
+    description: "akanjs",
+    dependencies: {}
+  };
+  return akanPackageJson;
+}
+function mergeImageConfig(config = {}) {
+  return {
+    ...DEFAULT_AKAN_IMAGE_CONFIG,
+    ...config,
+    deviceSizes: config.deviceSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.deviceSizes,
+    imageSizes: config.imageSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.imageSizes,
+    formats: config.formats ?? DEFAULT_AKAN_IMAGE_CONFIG.formats,
+    qualities: config.qualities ?? DEFAULT_AKAN_IMAGE_CONFIG.qualities,
+    remotePatterns: config.remotePatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.remotePatterns,
+    localPatterns: config.localPatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.localPatterns
+  };
 }
 
+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, { 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 ?? []);
+  }
+}
+//! need to refactor
+var shiftBuildNum = async (app, delta) => {
+  const { buildNum } = (await AkanAppConfig.from(app)).mobile;
+  const akanConfigPath = path4.join(app.cwdPath, "akan.config.ts");
+  const akanConfig = fs2.readFileSync(akanConfigPath, "utf8");
+  fs2.writeFileSync(akanConfigPath, akanConfig.replace(`buildNum: ${buildNum}`, `buildNum: ${buildNum + delta}`));
+};
+var increaseBuildNum = async (app) => await shiftBuildNum(app, 1);
+var decreaseBuildNum = async (app) => await shiftBuildNum(app, -1);
 // pkgs/@akanjs/devkit/linter.ts
 import { spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
@@ -1299,15 +1259,24 @@ var asBiomeReport = (candidate) => {
   }
 };
 var BIOME_CONFIG_FILES = ["biome.json", "biome.jsonc"];
+var emptyResult = (filePath) => ({
+  filePath,
+  messages: [],
+  errorCount: 0,
+  warningCount: 0,
+  fixableErrorCount: 0,
+  fixableWarningCount: 0
+});
 
 class Linter {
+  static biomeBinName = process.platform === "win32" ? "biome.exe" : "biome";
   lintRoot;
   configPath;
   #biomeBin;
   constructor(cwdPath) {
     this.lintRoot = this.#findBiomeRootPath(cwdPath);
     this.configPath = Linter.#configPathIn(this.lintRoot) ?? path5.join(this.lintRoot, "biome.json");
-    const localBiomeBin = path5.join(this.lintRoot, "node_modules/.bin/biome");
+    const localBiomeBin = path5.join(this.lintRoot, "node_modules", ".bin", Linter.biomeBinName);
     this.#biomeBin = existsSync(localBiomeBin) ? localBiomeBin : "biome";
   }
   static #configPathIn(dir) {
@@ -1379,14 +1348,7 @@ class Linter {
       if (diagnostic.severity !== "error" && diagnostic.severity !== "warning")
         continue;
       const diagnosticFilePath = this.#diagnosticFilePath(diagnostic, filePath);
-      const result = resultsByPath.get(diagnosticFilePath) ?? {
-        filePath: diagnosticFilePath,
-        messages: [],
-        errorCount: 0,
-        warningCount: 0,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0
-      };
+      const result = resultsByPath.get(diagnosticFilePath) ?? emptyResult(diagnosticFilePath);
       const message = this.#createLintMessage(diagnostic);
       result.messages.push(message);
       if (message.severity === 2)
@@ -1396,14 +1358,7 @@ class Linter {
       resultsByPath.set(diagnosticFilePath, result);
     }
     return [
-      resultsByPath.get(filePath) ?? {
-        filePath,
-        messages: [],
-        errorCount: 0,
-        warningCount: 0,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0
-      },
+      resultsByPath.get(filePath) ?? emptyResult(filePath),
       ...[...resultsByPath.entries()].filter(([resultPath]) => resultPath !== filePath).map(([, result]) => result)
     ];
   }
@@ -1513,12 +1468,7 @@ ${errorText}, ${warningText} found`];
       warningCount: acc.warningCount + result.warningCount,
       fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
       fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount
-    }), {
-      errorCount: 0,
-      warningCount: 0,
-      fixableErrorCount: 0,
-      fixableWarningCount: 0
-    });
+    }), { errorCount: 0, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 });
     return { results, details, stats };
   }
   async hasNoLintErrors(filePath) {
@@ -1576,12 +1526,9 @@ ${errorText}, ${warningText} found`];
   async getProblematicRules(filePath) {
     const { results } = await this.lintFile(filePath);
     const ruleCounts = {};
-    results.forEach((result) => {
-      result.messages.forEach((message) => {
-        if (message.ruleId)
-          ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
-      });
-    });
+    for (const message of results.flatMap((result) => result.messages))
+      if (message.ruleId)
+        ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
     return ruleCounts;
   }
 }
@@ -1612,7 +1559,6 @@ var resolveRepoName = (workspaceRoot) => {
 };
 
 // pkgs/@akanjs/devkit/scanInfo.ts
-import { rm as rm2 } from "fs/promises";
 import path7 from "path";
 
 // pkgs/@akanjs/devkit/workspaceLayout.ts
@@ -1621,7 +1567,6 @@ var appRootAllowedFiles = new Set([
   "CLAUDE.md",
   "akan.app.json",
   "akan.config.ts",
-  "capacitor.config.ts",
   "client.ts",
   "main.ts",
   "package.json",
@@ -1631,12 +1576,9 @@ var appRootAllowedFiles = new Set([
 ]);
 var appRootAllowedDirs = new Set([
   ".akan",
-  "android",
   "common",
   "env",
-  "ios",
   "lib",
-  "mobile",
   "page",
   "plugin",
   "private",
@@ -1688,13 +1630,20 @@ var libFacetRootAllowedFiles = new Set([
 ]);
 var libFacetRootTestPattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
 var isAllowedLibFacetRootFile = (filename) => libFacetRootAllowedFiles.has(filename) || libFacetRootTestPattern.test(filename);
+var retiredAppRootEntries = new Set([
+  "android",
+  "ios",
+  "mobile",
+  "capacitor.config.ts",
+  "capacitor.config.js",
+  "capacitor.config.json"
+]);
+var rootEntryHintOf = (type, name) => type === "app" && retiredAppRootEntries.has(name) ? "a Capacitor-era entry; the native runtime generates its projects under .akan/mobile/<target>, so delete it" : null;
 var isScannedRootEntry = (type, name) => !name.startsWith(".") || rootAllowedDirs[type].has(name);
 
 // pkgs/@akanjs/devkit/scanInfo.ts
-var databaseFileTypes = [
-  "constant",
+var serviceFileTypes = [
   "dictionary",
-  "document",
   "service",
   "signal",
   "store",
@@ -1704,7 +1653,9 @@ var databaseFileTypes = [
   "view",
   "zone"
 ];
-var generatedRootCapacitorConfigFiles = ["capacitor.config.js", "capacitor.config.json"];
+var databaseFileTypes = ["constant", "dictionary", "document", ...serviceFileTypes.slice(1)];
+var uiFileTypes = new Set(["template", "unit", "util", "view", "zone"]);
+var fileTypeOf = (filename) => databaseFileTypes.find((type) => filename.endsWith(uiFileTypes.has(type) ? `.${type[0].toUpperCase()}${type.slice(1)}.tsx` : `.${type}.ts`));
 var internalLibDirs = new Set(["__lib", "__scalar"]);
 var moduleNonUiFileTypes = {
   database: new Set(["constant", "dictionary", "document", "service", "signal", "store"]),
@@ -1716,21 +1667,13 @@ var moduleUiFileTypes = {
   service: new Set(["Util", "Zone"]),
   scalar: new Set(["Template", "Unit"])
 };
-var testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
-var createDependencyScanner = async (exec) => (await import("./dependencyScanner-shs82ynp.js")).TypeScriptDependencyScanner.from(exec);
-var isAllowedTestFile = (filename) => testFilePattern.test(filename);
+var createDependencyScanner = async (exec) => (await import("./dependencyScanner-ye2e6pdz.js")).TypeScriptDependencyScanner.from(exec);
 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) => rm2(exec.getPath(filename), { force: true })));
-}
 var getModuleNameFromPath = (kind, modulePath) => {
   const dirname = path7.basename(modulePath);
   return kind === "service" ? dirname.replace(/^_+/, "") : dirname;
 };
 async function assertScanConvention(exec, libRoot) {
-  await clearGeneratedRootCapacitorConfigs(exec);
   const violations = [];
   const addViolation = (relativePath, reason) => {
     violations.push(`${getScanPath(exec, relativePath)}: ${reason}`);
@@ -1738,21 +1681,21 @@ async function assertScanConvention(exec, libRoot) {
   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`);
-  });
+  for (const filename of files)
+    if (!allowedRootFiles.has(filename))
+      addViolation(filename, rootEntryHintOf(exec.type, filename) ?? `unsupported ${exec.type} root file`);
+  for (const dirname of dirs)
+    if (!allowedRootDirs.has(dirname))
+      addViolation(dirname, rootEntryHintOf(exec.type, 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(path7.join("lib", dirname), "unsupported internal lib folder");
-  });
+  for (const filename of libRoot.files)
+    if (!isAllowedLibFacetRootFile(filename))
+      addViolation(path7.join("lib", filename), "unsupported lib facet root file");
+  for (const dirname of libRoot.dirs)
+    if (dirname.startsWith("__") && !internalLibDirs.has(dirname))
+      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");
@@ -1774,38 +1717,25 @@ async function validateModuleFiles(exec, violations, kind, modulePath) {
     violations.push(`${getScanPath(exec, path7.join(modulePath, dirname))}: unsupported module folder`);
   });
   const uiModuleName = moduleName[0].toUpperCase() + moduleName.slice(1);
-  files.forEach((filename) => {
-    const filePath = path7.join(modulePath, filename);
-    if (filename === "index.ts" || filename === "index.tsx" || isAllowedTestFile(filename))
-      return;
+  for (const filename of files) {
+    const scanPath = getScanPath(exec, path7.join(modulePath, filename));
+    if (filename === "index.ts" || filename === "index.tsx" || /\.(test|spec)\.(ts|tsx)$/.test(filename))
+      continue;
     if (filename === `${moduleName}.abstract.md`)
-      return;
+      continue;
     const uiMatch = filename.match(/^([A-Z][A-Za-z0-9]+)\.([A-Z][A-Za-z0-9]*)\.tsx$/);
-    if (uiMatch) {
-      const fileModuleName = uiMatch[1];
-      const fileType = uiMatch[2];
-      if (fileModuleName !== uiModuleName) {
-        violations.push(`${getScanPath(exec, filePath)}: module name mismatch: expected '${uiModuleName}', got '${fileModuleName}'`);
-      }
-      if (!moduleUiFileTypes[kind].has(fileType)) {
-        violations.push(`${getScanPath(exec, filePath)}: unsupported ${kind} UI file`);
-      }
-      return;
-    }
-    const nonUiMatch = filename.match(/^([a-z][a-zA-Z0-9]*)\.([a-z][a-z0-9]*)\.ts$/);
-    if (nonUiMatch) {
-      const fileModuleName = nonUiMatch[1];
-      const fileType = nonUiMatch[2];
-      if (fileModuleName !== moduleName) {
-        violations.push(`${getScanPath(exec, filePath)}: module name mismatch: expected '${moduleName}', got '${fileModuleName}'`);
-      }
-      if (!moduleNonUiFileTypes[kind].has(fileType)) {
-        violations.push(`${getScanPath(exec, filePath)}: unsupported ${kind} file`);
-      }
-      return;
+    const match = uiMatch ?? filename.match(/^([a-z][a-zA-Z0-9]*)\.([a-z][a-z0-9]*)\.ts$/);
+    if (!match) {
+      violations.push(`${scanPath}: unsupported module file`);
+      continue;
     }
-    violations.push(`${getScanPath(exec, filePath)}: unsupported module file`);
-  });
+    const [, fileModuleName, fileType] = match;
+    const expectedName = uiMatch ? uiModuleName : moduleName;
+    if (fileModuleName !== expectedName)
+      violations.push(`${scanPath}: module name mismatch: expected '${expectedName}', got '${fileModuleName}'`);
+    if (!(uiMatch ? moduleUiFileTypes : moduleNonUiFileTypes)[kind].has(fileType))
+      violations.push(`${scanPath}: unsupported ${kind}${uiMatch ? " UI" : ""} file`);
+  }
 }
 
 class ScanInfo {
@@ -1853,79 +1783,17 @@ class ScanInfo {
       } else
         databaseDirs.push(name);
     });
+    const collect = async (dir, name, kind) => {
+      for (const filename of await exec.readdir(dir)) {
+        const type = fileTypeOf(filename);
+        if (type)
+          files[type][kind]?.push(name);
+      }
+    };
     await Promise.all([
-      ...databaseDirs.map(async (name) => {
-        const filenames = await exec.readdir(path7.join("lib", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts"))
-            files.constant.databases.push(name);
-          else if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.databases.push(name);
-          else if (filename.endsWith(".document.ts"))
-            files.document.databases.push(name);
-          else if (filename.endsWith(".service.ts"))
-            files.service.databases.push(name);
-          else if (filename.endsWith(".signal.ts"))
-            files.signal.databases.push(name);
-          else if (filename.endsWith(".store.ts"))
-            files.store.databases.push(name);
-          else if (filename.endsWith(".Template.tsx"))
-            files.template.databases.push(name);
-          else if (filename.endsWith(".Unit.tsx"))
-            files.unit.databases.push(name);
-          else if (filename.endsWith(".Util.tsx"))
-            files.util.databases.push(name);
-          else if (filename.endsWith(".View.tsx"))
-            files.view.databases.push(name);
-          else if (filename.endsWith(".Zone.tsx"))
-            files.zone.databases.push(name);
-        });
-      }),
-      ...serviceDirs.map(async (dirname) => {
-        const name = dirname.slice(1);
-        const filenames = await exec.readdir(path7.join("lib", dirname));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.services.push(name);
-          else if (filename.endsWith(".service.ts"))
-            files.service.services.push(name);
-          else if (filename.endsWith(".signal.ts"))
-            files.signal.services.push(name);
-          else if (filename.endsWith(".store.ts"))
-            files.store.services.push(name);
-          else if (filename.endsWith(".Template.tsx"))
-            files.template.services.push(name);
-          else if (filename.endsWith(".Unit.tsx"))
-            files.unit.services.push(name);
-          else if (filename.endsWith(".Util.tsx"))
-            files.util.services.push(name);
-          else if (filename.endsWith(".View.tsx"))
-            files.view.services.push(name);
-          else if (filename.endsWith(".Zone.tsx"))
-            files.zone.services.push(name);
-        });
-      }),
-      ...scalarDirs.map(async (name) => {
-        const filenames = await exec.readdir(path7.join("lib/__scalar", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts"))
-            files.constant.scalars.push(name);
-          else if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.scalars.push(name);
-          else if (filename.endsWith(".document.ts"))
-            files.document.scalars.push(name);
-          else if (filename.endsWith(".Template.tsx"))
-            files.template.scalars.push(name);
-          else if (filename.endsWith(".Unit.tsx"))
-            files.unit.scalars.push(name);
-          else if (filename.endsWith(".Util.tsx"))
-            files.util.scalars.push(name);
-          else if (filename.endsWith(".View.tsx"))
-            files.view.scalars.push(name);
-          else if (filename.endsWith(".Zone.tsx"))
-            files.zone.scalars.push(name);
-        });
-      })
+      ...databaseDirs.map((name) => collect(path7.join("lib", name), name, "databases")),
+      ...serviceDirs.map((dirname) => collect(path7.join("lib", dirname), dirname.slice(1), "services")),
+      ...scalarDirs.map((name) => collect(path7.join("lib/__scalar", name), name, "scalars"))
     ]);
     const routes = exec.type === "lib" ? [] : await exec.getPageKeys();
     const common = {
@@ -1946,31 +1814,14 @@ class ScanInfo {
   constructor(scanResult) {
     this.name = scanResult.name;
     this.scanResult = scanResult;
-    Object.entries(scanResult.files).forEach(([_key, value]) => {
-      const key = _key;
-      const { databases, services, scalars } = value;
-      databases.forEach((modelName) => {
-        const model = this.database.get(modelName) ?? new Set;
-        model.add(key);
-        this.database.set(modelName, model);
-        this.file[key].all.add(modelName);
-        this.file[key].databases.add(modelName);
-      });
-      services?.forEach((serviceName) => {
-        const service = this.service.get(serviceName) ?? new Set;
-        service.add(key);
-        this.service.set(serviceName, service);
-        this.file[key].all.add(serviceName);
-        this.file[key].services.add(serviceName);
-      });
-      scalars?.forEach((scalarName) => {
-        const scalar = this.scalar.get(scalarName) ?? new Set;
-        scalar.add(key);
-        this.scalar.set(scalarName, scalar);
-        this.file[key].all.add(scalarName);
-        this.file[key].scalars.add(scalarName);
-      });
-    });
+    const modulesOf = { databases: this.database, services: this.service, scalars: this.scalar };
+    for (const [key, groups] of Object.entries(scanResult.files))
+      for (const kind of ["databases", "services", "scalars"])
+        for (const name of groups[kind] ?? []) {
+          modulesOf[kind].set(name, (modulesOf[kind].get(name) ?? new Set).add(key));
+          this.file[key].all.add(name);
+          this.file[key][kind].add(name);
+        }
   }
   getScanResult() {
     return this.scanResult;
@@ -1984,6 +1835,28 @@ class ScanInfo {
   getScalarModules() {
     return [...this.scalar.keys()];
   }
+  #sortedLibs = null;
+  sortedLibs(libDeps) {
+    if (this.#sortedLibs)
+      return this.#sortedLibs;
+    const libIndices = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = libDeps.sort((libNameA, libNameB) => {
+      const indexA = libIndices.get(libNameA);
+      const indexB = libIndices.get(libNameB);
+      if (indexA === undefined || indexB === undefined)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  sortedLibInfos(libDeps) {
+    return new Map(this.sortedLibs(libDeps).map((libName) => {
+      const libInfo = LibInfo.libInfos.get(libName);
+      if (!libInfo)
+        throw new Error(`LibInfo not found: ${libName}`);
+      return [libName, libInfo];
+    }));
+  }
 }
 var isAkanFrameworkDependency = (dep) => dep === "akanjs" || dep.startsWith("akanjs/");
 
@@ -2033,30 +1906,11 @@ class AppInfo extends ScanInfo {
     }));
     return [...libSet];
   }
-  #sortedLibs = null;
-  #getSortedLibs() {
-    if (this.#sortedLibs)
-      return this.#sortedLibs;
-    const libIndices = LibInfo.getSortedLibIndices();
-    this.#sortedLibs = this.libDeps.sort((libNameA, libNameB) => {
-      const indexA = libIndices.get(libNameA);
-      const indexB = libIndices.get(libNameB);
-      if (indexA === undefined || indexB === undefined)
-        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
-      return indexA - indexB;
-    });
-    return this.#sortedLibs;
-  }
   getLibs() {
-    return this.#getSortedLibs();
+    return this.sortedLibs(this.libDeps);
   }
   getLibInfos() {
-    return new Map(this.#getSortedLibs().map((libName) => {
-      const libInfo = LibInfo.libInfos.get(libName);
-      if (!libInfo)
-        throw new Error(`LibInfo not found: ${libName}`);
-      return [libName, libInfo];
-    }));
+    return this.sortedLibInfos(this.libDeps);
   }
 }
 
@@ -2096,38 +1950,18 @@ class LibInfo extends ScanInfo {
   getScanResult() {
     return this.scanResult;
   }
-  #sortedLibs = null;
-  #getSortedLibs() {
-    if (this.#sortedLibs)
-      return this.#sortedLibs;
-    const libs = LibInfo.getSortedLibIndices();
-    this.#sortedLibs = this.scanResult.libDeps.sort((libNameA, libNameB) => {
-      const indexA = libs.get(libNameA);
-      const indexB = libs.get(libNameB);
-      if (indexA === undefined || indexB === undefined)
-        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
-      return indexA - indexB;
-    });
-    return this.#sortedLibs;
-  }
   getLibs() {
-    return this.#getSortedLibs();
+    return this.sortedLibs(this.scanResult.libDeps);
   }
   getLibInfo(libName) {
     if (!this.getScanResult().libDeps.includes(libName))
       return;
-    const libSet = new Set(this.#getSortedLibs());
-    if (!libSet.has(libName))
+    if (!this.getLibs().includes(libName))
       throw new Error(`LibInfo is invalid: ${libName}`);
     return LibInfo.libInfos.get(libName);
   }
   getLibInfos() {
-    return new Map(this.#getSortedLibs().map((libName) => {
-      const libInfo = LibInfo.libInfos.get(libName);
-      if (!libInfo)
-        throw new Error(`LibInfo not found: ${libName}`);
-      return [libName, libInfo];
-    }));
+    return this.sortedLibInfos(this.scanResult.libDeps);
   }
 }
 
@@ -2139,18 +1973,14 @@ class PkgInfo {
     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((path) => tsconfig.compilerOptions.paths?.[path]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path) => path.replace("/*", "")));
+    const workspacePathOf = (resolve) => resolve.replace(/^\.\//, "");
+    const pkgPathSet = new Set(Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path) => tsconfig.compilerOptions.paths?.[path]?.some((resolve) => workspacePathOf(resolve).startsWith("pkgs/"))).map((path) => path.replace("/*", "")));
     const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
     const pkgDeps = [...pkgPathDepSet].map((path) => {
       const pathSplitLength = path.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+      return workspacePathOf(tsconfig.compilerOptions.paths?.[path]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
     }).filter((pkg) => pkg !== exec.name);
-    const pkgScanResult = {
-      name: exec.name,
-      pkgDeps,
-      dependencies: [...npmDepSet]
-    };
-    return pkgScanResult;
+    return { name: exec.name, pkgDeps, dependencies: [...npmDepSet] };
   }
   static #pkgInfos = new Map;
   static async fromExecutor(exec, options = {}) {
@@ -2188,17 +2018,9 @@ class WorkspaceInfo {
       return existingWorkspaceInfo;
     const [appNames, libNames, pkgNames] = await Promise.all([exec.getApps(), exec.getLibs(), exec.getPkgs()]);
     const [appInfos, libInfos, pkgInfos] = await Promise.all([
-      Promise.all(appNames.map(async (appName) => {
-        const app = AppExecutor.from(exec, appName);
-        return await app.scan();
-      })),
-      Promise.all(libNames.map(async (libName) => {
-        const lib = LibExecutor.from(exec, libName);
-        return await lib.scan();
-      })),
-      Promise.all(pkgNames.map(async (pkgName) => {
-        return await PkgExecutor.from(exec, pkgName).scan();
-      }))
+      Promise.all(appNames.map(async (appName) => await AppExecutor.from(exec, appName).scan())),
+      Promise.all(libNames.map(async (libName) => await LibExecutor.from(exec, libName).scan())),
+      Promise.all(pkgNames.map(async (pkgName) => await PkgExecutor.from(exec, pkgName).scan()))
     ]);
     const workspaceInfo = new WorkspaceInfo(new Map(appInfos.map((app) => [app.exec.name, app])), new Map(libInfos.map((lib) => [lib.exec.name, lib])), new Map(pkgInfos.map((pkg) => [pkg.exec.name, pkg])));
     WorkspaceInfo.#workspaceInfos.set(exec.name, workspaceInfo);
@@ -2207,40 +2029,9 @@ class WorkspaceInfo {
 }
 
 // pkgs/@akanjs/devkit/executors.ts
-var staticTemplateFileExtensions = new Set([
-  ".avif",
-  ".bmp",
-  ".cjs",
-  ".css",
-  ".eot",
-  ".gif",
-  ".html",
-  ".ico",
-  ".jpeg",
-  ".jpg",
-  ".js",
-  ".json",
-  ".map",
-  ".md",
-  ".mjs",
-  ".mp3",
-  ".mp4",
-  ".ogg",
-  ".otf",
-  ".pdf",
-  ".png",
-  ".svg",
-  ".ttf",
-  ".txt",
-  ".wasm",
-  ".wav",
-  ".webm",
-  ".webp",
-  ".woff",
-  ".woff2",
-  ".xml"
-]);
-var formatCommandArg = (value) => /^[\w@%+=:,./-]+$/.test(value) ? value : JSON.stringify(value);
+var staticTemplateFileExtensions = new Set(".avif .bmp .cjs .css .eot .gif .html .ico .jpeg .jpg .js .json .map .md .mjs .mp3 .mp4 .ogg .otf .pdf .png .svg".split(" ").concat(".ttf .txt .wasm .wav .webm .webp .woff .woff2 .xml".split(" ")));
+var plainCommandArgPattern = process.platform === "win32" ? /^[\w@%+=:,./\\-]+$/ : /^[\w@%+=:,./-]+$/;
+var formatCommandArg = (value) => plainCommandArgPattern.test(value) ? value : JSON.stringify(value);
 var formatCommandForDisplay = (command, args = []) => [command, ...args].map(formatCommandArg).join(" ");
 
 class CommandExecutionError extends Error {
@@ -2314,6 +2105,10 @@ var parseEnvFile = (envPath) => {
   }
   return env;
 };
+var withCapitalizedDict = (dict = {}) => ({
+  ...dict,
+  ...Object.fromEntries(Object.entries(dict).map(([key, value]) => [capitalize(key), capitalize(value)]))
+});
 
 class Executor {
   static verbose = false;
@@ -2340,144 +2135,51 @@ class Executor {
   #stderr(data) {
     Logger2.raw(chalk2.red(data.toString()));
   }
-  exec(command, options = {}) {
-    const cwd = options.cwd?.toString() ?? this.cwdPath;
-    const proc = exec(command, { cwd: this.cwdPath, ...options });
+  #settle(proc, target, { onClose = false, keepLogs = false, redStderr = false } = {}) {
     let stdout = "";
     let stderr = "";
     proc.stdout?.on("data", (data) => {
       stdout += data.toString();
+      if (keepLogs)
+        this.logs.push(data.toString());
       this.#stdout(data);
     });
     proc.stderr?.on("data", (data) => {
       stderr += data.toString();
-      this.#stdout(data);
+      if (keepLogs)
+        this.logs.push(data.toString());
+      if (redStderr)
+        this.#stderr(data);
+      else
+        this.#stdout(data);
     });
     return new Promise((resolve, reject) => {
-      proc.on("error", (error) => {
-        reject(new CommandExecutionError({
-          command,
-          cwd,
-          code: null,
-          signal: null,
-          stdout,
-          stderr,
-          cause: error
-        }));
-      });
-      proc.on("exit", (code, signal) => {
-        if (code || signal)
-          reject(new CommandExecutionError({
-            command,
-            cwd,
-            code,
-            signal,
-            stdout,
-            stderr
-          }));
+      proc.on("error", (cause) => reject(new CommandExecutionError({ ...target, code: null, signal: null, stdout, stderr, cause })));
+      proc.on(onClose ? "close" : "exit", (code, signal) => {
+        if ((onClose ? code !== 0 : code) || signal)
+          reject(new CommandExecutionError({ ...target, code, signal, stdout, stderr }));
         else
-          resolve({ code, signal });
+          resolve({ code, signal, stdout });
       });
     });
   }
+  exec(command, options = {}) {
+    const target = { command, cwd: options.cwd?.toString() ?? this.cwdPath };
+    const proc = exec(command, { cwd: this.cwdPath, ...options });
+    return this.#settle(proc, target).then(({ code, signal }) => ({ code, signal }));
+  }
   spawn(command, args = [], options = {}) {
-    const cwd = options.cwd?.toString() ?? this.cwdPath;
-    const proc = spawn2(command, args, {
-      cwd: this.cwdPath,
-      ...options
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout?.on("data", (data) => {
-      stdout += data.toString();
-      this.logs.push(data.toString());
-      this.#stdout(data);
-    });
-    proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
-      this.logs.push(data.toString());
-      this.#stdout(data);
-    });
-    return new Promise((resolve, reject) => {
-      proc.on("error", (error) => {
-        reject(new CommandExecutionError({
-          command,
-          args,
-          cwd,
-          code: null,
-          signal: null,
-          stdout,
-          stderr,
-          cause: error
-        }));
-      });
-      proc.on("close", (code, signal) => {
-        if (code !== 0 || signal)
-          reject(new CommandExecutionError({
-            command,
-            args,
-            cwd,
-            code,
-            signal,
-            stdout,
-            stderr
-          }));
-        else
-          resolve(stdout);
-      });
-    });
+    const target = { command, args, cwd: options.cwd?.toString() ?? this.cwdPath };
+    const proc = spawn2(command, args, { cwd: this.cwdPath, ...options });
+    return this.#settle(proc, target, { onClose: true, keepLogs: true }).then(({ stdout }) => stdout);
   }
   spawnSync(command, args = [], options = {}) {
-    const proc = spawn2(command, args, {
-      cwd: this.cwdPath,
-      ...options
-    });
-    return proc;
+    return spawn2(command, args, { cwd: this.cwdPath, ...options });
   }
   fork(modulePath, args = [], options = {}) {
-    const cwd = options.cwd?.toString() ?? this.cwdPath;
-    const proc = fork(modulePath, args, {
-      cwd: this.cwdPath,
-      ...options
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout?.on("data", (data) => {
-      stdout += data.toString();
-      this.#stdout(data);
-    });
-    proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
-      this.#stderr(data);
-    });
-    return new Promise((resolve, reject) => {
-      proc.on("error", (error) => {
-        reject(new CommandExecutionError({
-          command: modulePath,
-          args,
-          cwd,
-          code: null,
-          signal: null,
-          stdout,
-          stderr,
-          cause: error
-        }));
-      });
-      proc.on("exit", (code, signal) => {
-        if (code || signal)
-          reject(new CommandExecutionError({
-            command: modulePath,
-            args,
-            cwd,
-            code,
-            signal,
-            stdout,
-            stderr
-          }));
-        else
-          resolve({ code, signal });
-      });
-    });
+    const target = { command: modulePath, args, cwd: options.cwd?.toString() ?? this.cwdPath };
+    const proc = fork(modulePath, args, { cwd: this.cwdPath, ...options });
+    return this.#settle(proc, target, { redStderr: true }).then(({ code, signal }) => ({ code, signal }));
   }
   getPath(filePath) {
     if (path8.isAbsolute(filePath))
@@ -2501,8 +2203,8 @@ class Executor {
   }
   async mkdir(dirPath) {
     const writePath = this.getPath(dirPath);
-    if (!await FileSys.dirExists(writePath))
-      await mkdir3(writePath, { recursive: true });
+    if (!await FileSys2.dirExists(writePath))
+      await mkdir2(writePath, { recursive: true });
     this.logger.verbose(`Make directory ${writePath}`);
     return this;
   }
@@ -2521,27 +2223,25 @@ class Executor {
   }
   async getFilesAndDirs(dirPath) {
     const fullDirPath = this.getPath(dirPath);
-    const fileGlob = new Bun.Glob("*");
-    const files = Array.from(fileGlob.scanSync({ cwd: fullDirPath, onlyFiles: true }));
-    const dirGlob = new Bun.Glob("*");
-    const allEntries = Array.from(dirGlob.scanSync({ cwd: fullDirPath, onlyFiles: false }));
+    const glob = new Bun.Glob("*");
+    const files = Array.from(glob.scanSync({ cwd: fullDirPath, onlyFiles: true }));
+    const allEntries = Array.from(glob.scanSync({ cwd: fullDirPath, onlyFiles: false }));
     const dirs = allEntries.filter((entry) => !files.includes(entry));
     return { files, dirs };
   }
   async exists(filePath) {
-    const readPath = this.getPath(filePath);
-    return await FileSys.exists(readPath);
+    return await FileSys2.exists(this.getPath(filePath));
   }
   async remove(filePath) {
     const readPath = this.getPath(filePath);
-    if (await FileSys.fileExists(readPath))
-      await FileSys.delete(readPath);
+    if (await FileSys2.fileExists(readPath))
+      await FileSys2.delete(readPath);
     this.logger.verbose(`Remove file ${readPath}`);
     return this;
   }
   async removeDir(dirPath) {
     const readPath = path8.join(this.getPath(dirPath), ".");
-    if (await FileSys.entryExists(readPath))
+    if (await FileSys2.entryExists(readPath))
       await rm3(readPath, { recursive: true, force: true });
     this.logger.verbose(`Remove directory ${readPath}`);
     return this;
@@ -2549,22 +2249,22 @@ class Executor {
   async writeFile(filePath, content, { overwrite = true, silent = false } = {}) {
     const writePath = this.getPath(filePath);
     const dir = path8.dirname(writePath);
-    if (!await FileSys.dirExists(dir))
-      await mkdir3(dir, { recursive: true });
+    if (!await FileSys2.dirExists(dir))
+      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 (await FileSys2.fileExists(writePath)) {
+      const currentContent = await FileSys2.readText(writePath);
       if (currentContent === contentStr || !overwrite) {
         this.logger.verbose(`File ${writePath} is unchanged`);
         contentStr = currentContent;
       } else {
-        await FileSys.writeText(writePath, contentStr);
+        await FileSys2.writeText(writePath, contentStr);
         if (Logger2.isVerbose())
           this.logger.rawLog(chalk2.yellow(`File Update: ${filePath}`));
       }
     } else {
-      await FileSys.writeText(writePath, contentStr);
+      await FileSys2.writeText(writePath, contentStr);
       if (!silent)
         this.logger.rawLog(chalk2.green(`File Create: ${filePath}`));
     }
@@ -2579,22 +2279,20 @@ class Executor {
     return { filePath, content };
   }
   async readFile(filePath) {
-    const readPath = this.getPath(filePath);
-    return await FileSys.readText(readPath);
+    return await FileSys2.readText(this.getPath(filePath));
   }
   async readJson(filePath) {
-    const readPath = this.getPath(filePath);
-    return await FileSys.readJson(readPath);
+    return await FileSys2.readJson(this.getPath(filePath));
   }
   async cp(srcPath, destPath, { dereference = false } = {}) {
     const src = this.getPath(srcPath);
     const dest = this.getPath(destPath);
-    if (!await FileSys.exists(src))
+    if (!await FileSys2.exists(src))
       return;
     const isDirectory = (await stat2(src)).isDirectory();
-    if (!await FileSys.exists(dest) && isDirectory)
-      await mkdir3(dest, { recursive: true });
-    if (dereference)
+    if (!await FileSys2.exists(dest) && isDirectory)
+      await mkdir2(dest, { recursive: true });
+    if (dereference || process.platform === "win32")
       await cpEntry(src, dest, { recursive: isDirectory, dereference: true, force: true });
     else
       await $`cp -r ${src}${isDirectory ? "/." : ""} ${dest}`;
@@ -2618,19 +2316,10 @@ class Executor {
   async getTsConfig(pathname = "tsconfig.json", { refresh } = {}) {
     if (this.#tsconfig && !refresh)
       return this.#tsconfig;
-    const tsconfig = await this.readJson(pathname);
+    let tsconfig = await this.readJson(pathname);
     if (tsconfig.extends) {
-      const extendsTsconfig = await this.getTsConfig(tsconfig.extends);
-      const result = {
-        ...extendsTsconfig,
-        ...tsconfig,
-        compilerOptions: {
-          ...extendsTsconfig.compilerOptions,
-          ...tsconfig.compilerOptions
-        }
-      };
-      this.#tsconfig = result;
-      return result;
+      const base = await this.getTsConfig(tsconfig.extends, { refresh });
+      tsconfig = { ...base, ...tsconfig, compilerOptions: { ...base.compilerOptions, ...tsconfig.compilerOptions } };
     }
     this.#tsconfig = tsconfig;
     return tsconfig;
@@ -2666,6 +2355,7 @@ class Executor {
     scanInfo,
     overwrite = true
   }, dict = {}, options = {}) {
+    const convertPath = (target) => Object.entries(dict).reduce((converted, [key, value]) => converted.replace(new RegExp(`__${key}__`, "g"), value), target);
     if (targetPath.endsWith(".ts") || targetPath.endsWith(".tsx")) {
       const getContent = await import(templatePath);
       const result = await getContent.default(scanInfo ?? null, dict, options);
@@ -2673,24 +2363,21 @@ class Executor {
         return null;
       const filename = typeof result === "object" ? result.filename : path8.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
-      const dirname = path8.dirname(targetPath);
-      const convertedTargetPath = Object.entries(dict).reduce((path, [key, value]) => path.replace(new RegExp(`__${key}__`, "g"), value), `${dirname}/${filename}`);
+      const convertedTargetPath = convertPath(`${path8.dirname(targetPath)}/${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((path, [key, value]) => path.replace(new RegExp(`__${key}__`, "g"), value), targetPath.slice(0, -9));
+      const content = await FileSys2.readText(templatePath);
+      const convertedTargetPath = convertPath(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
-      });
+      return this.writeFile(convertedTargetPath, convertedContent, { overwrite });
     } 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 convertedTargetPath = convertPath(targetPath);
       const writePath = this.getPath(convertedTargetPath);
       const dirname = path8.dirname(writePath);
-      if (!await FileSys.dirExists(dirname))
-        await mkdir3(dirname, { recursive: true });
+      if (!await FileSys2.dirExists(dirname))
+        await mkdir2(dirname, { recursive: true });
       await copyFile(templatePath, writePath);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return { filePath: writePath, content: "" };
@@ -2707,12 +2394,10 @@ class Executor {
   }) {
     const templateRoot = await this.#resolveTemplateRoot();
     const templatePath = `${templateRoot}${template ? `/${template}` : ""}`;
-    const prefixTemplatePath = templatePath;
-    if ((await stat2(prefixTemplatePath)).isFile()) {
-      const filename = path8.basename(prefixTemplatePath);
+    if ((await stat2(templatePath)).isFile()) {
       const fileContent = await this.#applyTemplateFile({
-        templatePath: prefixTemplatePath,
-        targetPath: path8.join(basePath, filename),
+        templatePath,
+        targetPath: path8.join(basePath, path8.basename(templatePath)),
         scanInfo,
         overwrite
       }, dict, options);
@@ -2748,17 +2433,13 @@ class Executor {
       path8.resolve(getDirname2(import.meta.url), "../cli/templates")
     ];
     for (const candidate of candidates) {
-      if (await FileSys.dirExists(candidate))
+      if (await FileSys2.dirExists(candidate))
         return candidate;
     }
     return candidates[0];
   }
   async applyTemplate(options) {
-    const dict = {
-      ...options.dict ?? {},
-      ...Object.fromEntries(Object.entries(options.dict ?? {}).map(([key, value]) => [capitalize(key), capitalize(value)]))
-    };
-    const fileContents = await this._applyTemplate({ ...options, dict });
+    const fileContents = await this._applyTemplate({ ...options, dict: withCapitalizedDict(options.dict) });
     await this.#formatAppliedTemplate(fileContents);
     return fileContents;
   }
@@ -2775,7 +2456,7 @@ class Executor {
     }
   }
   async getTypeChecker() {
-    const { TypeChecker } = await import("./typeChecker-3xgrzc2v.js");
+    const { TypeChecker } = await import("./typeChecker-px49mezc.js");
     this.typeChecker ??= new TypeChecker(this);
     return this.typeChecker;
   }
@@ -2853,12 +2534,11 @@ class WorkspaceExecutor extends Executor {
     this.workspaceRoot = workspaceRoot;
     this.repoName = repoName;
   }
-  static #execs = new Map;
   static fromRoot({
     workspaceRoot = process.cwd(),
     repoName = resolveRepoName(workspaceRoot)
   } = {}) {
-    return WorkspaceExecutor.#execs.get(repoName) ?? new WorkspaceExecutor({ workspaceRoot, repoName });
+    return new WorkspaceExecutor({ workspaceRoot, repoName });
   }
   static getBaseDevEnv(envPath) {
     const sourceEnv = envPath ? { ...process.env, ...parseEnvFile(envPath) } : process.env;
@@ -2897,13 +2577,9 @@ class WorkspaceExecutor extends Executor {
     return await WorkspaceInfo.fromExecutor(this);
   }
   async getApps() {
-    if (!await FileSys.dirExists(`${this.workspaceRoot}/apps`))
-      return [];
     return await this.#getDirHasFile(`${this.workspaceRoot}/apps`, "akan.config.ts");
   }
   async getLibs() {
-    if (!await FileSys.dirExists(`${this.workspaceRoot}/libs`))
-      return [];
     return await this.#getDirHasFile(`${this.workspaceRoot}/libs`, "akan.config.ts");
   }
   async getSyss() {
@@ -2911,8 +2587,6 @@ class WorkspaceExecutor extends Executor {
     return [appNames, libNames];
   }
   async getPkgs() {
-    if (!await FileSys.dirExists(`${this.workspaceRoot}/pkgs`))
-      return [];
     return await this.#getDirHasFile(`${this.workspaceRoot}/pkgs`, "package.json");
   }
   async getExecs() {
@@ -2977,6 +2651,8 @@ class WorkspaceExecutor extends Executor {
     return stdout.split("\x00").filter((file) => !!file).sort();
   }
   async#getDirHasFile(basePath, targetFilename) {
+    if (!await FileSys2.dirExists(basePath))
+      return [];
     const AVOID_DIRS = ["node_modules", "dist", "public", "webkit"];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
       const dirs = await this.readdir(dirname);
@@ -2984,8 +2660,8 @@ class WorkspaceExecutor extends Executor {
         if (AVOID_DIRS.includes(dir))
           return;
         const dirPath = path8.join(dirname, dir);
-        if (await FileSys.dirExists(dirPath)) {
-          const hasTargetFile = await FileSys.fileExists(path8.join(dirPath, targetFilename));
+        if (await FileSys2.dirExists(dirPath)) {
+          const hasTargetFile = await FileSys2.fileExists(path8.join(dirPath, targetFilename));
           if (hasTargetFile)
             results.push(`${prefix}${dir}`);
           if (maxDepth > 0)
@@ -2994,39 +2670,25 @@ class WorkspaceExecutor extends Executor {
       }));
       return results;
     };
-    return await getDirs(basePath);
+    return (await getDirs(basePath)).sort((a, b) => a.localeCompare(b));
   }
-  async getScalarConstantFiles() {
+  async#fromEverySys(read) {
     const [appNames, libNames] = await this.getSyss();
-    const scalarConstantExampleFiles = [
-      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getScalarConstantFiles()))).flat(),
-      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getScalarConstantFiles()))).flat()
-    ];
-    return scalarConstantExampleFiles;
+    const fromApps = await Promise.all(appNames.map((appName) => read(AppExecutor.from(this, appName))));
+    const fromLibs = await Promise.all(libNames.map((libName) => read(LibExecutor.from(this, libName))));
+    return [...fromApps.flat(), ...fromLibs.flat()];
+  }
+  async getScalarConstantFiles() {
+    return await this.#fromEverySys((sys) => sys.getScalarConstantFiles());
   }
   async getConstantFiles() {
-    const [appNames, libNames] = await this.getSyss();
-    const moduleConstantExampleFiles = [
-      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getConstantFiles()))).flat(),
-      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getConstantFiles()))).flat()
-    ];
-    return moduleConstantExampleFiles;
+    return await this.#fromEverySys((sys) => sys.getConstantFiles());
   }
   async getDictionaryFiles() {
-    const [appNames, libNames] = await this.getSyss();
-    const moduleDictionaryExampleFiles = [
-      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getDictionaryFiles()))).flat(),
-      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getDictionaryFiles()))).flat()
-    ];
-    return moduleDictionaryExampleFiles;
+    return await this.#fromEverySys((sys) => sys.getDictionaryFiles());
   }
   async getViewFiles() {
-    const [appNames, libNames] = await this.getSyss();
-    const viewExampleFiles = [
-      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getViewsSourceCode()))).flat(),
-      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getViewsSourceCode()))).flat()
-    ];
-    return viewExampleFiles;
+    return await this.#fromEverySys((sys) => sys.getViewsSourceCode());
   }
 }
 var scanFacetDirs = ["ui", "webkit", "srvkit", "common", "plugin"];
@@ -3090,24 +2752,11 @@ class SysExecutor extends Executor {
         scanInfo,
         options: { exec: this, facet }
       })),
-      ...scanInfo.getDatabaseModules().map((model) => this._applyTemplate({
-        basePath: `lib/${model}`,
-        template: "moduleRoot",
-        scanInfo,
-        dict: { model, Model: capitalize(model) }
-      })),
-      ...scanInfo.getServiceModules().map((model) => this._applyTemplate({
-        basePath: `lib/_${model}`,
-        template: "moduleRoot",
-        scanInfo,
-        dict: { model, Model: capitalize(model) }
-      })),
-      ...scanInfo.getScalarModules().map((model) => this._applyTemplate({
-        basePath: `lib/__scalar/${model}`,
-        template: "moduleRoot",
-        scanInfo,
-        dict: { model, Model: capitalize(model) }
-      }))
+      ...[
+        ...scanInfo.getDatabaseModules().map((model) => [model, `lib/${model}`]),
+        ...scanInfo.getServiceModules().map((model) => [model, `lib/_${model}`]),
+        ...scanInfo.getScalarModules().map((model) => [model, `lib/__scalar/${model}`])
+      ].map(([model, basePath]) => this._applyTemplate({ basePath, template: "moduleRoot", scanInfo, dict: { model, Model: capitalize(model) } }))
     ];
   }
   async scan({
@@ -3174,40 +2823,38 @@ class SysExecutor extends Executor {
     return { filePath, content };
   }
   async getDatabaseModules() {
-    const databaseModules = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.constant.ts`).exists());
-    return databaseModules;
+    return (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.endsWith(".ts")).filter((name) => existsSync2(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
   }
   async getServiceModules() {
-    const serviceModules = (await this.readdir("lib")).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.service.ts`).exists());
-    return serviceModules;
+    return (await this.readdir("lib")).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => existsSync2(`${this.cwdPath}/lib/${name}/${name.slice(1)}.service.ts`));
   }
   async getScalarModules() {
-    const scalarModules = (await this.readdir("lib/__scalar")).filter((name) => !name.startsWith("_")).filter((name) => Bun.file(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`).exists());
-    return scalarModules;
+    return (await this.readdir("lib/__scalar")).filter((name) => !name.startsWith("_")).filter((name) => existsSync2(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
+  }
+  async#getComponentModules(role) {
+    return (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.endsWith(".ts")).filter((name) => existsSync2(`${this.cwdPath}/lib/${name}/${capitalize(name)}.${role}.tsx`));
+  }
+  async#getComponentSources(role) {
+    const modules = await this.#getComponentModules(role);
+    return Promise.all(modules.map((name) => this.getLocalFile(`lib/${name}/${capitalize(name)}.${role}.tsx`)));
   }
   async getViewComponents() {
-    const viewComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.View.tsx`).exists());
-    return viewComponents;
+    return await this.#getComponentModules("View");
   }
   async getUnitComponents() {
-    const unitComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Unit.tsx`).exists());
-    return unitComponents;
+    return await this.#getComponentModules("Unit");
   }
   async getTemplateComponents() {
-    const templateComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Template.tsx`).exists());
-    return templateComponents;
+    return await this.#getComponentModules("Template");
   }
   async getViewsSourceCode() {
-    const viewComponents = await this.getViewComponents();
-    return Promise.all(viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${capitalize(viewComponent)}.View.tsx`)));
+    return await this.#getComponentSources("View");
   }
   async getUnitsSourceCode() {
-    const unitComponents = await this.getUnitComponents();
-    return Promise.all(unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${capitalize(unitComponent)}.Unit.tsx`)));
+    return await this.#getComponentSources("Unit");
   }
   async getTemplatesSourceCode() {
-    const templateComponents = await this.getTemplateComponents();
-    return Promise.all(templateComponents.map((templateComponent) => this.getLocalFile(`lib/${templateComponent}/${capitalize(templateComponent)}.Template.tsx`)));
+    return await this.#getComponentSources("Template");
   }
   async getScalarConstantFiles() {
     const scalarModules = await this.getScalarModules();
@@ -3215,7 +2862,7 @@ class SysExecutor extends Executor {
   }
   async getScalarDictionaryFiles() {
     const scalarModules = await this.getScalarModules();
-    return Promise.all(scalarModules.map((scalarModule) => this.getLocalFile(`lib/${scalarModule}/${scalarModule}.dictionary.ts`)));
+    return Promise.all(scalarModules.map((scalarModule) => this.getLocalFile(`lib/__scalar/${scalarModule}/${scalarModule}.dictionary.ts`)));
   }
   async getConstantFiles() {
     const modules = await this.getModules();
@@ -3237,16 +2884,8 @@ class SysExecutor extends Executor {
     return Promise.all(modules.map((module) => this.getLocalFile(`lib/${module}/${module}.dictionary.ts`)));
   }
   async applyTemplate(options) {
-    const dict = {
-      ...options.dict ?? {},
-      ...Object.fromEntries(Object.entries(options.dict ?? {}).map(([key, value]) => [capitalize(key), capitalize(value)]))
-    };
     const scanInfo = await this.scan();
-    const fileContents = await this._applyTemplate({
-      ...options,
-      scanInfo,
-      dict
-    });
+    const fileContents = await this._applyTemplate({ ...options, scanInfo, dict: withCapitalizedDict(options.dict) });
     await this.scan();
     return fileContents;
   }
@@ -3255,7 +2894,7 @@ class SysExecutor extends Executor {
 class AppExecutor extends SysExecutor {
   static #routeSourceValidator = null;
   static async#getRouteSourceValidator() {
-    AppExecutor.#routeSourceValidator ??= (await import("./routeSourceValidator-apyqw7wk.js")).RouteSourceValidator;
+    AppExecutor.#routeSourceValidator ??= (await import("./routeSourceValidator-7ycnfz0e.js")).RouteSourceValidator;
     return AppExecutor.#routeSourceValidator;
   }
   dist;
@@ -3264,15 +2903,8 @@ class AppExecutor extends SysExecutor {
     super({ workspace, name, type: "app" });
     this.dist = new Executor(`dist/${name}`, `${this.workspace.workspaceRoot}/dist/apps/${name}`);
   }
-  static #execs = new Map;
   static from(executor, name) {
-    const exec = AppExecutor.#execs.get(name);
-    if (exec)
-      return exec;
-    else if (executor instanceof WorkspaceExecutor)
-      return new AppExecutor({ workspace: executor, name });
-    else
-      return new AppExecutor({ workspace: executor.workspace, name });
+    return new AppExecutor({ workspace: executor instanceof WorkspaceExecutor ? executor : executor.workspace, name });
   }
   getEnv() {
     return WorkspaceExecutor.getBaseDevEnv().env;
@@ -3288,10 +2920,8 @@ class AppExecutor extends SysExecutor {
     return basePort + appIndex + portOffset;
   }
   getCommandEnv(env = {}) {
-    const basePort = 8282;
-    const portOffset = WorkspaceExecutor.getBaseDevEnv().portOffset;
-    const PORT = (basePort + portOffset).toString();
-    const AKAN_PUBLIC_SERVER_PORT = portOffset ? (8282 + portOffset).toString() : undefined;
+    const { portOffset } = WorkspaceExecutor.getBaseDevEnv();
+    const PORT = (8282 + portOffset).toString();
     return {
       ...process.env,
       AKAN_PUBLIC_APP_NAME: this.name,
@@ -3299,18 +2929,24 @@ class AppExecutor extends SysExecutor {
       NODE_NO_WARNINGS: "1",
       PORT,
       AKAN_PUBLIC_CLIENT_PORT: PORT,
-      ...AKAN_PUBLIC_SERVER_PORT ? { AKAN_PUBLIC_SERVER_PORT } : {},
+      ...portOffset ? { AKAN_PUBLIC_SERVER_PORT: PORT } : {},
       ...env
     };
   }
+  async getDatabaseModeEnv() {
+    const akanConfig = await this.getConfig();
+    return {
+      AKAN_DATABASE_MODE: akanConfig.resolveDatabaseMode(),
+      AKAN_DATABASE_MODES: akanConfig.database.modes.join(",")
+    };
+  }
   async prepareCommand(type) {
     const akanConfig = await this.getConfig();
-    const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
     const routeEnv = {
       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
+      ...await this.getDatabaseModeEnv()
     };
     Object.assign(process.env, routeEnv);
     if (type === "build") {
@@ -3339,6 +2975,8 @@ class AppExecutor extends SysExecutor {
       const buildEnv = { ...env };
       delete buildEnv.AKAN_PUBLIC_CLIENT_PORT;
       delete buildEnv.AKAN_PUBLIC_SERVER_PORT;
+      delete buildEnv.AKAN_PUBLIC_OPERATION_MODE;
+      delete process.env.AKAN_PUBLIC_OPERATION_MODE;
       Object.assign(process.env, buildEnv);
     }
     return { env };
@@ -3348,16 +2986,7 @@ class AppExecutor extends SysExecutor {
     if (this.#publicEnv)
       return this.#publicEnv;
     const searchPatterns = [...patterns, "AKAN_PUBLIC_*"];
-    const regexes = searchPatterns.map((pattern) => {
-      let body = "";
-      for (const ch of pattern) {
-        if (ch === "*")
-          body += ".*";
-        else
-          body += ch.replace(/[.+^${}()|[\]\\?]/g, "\\$&");
-      }
-      return new RegExp(`^${body}$`);
-    });
+    const regexes = searchPatterns.map((pattern) => new RegExp(`^${pattern.split("*").map((part) => part.replace(/[.+^${}()|[\]\\?]/g, "\\$&")).join(".*")}$`));
     const publicEnv = {};
     for (const [k, v] of Object.entries(process.env)) {
       if (typeof v !== "string")
@@ -3386,8 +3015,10 @@ class AppExecutor extends SysExecutor {
     const owners = new Map;
     const devOnlyKeys = new Set;
     const devOnlyDirs = [];
-    for (const root of await this.getPageRoots()) {
-      if (!await FileSys.dirExists(root.dir))
+    const pageRoots = await this.getPageRoots();
+    const libKeyPrefixes = pageRoots.map((root) => root.keyPrefix).filter(Boolean);
+    for (const root of pageRoots) {
+      if (!await FileSys2.dirExists(root.dir))
         continue;
       for await (const rel of glob.scan({
         cwd: root.dir,
@@ -3398,6 +3029,8 @@ class AppExecutor extends SysExecutor {
         if (segments.some((s) => s === "node_modules"))
           continue;
         const posix = `${root.keyPrefix}${segments.join("/")}`;
+        if (!root.keyPrefix && libKeyPrefixes.some((prefix) => posix.startsWith(prefix)))
+          continue;
         const absPath = path8.join(root.dir, ...segments);
         validatePageSourceFile(posix, { filePath: absPath });
         if (!isRouteSourceFile(posix))
@@ -3462,7 +3095,7 @@ class AppExecutor extends SysExecutor {
       const entries = await readDirEntries(libsDir).catch(() => []);
       for (const entry of entries.sort()) {
         const dir = `${libsDir}/${entry}`;
-        if (!await FileSys.dirExists(dir))
+        if (!await FileSys2.dirExists(dir))
           continue;
         roots.push({ dir, realDir: await realpath(dir), keyPrefix: `${parent}${AppExecutor.#pageLibsDir}/${entry}/` });
       }
@@ -3487,7 +3120,8 @@ class AppExecutor extends SysExecutor {
       return entries.map((entry) => `${parent}${AppExecutor.#pageLibsDir}/${entry}/`);
     }))).flat();
     const wanted = parents.flatMap((parent) => libs.map((lib) => `${parent}${AppExecutor.#pageLibsDir}/(${lib})/`));
-    if (linked.sort().join(",") === wanted.sort().join(","))
+    const isLink = async (key) => (await lstat(`${this.cwdPath}/page/${key.slice(0, -1)}`).catch(() => null))?.isSymbolicLink() ?? false;
+    if (linked.sort().join(",") === wanted.sort().join(",") && (await Promise.all(linked.map(isLink))).every(Boolean))
       return false;
     await Promise.all(parents.map((parent) => this.removeDir(`${this.cwdPath}/page/${parent}${AppExecutor.#pageLibsDir}`)));
     for (const parent of parents) {
@@ -3503,7 +3137,7 @@ class AppExecutor extends SysExecutor {
   async#resolvePageLibs(syncPageLibs, libDeps) {
     if (!syncPageLibs)
       return [];
-    const hasPageDir = async (lib) => await FileSys.dirExists(`${this.workspace.workspaceRoot}/libs/${lib}/page`);
+    const hasPageDir = async (lib) => await FileSys2.dirExists(`${this.workspace.workspaceRoot}/libs/${lib}/page`);
     if (syncPageLibs === true) {
       const libs = [];
       for (const lib of libDeps)
@@ -3543,7 +3177,7 @@ class AppExecutor extends SysExecutor {
     } catch (error) {
       if (!isWindows)
         throw error;
-      await mkdir3(linkPath, { recursive: true });
+      await mkdir2(linkPath, { recursive: true });
       await cpEntry(targetPath, linkPath, { recursive: true, dereference: true, force: true });
     }
   }
@@ -3575,13 +3209,14 @@ class AppExecutor extends SysExecutor {
       appPath: this.cwdPath,
       executor: this,
       getPath: (rel) => this.getPath(rel),
-      fileExists: (rel) => FileSys.fileExists(this.getPath(rel)),
+      fileExists: (rel) => FileSys2.fileExists(this.getPath(rel)),
+      readFile: (rel) => this.readFile(rel),
       writeFile: async (rel, content, opts) => {
         await this.writeFile(rel, content, opts);
       },
       readEnvClient: async () => {
         const envClientPath = path8.join(this.cwdPath, "env", "env.client.ts");
-        if (!await FileSys.fileExists(envClientPath))
+        if (!await FileSys2.fileExists(envClientPath))
           return null;
         try {
           const envUrl = pathToFileURL(envClientPath);
@@ -3612,16 +3247,6 @@ class AppExecutor extends SysExecutor {
       return true;
     });
   }
-  async getPluginRuntimePackages() {
-    const plugins = await this.collectPlugins();
-    const appConfig = await this.getConfig();
-    const ctx = {
-      appName: this.name,
-      mobile: appConfig.mobile,
-      hasMobilePermission: (permission) => Object.values(appConfig.mobile.targets).some((target) => target.permissions?.includes(permission) ?? false)
-    };
-    return [...new Set(plugins.flatMap((plugin) => plugin.runtimePackages?.(ctx) ?? []))];
-  }
   async increaseBuildNum() {
     await increaseBuildNum(this);
   }
@@ -3637,15 +3262,8 @@ class LibExecutor extends SysExecutor {
     super({ workspace, name, type: "lib" });
     this.dist = new Executor(`dist/${name}`, `${this.workspace.workspaceRoot}/dist/libs/${name}`);
   }
-  static #execs = new Map;
   static from(executor, name) {
-    const exec = LibExecutor.#execs.get(name);
-    if (exec)
-      return exec;
-    else if (executor instanceof WorkspaceExecutor)
-      return new LibExecutor({ workspace: executor, name });
-    else
-      return new LibExecutor({ workspace: executor.workspace, name });
+    return new LibExecutor({ workspace: executor instanceof WorkspaceExecutor ? executor : executor.workspace, name });
   }
   #akanConfig = null;
   async getConfig({ refresh } = {}) {
@@ -3668,9 +3286,7 @@ class PkgExecutor extends Executor {
     this.dist = new Executor(`dist/${name}`, `${this.workspace.workspaceRoot}/dist/pkgs/${name}`);
   }
   static from(executor, name) {
-    if (executor instanceof WorkspaceExecutor)
-      return new PkgExecutor({ workspace: executor, name });
-    return new PkgExecutor({ workspace: executor.workspace, name });
+    return new PkgExecutor({ workspace: executor instanceof WorkspaceExecutor ? executor : executor.workspace, name });
   }
   #scanInfo = null;
   async scan({ refresh } = {}) {
@@ -3688,6 +3304,9 @@ class PkgExecutor extends Executor {
     const rootVersion = rootDeps[dep];
     if (rootVersion)
       return rootVersion;
+    const overrideVersion = rootPackageJson.overrides?.[dep];
+    if (typeof overrideVersion === "string")
+      return overrideVersion;
     try {
       const packageJsonPath = `pkgs/${dep}/package.json`;
       if (!await Bun.file(path8.join(this.workspace.workspaceRoot, packageJsonPath)).exists())
@@ -3713,16 +3332,8 @@ class PkgExecutor extends Executor {
     }
     if (missingDeps.length > 0)
       throw new Error(`Missing dependency versions in root package.json: ${missingDeps.join(", ")}`);
-    const toDependencyEntries = (names) => names.map((dep) => {
-      const version = dependencyVersions.get(dep);
-      if (!version)
-        throw new Error(`Missing dependency versions in root package.json: ${dep}`);
-      return [dep, version];
-    });
-    return {
-      dependencies: Object.fromEntries(toDependencyEntries(dependencyNames)),
-      devDependencies: Object.fromEntries(toDependencyEntries(devDependencyNames))
-    };
+    const toDependencyMap = (names) => Object.fromEntries(names.map((dep) => [dep, dependencyVersions.get(dep)]));
+    return { dependencies: toDependencyMap(dependencyNames), devDependencies: toDependencyMap(devDependencyNames) };
   }
   async updatePackageJsonDependencies(dependencies = [], devDependencies = []) {
     const [rootPackageJson, pkgJson] = await Promise.all([this.workspace.getPackageJson(), this.getPackageJson()]);
@@ -3791,4 +3402,4 @@ class ModuleExecutor extends Executor {
   }
 }
 
-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 };
+export { AGENT_BLOCK_START, AGENT_BLOCK_END, stampBlockVersion, extractBlockVersion, readDevkitVersion, upsertAgentBlock, extractAgentBlock, renderRecipeEntries, collectScopeRecipeSources, renderScopeAgentBlock, CLAUDE_COMMENT_RULE, AsyncDefaultExportDetector, resolveSsrPageEntriesForApp, CodegenLock, Linter, rootAllowedFiles, rootAllowedDirs, isAllowedLibFacetRootFile, rootEntryHintOf, isScannedRootEntry, AppInfo, Spinner, Executor, WorkspaceExecutor, SysExecutor, AppExecutor, LibExecutor, PkgExecutor, ModuleExecutor };