@akanjs/cli 2.4.1-rc.6 → 2.4.1

package/index-khzzttv1.js

@@ -1,4274 +0,0 @@
-// @bun
-import {
-  __require
-} from "./index-r24hmh0q.js";
-
-// pkgs/@akanjs/devkit/frontendBuild/clientEntryDiscovery.ts
-import path3 from "path";
-
-// pkgs/@akanjs/devkit/transforms/barrelAnalyzer.ts
-import path from "path";
-import { Logger } from "akanjs/common";
-var REEXPORT_RE = /(?:^|\n)\s*export\s+(?:type\s+)?(?:(\*)(?:\s+as\s+(\w+))?|\{\s*([^}]*?)\s*\})\s+from\s+(["'])([^"']+)\4;?/g;
-var LOCAL_NAMED_RE = /(?:^|\n)\s*export\s+\{\s*([^}]*?)\s*\}(?!\s*from)/g;
-var CANDIDATE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-
-class BarrelAnalyzer {
-  #logger = new Logger("BarrelAnalyzer");
-  #opts;
-  #cache = new Map;
-  #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
-  #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
-  constructor(opts) {
-    this.#opts = opts;
-  }
-  analyze(pkgName) {
-    const cached = this.#cache.get(pkgName);
-    if (cached)
-      return cached;
-    const promise = this.#analyzeSafe(pkgName);
-    this.#cache.set(pkgName, promise);
-    return promise;
-  }
-  async#analyzeSafe(pkgName) {
-    try {
-      return await this.#analyzeUncached(pkgName);
-    } catch (err) {
-      this.#logger.error(`analyze failed for ${pkgName}: ${err.message}`);
-      return null;
-    }
-  }
-  async#analyzeUncached(pkgName) {
-    const pkg = await this.#opts.resolvePackage(pkgName);
-    if (!pkg)
-      return null;
-    const map = new Map;
-    const visited = new Set;
-    await this.#walk(pkg.entryFile, pkg, map, visited);
-    return map;
-  }
-  async#walk(absFile, pkg, map, visited) {
-    if (visited.has(absFile))
-      return;
-    visited.add(absFile);
-    const source = await readIfExists(absFile);
-    if (source === null)
-      return;
-    const currentSubpath = this.#subpathFor(pkg, absFile);
-    if (!currentSubpath)
-      return;
-    const authoritative = this.#scanExports(source, absFile);
-    authoritative.delete("default");
-    const attributed = new Set;
-    REEXPORT_RE.lastIndex = 0;
-    let m = REEXPORT_RE.exec(source);
-    while (m !== null) {
-      const star = m[1];
-      const nsAs = m[2];
-      const namedList = m[3];
-      const spec = m[5] ?? "";
-      m = REEXPORT_RE.exec(source);
-      if (!isRelative(spec))
-        continue;
-      if (star) {
-        if (nsAs) {
-          authoritative.delete(nsAs);
-          continue;
-        }
-        const targetAbs = await this.#resolveRel(absFile, spec);
-        if (!targetAbs)
-          continue;
-        await this.#walk(targetAbs, pkg, map, visited);
-        continue;
-      }
-      if (namedList !== undefined) {
-        const targetAbs = await this.#resolveRel(absFile, spec);
-        if (!targetAbs)
-          continue;
-        const targetSubpath = this.#subpathFor(pkg, targetAbs);
-        if (!targetSubpath)
-          continue;
-        for (const item of parseNamedList(namedList)) {
-          if (item.isType)
-            continue;
-          if (item.imported === "default")
-            continue;
-          if (!authoritative.has(item.local))
-            continue;
-          attributed.add(item.local);
-          if (!map.has(item.local)) {
-            map.set(item.local, { subpath: targetSubpath, originalName: item.imported });
-          }
-        }
-      }
-    }
-    LOCAL_NAMED_RE.lastIndex = 0;
-    let n = LOCAL_NAMED_RE.exec(source);
-    while (n !== null) {
-      const body = n[1] ?? "";
-      n = LOCAL_NAMED_RE.exec(source);
-      for (const item of parseNamedList(body)) {
-        if (item.isType)
-          continue;
-        if (item.imported === "default")
-          continue;
-        if (!authoritative.has(item.local))
-          continue;
-        attributed.add(item.local);
-        if (!map.has(item.local)) {
-          map.set(item.local, { subpath: currentSubpath, originalName: item.imported });
-        }
-      }
-    }
-    for (const name of authoritative) {
-      if (attributed.has(name))
-        continue;
-      if (map.has(name))
-        continue;
-      map.set(name, { subpath: currentSubpath, originalName: name });
-    }
-  }
-  #scanExports(source, absFile) {
-    try {
-      const transpiler = [".tsx", ".jsx"].includes(path.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
-      const { exports } = transpiler.scan(source);
-      return new Set(exports);
-    } catch (err) {
-      this.#logger.error(`scan failed: ${err.message}`);
-      return new Set;
-    }
-  }
-  #subpathFor(pkg, absFile) {
-    const rel = path.relative(pkg.pkgDir, absFile);
-    if (!rel || rel.startsWith("..") || path.isAbsolute(rel))
-      return null;
-    if (pkg.preserveFilePath)
-      return `${pkg.pkgName}/${rel.split(path.sep).join("/")}`;
-    const noExt = stripKnownExt(rel);
-    const tail = collapseIndex(noExt);
-    if (tail === "")
-      return pkg.pkgName;
-    return `${pkg.pkgName}/${tail.split(path.sep).join("/")}`;
-  }
-  async#resolveRel(fromFile, relSpec) {
-    if (this.#opts.resolveRelative)
-      return this.#opts.resolveRelative(fromFile, relSpec);
-    return defaultResolveRelative(fromFile, relSpec);
-  }
-}
-var parseNamedList = (listBody) => {
-  const out = [];
-  for (const raw of listBody.split(",")) {
-    const s = raw.trim();
-    if (!s)
-      continue;
-    let rest = s;
-    let isType = false;
-    if (rest.startsWith("type ")) {
-      isType = true;
-      rest = rest.slice(5).trim();
-    }
-    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
-    if (asMatch) {
-      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
-      continue;
-    }
-    if (/^\w+$/.test(rest)) {
-      out.push({ imported: rest, local: rest, isType });
-    }
-  }
-  return out;
-};
-var isRelative = (spec) => {
-  return spec.startsWith("./") || spec.startsWith("../") || spec === "." || spec === "..";
-};
-var readIfExists = async (absFile) => {
-  const file = Bun.file(absFile);
-  if (!await file.exists())
-    return null;
-  return file.text();
-};
-var defaultResolveRelative = async (fromFile, relSpec) => {
-  const baseDir = path.dirname(fromFile);
-  const joined = path.resolve(baseDir, relSpec);
-  if (path.extname(joined)) {
-    if (await Bun.file(joined).exists())
-      return joined;
-    return null;
-  }
-  for (const ext of CANDIDATE_EXTS) {
-    const cand = joined + ext;
-    if (await Bun.file(cand).exists())
-      return cand;
-  }
-  for (const ext of CANDIDATE_EXTS) {
-    const cand = path.join(joined, `index${ext}`);
-    if (await Bun.file(cand).exists())
-      return cand;
-  }
-  return null;
-};
-var stripKnownExt = (relPath) => {
-  for (const ext of CANDIDATE_EXTS) {
-    if (relPath.endsWith(ext))
-      return relPath.slice(0, -ext.length);
-  }
-  return relPath;
-};
-var collapseIndex = (relPathNoExt) => {
-  const parts = relPathNoExt.split(path.sep);
-  if (parts[parts.length - 1] === "index")
-    parts.pop();
-  return parts.join(path.sep);
-};
-
-// pkgs/@akanjs/devkit/transforms/barrelImportsPlugin.ts
-import path2 from "path";
-import ts from "typescript";
-var createBarrelImportsPlugin = async (app, { skipPath = defaultSkipPath, pipeAfter } = {}) => {
-  const akanConfig = await app.getConfig();
-  const barrels = [...new Set(akanConfig.barrelImports)].filter(Boolean);
-  const analyzer = new BarrelAnalyzer({
-    resolvePackage: await createTsconfigPackageResolver(app)
-  });
-  return {
-    name: "barrel-imports",
-    setup(build) {
-      build.onLoad({
-        filter: /^(?:(?!.*[\\/]node_modules[\\/]).*|.*[\\/]node_modules[\\/]akanjs[\\/].*)\.(tsx|ts|jsx|js)(\?v=\d+)?$/
-      }, async (args) => {
-        const realPath = args.path.replace(/\?v=\d+$/, "");
-        const loader = loaderFor(realPath);
-        if (skipPath(realPath)) {
-          const raw = await Bun.file(realPath).text();
-          return { contents: raw, loader };
-        }
-        let source = await Bun.file(realPath).text();
-        const hasMacroAttr = MACRO_ATTR_RE.test(source);
-        if (!hasMacroAttr && barrels.length > 0) {
-          let maybe = false;
-          for (const b of barrels) {
-            if (source.includes(b)) {
-              maybe = true;
-              break;
-            }
-          }
-          if (maybe) {
-            const rewritten = await rewriteBarrelImports(source, barrels, analyzer);
-            if (rewritten !== null)
-              source = rewritten;
-          }
-        }
-        if (pipeAfter) {
-          const piped = await pipeAfter(source, { path: realPath });
-          if (piped !== null)
-            source = piped;
-        }
-        return { contents: source, loader };
-      });
-    }
-  };
-};
-var createTsconfigPackageResolver = async (app) => {
-  const tsconfig = await app.getTsConfig();
-  const tsconfigPaths = tsconfig.compilerOptions.paths ?? {};
-  const wildcardEntries = Object.entries(tsconfigPaths).filter(([k]) => k.endsWith("/*")).map(([k, v]) => ({
-    prefix: k.slice(0, -1),
-    replacements: v
-  })).sort((a, b) => b.prefix.length - a.prefix.length);
-  return async (pkgName) => {
-    const exact = tsconfigPaths[pkgName];
-    if (exact && exact.length > 0) {
-      const raw = exact[0];
-      if (!raw)
-        return null;
-      const entryFile = path2.resolve(app.workspace.workspaceRoot, raw);
-      if (!await Bun.file(entryFile).exists())
-        return null;
-      const parsed = path2.parse(entryFile);
-      const lastSlash = pkgName.lastIndexOf("/");
-      if (parsed.name !== "index" && lastSlash !== -1) {
-        const facet = pkgName.slice(lastSlash + 1);
-        const parentSpec = pkgName.slice(0, lastSlash);
-        if (facet === parsed.name && parentSpec.length > 0) {
-          return { pkgName: parentSpec, entryFile, pkgDir: parsed.dir };
-        }
-      }
-      return { pkgName, entryFile, pkgDir: path2.dirname(entryFile) };
-    }
-    for (const { prefix, replacements } of wildcardEntries) {
-      if (!pkgName.startsWith(prefix))
-        continue;
-      const suffix = pkgName.slice(prefix.length);
-      for (const repl of replacements) {
-        if (!repl)
-          continue;
-        const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
-        const candidate = path2.resolve(app.workspace.workspaceRoot, replPath + suffix);
-        for (const ext of CANDIDATE_EXTS2) {
-          const file = `${candidate}${ext}`;
-          if (await Bun.file(file).exists()) {
-            const lastSlash = pkgName.lastIndexOf("/");
-            if (lastSlash !== -1) {
-              const parentSpec = pkgName.slice(0, lastSlash);
-              if (parentSpec.length > 0) {
-                return { pkgName: parentSpec, entryFile: file, pkgDir: path2.dirname(file) };
-              }
-            }
-            return { pkgName, entryFile: file, pkgDir: path2.dirname(file) };
-          }
-        }
-        for (const ext of CANDIDATE_EXTS2) {
-          const file = path2.join(candidate, `index${ext}`);
-          if (await Bun.file(file).exists()) {
-            return { pkgName, entryFile: file, pkgDir: candidate };
-          }
-        }
-      }
-      return null;
-    }
-    const exported = await resolveNodePackageExport(app.workspace.workspaceRoot, pkgName);
-    if (exported)
-      return exported;
-    const pkgJsonPath = path2.join(app.workspace.workspaceRoot, "node_modules", pkgName, "package.json");
-    if (!await Bun.file(pkgJsonPath).exists())
-      return null;
-    try {
-      const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
-      const rel = pkgJson.module ?? pkgJson.main ?? "index.js";
-      const entryFile = path2.resolve(path2.dirname(pkgJsonPath), rel);
-      if (!await Bun.file(entryFile).exists())
-        return null;
-      return { pkgName, entryFile, pkgDir: path2.dirname(pkgJsonPath) };
-    } catch {
-      return null;
-    }
-  };
-};
-var CANDIDATE_EXTS2 = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-var NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
-var AKANJS_NODE_MODULE_RE = /[\\/]node_modules[\\/]akanjs[\\/]/;
-var defaultSkipPath = (absPath) => NODE_MODULES_RE.test(absPath) && !AKANJS_NODE_MODULE_RE.test(absPath);
-var resolveNodePackageExport = async (workspaceRoot, specifier) => {
-  const packageName = getPackageName(specifier);
-  if (!packageName)
-    return null;
-  const pkgJsonPath = path2.join(workspaceRoot, "node_modules", packageName, "package.json");
-  if (!await Bun.file(pkgJsonPath).exists())
-    return null;
-  try {
-    const pkgDir = path2.dirname(pkgJsonPath);
-    const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
-    const subpath = specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
-    const exported = resolvePackageExport(pkgJson.exports, subpath);
-    const rel = exported ?? (subpath === "." ? pkgJson.module ?? pkgJson.main ?? "index.js" : null);
-    if (!rel || !rel.startsWith("."))
-      return null;
-    const entryFile = await resolveFileCandidate(path2.resolve(pkgDir, rel));
-    if (!entryFile)
-      return null;
-    const pkgEntryName = specifier;
-    return { pkgName: pkgEntryName, entryFile, pkgDir: path2.dirname(entryFile), preserveFilePath: true };
-  } catch {
-    return null;
-  }
-};
-var resolveExportValue = (value) => {
-  if (!value)
-    return null;
-  if (typeof value === "string")
-    return value;
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      const resolved = resolveExportValue(item);
-      if (resolved)
-        return resolved;
-    }
-    return null;
-  }
-  for (const condition of ["source", "import", "default", "types"]) {
-    const resolved = resolveExportValue(value[condition]);
-    if (resolved)
-      return resolved;
-  }
-  return null;
-};
-var resolvePackageExport = (exportsMap, subpath) => {
-  if (!exportsMap)
-    return null;
-  const exact = resolveExportValue(exportsMap[subpath]);
-  if (exact)
-    return exact;
-  for (const [key, value] of Object.entries(exportsMap)) {
-    const starIdx = key.indexOf("*");
-    if (starIdx === -1)
-      continue;
-    const prefix = key.slice(0, starIdx);
-    const suffix = key.slice(starIdx + 1);
-    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
-      continue;
-    const wildcard = subpath.slice(prefix.length, subpath.length - suffix.length);
-    const resolved = resolveExportValue(value);
-    if (resolved)
-      return resolved.replace("*", wildcard);
-  }
-  return null;
-};
-var getPackageName = (specifier) => {
-  const parts = specifier.split("/");
-  if (!parts[0])
-    return null;
-  if (specifier.startsWith("@"))
-    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
-  return parts[0];
-};
-var resolveFileCandidate = async (candidate) => {
-  if (await Bun.file(candidate).exists())
-    return candidate;
-  if (path2.extname(candidate))
-    return null;
-  for (const ext of CANDIDATE_EXTS2) {
-    const file = `${candidate}${ext}`;
-    if (await Bun.file(file).exists())
-      return file;
-  }
-  for (const ext of CANDIDATE_EXTS2) {
-    const file = path2.join(candidate, `index${ext}`);
-    if (await Bun.file(file).exists())
-      return file;
-  }
-  return null;
-};
-var MACRO_ATTR_RE = /with\s*\{\s*type\s*:\s*["']macro["']\s*\}/;
-var rewriteBarrelImports = async (source, barrels, analyzer) => {
-  const statements = findImportStatements(source);
-  if (statements.length === 0)
-    return null;
-  let changed = false;
-  let out = source;
-  for (let i = statements.length - 1;i >= 0; i--) {
-    const stmt = statements[i];
-    if (!stmt)
-      continue;
-    if (!barrels.includes(stmt.specifier))
-      continue;
-    const map = await analyzer.analyze(stmt.specifier);
-    if (!map || map.size === 0)
-      continue;
-    const replacement = rewriteSingleStatement(stmt, map);
-    if (replacement === null)
-      continue;
-    out = out.slice(0, stmt.start) + replacement + out.slice(stmt.end);
-    changed = true;
-  }
-  return changed ? out : null;
-};
-var findImportStatements = (source) => {
-  const statements = [];
-  const sourceFile = ts.createSourceFile("barrel-imports.tsx", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-  for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement))
-      continue;
-    if (!ts.isStringLiteral(statement.moduleSpecifier))
-      continue;
-    const importClause = statement.importClause;
-    if (!importClause)
-      continue;
-    const statementStart = statement.getStart(sourceFile);
-    const statementEnd = statement.end;
-    statements.push({
-      start: statementStart,
-      end: statementEnd,
-      clause: source.slice(importClause.getStart(sourceFile), importClause.end).trim(),
-      specifier: statement.moduleSpecifier.text,
-      trailingSemicolon: source.slice(statement.moduleSpecifier.end, statement.end).includes(";"),
-      raw: source.slice(statementStart, statementEnd)
-    });
-  }
-  return statements;
-};
-var parseImportClause = (clause) => {
-  let rest = clause.trim();
-  let typeOnly = false;
-  if (rest.startsWith("type ")) {
-    typeOnly = true;
-    rest = rest.slice(5).trim();
-  }
-  const parsed = { typeOnly };
-  const commaMatch = /^(\w+)\s*,\s*(.+)$/.exec(rest);
-  if (commaMatch) {
-    parsed.defaultImport = commaMatch[1];
-    rest = commaMatch[2] ?? "";
-  } else if (/^\w+$/.test(rest)) {
-    parsed.defaultImport = rest;
-    return parsed;
-  }
-  if (rest.startsWith("*")) {
-    const ns = /^\*\s+as\s+(\w+)$/.exec(rest);
-    if (!ns)
-      return null;
-    parsed.namespaceImport = ns[1];
-    return parsed;
-  }
-  if (rest.startsWith("{")) {
-    const close = rest.indexOf("}");
-    if (close === -1)
-      return null;
-    const inner = rest.slice(1, close);
-    parsed.named = parseNamedImportList(inner);
-    return parsed;
-  }
-  return parsed;
-};
-var parseNamedImportList = (body) => {
-  const out = [];
-  for (const raw of body.split(",")) {
-    const s = raw.trim();
-    if (!s)
-      continue;
-    let isType = false;
-    let rest = s;
-    if (rest.startsWith("type ")) {
-      isType = true;
-      rest = rest.slice(5).trim();
-    }
-    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
-    if (asMatch) {
-      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
-      continue;
-    }
-    if (/^\w+$/.test(rest)) {
-      out.push({ imported: rest, local: rest, isType });
-    }
-  }
-  return out;
-};
-var rewriteSingleStatement = (stmt, map) => {
-  const clause = parseImportClause(stmt.clause);
-  if (!clause)
-    return null;
-  if (clause.namespaceImport)
-    return null;
-  if (clause.typeOnly && !clause.defaultImport)
-    return null;
-  if (!clause.named || clause.named.length === 0) {
-    return null;
-  }
-  const remaining = [];
-  const rewrites = new Map;
-  for (const item of clause.named) {
-    if (item.isType) {
-      remaining.push(item);
-      continue;
-    }
-    const target = map.get(item.imported);
-    if (!target) {
-      remaining.push(item);
-      continue;
-    }
-    const list = rewrites.get(target.subpath) ?? [];
-    list.push({ imported: target.originalName, local: item.local, isType: false });
-    rewrites.set(target.subpath, list);
-  }
-  if (rewrites.size === 0)
-    return null;
-  const lines = [];
-  const tail = ";";
-  if (shouldPreserveBarrelSideEffects(stmt.specifier)) {
-    lines.push(`import "${stmt.specifier}"${tail}`);
-  }
-  if (clause.defaultImport || remaining.length > 0) {
-    const parts = [];
-    if (clause.defaultImport)
-      parts.push(clause.defaultImport);
-    if (remaining.length > 0) {
-      parts.push(`{ ${remaining.map(serializeNamedItem).join(", ")} }`);
-    }
-    lines.push(`import ${parts.join(", ")} from "${stmt.specifier}"${tail}`);
-  }
-  for (const [subpath, items] of rewrites) {
-    lines.push(`import { ${items.map(serializeNamedItem).join(", ")} } from "${subpath}"${tail}`);
-  }
-  return lines.join(`
-`);
-};
-var shouldPreserveBarrelSideEffects = (specifier) => /^@(apps|libs)\/[^/]+\/client$/.test(specifier);
-var serializeNamedItem = (item) => {
-  const prefix = item.isType ? "type " : "";
-  if (item.imported === item.local)
-    return `${prefix}${item.imported}`;
-  return `${prefix}${item.imported} as ${item.local}`;
-};
-var loaderFor = (absPath) => {
-  if (absPath.endsWith(".tsx"))
-    return "tsx";
-  if (absPath.endsWith(".jsx"))
-    return "jsx";
-  if (absPath.endsWith(".ts"))
-    return "ts";
-  return "js";
-};
-
-// pkgs/@akanjs/devkit/frontendBuild/clientEntryDiscovery.ts
-var USE_CLIENT_RE = /^\s*(?:\/\*[\s\S]*?\*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
-var SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-var NODE_MODULES_RE2 = /[\\/]node_modules[\\/]/;
-var AKANJS_NODE_MODULE_RE2 = /[\\/]node_modules[\\/]akanjs[\\/]/;
-var NON_SOURCE_EXT_RE = /\.(css|scss|sass|less|json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav)$/i;
-var shouldSkipNodeModule = (absPath) => NODE_MODULES_RE2.test(absPath) && !AKANJS_NODE_MODULE_RE2.test(absPath);
-
-class GraphClientEntryDiscovery {
-  #akanConfig;
-  #resolvePackage;
-  #analyzer;
-  #tsTranspiler = new Bun.Transpiler({ loader: "tsx" });
-  #fileExistsCache = new Map;
-  #readCache = new Map;
-  #rewriteCache = new Map;
-  #importCache = new Map;
-  #resolvedFileCache = new Map;
-  #resolvedSpecifierCache = new Map;
-  #reachableEntriesCache = new Map;
-  constructor(akanConfig, resolvePackage) {
-    this.#akanConfig = akanConfig;
-    this.#resolvePackage = resolvePackage;
-    this.#analyzer = new BarrelAnalyzer({ resolvePackage });
-  }
-  static async create(app) {
-    return new GraphClientEntryDiscovery(await app.getConfig(), await createTsconfigPackageResolver(app));
-  }
-  async discover(seeds) {
-    const entries = new Set;
-    for (const seed of seeds) {
-      for (const entry of await this.#discoverFromFile(seed, new Set))
-        entries.add(entry);
-    }
-    return Array.from(entries).sort();
-  }
-  invalidate(files) {
-    for (const file of files) {
-      const absPath = path3.resolve(file);
-      this.#readCache.delete(absPath);
-      this.#rewriteCache.delete(absPath);
-      this.#importCache.delete(absPath);
-      this.#reachableEntriesCache.delete(absPath);
-    }
-    if (files.length > 0)
-      this.#reachableEntriesCache.clear();
-  }
-  async#fileExists(p) {
-    const absPath = path3.resolve(p);
-    let cached = this.#fileExistsCache.get(absPath);
-    if (!cached) {
-      cached = Bun.file(absPath).exists();
-      this.#fileExistsCache.set(absPath, cached);
-    }
-    return cached;
-  }
-  #readFile(file) {
-    const absPath = path3.resolve(file);
-    let cached = this.#readCache.get(absPath);
-    if (!cached) {
-      cached = Bun.file(absPath).text().catch(() => null);
-      this.#readCache.set(absPath, cached);
-    }
-    return cached;
-  }
-  async#resolveFileCandidate(absPathNoExt) {
-    const cacheKey = path3.resolve(absPathNoExt);
-    let cached = this.#resolvedFileCache.get(cacheKey);
-    if (cached)
-      return cached;
-    cached = (async () => {
-      if (await this.#fileExists(cacheKey))
-        return cacheKey;
-      for (const ext of SOURCE_EXTS) {
-        const f = `${cacheKey}${ext}`;
-        if (await this.#fileExists(f))
-          return f;
-      }
-      for (const ext of SOURCE_EXTS) {
-        const f = path3.join(cacheKey, `index${ext}`);
-        if (await this.#fileExists(f))
-          return f;
-      }
-      return null;
-    })();
-    this.#resolvedFileCache.set(cacheKey, cached);
-    return cached;
-  }
-  async#resolveSpecifier(spec, importerDir) {
-    const cacheKey = `${importerDir}\x00${spec}`;
-    let cached = this.#resolvedSpecifierCache.get(cacheKey);
-    if (cached)
-      return cached;
-    cached = (async () => {
-      if (spec.startsWith(".") || spec.startsWith("/")) {
-        const abs = spec.startsWith("/") ? spec : path3.resolve(importerDir, spec);
-        return this.#resolveFileCandidate(abs);
-      }
-      const pkg = await this.#resolvePackage(spec);
-      if (pkg)
-        return pkg.entryFile;
-      return null;
-    })();
-    this.#resolvedSpecifierCache.set(cacheKey, cached);
-    return cached;
-  }
-  async#getRewrittenSource(file, content) {
-    const absPath = path3.resolve(file);
-    let cached = this.#rewriteCache.get(absPath);
-    if (!cached) {
-      cached = (async () => {
-        if (this.#akanConfig.barrelImports.length === 0)
-          return content;
-        try {
-          return await rewriteBarrelImports(content, this.#akanConfig.barrelImports, this.#analyzer) ?? content;
-        } catch {
-          return content;
-        }
-      })();
-      this.#rewriteCache.set(absPath, cached);
-    }
-    return cached;
-  }
-  async#getImports(file, source) {
-    const absPath = path3.resolve(file);
-    let cached = this.#importCache.get(absPath);
-    if (!cached) {
-      cached = Promise.resolve().then(() => {
-        try {
-          return this.#tsTranspiler.scanImports(source);
-        } catch {
-          return [];
-        }
-      });
-      this.#importCache.set(absPath, cached);
-    }
-    return cached;
-  }
-  async#discoverFromFile(file, visiting) {
-    const absPath = path3.resolve(file);
-    const cached = this.#reachableEntriesCache.get(absPath);
-    if (cached)
-      return new Set(cached);
-    if (visiting.has(absPath) || shouldSkipNodeModule(absPath))
-      return new Set;
-    visiting.add(absPath);
-    const entries = new Set;
-    const content = await this.#readFile(absPath);
-    if (content === null)
-      return this.#finishDiscovery(absPath, visiting, entries);
-    if (USE_CLIENT_RE.test(content)) {
-      entries.add(absPath);
-      return this.#finishDiscovery(absPath, visiting, entries);
-    }
-    const source = await this.#getRewrittenSource(absPath, content);
-    const imports = await this.#getImports(absPath, source);
-    const importerDir = path3.dirname(absPath);
-    for (const imp of imports) {
-      const spec = imp.path;
-      if (!spec)
-        continue;
-      if (NON_SOURCE_EXT_RE.test(spec))
-        continue;
-      const resolved = await this.#resolveSpecifier(spec, importerDir);
-      if (!resolved)
-        continue;
-      if (shouldSkipNodeModule(resolved))
-        continue;
-      for (const entry of await this.#discoverFromFile(resolved, visiting))
-        entries.add(entry);
-    }
-    return this.#finishDiscovery(absPath, visiting, entries);
-  }
-  #finishDiscovery(absPath, visiting, entries) {
-    visiting.delete(absPath);
-    this.#reachableEntriesCache.set(absPath, entries);
-    return new Set(entries);
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/routeClientBuilder.ts
-import { mkdir } from "fs/promises";
-import path6 from "path";
-
-// pkgs/@akanjs/devkit/transforms/rscUseClientTransform.ts
-import path4 from "path";
-var USE_CLIENT_RE2 = /^\s*(?:\/\*[\s\S]*?\*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
-var IMPLICIT_ROOT_LAYOUT_RE = /[/\\]\.akan[/\\]generated[/\\](?:implicit-root-layout|root-layouts[/\\].*__root_layout)\.(tsx|ts|jsx|js)$/;
-function toClientReferencePath(absPath, workspaceRoot) {
-  return path4.relative(path4.resolve(workspaceRoot), path4.resolve(absPath)).split(path4.sep).join("/");
-}
-function transformUseClient(source, args) {
-  if (!USE_CLIENT_RE2.test(source))
-    return null;
-  if (IMPLICIT_ROOT_LAYOUT_RE.test(args.path))
-    return null;
-  const transpiler = new Bun.Transpiler({ loader: loaderFor2(args.path) });
-  const { exports } = transpiler.scan(source);
-  if (exports.length === 0)
-    return null;
-  const referencePath = args.workspaceRoot ? toClientReferencePath(args.path, args.workspaceRoot) : args.path;
-  const filePathLit = JSON.stringify(referencePath);
-  const lines = [`import { registerClientReference } from "react-server-dom-webpack/server.node";`];
-  for (const name of exports) {
-    const nameLit = JSON.stringify(name);
-    const errMsg = JSON.stringify(`Attempted to call '${name}' from '${referencePath}' on the server, but it is a client-only export.`);
-    const proxy = `() => { throw new Error(${errMsg}); }`;
-    const binding = name === "default" ? `export default registerClientReference(${proxy}, ${filePathLit}, ${nameLit});` : `export const ${name} = registerClientReference(${proxy}, ${filePathLit}, ${nameLit});`;
-    lines.push(binding);
-  }
-  return lines.join(`
-`);
-}
-function loaderFor2(absPath) {
-  if (absPath.endsWith(".tsx"))
-    return "tsx";
-  if (absPath.endsWith(".jsx"))
-    return "jsx";
-  if (absPath.endsWith(".ts"))
-    return "ts";
-  return "js";
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/clientEntriesBundler.ts
-import fs from "fs";
-import path5 from "path";
-
-// pkgs/@akanjs/devkit/frontendBuild/clientBuildTypes.ts
-var CLIENT_BUNDLE_NAMING = {
-  entry: "[name]-[hash].[ext]",
-  chunk: "chunks/[hash].[ext]",
-  asset: "assets/[hash].[ext]"
-};
-
-// pkgs/@akanjs/devkit/frontendBuild/clientEntriesBundler.ts
-class ClientEntriesBundler {
-  #app;
-  #entries;
-  #plugins;
-  #external;
-  #externalSubpaths;
-  #externalAliases;
-  #command;
-  #outputSubdir;
-  #reactFastRefresh;
-  #artifactDir;
-  #outdir;
-  #servePrefix;
-  #manifest = {};
-  #ssrManifest = { moduleLoading: null, moduleMap: {} };
-  #entryUrlsByAbsPath = new Map;
-  #entryOutputAbsByAbsPath = new Map;
-  #entryDepsByAbsPath = new Map;
-  #clientReferenceIdByAbsPath = new Map;
-  #opaqueEntries = null;
-  #metafileOutputsByAbs = new Map;
-  constructor(options) {
-    this.#app = options.app;
-    this.#entries = options.entries;
-    this.#plugins = options.plugins ?? [];
-    this.#external = options.external ?? [];
-    this.#externalSubpaths = options.externalSubpaths ?? [];
-    this.#externalAliases = options.externalAliases ?? {};
-    this.#command = options.command ?? "start";
-    this.#outputSubdir = options.outputSubdir ?? "client";
-    this.#reactFastRefresh = options.reactFastRefresh ?? false;
-    this.#artifactDir = `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
-    this.#outdir = `${this.#artifactDir}/${this.#outputSubdir}`;
-    this.#servePrefix = `/_akan/${this.#outputSubdir}`;
-  }
-  async bundle() {
-    const akanConfig = await this.#app.getConfig();
-    this.#opaqueEntries = await this.#createOpaqueEntryAliases();
-    const result = await Bun.build({
-      entrypoints: this.#opaqueEntries.entries,
-      outdir: this.#outdir,
-      splitting: true,
-      target: "browser",
-      format: "esm",
-      naming: CLIENT_BUNDLE_NAMING,
-      metafile: true,
-      define: this.#getDefine(),
-      minify: this.#command === "build",
-      optimizeImports: akanConfig.optimizeImports,
-      reactFastRefresh: this.#command === "start" && this.#outputSubdir === "client" && this.#reactFastRefresh,
-      plugins: this.#external.length > 0 || this.#externalSubpaths.length > 0 || Object.keys(this.#externalAliases).length > 0 ? [...this.#plugins, this.#createExternalSpecifiersPlugin()] : this.#plugins
-    });
-    if (!result.success)
-      throw new AggregateError(result.logs, "[ClientEntriesBundler] Bun.build failed");
-    await this.#rewriteExternalImportSpecifiers(result.outputs);
-    const metafile = result.metafile;
-    if (!metafile)
-      throw new Error("[ClientEntriesBundler] metafile is missing");
-    this.#metafileOutputsByAbs = new Map(Object.entries(metafile.outputs).map(([k, v]) => [this.#absFromOutdir(k), v]));
-    for (const artifact of result.outputs.filter((a) => a.kind === "entry-point"))
-      this.#addEntryArtifact(artifact.path);
-    return {
-      manifest: this.#manifest,
-      ssrManifest: this.#ssrManifest,
-      entryUrlsByAbsPath: this.#entryUrlsByAbsPath,
-      entryOutputAbsByAbsPath: this.#entryOutputAbsByAbsPath,
-      entryDepsByAbsPath: this.#entryDepsByAbsPath,
-      clientReferenceIdByAbsPath: this.#clientReferenceIdByAbsPath
-    };
-  }
-  #getDefine() {
-    const nodeEnv = this.#command === "build" ? "production" : "development";
-    return {
-      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
-      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("ssr"),
-      ...Object.fromEntries(Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
-    };
-  }
-  async#createOpaqueEntryAliases() {
-    const aliasDir = path5.join(this.#app.cwdPath, ".akan", "generated", "client-entry-alias", this.#outputSubdir);
-    fs.mkdirSync(aliasDir, { recursive: true });
-    const originalByAlias = new Map;
-    const aliasedEntries = await Promise.all(this.#entries.map(async (entry) => {
-      const absEntry = path5.resolve(entry);
-      const hash = Bun.hash(`${this.#app.name}
-${this.#outputSubdir}
-${absEntry}`).toString(36);
-      const aliasPath = path5.join(aliasDir, `${hash}.tsx`);
-      await Bun.write(aliasPath, this.#createOpaqueEntryAliasSource(absEntry, await this.#scanEntryExportNames(absEntry)));
-      originalByAlias.set(path5.resolve(aliasPath), absEntry);
-      return aliasPath;
-    }));
-    return { entries: aliasedEntries, originalByAlias, aliasDir };
-  }
-  #createOpaqueEntryAliasSource(absEntry, exportNames) {
-    const entryLit = JSON.stringify(path5.resolve(absEntry));
-    if (exportNames.length === 0)
-      return `export * from ${entryLit};
-`;
-    const namedExports = exportNames.filter((name) => name !== "default");
-    const lines = namedExports.length > 0 ? [`export { ${namedExports.join(", ")} } from ${entryLit};`] : [];
-    if (exportNames.includes("default"))
-      lines.push(`export { default } from ${entryLit};`);
-    return `${lines.join(`
-`)}
-`;
-  }
-  async#scanEntryExportNames(absEntry) {
-    const source = await Bun.file(absEntry).text();
-    const transpiler = new Bun.Transpiler({ loader: this.#loaderForEntry(absEntry) });
-    return transpiler.scan(source).exports;
-  }
-  #loaderForEntry(absPath) {
-    if (absPath.endsWith(".tsx"))
-      return "tsx";
-    if (absPath.endsWith(".jsx"))
-      return "jsx";
-    if (absPath.endsWith(".ts"))
-      return "ts";
-    return "js";
-  }
-  #createExternalSpecifiersPlugin() {
-    const set = new Set(this.#external);
-    const subpathSet = new Set(this.#externalSubpaths);
-    const aliases = this.#externalAliases;
-    const specifiers = [...new Set([...this.#external, ...this.#externalSubpaths, ...Object.keys(aliases)])];
-    const escaped = specifiers.map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-    const filter = new RegExp(`^(${escaped.join("|")})(?:/.*)?$`);
-    return {
-      name: "akan-externalize-specifiers",
-      setup(build) {
-        build.onResolve({ filter }, (args) => {
-          const alias = aliases[args.path];
-          if (alias)
-            return { path: alias, external: true };
-          if (!ClientEntriesBundler.#matchesExternalSpecifier(args.path, set, subpathSet))
-            return;
-          return { path: args.path, external: true };
-        });
-      }
-    };
-  }
-  static #matchesExternalSpecifier(specifier, exactExternals, subpathExternals) {
-    if (exactExternals.has(specifier))
-      return true;
-    if (subpathExternals.has(specifier))
-      return true;
-    for (const external of subpathExternals) {
-      if (specifier.startsWith(`${external}/`))
-        return true;
-    }
-    return false;
-  }
-  async#rewriteExternalImportSpecifiers(outputs) {
-    if (Object.keys(this.#externalAliases).length === 0)
-      return;
-    await Promise.all(outputs.filter((output) => output.path.endsWith(".js")).map(async (output) => {
-      const source = await Bun.file(output.path).text();
-      const rewritten = ClientEntriesBundler.rewriteExternalImportSpecifiers(source, this.#externalAliases);
-      if (rewritten !== source)
-        await Bun.write(output.path, rewritten);
-    }));
-  }
-  static rewriteExternalImportSpecifiers(source, aliases) {
-    let rewritten = source;
-    for (const [specifier, alias] of Object.entries(aliases)) {
-      if (!alias)
-        continue;
-      const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      rewritten = rewritten.replace(new RegExp(`(\\bfrom\\s*["'])${escaped}(["'])`, "g"), (_match, prefix, suffix) => {
-        return `${prefix}${alias}${suffix}`;
-      }).replace(new RegExp(`(\\bimport\\s*["'])${escaped}(["'])`, "g"), (_match, prefix, suffix) => {
-        return `${prefix}${alias}${suffix}`;
-      });
-    }
-    return rewritten;
-  }
-  #toServeUrl(absOutPath) {
-    const rel = path5.relative(this.#outdir, absOutPath).split(path5.sep).join("/");
-    return `${this.#servePrefix}/${rel}`;
-  }
-  #absFromOutdir(p) {
-    return path5.isAbsolute(p) ? p : path5.resolve(this.#outdir, p);
-  }
-  #absFromEntryPoint(p) {
-    if (path5.isAbsolute(p))
-      return path5.resolve(p);
-    const candidates = [path5.resolve(process.cwd(), p), path5.resolve(this.#app.cwdPath, p)];
-    return candidates.find((candidate) => fs.existsSync(candidate)) ?? candidates[0];
-  }
-  #collectChunkUrls(absOutPath, visited = new Set) {
-    if (visited.has(absOutPath))
-      return [];
-    visited.add(absOutPath);
-    const info = this.#metafileOutputsByAbs.get(absOutPath);
-    if (!info)
-      return [this.#toServeUrl(absOutPath)];
-    const urls = [this.#toServeUrl(absOutPath)];
-    for (const imp of info.imports) {
-      if (imp.kind === "dynamic-import")
-        continue;
-      const absImp = this.#absFromOutdir(imp.path);
-      if (!absImp.endsWith(".js"))
-        continue;
-      urls.push(...this.#collectChunkUrls(absImp, visited));
-    }
-    return urls;
-  }
-  #collectClientDeps(absOutPath, visited = new Set) {
-    if (visited.has(absOutPath))
-      return new Set;
-    visited.add(absOutPath);
-    const deps = new Set;
-    const info = this.#metafileOutputsByAbs.get(absOutPath);
-    if (!info)
-      return deps;
-    if (!this.#opaqueEntries)
-      throw new Error("[ClientEntriesBundler] opaque entries are missing");
-    for (const input of Object.keys(info.inputs ?? {})) {
-      const absInput = this.#absFromEntryPoint(input);
-      if (!absInput.includes("node_modules") && !absInput.startsWith(this.#opaqueEntries.aliasDir))
-        deps.add(absInput);
-    }
-    for (const imp of info.imports) {
-      if (imp.kind === "dynamic-import")
-        continue;
-      const absImp = this.#absFromOutdir(imp.path);
-      if (!absImp.endsWith(".js"))
-        continue;
-      for (const dep of this.#collectClientDeps(absImp, visited))
-        deps.add(dep);
-    }
-    return deps;
-  }
-  #addEntryArtifact(absOut) {
-    if (!this.#opaqueEntries)
-      throw new Error("[ClientEntriesBundler] opaque entries are missing");
-    const info = this.#metafileOutputsByAbs.get(absOut);
-    const buildEntryPointAbs = info?.entryPoint ? this.#absFromEntryPoint(info.entryPoint) : null;
-    const entryPointAbs = buildEntryPointAbs ? this.#opaqueEntries.originalByAlias.get(buildEntryPointAbs) ?? buildEntryPointAbs : null;
-    if (!entryPointAbs)
-      return;
-    const chunkUrls = this.#collectChunkUrls(absOut);
-    const entryUrl = chunkUrls[0] ?? this.#toServeUrl(absOut);
-    this.#entryUrlsByAbsPath.set(entryPointAbs, entryUrl);
-    this.#entryOutputAbsByAbsPath.set(entryPointAbs, absOut);
-    this.#entryDepsByAbsPath.set(entryPointAbs, [...this.#collectClientDeps(absOut)].sort());
-    const clientReferenceId = toClientReferencePath(entryPointAbs, this.#app.workspace.workspaceRoot);
-    this.#clientReferenceIdByAbsPath.set(entryPointAbs, clientReferenceId);
-    const flatChunks = [];
-    for (const url of chunkUrls)
-      flatChunks.push(url, url);
-    const exportNames = info?.exports && info.exports.length > 0 ? info.exports : ["default"];
-    const ssrEntriesByName = {};
-    for (const name of exportNames) {
-      const key = `${clientReferenceId}#${name}`;
-      this.#manifest[key] = { id: entryUrl, chunks: flatChunks, name, async: true };
-      ssrEntriesByName[name] = { id: absOut, chunks: [absOut, absOut], name, async: true };
-    }
-    this.#ssrManifest.moduleMap[entryUrl] = ssrEntriesByName;
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/vendorSpecifiers.ts
-var VENDOR_SPECIFIERS = [
-  "react",
-  "react-dom",
-  "react-dom/client",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime",
-  "react-refresh/runtime",
-  "scheduler",
-  "react-server-dom-webpack/client.browser",
-  "akanjs/store",
-  "akanjs/base",
-  "akanjs/common",
-  "akanjs/constant"
-];
-
-// pkgs/@akanjs/devkit/frontendBuild/routeClientBuilder.ts
-var SSR_CLIENT_EXTERNALS = [
-  "react",
-  "react-dom",
-  "react-dom/client",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime",
-  "akanjs/fetch"
-];
-var SSR_CLIENT_ALIAS_EXTERNALS = [
-  "react",
-  "react-dom",
-  "react-dom/client",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime"
-];
-
-class RouteClientBuilder {
-  #app;
-  #seeds;
-  #knownEntries;
-  #command;
-  #discovery;
-  constructor(options) {
-    this.#app = options.app;
-    this.#seeds = options.seeds;
-    this.#knownEntries = options.knownEntries ?? new Set;
-    this.#command = options.command ?? "start";
-    this.#discovery = options.discovery;
-  }
-  async build() {
-    const discovery = this.#discovery ?? await GraphClientEntryDiscovery.create(this.#app);
-    const discovered = await discovery.discover(this.#seeds);
-    const entries = discovered.filter((e) => !this.#knownEntries.has(e));
-    if (entries.length === 0)
-      return this.#emptyResult(discovered);
-    const bootstrapEntries = await this.#createBootstrapEntries(entries);
-    const browserBundle = await this.#buildBrowserBundle(bootstrapEntries);
-    const ssrBundle = await this.#buildSsrBundle(bootstrapEntries);
-    const acceptedEntries = new Set(entries);
-    const manifestDelta = {};
-    const ssrModuleMap = {};
-    const clientDeps = new Set;
-    const clientDepsByEntry = {};
-    for (const [key, row] of Object.entries(browserBundle.manifest)) {
-      const manifestEntry = RouteClientBuilder.resolveOriginalManifestEntry(key, bootstrapEntries.originalByBuildEntry, browserBundle.clientReferenceIdByAbsPath, this.#app.workspace.workspaceRoot);
-      if (!manifestEntry)
-        continue;
-      if (!acceptedEntries.has(manifestEntry.originalEntry))
-        continue;
-      manifestDelta[manifestEntry.key] = row;
-      const ssrOutput = ssrBundle.entryOutputAbsByAbsPath.get(manifestEntry.buildEntry);
-      if (!ssrOutput)
-        continue;
-      ssrModuleMap[row.id] ??= {};
-      ssrModuleMap[row.id][row.name] = { id: ssrOutput, chunks: [ssrOutput, ssrOutput], name: row.name, async: true };
-    }
-    for (const entry of bootstrapEntries.buildEntries) {
-      const buildEntry = path6.resolve(entry);
-      const originalEntry = path6.resolve(bootstrapEntries.originalByBuildEntry.get(buildEntry) ?? buildEntry);
-      if (!acceptedEntries.has(originalEntry))
-        continue;
-      const deps = new Set([originalEntry]);
-      for (const dep of browserBundle.entryDepsByAbsPath.get(buildEntry) ?? [])
-        deps.add(path6.resolve(dep));
-      const sortedDeps = [...deps].sort();
-      clientDepsByEntry[originalEntry] = sortedDeps;
-      for (const dep of sortedDeps)
-        clientDeps.add(dep);
-    }
-    return {
-      manifestDelta,
-      ssrManifestDelta: { moduleLoading: null, moduleMap: ssrModuleMap },
-      newEntries: entries,
-      discoveredEntries: discovered,
-      clientDeps: [...clientDeps].sort(),
-      clientDepsByEntry
-    };
-  }
-  #emptyResult(discoveredEntries = []) {
-    return {
-      manifestDelta: {},
-      ssrManifestDelta: { moduleLoading: null, moduleMap: {} },
-      newEntries: [],
-      discoveredEntries,
-      clientDeps: [],
-      clientDepsByEntry: {}
-    };
-  }
-  async#buildBrowserBundle(bootstrapEntries) {
-    const reactFastRefresh = process.env.AKAN_REACT_FAST_REFRESH !== "0";
-    return new ClientEntriesBundler({
-      app: this.#app,
-      entries: bootstrapEntries.buildEntries,
-      plugins: [
-        await createBarrelImportsPlugin(this.#app, {
-          pipeAfter: reactFastRefresh ? RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh : undefined
-        })
-      ],
-      external: VENDOR_SPECIFIERS,
-      command: this.#command,
-      reactFastRefresh
-    }).bundle();
-  }
-  async#buildSsrBundle(bootstrapEntries) {
-    const externalOptions = RouteClientBuilder.resolveSsrClientExternalOptions(this.#command);
-    return new ClientEntriesBundler({
-      app: this.#app,
-      entries: bootstrapEntries.buildEntries,
-      plugins: [await createBarrelImportsPlugin(this.#app)],
-      ...externalOptions,
-      outputSubdir: "client-ssr",
-      command: this.#command
-    }).bundle();
-  }
-  async#createBootstrapEntries(entries) {
-    if (!await Bun.file(path6.join(this.#app.cwdPath, "lib", "st.ts")).exists()) {
-      return { buildEntries: entries, originalByBuildEntry: new Map };
-    }
-    const outdir = path6.join(this.#app.cwdPath, ".akan", "generated", "client-entry-bootstrap");
-    await mkdir(outdir, { recursive: true });
-    const originalByBuildEntry = new Map;
-    const buildEntries = await Promise.all(entries.map(async (entry) => {
-      const absEntry = path6.resolve(entry);
-      const hash = Bun.hash(`${this.#app.name}
-${absEntry}`).toString(36);
-      const base = path6.basename(absEntry).replace(/[^A-Za-z0-9._-]/g, "_");
-      const wrapperEntry = path6.join(outdir, `${base}-${hash}.tsx`);
-      const exportNames = await this.#scanExportNames(absEntry);
-      await Bun.write(wrapperEntry, RouteClientBuilder.createStoreBootstrapEntrySource({
-        appName: this.#app.name,
-        originalEntry: absEntry,
-        exportNames
-      }));
-      originalByBuildEntry.set(path6.resolve(wrapperEntry), absEntry);
-      return wrapperEntry;
-    }));
-    return { buildEntries, originalByBuildEntry };
-  }
-  async#scanExportNames(absEntry) {
-    const source = await Bun.file(absEntry).text();
-    const transpiler = new Bun.Transpiler({ loader: this.#loaderFor(absEntry) });
-    return transpiler.scan(source).exports;
-  }
-  #loaderFor(absPath) {
-    if (absPath.endsWith(".tsx"))
-      return "tsx";
-    if (absPath.endsWith(".jsx"))
-      return "jsx";
-    if (absPath.endsWith(".ts"))
-      return "ts";
-    return "js";
-  }
-  static normalizeNamedDefaultFunctionForFastRefresh(source) {
-    let changed = false;
-    const defaultNames = [];
-    const next = source.replace(/(^|\n)(\s*)export\s+default\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)(?=\s*(?:<|\())/g, (match, lineStart, indent, asyncKeyword, name) => {
-      changed = true;
-      defaultNames.push(name);
-      return `${lineStart}${indent}${asyncKeyword ?? ""}function ${name}`;
-    });
-    if (!changed)
-      return null;
-    return `${next}
-${defaultNames.map((name) => `export default ${name};`).join(`
-`)}
-`;
-  }
-  static resolveSsrClientRuntimeAliases() {
-    const serverEntry = RouteClientBuilder.resolveAkanServerEntry();
-    return { [Bun.resolveSync("akanjs/fetch", serverEntry)]: "akanjs/fetch" };
-  }
-  static resolveSsrClientExternalOptions(command) {
-    if (command === "start") {
-      return {
-        external: SSR_CLIENT_EXTERNALS,
-        externalSubpaths: ["akanjs/fetch"],
-        externalAliases: RouteClientBuilder.resolveSsrClientRuntimeAliases()
-      };
-    }
-    return { external: SSR_CLIENT_ALIAS_EXTERNALS };
-  }
-  static resolveAkanServerEntry() {
-    try {
-      return Bun.resolveSync("akanjs/server", import.meta.dir);
-    } catch {
-      return path6.resolve(import.meta.dir, "../../../server/index.ts");
-    }
-  }
-  static createStoreBootstrapEntrySource(args) {
-    const originalEntry = JSON.stringify(path6.resolve(args.originalEntry));
-    const namedExports = args.exportNames.filter((name) => name !== "default");
-    const lines = [
-      `import ${JSON.stringify(`@apps/${args.appName}/client`)};`,
-      ...namedExports.length > 0 ? [`export { ${namedExports.join(", ")} } from ${originalEntry};`] : []
-    ];
-    if (args.exportNames.includes("default"))
-      lines.push(`export { default } from ${originalEntry};`);
-    return `${lines.join(`
-`)}
-`;
-  }
-  static resolveOriginalManifestEntry(manifestKey, originalByBuildEntry, clientReferenceIdByBuildEntry = new Map, workspaceRoot = process.cwd()) {
-    const hashIdx = manifestKey.lastIndexOf("#");
-    if (hashIdx < 0)
-      return null;
-    const buildReferenceId = manifestKey.slice(0, hashIdx);
-    const name = manifestKey.slice(hashIdx + 1);
-    const buildEntry = [...clientReferenceIdByBuildEntry.entries()].find(([, referenceId]) => referenceId === buildReferenceId)?.[0] ?? buildReferenceId;
-    const originalEntry = originalByBuildEntry.get(buildEntry) ?? buildEntry;
-    const originalReferenceId = toClientReferencePath(originalEntry, workspaceRoot);
-    return { buildEntry, originalEntry, name, key: `${originalReferenceId}#${name}` };
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
-import path10 from "path";
-
-// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import path7 from "path";
-var LAYOUT_KEY_RE = /^\.\/(.+\/)?_layout\.(tsx|ts|jsx|js)$/;
-async function appHasStModule(appCwdPath) {
-  return Bun.file(path7.join(appCwdPath, "lib", "st.ts")).exists();
-}
-var IMPLICIT_LAYOUT_DIR = path7.join(".akan", "generated", "root-layouts");
-var IMPLICIT_DICT_DIR = path7.join(".akan", "generated", "dict");
-var IMPLICIT_OVERRIDES_DIR = path7.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 = path7.join(path7.resolve(opts.appCwdPath), IMPLICIT_OVERRIDES_DIR, filename);
-  const userRel = path7.relative(path7.dirname(absPath), opts.userAbsPath).split(path7.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 path7.join(path7.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
-}
-function implicitDictionaryMacroAbsPath(appCwdPath) {
-  return path7.join(path7.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: path7.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
-      segments
-    });
-  }
-  const hasExplicitRootBoundary = [...boundaries.values()].some((boundary) => boundary.segments.length === 0);
-  if (!hasExplicitRootBoundary && boundaries.size === 0) {
-    boundaries.set("", { sourceKey: null, sourceAbsPath: null, segments: [] });
-  }
-  return [...boundaries.values()].sort((a, b) => a.segments.join("/").localeCompare(b.segments.join("/")));
-}
-function hasAncestorRootBoundary(boundary, boundaries) {
-  return boundaries.some((candidate) => candidate !== boundary && candidate.segments.length < boundary.segments.length && candidate.segments.every((segment, index) => boundary.segments[index] === segment));
-}
-function findExplicitRootLayoutAbsPath(pageKeys, appCwdPath) {
-  const rootLayoutKey = pageKeys.find((key) => {
-    const segments = getRootBoundarySegments(key);
-    return segments !== null && segments.length === 0;
-  });
-  return rootLayoutKey ? path7.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 = path7.join(appCwdPath, "env", "env.client.ts");
-  if (!await Bun.file(envPath).exists()) {
-    throw new Error(`[route-convention] app "${appName}" must provide env/env.client.ts exporting "env" for generated System.Provider`);
-  }
-}
-async function writeGeneratedDictionaryMacroFile(appCwdPath, appName) {
-  const absPath = implicitDictionaryMacroAbsPath(appCwdPath);
-  await mkdir2(path7.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(path7.dirname(absPath), { recursive: true });
-  const dictMacroRel = dictMacroAbsPath ? path7.relative(path7.dirname(absPath), dictMacroAbsPath).split(path7.sep).join("/") : null;
-  const dictMacroSpecifier = dictMacroRel ? dictMacroRel.startsWith(".") ? dictMacroRel : `./${dictMacroRel}` : null;
-  const sourceRel = opts.boundary.sourceAbsPath ? path7.relative(path7.dirname(absPath), opts.boundary.sourceAbsPath).split(path7.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 ? path7.relative(path7.dirname(absPath), inheritedSourceAbsPath).split(path7.sep).join("/") : null;
-  const inheritedSourceSpecifier = inheritedSourceRel ? inheritedSourceRel.startsWith(".") ? inheritedSourceRel : `./${inheritedSourceRel}` : null;
-  const clientImport = opts.includeStInit ? `import { st } from "@apps/${opts.appName}/client";
-void st;
-` : `import "@apps/${opts.appName}/client";
-`;
-  const inheritedImport = inheritedSourceSpecifier ? `import * as inheritedLayout from ${JSON.stringify(inheritedSourceSpecifier)};
-` : `const inheritedLayout = {};
-`;
-  const prefix = routePrefixForSegments(opts.boundary.segments);
-  const userImport = sourceSpecifier ? `import UserLayout, * as userLayout from ${JSON.stringify(sourceSpecifier)};
-` : `const UserLayout = ({ children }) => children;
-const userLayout = {};
-`;
-  const source = opts.includeSystemProvider ? `import type { LayoutProps, PageProps } from "akanjs/client";
-import { loadFonts } from "akanjs/client";
-import { System } from "akanjs/ui";
-import { env } from "@apps/${opts.appName}/env/env.client";
-import { allDictionary } from ${JSON.stringify(dictMacroSpecifier)};
-${clientImport}${inheritedImport}${userImport}
-const userFonts = userLayout.fonts ?? inheritedLayout.fonts ?? [];
-const defaultFonts = userFonts.filter((font) => font.default);
-if (defaultFonts.length > 1) throw new Error("[route-convention] only one default font is allowed per root layout");
-const defaultFont = defaultFonts[0];
-const defaultFontClassName = defaultFont ? (defaultFont.className ?? \`font-\${defaultFont.name}\`) : undefined;
-
-export async function generateHead(props: PageProps) {
-  if (userLayout.generateHead) return userLayout.generateHead(props);
-  if (userLayout.head !== undefined) return userLayout.head;
-  if (inheritedLayout.generateHead) return inheritedLayout.generateHead(props);
-  return inheritedLayout.head;
-}
-
-export async function generateMetadata(props: PageProps) {
-  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
-  if (userLayout.metadata !== undefined) return userLayout.metadata;
-  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
-  return inheritedLayout.metadata;
-}
-
-export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
-export const Error = userLayout.Error ?? inheritedLayout.Error;
-export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
-
-export default function GeneratedLayout({ children, params, searchParams }: LayoutProps) {
-  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}
-    >
-      <UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>
-    </System.Provider>
-  );
-}
-` : `import type { LayoutProps, PageProps } from "akanjs/client";
-${inheritedImport}${userImport}
-export async function generateHead(props: PageProps) {
-  if (userLayout.generateHead) return userLayout.generateHead(props);
-  if (userLayout.head !== undefined) return userLayout.head;
-  if (inheritedLayout.generateHead) return inheritedLayout.generateHead(props);
-  return inheritedLayout.head;
-}
-
-export async function generateMetadata(props: PageProps) {
-  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
-  if (userLayout.metadata !== undefined) return userLayout.metadata;
-  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
-  return inheritedLayout.metadata;
-}
-
-export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
-export const Error = userLayout.Error ?? inheritedLayout.Error;
-export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
-
-export default function GeneratedLayout({ children, params, searchParams }: LayoutProps) {
-  return <UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>;
-}
-`;
-  await Bun.write(absPath, source);
-  return absPath;
-}
-async function resolveSsrPageEntries(opts) {
-  const absPageDir = path7.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 = path7.resolve(absPageDir, key);
-    if (OVERRIDES_KEY_RE.test(key)) {
-      const moduleAbsPath = await writeGeneratedOverridesLayoutFile({
-        appCwdPath: opts.appCwdPath,
-        key,
-        userAbsPath
-      });
-      return { key, moduleAbsPath, seedAbsPaths: [userAbsPath] };
-    }
-    return { key, moduleAbsPath: userAbsPath };
-  }));
-  const generated = await Promise.all(rootBoundaries.map(async (boundary) => ({
-    key: implicitRootLayoutKey(boundary.segments),
-    moduleAbsPath: await writeGeneratedRootLayoutFile({
-      appCwdPath: opts.appCwdPath,
-      appName: opts.appName,
-      boundary,
-      rootSourceAbsPath,
-      includeStInit: hasSt && boundary.segments.length === 0,
-      includeSystemProvider: !hasAncestorRootBoundary(boundary, rootBoundaries)
-    }),
-    seedAbsPaths: [...new Set([boundary.sourceAbsPath, rootSourceAbsPath].filter((absPath) => absPath !== null))]
-  })));
-  const entries = [...base, ...generated];
-  entries.sort((a, b) => a.key.localeCompare(b.key));
-  return entries;
-}
-async function resolveSsrPageEntriesForApp(app, pageKeys) {
-  const config = await app.getConfig();
-  return resolveSsrPageEntries({ appCwdPath: app.cwdPath, appName: app.name, pageKeys, basePaths: config.basePaths });
-}
-
-// pkgs/@akanjs/devkit/artifact/routeSeedIndex.ts
-import path8 from "path";
-import { assertUniqueRoutePatterns, compareRouteSpecificity, parseRouteModuleKey } from "akanjs/common";
-function computeRouteSeedIndex(pageEntries) {
-  const layoutsByPrefix = new Map;
-  const pagesBySegments = [];
-  for (const { key, moduleAbsPath, seedAbsPaths } of pageEntries) {
-    const parsed = parseRouteModuleKey(key);
-    const files = [path8.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path8.resolve(seed))];
-    if (parsed.kind === "layout" || parsed.kind === "overrides") {
-      const prefix = parsed.routeSegments.join("/");
-      const prev = layoutsByPrefix.get(prefix) ?? [];
-      layoutsByPrefix.set(prefix, [...prev, ...files]);
-    } else if (parsed.kind === "page") {
-      pagesBySegments.push({
-        key,
-        pattern: parsed.pattern,
-        segments: parsed.routeSegments,
-        files,
-        includeOwnLayout: parsed.leaf === "_index"
-      });
-    }
-  }
-  assertUniqueRoutePatterns(pagesBySegments);
-  const rootLayouts = layoutsByPrefix.get("") ?? [];
-  const globalLayoutFiles = rootLayouts;
-  const seedEntries = [];
-  for (const { pattern, segments, files, includeOwnLayout } of pagesBySegments) {
-    const layouts = [];
-    const maxPrefixLength = includeOwnLayout ? segments.length : Math.max(segments.length - 1, 0);
-    for (let i = 0;i <= maxPrefixLength; i++) {
-      const prefix = segments.slice(0, i).join("/");
-      const layoutFiles = layoutsByPrefix.get(prefix);
-      if (layoutFiles)
-        layouts.push(...layoutFiles);
-    }
-    const seeds = Array.from(new Set([...layouts, ...files]));
-    const routeId = pattern || "/";
-    seedEntries.push({ routeId, pattern: routeId, seeds });
-  }
-  seedEntries.sort((a, b) => compareRouteSpecificity(a.pattern, b.pattern));
-  return { entries: seedEntries, globalLayoutFiles };
-}
-var ROUTE_SEED_INDEX_JSON = "route-seed-index.json";
-function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
-  const normalizedArtifactDir = path8.resolve(artifactDir);
-  if (options.production) {
-    return {
-      entries: index.entries.map((entry) => ({ routeId: entry.routeId }))
-    };
-  }
-  return {
-    entries: index.entries.map((entry) => ({
-      ...entry,
-      seeds: entry.seeds.map((seed) => serializeArtifactPath(seed, normalizedArtifactDir))
-    })),
-    globalLayoutFiles: index.globalLayoutFiles.map((file) => serializeArtifactPath(file, normalizedArtifactDir))
-  };
-}
-async function saveRouteSeedIndex(artifactDir, index, options = {}) {
-  const absPath = path8.join(path8.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
-  await Bun.write(absPath, `${JSON.stringify(serializeRouteSeedIndexForArtifact(index, artifactDir, options), null, 2)}
-`);
-  return absPath;
-}
-function serializeArtifactPath(artifactPath, artifactDir) {
-  if (!path8.isAbsolute(artifactPath))
-    return artifactPath;
-  return path8.relative(artifactDir, artifactPath).split(path8.sep).join("/");
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/routesManifestArtifactSerializer.ts
-import path9 from "path";
-
-class RoutesManifestArtifactSerializer {
-  #manifest;
-  #artifactDir;
-  #production;
-  constructor(manifest, artifactDir, options = {}) {
-    this.#manifest = manifest;
-    this.#artifactDir = path9.resolve(artifactDir);
-    this.#production = options.production ?? false;
-  }
-  static serialize(manifest, artifactDir, options = {}) {
-    return new RoutesManifestArtifactSerializer(manifest, artifactDir, options).serialize();
-  }
-  serialize() {
-    const serialized = {
-      ...this.#manifest,
-      knownEntries: this.#manifest.knownEntries.map((entry) => this.#serializeArtifactPath(entry))
-    };
-    if (this.#production)
-      delete serialized.knownEntries;
-    return {
-      ...serialized,
-      clientManifest: Object.fromEntries(Object.entries(this.#manifest.clientManifest).map(([key, row]) => [this.#serializeArtifactPath(key), row])),
-      ssrManifest: {
-        ...this.#manifest.ssrManifest,
-        moduleMap: Object.fromEntries(Object.entries(this.#manifest.ssrManifest.moduleMap).map(([entryUrl, byName]) => [
-          entryUrl,
-          Object.fromEntries(Object.entries(byName).map(([name, entry]) => [
-            name,
-            {
-              ...entry,
-              id: this.#serializeArtifactPath(entry.id),
-              chunks: entry.chunks.map((chunk) => this.#serializeArtifactPath(chunk))
-            }
-          ]))
-        ]))
-      }
-    };
-  }
-  #serializeArtifactPath(artifactPath) {
-    if (!path9.isAbsolute(artifactPath))
-      return artifactPath;
-    return path9.relative(this.#artifactDir, artifactPath).split(path9.sep).join("/");
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
-class AllRoutesBuilder {
-  #app;
-  #artifact;
-  #command;
-  #artifactDir;
-  #merged = {
-    clientManifest: {},
-    ssrManifest: { moduleLoading: null, moduleMap: {} },
-    knownEntries: []
-  };
-  #knownSet = new Set;
-  #routeIds = [];
-  #discovery = null;
-  constructor(app, artifact, command = "start") {
-    this.#app = app;
-    this.#artifact = artifact;
-    this.#command = command;
-    this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
-  }
-  async build() {
-    const pageKeys = await this.#app.getPageKeys();
-    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
-    const seedIndex = computeRouteSeedIndex(pageEntries);
-    this.#app.verbose(`[build-all] discovered ${seedIndex.entries.length} routes`);
-    this.#discovery = await GraphClientEntryDiscovery.create(this.#app);
-    for (const entry of seedIndex.entries) {
-      const seeds = Array.from(new Set([...seedIndex.globalLayoutFiles, ...entry.seeds]));
-      const delta = await this.#buildRoute(entry.routeId, seeds);
-      this.#mergeRoute(entry.routeId, delta);
-    }
-    this.#merged.knownEntries = Array.from(this.#knownSet);
-    const manifest = {
-      routeIds: this.#routeIds,
-      ...this.#merged
-    };
-    const manifestPath = path10.join(path10.resolve(this.#artifactDir), "routes-manifest.json");
-    await Bun.write(manifestPath, `${JSON.stringify(RoutesManifestArtifactSerializer.serialize(manifest, this.#artifactDir, {
-      production: this.#command === "build"
-    }), null, 2)}
-`);
-    this.#app.verbose(`[build-all] wrote ${manifestPath} routes=${this.#routeIds.length} entries=${this.#merged.knownEntries.length}`);
-    return { manifest, manifestPath, seedIndex };
-  }
-  async#buildRoute(routeId, seeds) {
-    if (!this.#discovery)
-      throw new Error("[build-all] client entry discovery is not initialized");
-    const started = Date.now();
-    const delta = await new RouteClientBuilder({
-      app: this.#app,
-      routeId,
-      seeds,
-      artifact: this.#artifact,
-      knownEntries: this.#knownSet,
-      discovery: this.#discovery,
-      command: this.#command
-    }).build();
-    this.#app.verbose(`[build-all] ${routeId} +${delta.newEntries.length} entries (${Date.now() - started}ms)`);
-    return delta;
-  }
-  #mergeRoute(routeId, delta) {
-    for (const [key, row] of Object.entries(delta.manifestDelta))
-      this.#merged.clientManifest[key] = row;
-    for (const [url, byName] of Object.entries(delta.ssrManifestDelta.moduleMap)) {
-      this.#merged.ssrManifest.moduleMap[url] = byName;
-    }
-    for (const abs of delta.newEntries)
-      this.#knownSet.add(abs);
-    this.#routeIds.push(routeId);
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/autoImportSync.ts
-import { readdir, readFile, stat, writeFile } from "fs/promises";
-import path11 from "path";
-import ts2 from "typescript";
-var TEST_FILE_RE = /\.(test|spec)\.(ts|tsx)$/;
-var AKAN_BASE = {
-  names: ["Int", "Float", "ID", "Any", "Upload", "enumOf", "dayjs"],
-  specifier: "akanjs/base",
-  kind: "named"
-};
-var AKAN_BASE_TYPES = { names: ["Dayjs"], specifier: "akanjs/base", kind: "named", typeOnly: true };
-var CNST_NS = { names: ["cnst"], specifier: "../cnst", kind: "namespace" };
-var DB_NS = { names: ["db"], specifier: "../db", kind: "namespace" };
-var SRV_NS = { names: ["srv"], specifier: "../srv", kind: "namespace" };
-var ERR_DICT = { names: ["Err"], specifier: "../dict", kind: "named" };
-var RULES = {
-  constant: [AKAN_BASE, AKAN_BASE_TYPES, { names: ["via"], specifier: "akanjs/constant", kind: "named" }],
-  document: [
-    AKAN_BASE,
-    AKAN_BASE_TYPES,
-    CNST_NS,
-    DB_NS,
-    ERR_DICT,
-    {
-      names: ["by", "from", "into", "SchemaOf", "DataInputOf", "DocumentUpdateHelper", "documentQueryHelper", "Mdl"],
-      specifier: "akanjs/document",
-      kind: "named"
-    }
-  ],
-  service: [
-    AKAN_BASE,
-    AKAN_BASE_TYPES,
-    DB_NS,
-    SRV_NS,
-    CNST_NS,
-    ERR_DICT,
-    { names: ["serve"], specifier: "akanjs/service", kind: "named" },
-    {
-      names: ["DataInputOf", "ListQueryOption", "DatabaseRegistry", "getFilterInfoByKey"],
-      specifier: "akanjs/document",
-      kind: "named"
-    }
-  ],
-  signal: [
-    AKAN_BASE,
-    AKAN_BASE_TYPES,
-    SRV_NS,
-    CNST_NS,
-    ERR_DICT,
-    {
-      names: ["endpoint", "internal", "slice", "Public", "Req", "Ws", "None", "Res"],
-      specifier: "akanjs/signal",
-      kind: "named"
-    }
-  ],
-  dictionary: [
-    {
-      names: ["modelDictionary", "scalarDictionary", "serviceDictionary"],
-      specifier: "akanjs/dictionary",
-      kind: "named"
-    }
-  ],
-  srvkit: [
-    AKAN_BASE,
-    AKAN_BASE_TYPES,
-    { names: ["Logger", "HttpClient", "sleep"], specifier: "akanjs/common", kind: "named" },
-    { names: ["adapt"], specifier: "akanjs/service", kind: "named" },
-    { names: ["SignalContext", "Guard", "InternalArg", "Middleware"], specifier: "akanjs/signal", kind: "named" }
-  ],
-  common: [AKAN_BASE, AKAN_BASE_TYPES],
-  store: [
-    CNST_NS,
-    { names: ["store"], specifier: "akanjs/store", kind: "named" },
-    { names: ["fetch", "usePage", "sig"], specifier: "../useClient", kind: "named" },
-    { names: ["st"], specifier: "../st", kind: "named" },
-    { names: ["RootStore"], specifier: "../st", kind: "named", typeOnly: true }
-  ],
-  client: [
-    {
-      names: ["cnst", "fetch", "st", "usePage"],
-      specifier: (ctx) => `@${ctx.scope}/${ctx.project}/client`,
-      kind: "named"
-    }
-  ]
-};
-var PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9]*$/;
-var DOMAIN_ROLE_KINDS = {
-  constant: ["constant"],
-  dictionary: ["constant", "document", "signal"],
-  common: ["constant"]
-};
-var LIB_BARRELS = {
-  Err: { barrel: "dict", kind: "named" },
-  db: { barrel: "db", kind: "namespace" },
-  cnst: { barrel: "cnst", kind: "namespace" },
-  srv: { barrel: "srv", kind: "namespace" }
-};
-var DOMAIN_DENYLIST = new Set([
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "Date",
-  "Promise",
-  "Array",
-  "Object",
-  "Error",
-  "TypeError",
-  "RangeError",
-  "RegExp",
-  "Symbol",
-  "Proxy",
-  "Reflect",
-  "JSON",
-  "Math",
-  "Number",
-  "BigInt",
-  "Function",
-  "Boolean",
-  "String",
-  "Record",
-  "Partial",
-  "Required",
-  "Readonly",
-  "Pick",
-  "Omit",
-  "Exclude",
-  "Extract",
-  "NonNullable",
-  "ReturnType",
-  "Parameters",
-  "Awaited",
-  "InstanceType"
-]);
-
-class AutoImportSync {
-  #workspaceRoot;
-  #domainCache = new Map;
-  constructor({ workspaceRoot }) {
-    this.#workspaceRoot = path11.resolve(workspaceRoot);
-  }
-  async syncForBatch(files) {
-    const changedFiles = [];
-    const errors = [];
-    const seen = new Set;
-    for (const file of files) {
-      const pkgRoot = this.#domainPkgRootOf(file);
-      if (pkgRoot)
-        this.#domainCache.delete(pkgRoot);
-    }
-    for (const file of files) {
-      const abs = path11.resolve(file);
-      if (seen.has(abs))
-        continue;
-      seen.add(abs);
-      const ctx = this.#contextFor(abs);
-      if (!ctx)
-        continue;
-      try {
-        const changed = await this.#syncFile(abs, ctx);
-        if (changed)
-          changedFiles.push(abs);
-      } catch (err) {
-        errors.push(`[auto-import] sync failed for ${file}: ${formatError(err)}`);
-      }
-    }
-    return { changedFiles, errors };
-  }
-  #contextFor(abs) {
-    const rel = path11.relative(this.#workspaceRoot, abs);
-    if (rel.startsWith("..") || path11.isAbsolute(rel))
-      return null;
-    const base = path11.basename(abs);
-    if (TEST_FILE_RE.test(base) || base === "index.ts" || base === "index.tsx" || base.endsWith(".d.ts"))
-      return null;
-    const parts = rel.split(path11.sep).filter(Boolean);
-    const [scope, project, facet] = parts;
-    if (scope !== "apps" && scope !== "libs" || !project || !facet)
-      return null;
-    const role = roleFor(facet, base);
-    if (!role)
-      return null;
-    return { role, scope, project };
-  }
-  async#syncFile(abs, ctx) {
-    const stats = await stat(abs).catch(() => null);
-    if (!stats?.isFile())
-      return false;
-    const source = await readFile(abs, "utf8");
-    const resolveExtra = await this.#extraResolverFor(abs, ctx);
-    const next = transformSource(source, abs, ctx, resolveExtra);
-    if (next === null || next === source)
-      return false;
-    await writeFile(abs, next);
-    return true;
-  }
-  async#extraResolverFor(abs, ctx) {
-    const resolvers = [];
-    if (ctx.role === "srvkit" || ctx.role === "common")
-      resolvers.push(await this.#libBarrelResolver(abs, ctx));
-    const kinds = DOMAIN_ROLE_KINDS[ctx.role];
-    if (kinds)
-      resolvers.push(await this.#domainResolver(abs, ctx, kinds));
-    if (resolvers.length === 0)
-      return;
-    return (symbol) => {
-      for (const resolve of resolvers) {
-        const target = resolve(symbol);
-        if (target)
-          return target;
-      }
-      return null;
-    };
-  }
-  async#domainResolver(abs, ctx, kinds) {
-    const index = await this.#domainIndex(path11.join(this.#workspaceRoot, ctx.scope, ctx.project));
-    const fileDir = path11.dirname(abs);
-    return (symbol) => {
-      if (!PASCAL_CASE_RE.test(symbol) || DOMAIN_DENYLIST.has(symbol))
-        return null;
-      const entries = (index.get(symbol) ?? []).filter((entry) => kinds.includes(entry.kind));
-      if (entries.length !== 1)
-        return null;
-      return { specifier: relativeSpecifier(fileDir, entries[0].file), kind: "named" };
-    };
-  }
-  async#libBarrelResolver(abs, ctx) {
-    const fileDir = path11.dirname(abs);
-    const libDir = path11.join(this.#workspaceRoot, ctx.scope, ctx.project, "lib");
-    const available = new Map;
-    for (const [symbol, { barrel, kind }] of Object.entries(LIB_BARRELS)) {
-      if (await fileExists(path11.join(libDir, `${barrel}.ts`)))
-        available.set(symbol, { specifier: relativeSpecifier(fileDir, path11.join(libDir, barrel)), kind });
-    }
-    return (symbol) => available.get(symbol) ?? null;
-  }
-  async#domainIndex(pkgRoot) {
-    const cached = this.#domainCache.get(pkgRoot);
-    if (cached)
-      return cached;
-    const index = await buildDomainIndex(path11.join(pkgRoot, "lib"));
-    this.#domainCache.set(pkgRoot, index);
-    return index;
-  }
-  #domainPkgRootOf(file) {
-    const rel = path11.relative(this.#workspaceRoot, path11.resolve(file));
-    if (rel.startsWith("..") || path11.isAbsolute(rel))
-      return null;
-    const [scope, project, facet] = rel.split(path11.sep).filter(Boolean);
-    if (scope !== "apps" && scope !== "libs" || !project || facet !== "lib")
-      return null;
-    if (!domainKindOf(path11.basename(file)))
-      return null;
-    return path11.join(this.#workspaceRoot, scope, project);
-  }
-}
-var roleFor = (facet, base) => {
-  if (facet === "lib") {
-    if (base.endsWith(".constant.ts"))
-      return "constant";
-    if (base.endsWith(".document.ts"))
-      return "document";
-    if (base.endsWith(".service.ts"))
-      return "service";
-    if (base.endsWith(".signal.ts"))
-      return "signal";
-    if (base.endsWith(".dictionary.ts"))
-      return "dictionary";
-    if (base.endsWith(".store.ts"))
-      return "store";
-    if (base.endsWith(".tsx"))
-      return "client";
-    return null;
-  }
-  if (facet === "ui" || facet === "page")
-    return base.endsWith(".tsx") ? "client" : null;
-  if (facet === "webkit")
-    return base.endsWith(".ts") || base.endsWith(".tsx") ? "client" : null;
-  if (facet === "srvkit")
-    return base.endsWith(".ts") ? "srvkit" : null;
-  if (facet === "common")
-    return base.endsWith(".ts") || base.endsWith(".tsx") ? "common" : null;
-  return null;
-};
-var targetFor = (symbol, ctx) => {
-  for (const rule of RULES[ctx.role]) {
-    if (!rule.names.includes(symbol))
-      continue;
-    const specifier = typeof rule.specifier === "function" ? rule.specifier(ctx) : rule.specifier;
-    return { specifier, kind: rule.kind, typeOnly: rule.typeOnly };
-  }
-  return null;
-};
-var transformSource = (source, fileName, ctx, resolveExtra) => {
-  const sf = ts2.createSourceFile(fileName, source, ts2.ScriptTarget.Latest, true, scriptKindFor(fileName));
-  const bound = collectBoundNames(sf);
-  const used = collectUsedReferences(sf);
-  const namedBySpecifier = new Map;
-  const namespaceImports = [];
-  for (const name of used) {
-    if (bound.has(name))
-      continue;
-    const target = targetFor(name, ctx) ?? resolveExtra?.(name) ?? null;
-    if (!target)
-      continue;
-    if (target.kind === "namespace")
-      namespaceImports.push({ name, specifier: target.specifier });
-    else {
-      const names = namedBySpecifier.get(target.specifier) ?? new Map;
-      names.set(name, target.typeOnly ?? false);
-      namedBySpecifier.set(target.specifier, names);
-    }
-  }
-  if (namedBySpecifier.size === 0 && namespaceImports.length === 0)
-    return null;
-  const importDecls = sf.statements.filter(ts2.isImportDeclaration);
-  const anchor = importDecls.at(-1) ?? null;
-  const namedImportsBySpecifier = collectExistingNamedImports(importDecls);
-  const edits = [];
-  const newStatements = [];
-  for (const [specifier, names] of namedBySpecifier) {
-    const existing = namedImportsBySpecifier.get(specifier);
-    if (existing) {
-      const merged = new Map(existing.names);
-      for (const [name, isType] of names)
-        if (!merged.has(name))
-          merged.set(name, isType);
-      edits.push({
-        start: existing.decl.getStart(sf),
-        end: existing.decl.getEnd(),
-        text: formatNamedImport(specifier, merged)
-      });
-    } else
-      newStatements.push(formatNamedImport(specifier, names));
-  }
-  for (const ns of namespaceImports)
-    newStatements.push(`import * as ${ns.name} from "${ns.specifier}";`);
-  if (newStatements.length > 0) {
-    const anchorEdit = anchor ? edits.find((edit) => edit.start === anchor.getStart(sf)) : undefined;
-    if (anchorEdit)
-      anchorEdit.text = `${anchorEdit.text}
-${newStatements.join(`
-`)}`;
-    else if (anchor)
-      edits.push({ start: anchor.getEnd(), end: anchor.getEnd(), text: `
-${newStatements.join(`
-`)}` });
-    else {
-      const prologueEnd = directivePrologueEnd(sf);
-      if (prologueEnd >= 0)
-        edits.push({ start: prologueEnd, end: prologueEnd, text: `
-${newStatements.join(`
-`)}` });
-      else
-        edits.push({ start: 0, end: 0, text: `${newStatements.join(`
-`)}
-
-` });
-    }
-  }
-  if (edits.length === 0)
-    return null;
-  edits.sort((a, b) => b.start - a.start);
-  let out = source;
-  for (const edit of edits)
-    out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
-  return out === source ? null : out;
-};
-var collectBoundNames = (sf) => {
-  const names = new Set;
-  const visit = (node) => {
-    if (ts2.isImportClause(node)) {
-      if (node.name)
-        names.add(node.name.text);
-      const bindings = node.namedBindings;
-      if (bindings && ts2.isNamespaceImport(bindings))
-        names.add(bindings.name.text);
-      if (bindings && ts2.isNamedImports(bindings))
-        for (const el of bindings.elements)
-          names.add(el.name.text);
-    }
-    if ((ts2.isVariableDeclaration(node) || ts2.isFunctionDeclaration(node) || ts2.isClassDeclaration(node) || ts2.isParameter(node) || ts2.isBindingElement(node) || ts2.isEnumDeclaration(node) || ts2.isTypeAliasDeclaration(node) || ts2.isInterfaceDeclaration(node)) && node.name && ts2.isIdentifier(node.name))
-      names.add(node.name.text);
-    ts2.forEachChild(node, visit);
-  };
-  ts2.forEachChild(sf, visit);
-  return names;
-};
-var collectUsedReferences = (sf) => {
-  const used = new Set;
-  const visit = (node) => {
-    if (ts2.isIdentifier(node) && isReferencePosition(node))
-      used.add(node.text);
-    ts2.forEachChild(node, visit);
-  };
-  ts2.forEachChild(sf, visit);
-  return used;
-};
-var isReferencePosition = (node) => {
-  const parent = node.parent;
-  if (!parent)
-    return true;
-  if (ts2.isPropertyAccessExpression(parent) && parent.name === node)
-    return false;
-  if (ts2.isQualifiedName(parent) && parent.right === node)
-    return false;
-  if (ts2.isPropertyAssignment(parent) && parent.name === node)
-    return false;
-  if (ts2.isPropertySignature(parent) && parent.name === node)
-    return false;
-  if (ts2.isBindingElement(parent) && parent.propertyName === node)
-    return false;
-  if (ts2.isImportSpecifier(parent) || ts2.isExportSpecifier(parent))
-    return false;
-  return true;
-};
-var collectExistingNamedImports = (importDecls) => {
-  const map = new Map;
-  for (const decl of importDecls) {
-    const clause = decl.importClause;
-    const bindings = clause?.namedBindings;
-    if (!clause || !bindings || !ts2.isNamedImports(bindings))
-      continue;
-    if (!ts2.isStringLiteral(decl.moduleSpecifier))
-      continue;
-    const specifier = decl.moduleSpecifier.text;
-    if (map.has(specifier))
-      continue;
-    const names = new Map;
-    for (const el of bindings.elements)
-      names.set(el.name.text, clause.isTypeOnly || el.isTypeOnly);
-    map.set(specifier, { decl, names });
-  }
-  return map;
-};
-var formatNamedImport = (specifier, names) => {
-  const entries = [...names.entries()].sort((a, b) => compareNames(a[0], b[0]));
-  if (entries.every(([, isType]) => isType))
-    return `import type { ${entries.map(([name]) => name).join(", ")} } from "${specifier}";`;
-  const parts = entries.map(([name, isType]) => isType ? `type ${name}` : name);
-  return `import { ${parts.join(", ")} } from "${specifier}";`;
-};
-var directivePrologueEnd = (sf) => {
-  let end = -1;
-  for (const stmt of sf.statements) {
-    if (ts2.isExpressionStatement(stmt) && ts2.isStringLiteral(stmt.expression))
-      end = stmt.getEnd();
-    else
-      break;
-  }
-  return end;
-};
-var scriptKindFor = (fileName) => fileName.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS;
-var compareNames = (a, b) => {
-  const [la, lb] = [a.toLowerCase(), b.toLowerCase()];
-  if (la !== lb)
-    return la < lb ? -1 : 1;
-  return a < b ? -1 : a > b ? 1 : 0;
-};
-var formatError = (err) => err instanceof Error ? err.message : String(err);
-var fileExists = async (file) => stat(file).then((s) => s.isFile()).catch(() => false);
-var domainKindOf = (base) => {
-  if (base.endsWith(".constant.ts"))
-    return "constant";
-  if (base.endsWith(".document.ts"))
-    return "document";
-  if (base.endsWith(".signal.ts"))
-    return "signal";
-  return null;
-};
-var buildDomainIndex = async (libDir) => {
-  const index = new Map;
-  for (const file of await collectDomainFiles(libDir)) {
-    const kind = domainKindOf(path11.basename(file));
-    if (!kind)
-      continue;
-    const src = await readFile(file, "utf8").catch(() => null);
-    if (src === null)
-      continue;
-    for (const name of exportedPascalNames(src, file)) {
-      const entries = index.get(name) ?? [];
-      entries.push({ file, kind });
-      index.set(name, entries);
-    }
-  }
-  return index;
-};
-var collectDomainFiles = async (dir) => {
-  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
-  const files = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") || entry.name === "node_modules")
-      continue;
-    const full = path11.join(dir, entry.name);
-    if (entry.isDirectory())
-      files.push(...await collectDomainFiles(full));
-    else if (domainKindOf(entry.name) && !TEST_FILE_RE.test(entry.name))
-      files.push(full);
-  }
-  return files;
-};
-var exportedPascalNames = (source, fileName) => {
-  const sf = ts2.createSourceFile(fileName, source, ts2.ScriptTarget.Latest, true);
-  const isExported = (node) => ts2.canHaveModifiers(node) && (ts2.getModifiers(node) ?? []).some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
-  const names = [];
-  for (const stmt of sf.statements) {
-    if ((ts2.isClassDeclaration(stmt) || ts2.isFunctionDeclaration(stmt) || ts2.isEnumDeclaration(stmt)) && stmt.name) {
-      if (isExported(stmt))
-        names.push(stmt.name.text);
-    } else if (ts2.isVariableStatement(stmt) && isExported(stmt)) {
-      for (const decl of stmt.declarationList.declarations)
-        if (ts2.isIdentifier(decl.name))
-          names.push(decl.name.text);
-    } else if (ts2.isExportDeclaration(stmt) && stmt.exportClause && ts2.isNamedExports(stmt.exportClause)) {
-      for (const el of stmt.exportClause.elements)
-        names.push(el.name.text);
-    }
-  }
-  return names.filter((name) => PASCAL_CASE_RE.test(name));
-};
-var relativeSpecifier = (fromDir, toFile) => {
-  const rel = path11.relative(fromDir, toFile).replace(/\.tsx?$/, "").split(path11.sep).join("/");
-  return rel.startsWith(".") ? rel : `./${rel}`;
-};
-
-// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
-import { mkdir as mkdir3, rm, unlink } from "fs/promises";
-import path13 from "path";
-
-// pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
-import fs2 from "fs";
-import path12 from "path";
-import ts3 from "typescript";
-
-class PagesEntrySourceGenerator {
-  #pageEntries;
-  constructor(pageEntries) {
-    this.#pageEntries = pageEntries;
-  }
-  static generate(pageEntries) {
-    return new PagesEntrySourceGenerator(pageEntries).generate();
-  }
-  generate() {
-    const lines = this.#pageEntries.map(({ key, moduleAbsPath }) => {
-      const specifier = PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
-      return `  ${JSON.stringify(key)}: () => import(${JSON.stringify(specifier)}),`;
-    });
-    return `export const pages = {
-${lines.join(`
-`)}
-};
-`;
-  }
-  static generateStatic(pageEntries) {
-    return new PagesEntrySourceGenerator(pageEntries).generateStatic();
-  }
-  generateStatic() {
-    const imports = this.#pageEntries.map(({ moduleAbsPath }, index) => {
-      const specifier = PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
-      return `import * as page${index} from ${JSON.stringify(specifier)};`;
-    });
-    const entries = this.#pageEntries.map(({ key, moduleAbsPath }, index) => {
-      const isAsyncDefault = PagesEntrySourceGenerator.#hasAsyncDefaultExport(moduleAbsPath);
-      return `  ${JSON.stringify(key)}: { loader: async () => page${index}, isAsyncDefault: ${isAsyncDefault} },`;
-    });
-    return `${imports.join(`
-`)}
-export const pages = {
-${entries.join(`
-`)}
-};
-`;
-  }
-  static #toImportSpecifier(moduleAbsPath) {
-    return path12.resolve(moduleAbsPath).split(path12.sep).join("/");
-  }
-  static #hasAsyncDefaultExport(moduleAbsPath) {
-    try {
-      const source = fs2.readFileSync(path12.resolve(moduleAbsPath), "utf8");
-      const sourceFile = ts3.createSourceFile(moduleAbsPath, source, ts3.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
-      return PagesEntrySourceGenerator.#sourceFileHasAsyncDefaultExport(sourceFile);
-    } catch {
-      return false;
-    }
-  }
-  static #sourceFileHasAsyncDefaultExport(sourceFile) {
-    const asyncBindings = new Map;
-    let defaultIdentifier = null;
-    for (const statement of sourceFile.statements) {
-      if (ts3.isFunctionDeclaration(statement)) {
-        if (PagesEntrySourceGenerator.#hasModifier(statement, ts3.SyntaxKind.DefaultKeyword)) {
-          return PagesEntrySourceGenerator.#hasModifier(statement, ts3.SyntaxKind.AsyncKeyword);
-        }
-        if (statement.name) {
-          asyncBindings.set(statement.name.text, PagesEntrySourceGenerator.#hasModifier(statement, ts3.SyntaxKind.AsyncKeyword));
-        }
-        continue;
-      }
-      if (ts3.isVariableStatement(statement)) {
-        for (const declaration of statement.declarationList.declarations) {
-          if (!ts3.isIdentifier(declaration.name))
-            continue;
-          asyncBindings.set(declaration.name.text, PagesEntrySourceGenerator.#isAsyncFunctionExpression(declaration.initializer));
-        }
-        continue;
-      }
-      if (ts3.isExportAssignment(statement)) {
-        if (PagesEntrySourceGenerator.#isAsyncFunctionExpression(statement.expression))
-          return true;
-        if (ts3.isIdentifier(statement.expression))
-          defaultIdentifier = statement.expression.text;
-        continue;
-      }
-      if (ts3.isExportDeclaration(statement) && statement.exportClause && ts3.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;
-  }
-  static #hasModifier(node, kind) {
-    return ts3.canHaveModifiers(node) && (ts3.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
-  }
-  static #isAsyncFunctionExpression(node) {
-    return Boolean(node && (ts3.isArrowFunction(node) || ts3.isFunctionExpression(node)) && PagesEntrySourceGenerator.#hasModifier(node, ts3.SyntaxKind.AsyncKeyword));
-  }
-  static #scriptKind(moduleAbsPath) {
-    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS;
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
-class CsrArtifactBuilder {
-  #app;
-  #command;
-  #lang;
-  constructor(app, command = "start", lang = "en") {
-    this.#app = app;
-    this.#command = command;
-    this.#lang = lang;
-  }
-  async build() {
-    const pageKeys = await this.#app.getPageKeys();
-    if (pageKeys.length === 0) {
-      this.#app.log(`[cli] no route files under ${this.#app.cwdPath}/page \u2014 skipping CSR build`);
-      return null;
-    }
-    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
-    const akanConfig = await this.#app.getConfig();
-    const artifact = await this.#loadCsrArtifact();
-    const csrBasePaths = [...akanConfig.basePaths];
-    const htmlEntries = csrBasePaths.length > 0 ? csrBasePaths : ["index"];
-    await rm(this.#outputDir, { recursive: true, force: true });
-    await mkdir3(path13.join(this.#app.cwdPath, ".akan/generated/csr"), { recursive: true });
-    const generatedHtmlFiles = Object.fromEntries(htmlEntries.map((basePath) => this.#createHtmlFile(basePath)));
-    const result = await Bun.build({
-      target: "browser",
-      entrypoints: Object.keys(generatedHtmlFiles),
-      files: {
-        ...generatedHtmlFiles,
-        [`${this.#app.cwdPath}/.akan/generated/csr/csr.tsx`]: `
-import { bootCsr } from "akanjs/webkit";
-${PagesEntrySourceGenerator.generateStatic(pageEntries)}
-void bootCsr(pages);
-  `
-      },
-      root: `${this.#app.cwdPath}/.akan/generated/csr`,
-      outdir: this.#outputDir,
-      splitting: false,
-      minify: true,
-      env: "AKAN_PUBLIC_*",
-      define: this.#define(),
-      optimizeImports: akanConfig.optimizeImports
-    });
-    if (!result.success) {
-      const logs = result.logs.map((log) => log.message).join(`
-`);
-      throw new Error(`[csr-build] failed${logs ? `
-${logs}` : ""}`);
-    }
-    await this.#inlineCsrArtifacts(artifact.cssAssets ?? {});
-    this.#app.verbose(`[csr-build] output -> ${this.#outputDir}`);
-    return { outputDir: this.#outputDir };
-  }
-  get #outputDir() {
-    return path13.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
-  }
-  #define() {
-    const nodeEnv = this.#command === "build" ? "production" : "development";
-    return {
-      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
-      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("csr"),
-      ...Object.fromEntries(Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
-    };
-  }
-  #createHtmlFile(basePath) {
-    const filename = `${basePath}.html`;
-    return [
-      `${this.#app.cwdPath}/.akan/generated/csr/${filename}`,
-      `<!doctype html>
-<html lang="${this.#lang}">
-  <head>
-    <meta charset="utf-8" />
-    <title>${this.#app.name}</title>
-    <base href="/" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="./csr.tsx"></script>
-  </body>
-</html>
-  `
-    ];
-  }
-  async#loadCsrArtifact() {
-    const artifactDir = path13.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
-    const artifactFile = Bun.file(path13.join(artifactDir, "base-artifact.json"));
-    if (!await artifactFile.exists())
-      return { cssAssets: {} };
-    const artifact = await artifactFile.json();
-    return { cssAssets: artifact.cssAssets ?? {} };
-  }
-  async#inlineCsrArtifacts(cssAssets) {
-    const jsFiles = new Set;
-    const cssFiles = new Set;
-    for (const htmlPath of await this.#htmlOutputPaths()) {
-      const htmlFile = Bun.file(htmlPath);
-      if (!await htmlFile.exists())
-        continue;
-      const basePath = path13.basename(htmlPath, ".html") === "index" ? "" : path13.basename(htmlPath, ".html");
-      const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAssets[basePath]);
-      for (const filePath of inlined.jsFiles)
-        jsFiles.add(filePath);
-      for (const filePath of inlined.cssFiles)
-        cssFiles.add(filePath);
-      await Bun.write(htmlPath, inlined.html);
-    }
-    for (const filePath of jsFiles)
-      await unlink(filePath).catch(() => {
-        return;
-      });
-    for (const filePath of cssFiles)
-      await unlink(filePath).catch(() => {
-        return;
-      });
-    const remainingJs = await this.#listOutputFiles((filePath) => filePath.endsWith(".js"));
-    const remainingCss = await this.#listOutputFiles((filePath) => filePath.endsWith(".css"));
-    const remainingAssets = [...remainingJs, ...remainingCss];
-    if (remainingAssets.length > 0) {
-      throw new Error(`[csr-build] expected single-file HTML, but CSR assets remain:
-${remainingAssets.join(`
-`)}`);
-    }
-  }
-  async#inlineHtmlAssets(html, htmlPath, cssAsset) {
-    const jsFiles = [];
-    const cssFiles = CsrArtifactBuilder.collectStylesheetHrefs(html).map((href) => CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, href));
-    let next = CsrArtifactBuilder.stripBundledStylesheetLinks(html);
-    next = await CsrArtifactBuilder.replaceModuleScriptSrc(next, async (src) => {
-      const jsPath = CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, src);
-      jsFiles.push(jsPath);
-      return await Bun.file(jsPath).text();
-    });
-    const bundledCss = (await Promise.all(cssFiles.map((cssFile) => Bun.file(cssFile).text().catch(() => "")))).filter(Boolean).join(`
-`);
-    if (bundledCss) {
-      const style = CsrArtifactBuilder.createInlineStyle(bundledCss);
-      if (!next.includes(style))
-        next = CsrArtifactBuilder.injectBeforeHeadEnd(next, style);
-    }
-    if (cssAsset) {
-      const cssPath = path13.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact", cssAsset.cssRelPath);
-      const css = await Bun.file(cssPath).text();
-      const style = CsrArtifactBuilder.createInlineStyle(css);
-      if (!next.includes(style))
-        next = CsrArtifactBuilder.injectBeforeHeadEnd(next, style);
-    }
-    return { html: next, jsFiles, cssFiles };
-  }
-  async#htmlOutputPaths() {
-    return await this.#listOutputFiles((filePath) => filePath.endsWith(".html"));
-  }
-  async#listOutputFiles(predicate) {
-    const glob = new Bun.Glob("**/*");
-    const files = [];
-    for await (const filePath of glob.scan({ cwd: this.#outputDir, absolute: true })) {
-      if (predicate(filePath))
-        files.push(filePath);
-    }
-    return files.sort();
-  }
-  static injectBeforeHeadEnd(html, snippet) {
-    const matches = [...html.matchAll(/<\/head\s*>/gi)];
-    const bodyStart = html.search(/<body(?:\s|>)/i);
-    const headEnd = matches.filter((match) => match.index !== undefined && (bodyStart === -1 || match.index < bodyStart)).at(-1);
-    if (!headEnd || headEnd.index === undefined)
-      return `${snippet}
-${html}`;
-    return `${html.slice(0, headEnd.index)}${snippet}
-${html.slice(headEnd.index)}`;
-  }
-  static stripBundledStylesheetLinks(html) {
-    return html.replace(/<link\b(?=[^>]*\brel=["']stylesheet["'])[^>]*>\s*/gi, "");
-  }
-  static collectStylesheetHrefs(html) {
-    const linkRe = /<link\b(?=[^>]*\brel=["']stylesheet["'])(?=[^>]*\bhref=["']([^"']+)["'])[^>]*>/gi;
-    return [...html.matchAll(linkRe)].map((match) => match[1]).filter((href) => !!href);
-  }
-  static createInlineStyle(css) {
-    return `<style data-akan-css="active">
-${css.replace(/<\/style/gi, "<\\/style")}
-</style>`;
-  }
-  static async replaceModuleScriptSrc(html, loadScript) {
-    const scriptRe = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>\s*<\/script>/gi;
-    let result = "";
-    let lastIndex = 0;
-    let matched = false;
-    for (const match of html.matchAll(scriptRe)) {
-      const full = match[0];
-      const src = match[1];
-      if (match.index === undefined || !src)
-        continue;
-      matched = true;
-      result += html.slice(lastIndex, match.index);
-      result += `<script type="module">
-${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
-</script>`;
-      lastIndex = match.index + full.length;
-    }
-    if (!matched)
-      return html;
-    return result + html.slice(lastIndex);
-  }
-  static escapeInlineScript(source) {
-    return source.replace(/<\/script/gi, "<\\/script");
-  }
-  static resolveHtmlAssetPath(htmlPath, src) {
-    if (/^[a-z][a-z0-9+.-]*:/i.test(src) || src.startsWith("//")) {
-      throw new Error(`[csr-build] cannot inline external script: ${src}`);
-    }
-    const normalized = src.startsWith("/") ? src.slice(1) : src;
-    return path13.resolve(path13.dirname(htmlPath), normalized);
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
-import path15 from "path";
-import { Logger as Logger2 } from "akanjs/common";
-import { compile } from "tailwindcss";
-
-// pkgs/@akanjs/devkit/frontendBuild/cssImportResolver.ts
-import path14 from "path";
-var CSS_IMPORT_EXTS = ["", ".css", "/styles.css", "/index.css"];
-
-class CssImportResolver {
-  #workspaceRoot;
-  #paths;
-  #wildcardEntries;
-  constructor(workspaceRoot, paths = {}) {
-    this.#workspaceRoot = workspaceRoot;
-    this.#paths = paths;
-    this.#wildcardEntries = Object.entries(paths).filter(([key]) => key.endsWith("/*")).map(([key, replacements]) => ({ prefix: key.slice(0, -1), replacements })).sort((a, b) => b.prefix.length - a.prefix.length);
-  }
-  static async create(app) {
-    const tsconfig = await app.getTsConfig();
-    return new CssImportResolver(app.workspace.workspaceRoot, tsconfig.compilerOptions.paths ?? {});
-  }
-  async resolve(id, fromBase) {
-    for (const resolve of [
-      () => this.#resolveWithTsconfig(id),
-      () => this.#resolveWithBun(id, fromBase),
-      () => this.#resolveWithRequire(id, fromBase),
-      () => this.#resolvePackageStyle(id, fromBase)
-    ]) {
-      const resolved = await resolve();
-      if (resolved)
-        return resolved;
-    }
-    return null;
-  }
-  #resolveWithBun(id, fromBase) {
-    for (const base of this.#resolutionBases(fromBase)) {
-      try {
-        const resolved = Bun.resolveSync(id, base);
-        if (CssImportResolver.isCssFile(resolved))
-          return resolved;
-      } catch {}
-    }
-    return null;
-  }
-  #resolveWithRequire(id, fromBase) {
-    for (const base of this.#resolutionBases(fromBase)) {
-      try {
-        const resolved = __require.resolve(id, { paths: [base] });
-        if (CssImportResolver.isCssFile(resolved))
-          return resolved;
-      } catch {}
-    }
-    return null;
-  }
-  async#resolveWithTsconfig(id) {
-    const exact = this.#paths[id];
-    if (exact) {
-      for (const repl of exact) {
-        const resolved = await this.#firstExisting(path14.resolve(this.#workspaceRoot, repl));
-        if (resolved)
-          return resolved;
-      }
-    }
-    for (const { prefix, replacements } of this.#wildcardEntries) {
-      if (!id.startsWith(prefix))
-        continue;
-      const suffix = id.slice(prefix.length);
-      for (const repl of replacements) {
-        const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
-        const resolved = await this.#firstExisting(path14.resolve(this.#workspaceRoot, replPath + suffix));
-        if (resolved)
-          return resolved;
-      }
-    }
-    return null;
-  }
-  async#resolvePackageStyle(id, fromBase) {
-    const pkgName = CssImportResolver.getPackageName(id);
-    if (!pkgName)
-      return null;
-    for (const base of this.#resolutionBases(fromBase)) {
-      try {
-        const pkgPath = __require.resolve(`${pkgName}/package.json`, { paths: [base] });
-        const resolved = await this.#resolvePackageStyleFromPackageJson(id, pkgName, pkgPath);
-        if (resolved)
-          return resolved;
-      } catch {}
-    }
-    for (const pkgPath of this.#packageJsonCandidates(pkgName)) {
-      const resolved = await this.#resolvePackageStyleFromPackageJson(id, pkgName, pkgPath);
-      if (resolved)
-        return resolved;
-    }
-    return null;
-  }
-  async#resolvePackageStyleFromPackageJson(id, pkgName, pkgPath) {
-    try {
-      if (!await Bun.file(pkgPath).exists())
-        return null;
-      const pkgDir = path14.dirname(pkgPath);
-      const pkg = await Bun.file(pkgPath).json();
-      const subpath = id === pkgName ? "." : `.${id.slice(pkgName.length)}`;
-      const exportValue = pkg.exports?.[subpath];
-      const styleEntry = (typeof exportValue === "string" ? exportValue : exportValue?.style || exportValue?.import || exportValue?.default) || pkg.exports?.["."]?.style || pkg.style || "index.css";
-      return await this.#firstExisting(path14.resolve(pkgDir, styleEntry));
-    } catch {
-      return null;
-    }
-  }
-  #resolutionBases(fromBase) {
-    return [fromBase, this.#workspaceRoot, path14.dirname(Bun.main), path14.resolve(path14.dirname(Bun.main), "../..")];
-  }
-  #packageJsonCandidates(pkgName) {
-    return [
-      path14.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
-      path14.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
-      path14.join(path14.dirname(Bun.main), "node_modules", pkgName, "package.json"),
-      path14.join(path14.dirname(Bun.main), "../../", pkgName, "package.json")
-    ];
-  }
-  async#firstExisting(basePath) {
-    for (const suffix of CSS_IMPORT_EXTS) {
-      const candidate = `${basePath}${suffix}`;
-      if (await Bun.file(candidate).exists())
-        return candidate;
-    }
-    return null;
-  }
-  static getPackageName(id) {
-    const parts = id.split("/");
-    if (id.startsWith("@"))
-      return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
-    return parts[0] ?? null;
-  }
-  static isCssFile(filePath) {
-    return path14.extname(filePath) === ".css";
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
-var SOURCE_EXTS2 = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-var NON_SOURCE_EXT_RE2 = /\.(json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav)$/i;
-var NODE_MODULES_RE3 = /[\\/]node_modules[\\/]/;
-var AKANJS_NODE_MODULE_RE3 = /[\\/]node_modules[\\/]akanjs[\\/]/;
-
-class CssCompiler {
-  #logger = new Logger2("CssCompiler");
-  #transpiler = new Bun.Transpiler({ loader: "tsx" });
-  #app;
-  #cssImportResolver = null;
-  constructor(app) {
-    this.#app = app;
-  }
-  #cssText = null;
-  #cssTextByBasePath = null;
-  async getCss({ refresh } = {}) {
-    if (this.#cssText !== null && !refresh)
-      return this.#cssText;
-    const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh });
-    this.#cssText = await this.compileCss(cssPaths, sourcePaths);
-    return this.#cssText;
-  }
-  async getCssByBasePath({ refresh } = {}) {
-    if (this.#cssTextByBasePath !== null && !refresh)
-      return this.#cssTextByBasePath;
-    const akanConfig = await this.#app.getConfig({ refresh });
-    const pageKeys = await this.#app.getPageKeys({ refresh });
-    const basePaths = [...akanConfig.basePaths];
-    const rootPageKeys = pageKeys.filter((pageKey) => getPageKeyBasePath(pageKey, basePaths) === null);
-    const cssEntries = await Promise.all([
-      (async () => {
-        if (rootPageKeys.length === 0)
-          return ["", ""];
-        const started = Date.now();
-        const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh, pageKeys: rootPageKeys });
-        const css = await this.compileCss(cssPaths, sourcePaths);
-        this.#logger.verbose(`css base=root paths=${cssPaths.length} sources=${sourcePaths.length} in ${Date.now() - started}ms`);
-        return ["", css];
-      })(),
-      ...basePaths.map(async (basePath) => {
-        const basePathPageKeys = pageKeys.filter((pageKey) => getPageKeyBasePath(pageKey, basePaths) === basePath);
-        if (basePathPageKeys.length === 0)
-          return [basePath, ""];
-        const started = Date.now();
-        const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh, pageKeys: basePathPageKeys });
-        const css = await this.compileCss(cssPaths, sourcePaths);
-        this.#logger.verbose(`css base=${basePath} paths=${cssPaths.length} sources=${sourcePaths.length} in ${Date.now() - started}ms`);
-        return [basePath, css];
-      })
-    ]);
-    this.#cssTextByBasePath = Object.fromEntries(cssEntries);
-    return this.#cssTextByBasePath;
-  }
-  async discoverCss({ refresh } = {}) {
-    const { cssPaths } = await this.discoverCssAndSources({ refresh });
-    return cssPaths;
-  }
-  async discoverCssAndSources({
-    refresh,
-    pageKeys
-  } = {}) {
-    pageKeys ??= await this.#app.getPageKeys({ refresh });
-    const seeds = pageKeys.map((key) => path15.resolve(this.#app.cwdPath, "page", key));
-    const cssFiles = new Set;
-    const sourceFiles = new Set;
-    const queue = [...seeds];
-    const resolvePackage = await createTsconfigPackageResolver(this.#app);
-    const analyzer = new BarrelAnalyzer({ resolvePackage });
-    const akanConfig = await this.#app.getConfig({ refresh });
-    while (queue.length > 0) {
-      const filePath = queue.shift();
-      if (!filePath || sourceFiles.has(filePath) || isIgnoredNodeModuleSource(filePath))
-        continue;
-      sourceFiles.add(filePath);
-      let content;
-      try {
-        content = await Bun.file(filePath).text();
-      } catch {
-        continue;
-      }
-      let source = content;
-      if (akanConfig.barrelImports.length > 0) {
-        try {
-          const rewritten = await rewriteBarrelImports(content, akanConfig.barrelImports, analyzer);
-          if (rewritten !== null)
-            source = rewritten;
-        } catch {}
-      }
-      let imports;
-      try {
-        imports = this.#transpiler.scanImports(source);
-      } catch {
-        continue;
-      }
-      const importerDir = path15.dirname(filePath);
-      for (const imp of imports) {
-        const spec = imp.path;
-        if (!spec)
-          continue;
-        if (spec.endsWith(".css")) {
-          const cssPath = await this.#resolveCssImport(spec, importerDir);
-          cssFiles.add(cssPath);
-          continue;
-        }
-        if (NON_SOURCE_EXT_RE2.test(spec))
-          continue;
-        const resolved = await this.#resolveSourceImport(spec, importerDir, resolvePackage);
-        if (!resolved || sourceFiles.has(resolved) || isIgnoredNodeModuleSource(resolved))
-          continue;
-        queue.push(resolved);
-      }
-    }
-    return { cssPaths: [...cssFiles], sourcePaths: [...sourceFiles] };
-  }
-  async compileCss(cssPaths, sourcePaths) {
-    if (cssPaths.length === 0)
-      return "";
-    const compileStarted = Date.now();
-    const compilers = await Promise.all(cssPaths.map(async (cssPath) => {
-      const css = await Bun.file(cssPath).text();
-      const base = path15.dirname(cssPath);
-      const compiler = await compile(css, {
-        base,
-        loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase),
-        loadModule: (id, fromBase) => this.#loadModule(id, fromBase)
-      });
-      return { cssPath, compiler };
-    }));
-    const sourceDirs = new Set;
-    for (const entry of compilers) {
-      if (!entry)
-        continue;
-      for (const s of entry.compiler.sources)
-        sourceDirs.add(s.base);
-    }
-    const scanStarted = Date.now();
-    const candidates = await this.#scanCandidates(sourcePaths, [...sourceDirs]);
-    this.#logger.verbose(`css candidates scanned count=${candidates.length} sources=${sourcePaths.length} dirs=${sourceDirs.size} in ${Date.now() - scanStarted}ms`);
-    const parts = [];
-    for (const entry of compilers) {
-      if (!entry)
-        continue;
-      parts.push(entry.compiler.build(candidates));
-    }
-    this.#logger.verbose(`css compiled paths=${cssPaths.length} candidates=${candidates.length} in ${Date.now() - compileStarted}ms`);
-    return parts.join(`
-`);
-  }
-  async#loadStylesheet(id, fromBase) {
-    const p = await this.#resolveCssImport(id, fromBase);
-    const content = await Bun.file(p).text();
-    return { path: p, base: path15.dirname(p), content };
-  }
-  async#resolveCssImport(id, fromBase) {
-    if (id.startsWith(".") || id.startsWith("/"))
-      return path15.resolve(fromBase, id);
-    const resolver = await this.#getCssImportResolver();
-    const resolved = await resolver.resolve(id, fromBase);
-    if (resolved)
-      return resolved;
-    throw new Error(`[css] failed to resolve stylesheet import "${id}" from ${fromBase}`);
-  }
-  async#getCssImportResolver() {
-    if (this.#cssImportResolver)
-      return this.#cssImportResolver;
-    this.#cssImportResolver = await CssImportResolver.create(this.#app);
-    return this.#cssImportResolver;
-  }
-  async#loadModule(id, fromBase) {
-    const p = __require.resolve(id, { paths: [fromBase] });
-    const mod = await import(p);
-    return { path: p, base: path15.dirname(p), module: mod.default ?? mod };
-  }
-  async#resolveSourceImport(id, fromBase, resolvePackage) {
-    if (id.startsWith(".") || id.startsWith("/")) {
-      const abs = id.startsWith("/") ? id : path15.resolve(fromBase, id);
-      return resolveSourceFileCandidate(abs);
-    }
-    const pkg = await resolvePackage(id);
-    if (pkg)
-      return pkg.entryFile;
-    for (const resolve of [() => resolveSourceWithBun(id, fromBase), () => resolveSourceWithRequire(id, fromBase)]) {
-      const resolved = await resolve();
-      if (resolved)
-        return resolved;
-    }
-    return null;
-  }
-  async#scanCandidates(sourcePaths, dirs) {
-    const CANDIDATE_RE = /-?[\w@][\w:/.-]*(?:\[[^\]]+\][\w:/.-]*)*/g;
-    const candidates = new Set;
-    const glob = new Bun.Glob("**/*.{tsx,ts,jsx,js,html}");
-    const files = new Set(sourcePaths);
-    await Promise.all(dirs.map(async (dir) => {
-      for await (const file of glob.scan({ cwd: dir, absolute: true })) {
-        if (isIgnoredNodeModuleSource(file))
-          continue;
-        files.add(file);
-      }
-    }));
-    await Promise.all([...files].map(async (file) => {
-      const content = await Bun.file(file).text();
-      for (const m of content.matchAll(CANDIDATE_RE))
-        candidates.add(m[0]);
-    }));
-    return [...candidates];
-  }
-}
-async function resolveSourceFileCandidate(absPathNoExt) {
-  if (await Bun.file(absPathNoExt).exists())
-    return isSourceFile(absPathNoExt) ? absPathNoExt : null;
-  for (const ext of SOURCE_EXTS2) {
-    const filePath = `${absPathNoExt}${ext}`;
-    if (await Bun.file(filePath).exists())
-      return filePath;
-  }
-  for (const ext of SOURCE_EXTS2) {
-    const filePath = path15.join(absPathNoExt, `index${ext}`);
-    if (await Bun.file(filePath).exists())
-      return filePath;
-  }
-  return null;
-}
-function resolveSourceWithBun(id, fromBase) {
-  try {
-    const resolved = Bun.resolveSync(id, fromBase);
-    return isSourceFile(resolved) ? resolved : null;
-  } catch {
-    return null;
-  }
-}
-function resolveSourceWithRequire(id, fromBase) {
-  try {
-    const resolved = __require.resolve(id, { paths: [fromBase] });
-    return isSourceFile(resolved) ? resolved : null;
-  } catch {
-    return null;
-  }
-}
-function isSourceFile(filePath) {
-  return SOURCE_EXTS2.includes(path15.extname(filePath));
-}
-function isIgnoredNodeModuleSource(filePath) {
-  return NODE_MODULES_RE3.test(filePath) && !AKANJS_NODE_MODULE_RE3.test(filePath);
-}
-function getPageKeyBasePath(pageKey, basePaths) {
-  const normalized = pageKey.split(path15.sep).join("/").replace(/^\.\//, "");
-  const segments = normalized.split("/");
-  const firstPublicSegment = segments.find((segment) => segment !== "[lang]" && !/^\(.+\)$/.test(segment));
-  return firstPublicSegment && basePaths.includes(firstPublicSegment) ? firstPublicSegment : null;
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/devChangePlanner.ts
-import path16 from "path";
-var SOURCE_EXTS3 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
-var BARREL_FACETS = new Set(["common", "srvkit", "ui", "webkit", "plugin"]);
-var CLIENT_SUFFIXES = [".Template.tsx", ".Unit.tsx", ".Util.tsx", ".View.tsx", ".Zone.tsx", ".store.ts"];
-var SHARED_SUFFIXES = [".constant.ts", ".dictionary.ts", ".signal.ts"];
-var SERVER_SUFFIXES = [".service.ts", ".document.ts"];
-var RUNTIME_METADATA_BASENAMES = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
-
-class DevChangePlanner {
-  #workspaceRoot;
-  constructor({ workspaceRoot }) {
-    this.#workspaceRoot = path16.resolve(workspaceRoot);
-  }
-  plan({ generation, files, kinds, generatedFiles = [] }) {
-    const fileList = uniqueResolved([...files, ...generatedFiles]);
-    const generatedSet = new Set(generatedFiles.map((file) => path16.resolve(file)));
-    const kindSet = new Set(kinds);
-    const roles = new Set;
-    const actions = new Set;
-    const reasonByFile = {};
-    for (const kind of kindSet) {
-      if (kind === "css") {
-        roles.add("css");
-        actions.add("rebuild-css");
-      }
-      if (kind === "config") {
-        roles.add("config");
-        actions.add("restart-dev-host");
-      }
-    }
-    for (const file of fileList) {
-      const reasons = new Set;
-      const fileRoles = this.#rolesForFile(file, { isGenerated: generatedSet.has(path16.resolve(file)), reasons });
-      for (const role of fileRoles)
-        roles.add(role);
-      if (reasons.has("runtime-metadata"))
-        actions.add("restart-builder");
-      if (reasons.size > 0)
-        reasonByFile[path16.resolve(file)] = [...reasons].sort();
-    }
-    if (roles.has("barrel"))
-      actions.add("sync-generated");
-    if (roles.has("server") || roles.has("shared"))
-      actions.add("restart-backend");
-    if (roles.has("client") || roles.has("shared"))
-      actions.add("rebuild-client");
-    if (roles.has("css"))
-      actions.add("rebuild-css");
-    return {
-      generation,
-      files: fileList,
-      generatedFiles: uniqueResolved(generatedFiles),
-      roles: [...roles].sort(),
-      actions: [...actions].sort(),
-      reasonByFile
-    };
-  }
-  #rolesForFile(file, { isGenerated, reasons }) {
-    const roles = new Set;
-    const abs = path16.resolve(file);
-    const base = path16.basename(abs);
-    const ext = path16.extname(abs).toLowerCase();
-    const isSource = SOURCE_EXTS3.has(ext);
-    const rel = path16.relative(this.#workspaceRoot, abs);
-    const parts = rel.split(path16.sep).filter(Boolean);
-    if (CONFIG_BASENAMES.has(base)) {
-      roles.add("config");
-      reasons.add("config-file");
-    }
-    if (ext === ".css") {
-      roles.add("css");
-      reasons.add("css-file");
-    }
-    if (isGenerated || isSource && this.#isBarrelFacetChild(parts)) {
-      roles.add("barrel");
-      reasons.add(isGenerated ? "generated-index" : "barrel-facet-child");
-    }
-    if (isSource && this.#isServerBiased(abs, parts)) {
-      roles.add("server");
-      reasons.add("server-path");
-    }
-    if (isSource && this.#isClientBiased(abs, parts)) {
-      roles.add("client");
-      reasons.add("client-path");
-    }
-    if (isSource && this.#isSharedBiased(abs, parts)) {
-      roles.add("shared");
-      reasons.add("shared-path");
-    }
-    if (isSource && this.#isRuntimeMetadataFile(parts, base)) {
-      reasons.add("runtime-metadata");
-    }
-    if (roles.has("server") && roles.has("client")) {
-      roles.delete("server");
-      roles.delete("client");
-      roles.add("shared");
-      reasons.add("server-client-overlap");
-    }
-    if (roles.size === 0 && SOURCE_EXTS3.has(ext) && this.#isWorkspaceSource(rel)) {
-      roles.add("shared");
-      reasons.add("workspace-source-fallback");
-    }
-    return roles;
-  }
-  #isServerBiased(abs, parts) {
-    const base = path16.basename(abs);
-    return parts.includes("srvkit") || SERVER_SUFFIXES.some((suffix) => base.endsWith(suffix)) || base === "main.ts" || base === "server.ts";
-  }
-  #isClientBiased(abs, parts) {
-    const base = path16.basename(abs);
-    return parts.includes("ui") || parts.includes("webkit") || parts.includes("page") || CLIENT_SUFFIXES.some((suffix) => base.endsWith(suffix));
-  }
-  #isSharedBiased(abs, parts) {
-    const base = path16.basename(abs);
-    return parts.includes("common") || SHARED_SUFFIXES.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES.has(base);
-  }
-  #isRuntimeMetadataFile(parts, base) {
-    const parent = parts.at(-2);
-    if (parent === "lib" && RUNTIME_METADATA_BASENAMES.has(base))
-      return true;
-    const libIndex = parts.lastIndexOf("lib");
-    if (libIndex < 0 || parts.length <= libIndex + 1)
-      return false;
-    return base.endsWith(".dictionary.ts") || base.endsWith(".signal.ts");
-  }
-  #isBarrelFacetChild(parts) {
-    if (parts.length < 4)
-      return false;
-    const [scope, , facet, child] = parts;
-    if (scope !== "apps" && scope !== "libs")
-      return false;
-    if (!facet || !BARREL_FACETS.has(facet))
-      return false;
-    if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx")
-      return false;
-    return true;
-  }
-  #isWorkspaceSource(rel) {
-    if (!rel || rel.startsWith("..") || path16.isAbsolute(rel))
-      return false;
-    const [scope] = rel.split(path16.sep);
-    return scope === "apps" || scope === "libs" || scope === "pkgs";
-  }
-}
-var uniqueResolved = (files) => [...new Set(files.map((file) => path16.resolve(file)))].sort();
-
-// pkgs/@akanjs/devkit/frontendBuild/devGeneratedIndexSync.ts
-import { mkdir as mkdir4, readdir as readdir2, readFile as readFile2, rm as rm2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import path17 from "path";
-var BARREL_FACETS2 = new Set(["common", "srvkit", "ui", "webkit", "plugin"]);
-var FACET_SOURCE_FILE_RE = /\.(ts|tsx)$/;
-var FACET_EXCLUDED_FILE_RE = /(^index\.tsx?$|\.d\.ts$|\.(test|spec)\.(ts|tsx)$|\.css$|\.scss$|\.sass$)/;
-var FACET_PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9]*$/;
-var FACET_CAMEL_CASE_RE = /^[a-z][A-Za-z0-9]*$/;
-var MODULE_UI_TYPES = ["Template", "Unit", "Util", "View", "Zone"];
-var SERVICE_UI_TYPES = ["Util", "Zone"];
-var SCALAR_UI_TYPES = ["Template", "Unit"];
-
-class DevGeneratedIndexSync {
-  #workspaceRoot;
-  constructor({ workspaceRoot }) {
-    this.#workspaceRoot = path17.resolve(workspaceRoot);
-  }
-  async syncForBatch(files) {
-    const indexPaths = new Set;
-    const errors = [];
-    for (const file of files) {
-      const facetIndex = this.#facetIndexFor(file);
-      if (facetIndex)
-        indexPaths.add(facetIndex);
-      const moduleIndex = await this.#moduleIndexForDirectoryEvent(file).catch((err) => {
-        errors.push(`[generated-index] module detection failed for ${file}: ${formatError2(err)}`);
-        return null;
-      });
-      if (moduleIndex)
-        indexPaths.add(moduleIndex);
-    }
-    const changedFiles = [];
-    for (const indexPath of [...indexPaths].sort()) {
-      try {
-        const changed = await this.#syncIndex(indexPath);
-        if (changed)
-          changedFiles.push(indexPath);
-      } catch (err) {
-        errors.push(`[generated-index] sync failed for ${indexPath}: ${formatError2(err)}`);
-      }
-    }
-    return { changedFiles, errors };
-  }
-  #facetIndexFor(file) {
-    const abs = path17.resolve(file);
-    const rel = path17.relative(this.#workspaceRoot, abs);
-    if (rel.startsWith("..") || path17.isAbsolute(rel))
-      return null;
-    const parts = rel.split(path17.sep).filter(Boolean);
-    if (parts.length < 4)
-      return null;
-    const [scope, project, facet, child] = parts;
-    if (scope !== "apps" && scope !== "libs" || !project || !facet || !BARREL_FACETS2.has(facet))
-      return null;
-    if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx")
-      return null;
-    return path17.join(this.#workspaceRoot, scope, project, facet, "index.ts");
-  }
-  async#moduleIndexForDirectoryEvent(file) {
-    const abs = path17.resolve(file);
-    const rel = path17.relative(this.#workspaceRoot, abs);
-    if (rel.startsWith("..") || path17.isAbsolute(rel))
-      return null;
-    const parts = rel.split(path17.sep).filter(Boolean);
-    if (parts.length !== 4 && parts.length !== 5)
-      return null;
-    const [scope, project, libSegment, moduleSegment, scalarSegment] = parts;
-    if (scope !== "apps" && scope !== "libs" || !project || libSegment !== "lib")
-      return null;
-    const isExistingDirectory = await stat2(abs).then((s) => s.isDirectory()).catch(() => false);
-    const looksLikeDeletedDirectory = !path17.extname(abs);
-    if (!isExistingDirectory && !looksLikeDeletedDirectory)
-      return null;
-    if (moduleSegment === "__scalar" && scalarSegment) {
-      return path17.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
-    }
-    if (!moduleSegment || moduleSegment === "__scalar")
-      return null;
-    return path17.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
-  }
-  async#syncIndex(indexPath) {
-    const dir = path17.dirname(indexPath);
-    const content = await this.#contentForIndex(indexPath);
-    if (content === null) {
-      if (!await exists(indexPath))
-        return false;
-      await rm2(indexPath, { force: true });
-      return true;
-    }
-    const current = await readFile2(indexPath, "utf8").catch(() => null);
-    if (current === content)
-      return false;
-    await mkdir4(dir, { recursive: true });
-    await writeFile2(indexPath, content);
-    return true;
-  }
-  async#contentForIndex(indexPath) {
-    const parts = path17.relative(this.#workspaceRoot, indexPath).split(path17.sep).filter(Boolean);
-    const facet = parts.at(-2);
-    if (facet && BARREL_FACETS2.has(facet))
-      return this.#facetContent(path17.dirname(indexPath));
-    return this.#moduleContent(path17.dirname(indexPath));
-  }
-  async#facetContent(dir) {
-    const nameCasePattern = path17.basename(dir) === "ui" ? FACET_PASCAL_CASE_RE : FACET_CAMEL_CASE_RE;
-    const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
-    const exportNames = entries.flatMap((entry) => {
-      const name = entry.name;
-      if (name.startsWith("."))
-        return [];
-      if (entry.isDirectory())
-        return nameCasePattern.test(name) ? [name] : [];
-      if (!entry.isFile())
-        return [];
-      if (!FACET_SOURCE_FILE_RE.test(name) || FACET_EXCLUDED_FILE_RE.test(name))
-        return [];
-      const exportName = name.replace(FACET_SOURCE_FILE_RE, "");
-      return nameCasePattern.test(exportName) ? [exportName] : [];
-    }).sort();
-    if (exportNames.length === 0)
-      return null;
-    return `${exportNames.map((name) => `export * from "./${name}";`).join(`
-`)}
-`;
-  }
-  async#moduleContent(dir) {
-    const rel = path17.relative(this.#workspaceRoot, dir);
-    const parts = rel.split(path17.sep).filter(Boolean);
-    const moduleSegment = parts.at(-1);
-    if (!moduleSegment)
-      return null;
-    const isScalar = parts.at(-2) === "__scalar";
-    const rawModel = moduleSegment.startsWith("_") ? moduleSegment.slice(1) : moduleSegment;
-    if (!rawModel)
-      return null;
-    const modelName = capitalize(rawModel);
-    const allowedTypes = isScalar ? SCALAR_UI_TYPES : moduleSegment.startsWith("_") ? SERVICE_UI_TYPES : MODULE_UI_TYPES;
-    const fileTypes = [];
-    for (const type of allowedTypes) {
-      if (await exists(path17.join(dir, `${modelName}.${type}.tsx`)))
-        fileTypes.push(type);
-    }
-    if (fileTypes.length === 0)
-      return null;
-    return `
-${fileTypes.map((type) => `import * as ${type} from "./${modelName}.${type}";`).join(`
-`)}
-
-export const ${modelName} = { ${fileTypes.join(", ")} };`;
-  }
-}
-var exists = async (file) => stat2(file).then(() => true).catch(() => false);
-var capitalize = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
-var formatError2 = (err) => err instanceof Error ? err.message : String(err);
-
-// pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
-import { mkdir as mkdir5, stat as stat3 } from "fs/promises";
-import path18 from "path";
-import ts4 from "typescript";
-var FONT_URL_PREFIX = "/_akan/fonts";
-var DEFAULT_FONT_SUBSETS = ["latin"];
-
-class FontOptimizer {
-  #app;
-  #command;
-  #artifactRoot;
-  #files = [];
-  #cssParts = [];
-  #woff2Ready = null;
-  static #ksX1001Text = null;
-  static #cacheVersion = 1;
-  constructor(app, command = "start") {
-    this.#app = app;
-    this.#command = command;
-    this.#artifactRoot = path18.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
-  }
-  async optimize() {
-    const fonts = await this.discoverFonts();
-    const cacheKey = await this.#buildCacheKey(fonts);
-    const cached = cacheKey ? await this.#readCache(cacheKey) : null;
-    if (cached) {
-      this.#app.verbose(`[font] reused ${cached.files.length} cached file(s); skipped subsetting`);
-      return { css: cached.css, fonts, files: cached.files };
-    }
-    for (const font of fonts) {
-      if (!this.#isFontOptimizationEnabled(font))
-        continue;
-      await this.#optimizeFont(font);
-    }
-    const fontUtilityCss = this.#buildFontUtilityRules(fonts);
-    if (fontUtilityCss)
-      this.#cssParts.push(fontUtilityCss);
-    const result = { css: this.#cssParts.join(`
-`), fonts, files: this.#files };
-    if (cacheKey)
-      await this.#writeCache(cacheKey, result);
-    return result;
-  }
-  get #cachePath() {
-    return path18.join(this.#artifactRoot, "fontCache.json");
-  }
-  async#buildCacheKey(fonts) {
-    const sources = [];
-    for (const font of fonts) {
-      if (!this.#isFontOptimizationEnabled(font))
-        continue;
-      for (const face of this.#getFontFaces(font)) {
-        const sourcePath = await this.#resolveFontSourcePath(face.src);
-        const stamp = sourcePath ? await this.#fileStamp(sourcePath) : null;
-        if (!stamp)
-          return null;
-        sources.push({ optimizedSrc: face.optimizedSrc, ...stamp });
-      }
-      for (const filePath of font.subsetFiles ?? []) {
-        const abs = path18.isAbsolute(filePath) ? filePath : path18.join(this.#app.cwdPath, filePath);
-        const stamp = await this.#fileStamp(abs);
-        if (!stamp)
-          return null;
-        sources.push({ subsetFile: filePath, ...stamp });
-      }
-      if (this.#getFontSubsets(font).includes("auto"))
-        sources.push({ autoSubsetText: this.#hashFontConfig(await this.#collectAutoSubsetText()) });
-    }
-    return this.#hashFontConfig({ version: FontOptimizer.#cacheVersion, fonts, sources });
-  }
-  async#fileStamp(filePath) {
-    try {
-      const stats = await stat3(filePath);
-      return { mtimeMs: Math.round(stats.mtimeMs), size: stats.size };
-    } catch {
-      return null;
-    }
-  }
-  async#readCache(key) {
-    const cache = await Bun.file(this.#cachePath).json().catch(() => null);
-    if (cache?.version !== FontOptimizer.#cacheVersion || cache.key !== key)
-      return null;
-    const files = cache.files.map((relativePath) => path18.join(this.#artifactRoot, relativePath));
-    for (const filePath of files) {
-      if (!await Bun.file(filePath).exists())
-        return null;
-    }
-    return { css: cache.css, files };
-  }
-  async#writeCache(key, result) {
-    const cache = {
-      version: FontOptimizer.#cacheVersion,
-      key,
-      css: result.css,
-      files: result.files.map((filePath) => path18.relative(this.#artifactRoot, filePath))
-    };
-    await Bun.write(this.#cachePath, JSON.stringify(cache));
-  }
-  async discoverFonts() {
-    const pageKeys = await this.#app.getPageKeys();
-    const fonts = [];
-    await Promise.all(pageKeys.map(async (key) => {
-      const filePath = path18.resolve(this.#app.cwdPath, "page", key);
-      const file = Bun.file(filePath);
-      if (!await file.exists())
-        return;
-      const source = await file.text();
-      if (!source.includes("fonts"))
-        return;
-      fonts.push(...this.#extractFontsExport(source, filePath));
-    }));
-    return this.#dedupeFonts(fonts);
-  }
-  async#optimizeFont(font) {
-    const faceCss = [];
-    for (const face of this.#getFontFaces(font)) {
-      const sourcePath = await this.#resolveFontSourcePath(face.src);
-      if (!sourcePath) {
-        this.#app.logger.warn(`[font] source not found: ${face.src}`);
-        continue;
-      }
-      const outputPath = path18.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
-      await mkdir5(path18.dirname(outputPath), { recursive: true });
-      const sourceBuffer = Buffer.from(await Bun.file(sourcePath).arrayBuffer());
-      const outputBuffer = await this.#buildFontBuffer(font, sourceBuffer, sourcePath);
-      await Bun.write(outputPath, outputBuffer);
-      this.#files.push(outputPath);
-      faceCss.push(this.#buildOptimizedFontFaceRule(font, face));
-      const fallbackCss = await this.#buildFontaineFallbackCss(font, face, outputPath);
-      if (fallbackCss)
-        faceCss.push(fallbackCss);
-    }
-    if (faceCss.length > 0)
-      this.#cssParts.push(...faceCss, this.#buildRootVariableRule(font));
-  }
-  #extractFontsExport(source, filePath) {
-    const sourceFile = ts4.createSourceFile(filePath, source, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TSX);
-    const fonts = [];
-    for (const statement of sourceFile.statements) {
-      if (!ts4.isVariableStatement(statement))
-        continue;
-      const modifiers = ts4.canHaveModifiers(statement) ? ts4.getModifiers(statement) : undefined;
-      const isExported = modifiers?.some((modifier) => modifier.kind === ts4.SyntaxKind.ExportKeyword) ?? false;
-      if (!isExported)
-        continue;
-      for (const declaration of statement.declarationList.declarations) {
-        if (!ts4.isIdentifier(declaration.name) || declaration.name.text !== "fonts")
-          continue;
-        const value = declaration.initializer ? this.#literalToValue(declaration.initializer) : null;
-        if (Array.isArray(value)) {
-          fonts.push(...value.map((font) => this.#withFontDefaults(font)));
-        }
-      }
-    }
-    return fonts;
-  }
-  #literalToValue(node) {
-    if (ts4.isStringLiteralLike(node))
-      return node.text;
-    if (ts4.isNumericLiteral(node))
-      return Number(node.text);
-    if (node.kind === ts4.SyntaxKind.TrueKeyword)
-      return true;
-    if (node.kind === ts4.SyntaxKind.FalseKeyword)
-      return false;
-    if (ts4.isArrayLiteralExpression(node))
-      return node.elements.map((element) => this.#literalToValue(element));
-    if (ts4.isObjectLiteralExpression(node)) {
-      const obj = {};
-      for (const prop of node.properties) {
-        if (!ts4.isPropertyAssignment(prop))
-          continue;
-        const name = this.#getPropertyName(prop.name);
-        if (!name)
-          continue;
-        obj[name] = this.#literalToValue(prop.initializer);
-      }
-      return obj;
-    }
-    if (ts4.isAsExpression(node) || ts4.isSatisfiesExpression(node) || ts4.isParenthesizedExpression(node)) {
-      return this.#literalToValue(node.expression);
-    }
-    return;
-  }
-  #getPropertyName(name) {
-    if (ts4.isIdentifier(name) || ts4.isStringLiteral(name) || ts4.isNumericLiteral(name))
-      return name.text;
-    return null;
-  }
-  #dedupeFonts(fonts) {
-    const map = new Map;
-    for (const font of fonts)
-      map.set(JSON.stringify(font), font);
-    return [...map.values()];
-  }
-  #withFontDefaults(font) {
-    return { ...font, subsets: font.subsets ?? [...DEFAULT_FONT_SUBSETS] };
-  }
-  #getFontSubsets(font) {
-    return font.subsets ?? DEFAULT_FONT_SUBSETS;
-  }
-  #getFontVariableName(font) {
-    return font.variable ?? `--font-${font.name}`;
-  }
-  #getFontFallbackName(font) {
-    return font.fallbackName ?? `${font.name} fallback`;
-  }
-  #isFontOptimizationEnabled(font) {
-    return font.optimize !== false;
-  }
-  #getFontStyles(font) {
-    return font.styles?.length ? font.styles : ["normal"];
-  }
-  #getFontFaces(font) {
-    const enabledStyles = new Set(this.#getFontStyles(font));
-    return font.paths.map((fontPath) => {
-      const style = fontPath.style ?? "normal";
-      return {
-        font,
-        path: fontPath,
-        src: fontPath.src,
-        weight: fontPath.weight,
-        style,
-        optimizedSrc: this.#getOptimizedFontSrc(font, fontPath)
-      };
-    }).filter((face) => enabledStyles.has(face.style));
-  }
-  #getOptimizedFontSrc(font, fontPath) {
-    const style = fontPath.style ?? "normal";
-    const hash = this.#hashFontConfig({
-      name: font.name,
-      src: fontPath.src,
-      weight: fontPath.weight,
-      style,
-      display: font.display,
-      subset: font.subset,
-      subsets: this.#getFontSubsets(font),
-      subsetText: font.subsetText,
-      subsetFiles: font.subsetFiles,
-      declarations: [...font.declarations ?? [], ...fontPath.declarations ?? []]
-    });
-    return `${FONT_URL_PREFIX}/${this.#slugFontPart(font.name)}-${this.#slugFontPart(String(fontPath.weight))}-${style}-${hash}.woff2`;
-  }
-  #hashFontConfig(value) {
-    const input = this.#stableStringify(value);
-    let hash = 2166136261;
-    for (let i = 0;i < input.length; i++) {
-      hash ^= input.charCodeAt(i);
-      hash = Math.imul(hash, 16777619);
-    }
-    return (hash >>> 0).toString(36);
-  }
-  #stableStringify(value) {
-    if (Array.isArray(value))
-      return `[${value.map((item) => this.#stableStringify(item)).join(",")}]`;
-    if (value && typeof value === "object") {
-      const entries = Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b));
-      return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${this.#stableStringify(v)}`).join(",")}}`;
-    }
-    return JSON.stringify(value);
-  }
-  #slugFontPart(value) {
-    return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "font";
-  }
-  async#resolveFontSourcePath(src) {
-    if (!src.startsWith("/"))
-      return null;
-    const rel = src.replace(/^\//, "");
-    const candidates = [
-      this.#command === "build" ? path18.join(this.#app.dist.cwdPath, "public", rel) : null,
-      path18.join(this.#app.cwdPath, "public", rel),
-      this.#resolveWorkspacePublicPath(rel)
-    ].filter(Boolean);
-    for (const candidate of candidates) {
-      if (await Bun.file(candidate).exists())
-        return candidate;
-    }
-    return null;
-  }
-  async#buildFontBuffer(font, sourceBuffer, sourcePath) {
-    if (font.subset === false)
-      return this.#convertToWoff2(sourceBuffer, sourcePath);
-    const { default: subsetFont } = await import("subset-font");
-    return subsetFont(sourceBuffer, await this.#getSubsetText(font), { targetFormat: "woff2" });
-  }
-  async#convertToWoff2(buffer, sourcePath) {
-    const { createFont } = await import("fonteditor-core");
-    await this.#initWoff2();
-    const font = createFont(buffer, { type: this.#getFontType(sourcePath, buffer) });
-    return font.write({ type: "woff2", toBuffer: true });
-  }
-  async#initWoff2() {
-    this.#woff2Ready ??= import("fonteditor-core").then(({ woff2 }) => woff2.init()).then(() => {
-      return;
-    });
-    return this.#woff2Ready;
-  }
-  #getFontType(sourcePath, buffer) {
-    const signature = buffer.toString("ascii", 0, 4);
-    if (signature === "wOFF")
-      return "woff";
-    if (signature === "wOF2")
-      return "woff2";
-    if (signature === "OTTO")
-      return "otf";
-    const ext = path18.extname(sourcePath).slice(1).toLowerCase();
-    if (ext === "otf" || ext === "woff" || ext === "woff2")
-      return ext;
-    return "ttf";
-  }
-  #resolveWorkspacePublicPath(rel) {
-    const [root, dep, ...rest] = rel.split("/");
-    if (root !== "libs" || !dep || rest.length === 0)
-      return null;
-    return path18.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
-  }
-  async#getSubsetText(font) {
-    const parts = new Set;
-    const subsets = this.#getFontSubsets(font);
-    for (const subset of subsets)
-      parts.add(await this.#getSubsetPresetText(subset));
-    if (font.subsetText)
-      parts.add(font.subsetText);
-    for (const filePath of font.subsetFiles ?? []) {
-      const abs = path18.isAbsolute(filePath) ? filePath : path18.join(this.#app.cwdPath, filePath);
-      const file = Bun.file(abs);
-      if (await file.exists())
-        parts.add(await file.text());
-    }
-    return [...parts].join("");
-  }
-  async#getSubsetPresetText(subset) {
-    if (subset === "latin")
-      return this.#rangeText(32, 126);
-    if (subset === "latin-ext")
-      return `${this.#rangeText(32, 126)}${this.#rangeText(160, 591)}`;
-    if (subset === "ks-x-1001")
-      return FontOptimizer.#getKsX1001Text();
-    if (subset === "auto")
-      return this.#collectAutoSubsetText();
-    return "";
-  }
-  async#collectAutoSubsetText() {
-    const roots = ["page", "ui"].map((dir) => path18.join(this.#app.cwdPath, dir));
-    const glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,html,md}");
-    const parts = [];
-    await Promise.all(roots.map(async (root) => {
-      if (!await Bun.file(root).exists())
-        return;
-      for await (const filePath of glob.scan({ cwd: root, absolute: true })) {
-        parts.push(await Bun.file(filePath).text());
-      }
-    }));
-    return parts.join("");
-  }
-  #rangeText(start, end) {
-    let text = "";
-    for (let code = start;code <= end; code++)
-      text += String.fromCodePoint(code);
-    return text;
-  }
-  static #getKsX1001Text() {
-    if (FontOptimizer.#ksX1001Text)
-      return FontOptimizer.#ksX1001Text;
-    try {
-      const decoder = new TextDecoder("euc-kr");
-      const chars = new Set;
-      for (let lead = 161;lead <= 254; lead++) {
-        for (let trail = 161;trail <= 254; trail++) {
-          const char = decoder.decode(Uint8Array.of(lead, trail));
-          if (char && char !== "\uFFFD")
-            chars.add(char);
-        }
-      }
-      FontOptimizer.#ksX1001Text = [...chars].join("");
-    } catch {
-      FontOptimizer.#ksX1001Text = FontOptimizer.#rangeTextStatic(44032, 55203);
-    }
-    return FontOptimizer.#ksX1001Text;
-  }
-  static #rangeTextStatic(start, end) {
-    let text = "";
-    for (let code = start;code <= end; code++)
-      text += String.fromCodePoint(code);
-    return text;
-  }
-  #buildOptimizedFontFaceRule(font, face) {
-    const declarations = [
-      ["font-family", this.#quote(font.name)],
-      ["src", `url(${this.#quote(face.optimizedSrc)}) format("woff2")`],
-      ["font-weight", String(face.weight)],
-      ["font-style", face.style],
-      ["font-display", font.display ?? "swap"],
-      ...this.#toDeclarationEntries(font.declarations),
-      ...this.#toDeclarationEntries(face.path.declarations)
-    ];
-    return `@font-face {
-${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
-`)}
-}`;
-  }
-  async#buildFontaineFallbackCss(font, face, outputPath) {
-    if (font.adjustFontFallback === false)
-      return "";
-    const { generateFontFace, getMetricsForFamily, readMetrics, resolveCategoryFallbacks } = await import("fontaine");
-    const metrics = await readMetrics(outputPath).catch(() => null);
-    if (!metrics)
-      return "";
-    const fallbacks = resolveCategoryFallbacks({
-      fontFamily: font.name,
-      fallbacks: font.fallbacks ?? {},
-      metrics: { ...metrics, category: font.category }
-    });
-    const css = [];
-    for (let i = fallbacks.length - 1;i >= 0; i--) {
-      const fallback = fallbacks[i];
-      const fallbackMetrics = await getMetricsForFamily(fallback);
-      if (!fallbackMetrics)
-        continue;
-      css.push(generateFontFace({ ...metrics, category: font.category }, {
-        name: this.#getFontFallbackName(font),
-        font: fallback,
-        metrics: fallbackMetrics,
-        "font-weight": String(face.weight),
-        "font-style": face.style
-      }));
-    }
-    return css.join("");
-  }
-  #buildRootVariableRule(font) {
-    return `:root { ${this.#getFontVariableName(font)}: ${this.#quote(font.name)}, ${this.#quote(this.#getFontFallbackName(font))}; }`;
-  }
-  #buildFontUtilityRules(fonts) {
-    const rules = [];
-    const seen = new Set;
-    for (const font of fonts) {
-      const className = font.className || `font-${font.name}`;
-      const selector = `.${this.#escapeCssClassName(className)}`;
-      const rule = `${selector} { font-family: var(${this.#getFontVariableName(font)}); }`;
-      if (seen.has(rule))
-        continue;
-      seen.add(rule);
-      rules.push(rule);
-    }
-    return rules.join(`
-`);
-  }
-  #escapeCssClassName(value) {
-    return value.replace(/^-?\d|[^a-zA-Z0-9_-]/g, (part) => [...part].map((char) => `\\${char.codePointAt(0)?.toString(16)} `).join(""));
-  }
-  #toDeclarationEntries(declarations = []) {
-    return declarations.map((declaration) => [declaration.prop, declaration.value]);
-  }
-  #quote(value) {
-    return JSON.stringify(value);
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-import path20 from "path";
-
-// pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
-import path19 from "path";
-var DEFAULT_INCLUDE = ["akanjs/", "@apps/", "@libs/"];
-var DEFAULT_EXCLUDE_EXACT = new Set(["akanjs/webkit", "@akanjs/cli", "@akanjs/devkit"]);
-var DEFAULT_EXCLUDE_PREFIX = ["@akanjs/cli/", "@akanjs/devkit/"];
-var OPTIONAL_BACKEND_EXTERNAL_EXACT = new Set([
-  "@libsql/client",
-  "bullmq",
-  "croner",
-  "ioredis",
-  "postgres",
-  "protobufjs"
-]);
-var RUNTIME_EXTERNAL_EXACT = new Set([
-  "react",
-  "react-dom",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime",
-  "react-server-dom-webpack",
-  "react-server-dom-webpack/server.node",
-  "react-server-dom-webpack/client.node",
-  "react-server-dom-webpack/client.browser"
-]);
-var RUNTIME_EXTERNAL_PREFIX = ["react-dom/", "react-server-dom-webpack/"];
-var CANDIDATE_EXTS3 = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
-async function createExternalizeFrameworkPlugin(options) {
-  const tsconfig = await options.app.getTsConfig();
-  const includePrefixes = options.include ?? DEFAULT_INCLUDE;
-  const extraExact = new Set(options.extra ?? []);
-  const workspaceRoot = options.app.workspace.workspaceRoot;
-  const tsconfigPaths = tsconfig.compilerOptions.paths ?? {};
-  const rootEntries = Object.entries(tsconfigPaths).filter(([k]) => !k.endsWith("/*")).map(([k, v]) => ({ pkg: k, entryFile: v[0] ?? null })).filter((e) => e.entryFile !== null);
-  const wildcardEntries = Object.entries(tsconfigPaths).filter(([k]) => k.endsWith("/*")).map(([k, v]) => ({ prefix: k.slice(0, -1), replacements: v })).sort((a, b) => b.prefix.length - a.prefix.length);
-  async function resolveWorkspaceSubpath(spec) {
-    if (!workspaceRoot)
-      return null;
-    for (const { prefix, replacements } of wildcardEntries) {
-      if (!spec.startsWith(prefix))
-        continue;
-      const suffix = spec.slice(prefix.length);
-      for (const repl of replacements) {
-        const replPath = repl?.endsWith("/*") ? repl.slice(0, -1) : repl ?? "";
-        if (!replPath)
-          continue;
-        const candidate = path19.resolve(workspaceRoot, replPath + suffix);
-        const hit = await firstExisting(candidate);
-        if (hit)
-          return hit;
-      }
-    }
-    for (const { pkg, entryFile } of rootEntries) {
-      if (spec !== pkg && !spec.startsWith(`${pkg}/`))
-        continue;
-      if (spec === pkg)
-        continue;
-      const suffix = spec.slice(pkg.length + 1);
-      const pkgDir = path19.dirname(path19.resolve(workspaceRoot, entryFile));
-      const candidate = path19.join(pkgDir, suffix);
-      const hit = await firstExisting(candidate);
-      if (hit)
-        return hit;
-    }
-    return null;
-  }
-  return {
-    name: "akan-externalize-framework",
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, async (args) => {
-        const spec = args.path;
-        if (spec === "." || spec === ".." || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/"))
-          return;
-        if (extraExact.has(spec) || DEFAULT_EXCLUDE_EXACT.has(spec))
-          return { path: spec, external: true };
-        for (const prefix of DEFAULT_EXCLUDE_PREFIX) {
-          if (spec.startsWith(prefix))
-            return { path: spec, external: true };
-        }
-        if (OPTIONAL_BACKEND_EXTERNAL_EXACT.has(spec))
-          return { path: spec, external: true };
-        if (RUNTIME_EXTERNAL_EXACT.has(spec))
-          return { path: spec, external: true };
-        for (const prefix of RUNTIME_EXTERNAL_PREFIX) {
-          if (spec.startsWith(prefix))
-            return { path: spec, external: true };
-        }
-        for (const prefix of includePrefixes) {
-          if (!spec.startsWith(prefix))
-            continue;
-          const resolved = await resolveWorkspaceSubpath(spec);
-          if (resolved)
-            return { path: resolved };
-          return;
-        }
-        return;
-      });
-    }
-  };
-}
-async function firstExisting(basePath) {
-  if (await Bun.file(basePath).exists())
-    return basePath;
-  for (const ext of CANDIDATE_EXTS3) {
-    const candidate = `${basePath}${ext}`;
-    if (await Bun.file(candidate).exists())
-      return candidate;
-  }
-  for (const ext of CANDIDATE_EXTS3) {
-    const candidate = path19.join(basePath, `index${ext}`);
-    if (await Bun.file(candidate).exists())
-      return candidate;
-  }
-  return null;
-}
-
-// pkgs/@akanjs/devkit/transforms/useClientBundlePlugin.ts
-function createUseClientBundlePlugin(options = {}) {
-  return {
-    name: "akan-use-client-bundle",
-    setup(build) {
-      build.onLoad({ filter: /\.(tsx|ts|jsx|js)$/ }, async (args) => {
-        if (args.path.includes("/node_modules/"))
-          return;
-        let source;
-        try {
-          source = await Bun.file(args.path).text();
-        } catch {
-          return;
-        }
-        const stubbed = transformUseClient(source, {
-          path: args.path,
-          workspaceRoot: options.workspaceRoot
-        });
-        if (stubbed === null)
-          return;
-        return { contents: stubbed, loader: loaderFor3(args.path) };
-      });
-    }
-  };
-}
-function loaderFor3(absPath) {
-  if (absPath.endsWith(".tsx"))
-    return "tsx";
-  if (absPath.endsWith(".jsx"))
-    return "jsx";
-  if (absPath.endsWith(".ts"))
-    return "ts";
-  return "js";
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-var VIRTUAL_PAGES_ENTRY = "akan-pages-entry";
-
-class PagesBundleBuilder {
-  #app;
-  #command;
-  #pageEntries;
-  #started = Date.now();
-  constructor(app, command = "start", pageEntries) {
-    this.#app = app;
-    this.#command = command;
-    this.#pageEntries = pageEntries;
-  }
-  async build() {
-    const akanConfig = await this.#app.getConfig();
-    const resolvedEntries = this.#pageEntries ?? await resolveSsrPageEntriesForApp(this.#app, await this.#app.getPageKeys());
-    const entrySource = PagesEntrySourceGenerator.generate(resolvedEntries);
-    const workspaceRoot = this.#app.workspace.workspaceRoot;
-    const result = await Bun.build({
-      entrypoints: [VIRTUAL_PAGES_ENTRY],
-      outdir: `${this.#artifactDir}/server`,
-      target: "bun",
-      format: "esm",
-      splitting: this.#splitting,
-      minify: this.#command === "build",
-      naming: {
-        entry: "pages-[hash].[ext]",
-        chunk: "chunks/[name]-[hash].[ext]",
-        asset: "assets/[name]-[hash].[ext]"
-      },
-      define: this.#define(),
-      plugins: [
-        PagesBundleBuilder.createPagesEntryPlugin(entrySource),
-        PagesBundleBuilder.createServerCssStubPlugin(),
-        PagesBundleBuilder.createServerUseClientFetchPlugin(),
-        await createExternalizeFrameworkPlugin({ app: this.#app, extra: akanConfig.externalLibs }),
-        akanConfig.barrelImports.length > 0 ? await createBarrelImportsPlugin(this.#app, {
-          pipeAfter: (source, args) => transformUseClient(source, {
-            path: args.path,
-            workspaceRoot
-          })
-        }) : createUseClientBundlePlugin({ workspaceRoot })
-      ]
-    });
-    if (!result.success)
-      throw new AggregateError(result.logs, "[PagesBundleBuilder] Bun.build failed");
-    const entryArtifact = result.outputs.find((a) => a.kind === "entry-point");
-    if (!entryArtifact)
-      throw new Error("[PagesBundleBuilder] Bun.build emitted no entry-point artifact");
-    const bundlePath = path20.resolve(entryArtifact.path);
-    const buildId = Date.now();
-    const outputBytes = result.outputs.reduce((sum, output) => sum + output.size, 0);
-    const chunkCount = result.outputs.filter((output) => output.kind === "chunk").length;
-    this.#app.verbose(`[PagesBundleBuilder] ${path20.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
-    return {
-      bundlePath,
-      buildId,
-      splitting: this.#splitting,
-      entryBytes: entryArtifact.size,
-      outputBytes,
-      outputCount: result.outputs.length,
-      chunkCount
-    };
-  }
-  get #artifactDir() {
-    return `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
-  }
-  get #splitting() {
-    return process.env.AKAN_SERVER_PAGES_SPLITTING === "1";
-  }
-  #define() {
-    const nodeEnv = this.#command === "build" ? "production" : "development";
-    return {
-      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
-      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("ssr"),
-      ...Object.fromEntries(Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
-    };
-  }
-  static createPagesEntryPlugin(source) {
-    return {
-      name: "akan-pages-entry",
-      setup(build) {
-        build.onResolve({ filter: /^akan-pages-entry$/ }, () => ({
-          path: VIRTUAL_PAGES_ENTRY,
-          namespace: "akan-virtual"
-        }));
-        build.onLoad({ filter: /^akan-pages-entry$/, namespace: "akan-virtual" }, () => ({
-          contents: source,
-          loader: "tsx"
-        }));
-      }
-    };
-  }
-  static createServerCssStubPlugin() {
-    return {
-      name: "akan-server-css-stub",
-      setup(build) {
-        build.onLoad({ filter: /\.css$/ }, () => ({
-          contents: "",
-          loader: "js"
-        }));
-      }
-    };
-  }
-  static createServerUseClientFetchPlugin() {
-    return {
-      name: "akan-server-use-client-fetch",
-      setup(build) {
-        build.onLoad({ filter: /[/\\]lib[/\\]useClient\.(ts|tsx|js|jsx)$/ }, async (args) => {
-          const source = await Bun.file(args.path).text();
-          const transformed = PagesBundleBuilder.transformServerUseClientFetchSource(source);
-          if (transformed === source)
-            return;
-          return { contents: transformed, loader: loaderFor4(args.path) };
-        });
-      }
-    };
-  }
-  static transformServerUseClientFetchSource(source) {
-    if (!source.includes(`with { type: "macro" }`) || !source.includes("FetchClient.build"))
-      return source;
-    return source.replace(/import\s+\{\s*getSerializedSignal\s*\}\s+from\s+["']\.\/sig["']\s+with\s+\{\s*type\s*:\s*["']macro["']\s*\};/, `import { fetch as serverFetch } from "./sig";`).replace(/const\s+fetchProto\s*=\s*FetchClient\.build<[^;]+;/, "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });");
-  }
-}
-function loaderFor4(absPath) {
-  if (absPath.endsWith(".tsx"))
-    return "tsx";
-  if (absPath.endsWith(".jsx"))
-    return "jsx";
-  if (absPath.endsWith(".ts"))
-    return "ts";
-  return "js";
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/precompressArtifacts.ts
-import fs3 from "fs";
-import path21 from "path";
-var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
-var MIN_COMPRESS_BYTES = 1024;
-async function precompressArtifacts(app) {
-  const roots = [path21.join(app.dist.cwdPath, ".akan/artifact/client")];
-  const result = { files: 0, inputBytes: 0, outputBytes: 0 };
-  await Promise.all(roots.map((root) => precompressRoot(root, result)));
-  if (result.files > 0) {
-    app.verbose(`[precompress] wrote ${result.files} gzip sidecars (${formatBytes(result.inputBytes)} -> ${formatBytes(result.outputBytes)})`);
-  }
-  return result;
-}
-async function precompressRoot(root, result) {
-  if (!fs3.existsSync(root) || !fs3.statSync(root).isDirectory())
-    return;
-  const glob = new Bun.Glob("**/*");
-  for await (const filePath of glob.scan({ cwd: root, absolute: true })) {
-    if (!await shouldPrecompress(filePath))
-      continue;
-    const bytes = await Bun.file(filePath).bytes();
-    const gz = Bun.gzipSync(toArrayBuffer(bytes));
-    await Bun.write(`${filePath}.gz`, gz);
-    result.files += 1;
-    result.inputBytes += bytes.byteLength;
-    result.outputBytes += gz.byteLength;
-  }
-}
-async function shouldPrecompress(filePath) {
-  if (filePath.endsWith(".gz"))
-    return false;
-  if (!COMPRESSIBLE_EXTS.has(path21.extname(filePath).toLowerCase()))
-    return false;
-  const file = Bun.file(filePath);
-  if (!await file.exists())
-    return false;
-  return file.size >= MIN_COMPRESS_BYTES;
-}
-function toArrayBuffer(bytes) {
-  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-}
-function formatBytes(bytes) {
-  if (bytes < 1024)
-    return `${bytes}B`;
-  if (bytes < 1024 * 1024)
-    return `${(bytes / 1024).toFixed(1)}KB`;
-  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/ssrBaseArtifactBuilder.ts
-import path22 from "path";
-import { optimize } from "@tailwindcss/node";
-function prepareCssAsset(command, basePath, cssText) {
-  return optimize(cssText, { file: `${basePath || "root"}.css`, minify: command === "build" }).code;
-}
-
-class SsrBaseArtifactBuilder {
-  #app;
-  #command;
-  #artifactDir;
-  #absArtifactDir;
-  #started = Date.now();
-  constructor(app, command = "start") {
-    this.#app = app;
-    this.#command = command;
-    this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
-    this.#absArtifactDir = path22.resolve(this.#artifactDir);
-  }
-  async build() {
-    const akanConfig = await this.#app.getConfig();
-    const { rscClientUrl, rscRuntimeClientManifest, rscRuntimeSsrManifest, vendorMap } = await this.#buildRuntimeClientEntries();
-    const pageKeys = await this.#app.getPageKeys();
-    this.#app.verbose(`[base-artifact] discovered ${pageKeys.length} route files under ${this.#app.cwdPath}/page`);
-    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
-    const { cssCompiler, optimizedFonts, cssAssets } = await this.#buildStyleAssets();
-    const pagesBundle = await new PagesBundleBuilder(this.#app, this.#command, pageEntries).build();
-    this.#app.verbose(`[base-artifact] pages bundle -> ${pagesBundle.bundlePath} (buildId=${pagesBundle.buildId}, splitting=${pagesBundle.splitting}, entry=${pagesBundle.entryBytes} bytes, outputs=${pagesBundle.outputCount}, chunks=${pagesBundle.chunkCount}, total=${pagesBundle.outputBytes} bytes)`);
-    const seedIndex = computeRouteSeedIndex(pageEntries);
-    const seedIndexPath = await saveRouteSeedIndex(this.#absArtifactDir, seedIndex, {
-      production: this.#command === "build"
-    });
-    this.#app.verbose(`[base-artifact] route seed index -> ${seedIndexPath} entries=${seedIndex.entries.length} globalLayouts=${seedIndex.globalLayoutFiles.length}`);
-    const artifact = {
-      rscClientUrl,
-      rscRuntimeClientManifest,
-      rscRuntimeSsrManifest,
-      vendorMap,
-      cssAssets,
-      pagesBundlePath: this.#command === "build" ? path22.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
-      pagesBundleBuildId: pagesBundle.buildId,
-      domains: [...akanConfig.domains],
-      subRoutes: Object.fromEntries(Array.from(akanConfig.subRoutes.entries()).map(([basePath, domains]) => [basePath, [...domains]])),
-      basePaths: [...akanConfig.basePaths],
-      branches: [...akanConfig.branches],
-      i18n: akanConfig.i18n,
-      imageConfig: akanConfig.images,
-      deepLinkAssociations: Object.values(akanConfig.mobile.targets).filter((target) => (target.deepLinks?.domains?.length ?? 0) > 0).map((target) => ({
-        targetName: target.name,
-        appId: target.appId,
-        domains: target.deepLinks?.domains ?? [],
-        iosTeamId: target.deepLinks?.ios?.teamId,
-        androidSha256CertFingerprints: target.deepLinks?.android?.sha256CertFingerprints
-      }))
-    };
-    await Bun.write(path22.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
-`);
-    this.#app.verbose(`[base-artifact] complete in ${Date.now() - this.#started}ms`);
-    return { artifact, seedIndex, cssCompiler, optimizedFonts };
-  }
-  async#buildRuntimeClientEntries() {
-    const akanServerPath = await this.#resolveAkanServerPath();
-    const rscClientEntry = path22.resolve(akanServerPath, "rscClient.tsx");
-    const rscSegmentOutletEntry = path22.resolve(akanServerPath, "rscSegmentOutlet.tsx");
-    const vendorEntries = VENDOR_SPECIFIERS.map((specifier) => ({
-      specifier,
-      absPath: path22.resolve(akanServerPath, "vendor", `${specifier.replaceAll("/", "-").replaceAll(".", "-")}.ts`)
-    }));
-    const entries = [rscClientEntry, rscSegmentOutletEntry, ...vendorEntries.map((v) => v.absPath)];
-    const clientBundle = await new ClientEntriesBundler({ app: this.#app, entries, command: this.#command }).bundle();
-    const ssrBundle = await new ClientEntriesBundler({
-      app: this.#app,
-      entries: [rscSegmentOutletEntry],
-      ...RouteClientBuilder.resolveSsrClientExternalOptions(this.#command),
-      outputSubdir: "client-ssr",
-      command: this.#command
-    }).bundle();
-    const rscClientUrl = clientBundle.entryUrlsByAbsPath.get(rscClientEntry) ?? "";
-    const rscRuntimeSsrManifest = {
-      moduleLoading: null,
-      moduleMap: Object.fromEntries(Object.entries(clientBundle.manifest).map(([key, row]) => {
-        const ssrOutput = ssrBundle.entryOutputAbsByAbsPath.get(rscSegmentOutletEntry);
-        if (!ssrOutput || key !== `${clientBundle.clientReferenceIdByAbsPath.get(rscSegmentOutletEntry)}#${row.name}`) {
-          return null;
-        }
-        return [
-          row.id,
-          { [row.name]: { id: ssrOutput, chunks: [ssrOutput, ssrOutput], name: row.name, async: true } }
-        ];
-      }).filter((entry) => Boolean(entry)))
-    };
-    const vendorMap = Object.fromEntries(vendorEntries.map(({ specifier, absPath }) => [specifier, clientBundle.entryUrlsByAbsPath.get(absPath) ?? ""]));
-    this.#app.verbose(`[base-artifact] rscClientUrl=${rscClientUrl} vendors=${Object.keys(vendorMap).length}`);
-    return {
-      rscClientUrl,
-      rscRuntimeClientManifest: clientBundle.manifest,
-      rscRuntimeSsrManifest,
-      vendorMap
-    };
-  }
-  async#resolveAkanServerPath() {
-    const candidates = [];
-    try {
-      candidates.push(path22.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
-    } catch {}
-    candidates.push(path22.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path22.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
-    try {
-      candidates.push(path22.dirname(Bun.resolveSync("akanjs/server", path22.dirname(Bun.main))));
-    } catch {}
-    candidates.push(path22.join(path22.dirname(Bun.main), "node_modules/akanjs/server"), path22.join(path22.dirname(Bun.main), "../../akanjs/server"), path22.resolve(import.meta.dir, "../../server"), path22.resolve(import.meta.dir, "../server"));
-    for (const candidate of candidates) {
-      if (await Bun.file(path22.join(candidate, "rscClient.tsx")).exists())
-        return candidate;
-    }
-    throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
-  }
-  async#buildStyleAssets() {
-    const cssCompiler = new CssCompiler(this.#app);
-    const cssByBasePath = await cssCompiler.getCssByBasePath();
-    const optimizedFonts = await new FontOptimizer(this.#app, this.#command).optimize();
-    const cssAssets = Object.fromEntries(await Promise.all(Object.entries(cssByBasePath).flatMap(([basePath, baseCssText]) => {
-      const cssText = [baseCssText, optimizedFonts.css].filter(Boolean).join(`
-`);
-      if (!cssText)
-        return [];
-      return [this.#writeCssAsset(basePath, cssText)];
-    })));
-    if (optimizedFonts.files.length > 0)
-      this.#app.verbose(`[base-artifact] optimized ${optimizedFonts.files.length} font files`);
-    return { cssCompiler, optimizedFonts, cssAssets };
-  }
-  async#writeCssAsset(basePath, cssText) {
-    const cssAssetName = basePath || "root";
-    const preparedCssText = await prepareCssAsset(this.#command, basePath, cssText);
-    const cssHash = Bun.hash(`${basePath}
-${preparedCssText}`).toString(36);
-    const [cssRelPath, cssUrl] = [
-      `styles/${cssAssetName}-${cssHash}.css`,
-      `/_akan/styles/${cssAssetName}-${cssHash}.css`
-    ];
-    await Bun.write(path22.join(this.#absArtifactDir, cssRelPath), preparedCssText);
-    this.#app.verbose(`[base-artifact] wrote ${preparedCssText.length} bytes of CSS for ${basePath} -> ${cssRelPath}`);
-    return [basePath, { cssUrl, cssRelPath }];
-  }
-}
-export { GraphClientEntryDiscovery, RouteClientBuilder, AllRoutesBuilder, AutoImportSync, CsrArtifactBuilder, CssCompiler, DevChangePlanner, DevGeneratedIndexSync, FontOptimizer, PagesBundleBuilder, precompressArtifacts, SsrBaseArtifactBuilder };