@akanjs/cli 3.0.0-beta.8 → 3.0.0

package/index-6he6gvfg.js

@@ -0,0 +1,4300 @@
+// @bun
+import {
+  SOURCE_EXTS,
+  WatchRootResolver
+} from "./index-48k96p55.js";
+import {
+  FileSys2
+} from "./index-52w0fvh8.js";
+import {
+  AsyncDefaultExportDetector,
+  resolveSsrPageEntriesForApp
+} from "./index-3w94e7n3.js";
+
+// pkgs/@akanjs/devkit/artifact/routeSeedIndex.ts
+import path from "path";
+import { assertUniqueRoutePatterns, compareRouteSpecificity, parseRouteModuleKey } from "akanjs/common";
+import {
+  ROUTE_SEED_INDEX_JSON
+} from "akanjs/server/artifact/routeSeedIndexStore";
+function computeRouteSeedIndex(pageEntries) {
+  const layoutsByPrefix = new Map;
+  const pagesBySegments = [];
+  for (const { key, moduleAbsPath, seedAbsPaths } of pageEntries) {
+    const parsed = parseRouteModuleKey(key);
+    const files = [path.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path.resolve(seed))];
+    if (parsed.kind === "layout" || parsed.kind === "overrides") {
+      layoutsByPrefix.getOrInsert(parsed.routeSegments.join("/"), []).push(...files);
+    } else if (parsed.kind === "page") {
+      pagesBySegments.push({
+        key,
+        pattern: parsed.pattern,
+        segments: parsed.routeSegments,
+        files,
+        includeOwnLayout: parsed.leaf === "_index"
+      });
+    }
+  }
+  assertUniqueRoutePatterns(pagesBySegments);
+  const globalLayoutFiles = layoutsByPrefix.get("") ?? [];
+  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 };
+}
+function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
+  const normalizedArtifactDir = path.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 = path.join(path.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 (!path.isAbsolute(artifactPath))
+    return artifactPath;
+  return path.relative(artifactDir, artifactPath).split(path.sep).join("/");
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/clientEntryDiscovery.ts
+import fs from "fs";
+import path4 from "path";
+
+// pkgs/@akanjs/devkit/transforms/barrelAnalyzer.ts
+import path2 from "path";
+import { Logger } from "akanjs/common";
+
+// pkgs/@akanjs/devkit/transforms/moduleSyntax.ts
+var loaderFor = (absPath) => {
+  if (absPath.endsWith(".tsx"))
+    return "tsx";
+  if (absPath.endsWith(".jsx"))
+    return "jsx";
+  if (absPath.endsWith(".ts"))
+    return "ts";
+  return "js";
+};
+var parseNamedList = (listBody) => {
+  const out = [];
+  for (const raw of listBody.split(",")) {
+    let rest = raw.trim();
+    if (!rest)
+      continue;
+    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;
+};
+
+// pkgs/@akanjs/devkit/transforms/barrelAnalyzer.ts
+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 {
+      const pkg = await this.#opts.resolvePackage(pkgName);
+      if (!pkg)
+        return null;
+      const map = new Map;
+      await this.#walk(pkg.entryFile, pkg, map, new Set);
+      return map;
+    } catch (err) {
+      this.#logger.error(`analyze failed for ${pkgName}: ${err.message}`);
+      return null;
+    }
+  }
+  async#walk(absFile, pkg, map, visited) {
+    if (visited.has(absFile))
+      return;
+    visited.add(absFile);
+    const file = Bun.file(absFile);
+    if (!await file.exists())
+      return;
+    const source = await file.text();
+    const currentSubpath = this.#subpathFor(pkg, absFile);
+    if (!currentSubpath)
+      return;
+    const authoritative = this.#scanExports(source, absFile);
+    authoritative.delete("default");
+    const attributed = new Set;
+    const attribute = (listBody, subpath) => {
+      for (const item of parseNamedList(listBody)) {
+        if (item.isType || item.imported === "default" || !authoritative.has(item.local))
+          continue;
+        attributed.add(item.local);
+        if (!map.has(item.local))
+          map.set(item.local, { subpath, originalName: item.imported });
+      }
+    };
+    const starSpecs = [];
+    for (const m of source.matchAll(REEXPORT_RE)) {
+      const star = m[1];
+      const nsAs = m[2];
+      const namedList = m[3];
+      const spec = m[5] ?? "";
+      if (!isRelative(spec))
+        continue;
+      if (star) {
+        if (nsAs)
+          authoritative.delete(nsAs);
+        else
+          starSpecs.push(spec);
+        continue;
+      }
+      if (namedList !== undefined) {
+        const targetAbs = await this.#resolveRel(absFile, spec);
+        if (!targetAbs)
+          continue;
+        const targetSubpath = this.#subpathFor(pkg, targetAbs);
+        if (targetSubpath)
+          attribute(namedList, targetSubpath);
+      }
+    }
+    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);
+      attribute(body, currentSubpath);
+    }
+    for (const name of authoritative) {
+      if (attributed.has(name))
+        continue;
+      if (map.has(name))
+        continue;
+      map.set(name, { subpath: currentSubpath, originalName: name });
+    }
+    for (const spec of starSpecs) {
+      const targetAbs = await this.#resolveRel(absFile, spec);
+      if (targetAbs)
+        await this.#walk(targetAbs, pkg, map, visited);
+    }
+  }
+  #scanExports(source, absFile) {
+    try {
+      const transpiler = [".tsx", ".jsx"].includes(path2.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 = path2.relative(pkg.pkgDir, absFile);
+    if (!rel || rel.startsWith("..") || path2.isAbsolute(rel))
+      return null;
+    if (pkg.preserveFilePath)
+      return `${pkg.pkgName}/${rel.split(path2.sep).join("/")}`;
+    const ext = CANDIDATE_EXTS.find((candidate) => rel.endsWith(candidate));
+    const parts = (ext ? rel.slice(0, -ext.length) : rel).split(path2.sep);
+    if (parts[parts.length - 1] === "index")
+      parts.pop();
+    const tail = parts.join("/");
+    return tail === "" ? pkg.pkgName : `${pkg.pkgName}/${tail}`;
+  }
+  async#resolveRel(fromFile, relSpec) {
+    if (this.#opts.resolveRelative)
+      return this.#opts.resolveRelative(fromFile, relSpec);
+    return defaultResolveRelative(fromFile, relSpec);
+  }
+}
+var isRelative = (spec) => {
+  return spec.startsWith("./") || spec.startsWith("../") || spec === "." || spec === "..";
+};
+var defaultResolveRelative = async (fromFile, relSpec) => {
+  const baseDir = path2.dirname(fromFile);
+  const joined = path2.resolve(baseDir, relSpec);
+  if (path2.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 = path2.join(joined, `index${ext}`);
+    if (await Bun.file(cand).exists())
+      return cand;
+  }
+  return null;
+};
+
+// pkgs/@akanjs/devkit/transforms/barrelImportsPlugin.ts
+import path3 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);
+        let source = await Bun.file(realPath).text();
+        if (skipPath(realPath))
+          return { contents: source, loader };
+        if (!MACRO_ATTR_RE.test(source) && barrels.length > 0) {
+          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 = path3.resolve(app.workspace.workspaceRoot, raw);
+      if (!await Bun.file(entryFile).exists())
+        return null;
+      const parsed = path3.parse(entryFile);
+      const lastSlash = pkgName.lastIndexOf("/");
+      if (parsed.name !== "index" && lastSlash > 0 && pkgName.slice(lastSlash + 1) === parsed.name)
+        return { pkgName: pkgName.slice(0, lastSlash), entryFile, pkgDir: parsed.dir };
+      return { pkgName, entryFile, pkgDir: path3.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 = path3.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("/");
+            const parentSpec = lastSlash > 0 ? pkgName.slice(0, lastSlash) : pkgName;
+            return { pkgName: parentSpec, entryFile: file, pkgDir: path3.dirname(file) };
+          }
+        }
+        for (const ext of CANDIDATE_EXTS2) {
+          const file = path3.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 = path3.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 = path3.resolve(path3.dirname(pkgJsonPath), rel);
+      if (!await Bun.file(entryFile).exists())
+        return null;
+      return { pkgName, entryFile, pkgDir: path3.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 = path3.join(workspaceRoot, "node_modules", packageName, "package.json");
+  if (!await Bun.file(pkgJsonPath).exists())
+    return null;
+  try {
+    const pkgDir = path3.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?.startsWith("."))
+      return null;
+    const entryFile = await resolveFileCandidate(path3.resolve(pkgDir, rel));
+    if (!entryFile)
+      return null;
+    return { pkgName: specifier, entryFile, pkgDir: path3.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 (path3.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 = path3.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) => {
+  if (!barrels.some((barrel) => source.includes(barrel)))
+    return null;
+  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, false, 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;
+    statements.push({
+      start: statement.getStart(sourceFile),
+      end: statement.end,
+      clause: source.slice(importClause.getStart(sourceFile), importClause.end).trim(),
+      specifier: statement.moduleSpecifier.text
+    });
+  }
+  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;
+    parsed.named = parseNamedList(rest.slice(1, close));
+  }
+  return parsed;
+};
+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?.length)
+    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 = [];
+  if (shouldPreserveBarrelSideEffects(stmt.specifier))
+    lines.push(`import "${stmt.specifier}";`);
+  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}";`);
+  }
+  for (const [subpath, items] of rewrites) {
+    lines.push(`import { ${items.map(serializeNamedItem).join(", ")} } from "${subpath}";`);
+  }
+  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}`;
+};
+
+// pkgs/@akanjs/devkit/frontendBuild/clientEntryDiscovery.ts
+var USE_CLIENT_RE = /^\s*(?:\/\*[\s\S]*?\*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
+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;
+  #factsCache = new Map;
+  #resolvedFileCache = new Map;
+  #resolvedSpecifierCache = new Map;
+  #reachableEntriesCache = new Map;
+  #readFiles = new Set;
+  #epoch = 0;
+  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) {
+      const walk = { visiting: new Set, partial: new Set, memo: new Map };
+      for (const entry of await this.#discoverFromFile(seed, walk))
+        entries.add(entry);
+    }
+    return Array.from(entries).sort();
+  }
+  invalidate(files) {
+    if (files.length === 0)
+      return;
+    let moved = false;
+    for (const file of files) {
+      const absPath = path4.resolve(file);
+      const exists = fs.existsSync(absPath);
+      if (exists !== this.#readFiles.has(absPath))
+        moved = true;
+      if (!exists)
+        this.#readFiles.delete(absPath);
+      this.#factsCache.delete(absPath);
+      this.#fileExistsCache.delete(absPath);
+    }
+    this.#epoch += 1;
+    this.#reachableEntriesCache.clear();
+    if (!moved)
+      return;
+    this.#fileExistsCache.clear();
+    this.#resolvedFileCache.clear();
+    this.#resolvedSpecifierCache.clear();
+  }
+  #lookup(cache, key, run, isFound) {
+    const cached = cache.get(key);
+    if (cached && (cached.found || cached.epoch === this.#epoch))
+      return cached.promise;
+    const entry = { epoch: this.#epoch, promise: run() };
+    entry.promise.then((value) => {
+      entry.found = isFound(value);
+    }, () => {
+      entry.found = false;
+    });
+    cache.set(key, entry);
+    return entry.promise;
+  }
+  async#fileExists(p) {
+    const absPath = path4.resolve(p);
+    return await this.#lookup(this.#fileExistsCache, absPath, () => Bun.file(absPath).exists(), (exists) => exists);
+  }
+  #facts(file) {
+    const absPath = path4.resolve(file);
+    let cached = this.#factsCache.get(absPath);
+    if (!cached) {
+      cached = (async () => {
+        const content = await Bun.file(absPath).text().catch(() => null);
+        if (content === null)
+          return null;
+        this.#readFiles.add(absPath);
+        if (USE_CLIENT_RE.test(content))
+          return { isClientEntry: true, imports: [] };
+        return { isClientEntry: false, imports: this.#scanImports(await this.#rewrite(content)) };
+      })();
+      this.#factsCache.set(absPath, cached);
+    }
+    return cached;
+  }
+  async#rewrite(content) {
+    if (this.#akanConfig.barrelImports.length === 0)
+      return content;
+    try {
+      return await rewriteBarrelImports(content, this.#akanConfig.barrelImports, this.#analyzer) ?? content;
+    } catch {
+      return content;
+    }
+  }
+  #scanImports(source) {
+    try {
+      return this.#tsTranspiler.scanImports(source);
+    } catch {
+      return [];
+    }
+  }
+  async#resolveFileCandidate(absPathNoExt) {
+    const cacheKey = path4.resolve(absPathNoExt);
+    return await this.#lookup(this.#resolvedFileCache, cacheKey, 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 = path4.join(cacheKey, `index${ext}`);
+        if (await this.#fileExists(f))
+          return f;
+      }
+      return null;
+    }, (file) => file !== null);
+  }
+  async#resolveSpecifier(spec, importerDir) {
+    const cacheKey = `${importerDir}\x00${spec}`;
+    return await this.#lookup(this.#resolvedSpecifierCache, cacheKey, async () => {
+      if (spec.startsWith(".") || spec.startsWith("/")) {
+        const abs = spec.startsWith("/") ? spec : path4.resolve(importerDir, spec);
+        return await this.#resolveFileCandidate(abs);
+      }
+      const pkg = await this.#resolvePackage(spec);
+      return pkg ? pkg.entryFile : null;
+    }, (file) => file !== null);
+  }
+  async#discoverFromFile(file, walk) {
+    const epoch = this.#epoch;
+    const absPath = path4.resolve(file);
+    const cached = this.#reachableEntriesCache.get(absPath);
+    if (cached)
+      return new Set(cached);
+    const memo = walk.memo.get(absPath);
+    if (memo) {
+      if (walk.partial.has(absPath))
+        for (const onPath of walk.visiting)
+          walk.partial.add(onPath);
+      return new Set(memo);
+    }
+    if (walk.visiting.has(absPath)) {
+      let below = false;
+      for (const onPath of walk.visiting) {
+        if (below)
+          walk.partial.add(onPath);
+        else
+          below = onPath === absPath;
+      }
+      return new Set;
+    }
+    if (shouldSkipNodeModule(absPath))
+      return new Set;
+    walk.visiting.add(absPath);
+    const entries = new Set;
+    const facts = await this.#facts(absPath);
+    if (!facts)
+      return this.#finishDiscovery(absPath, walk, entries, epoch);
+    if (facts.isClientEntry) {
+      entries.add(absPath);
+      return this.#finishDiscovery(absPath, walk, entries, epoch);
+    }
+    const importerDir = path4.dirname(absPath);
+    for (const imp of facts.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, walk))
+        entries.add(entry);
+    }
+    return this.#finishDiscovery(absPath, walk, entries, epoch);
+  }
+  #finishDiscovery(absPath, walk, entries, epoch) {
+    walk.visiting.delete(absPath);
+    walk.memo.set(absPath, entries);
+    if (epoch === this.#epoch && !walk.partial.has(absPath))
+      this.#reachableEntriesCache.set(absPath, entries);
+    return new Set(entries);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/routeClientBuilder.ts
+import { mkdir } from "fs/promises";
+import path8 from "path";
+import { SSR_DEV_CHUNK, SSR_DEV_ID_PREFIX } from "akanjs/server/hmr/csrDevManifest";
+
+// pkgs/@akanjs/devkit/transforms/rscUseClientTransform.ts
+import path5 from "path";
+import ts2 from "typescript";
+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)$/;
+var STAR_REEXPORT_HINT_RE = /\bexport\s*\*\s*from\b/;
+var hasUseClientDirective = (source) => USE_CLIENT_RE2.test(source);
+function toClientReferencePath(absPath, workspaceRoot) {
+  return path5.relative(path5.resolve(workspaceRoot), path5.resolve(absPath)).split(path5.sep).join("/");
+}
+var starReexportSpecifiers = (source, filePath) => ts2.createSourceFile(filePath, source, ts2.ScriptTarget.Latest).statements.filter((statement) => ts2.isExportDeclaration(statement) && !statement.exportClause && !statement.isTypeOnly && !!statement.moduleSpecifier && ts2.isStringLiteral(statement.moduleSpecifier)).map((statement) => statement.moduleSpecifier.text);
+var scanUseClientExports = (source, filePath, workspaceRoot) => {
+  const stars = USE_CLIENT_RE2.test(source) && STAR_REEXPORT_HINT_RE.test(source) ? starReexportSpecifiers(source, filePath) : [];
+  if (stars.length) {
+    const file = workspaceRoot ? toClientReferencePath(filePath, workspaceRoot) : filePath;
+    const listed = stars.slice(0, 3).map((specifier) => `\`export * from ${JSON.stringify(specifier)}\``);
+    const written = stars.length > 3 ? `${listed.join(", ")} (and ${stars.length - 3} more)` : listed.join(", ");
+    throw new Error(`${file} is a "use client" module, so it cannot ${written}: the server sees only the names a client module ` + `declares, and a star re-export declares none. Re-export them by name \u2014 \`export { \u2026 } from ${JSON.stringify(stars[0])}\`.`);
+  }
+  return new Bun.Transpiler({ loader: loaderFor(filePath) }).scan(source).exports;
+};
+function transformUseClient(source, args) {
+  if (!USE_CLIENT_RE2.test(source))
+    return null;
+  if (IMPLICIT_ROOT_LAYOUT_RE.test(args.path))
+    return null;
+  const exports = scanUseClientExports(source, args.path, args.workspaceRoot);
+  if (exports.length === 0)
+    return null;
+  args.onClientModule?.(args.path, exports);
+  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(`
+`);
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/clientEntriesBundler.ts
+import fs2 from "fs";
+import path6 from "path";
+
+// pkgs/@akanjs/devkit/frontendBuild/bundleDefine.ts
+var bundleDefine = (app, command, renderEnv) => {
+  const nodeEnv = command === "build" ? "production" : "development";
+  return {
+    "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+    "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify(renderEnv),
+    ...Object.fromEntries(Object.entries(app.getPublicEnv()).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
+  };
+};
+
+// 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;
+  #target;
+  #outputSubdir;
+  #reactFastRefresh;
+  #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.#target = options.target ?? "browser";
+    this.#outputSubdir = options.outputSubdir ?? "client";
+    this.#reactFastRefresh = options.reactFastRefresh ?? false;
+    const artifactDir = `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
+    this.#outdir = `${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: this.#target,
+      format: "esm",
+      naming: CLIENT_BUNDLE_NAMING,
+      metafile: true,
+      define: bundleDefine(this.#app, this.#command, "ssr"),
+      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
+    };
+  }
+  async#createOpaqueEntryAliases() {
+    const aliasDir = path6.join(this.#app.cwdPath, ".akan", "generated", "client-entry-alias", this.#outputSubdir);
+    fs2.mkdirSync(aliasDir, { recursive: true });
+    const originalByAlias = new Map;
+    const aliasedEntries = await Promise.all(this.#entries.map(async (entry) => {
+      const absEntry = path6.resolve(entry);
+      const hash = Bun.hash(`${this.#app.name}
+${this.#outputSubdir}
+${absEntry}`).toString(36);
+      const aliasPath = path6.join(aliasDir, `${hash}.tsx`);
+      await Bun.write(aliasPath, this.#createOpaqueEntryAliasSource(absEntry, await this.#scanEntryExportNames(absEntry)));
+      originalByAlias.set(path6.resolve(aliasPath), absEntry);
+      return aliasPath;
+    }));
+    return { entries: aliasedEntries, originalByAlias, aliasDir };
+  }
+  #createOpaqueEntryAliasSource(absEntry, exportNames) {
+    const entryLit = JSON.stringify(path6.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) {
+    return scanUseClientExports(await Bun.file(absEntry).text(), absEntry, this.#app.workspace.workspaceRoot);
+  }
+  #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) || 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 = path6.relative(this.#outdir, absOutPath).split(path6.sep).join("/");
+    return `${this.#servePrefix}/${rel}`;
+  }
+  #absFromOutdir(p) {
+    return path6.isAbsolute(p) ? p : path6.resolve(this.#outdir, p);
+  }
+  #absFromEntryPoint(p) {
+    if (path6.isAbsolute(p))
+      return path6.resolve(p);
+    const candidates = [path6.resolve(process.cwd(), p), path6.resolve(this.#app.cwdPath, p)];
+    return candidates.find((candidate) => fs2.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/csrDevPaths.ts
+import fs3 from "fs";
+import path7 from "path";
+
+class CsrDevPaths {
+  static modulePrefix = "akan-module:";
+  static stubPrefix = "stub:";
+  static emptyStubPrefix = "stub:empty:";
+  static vendorPrefix = "vendor:";
+  root;
+  constructor(workspaceRoot) {
+    this.root = CsrDevPaths.realpath(workspaceRoot);
+  }
+  idOf(file) {
+    const real = CsrDevPaths.realpath(file);
+    const relative = path7.relative(this.root, real);
+    const id = relative.startsWith("..") || path7.isAbsolute(relative) ? real : relative;
+    return id.split(path7.sep).join("/");
+  }
+  fileOf(id) {
+    return path7.isAbsolute(id) ? id : path7.join(this.root, id);
+  }
+  static isStub(target) {
+    return target.startsWith(CsrDevPaths.stubPrefix);
+  }
+  static isVendorFile(file) {
+    return file.includes(`${path7.sep}node_modules${path7.sep}`);
+  }
+  static isScript(file) {
+    return /\.[cm]?[jt]sx?$/.test(file);
+  }
+  static mtimeOf(file) {
+    return fs3.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? -1;
+  }
+  static async hashOf(file) {
+    const source = Bun.file(file);
+    return await source.exists() ? Bun.hash(await source.arrayBuffer()).toString(36) : "";
+  }
+  static realpath(file) {
+    return fs3.existsSync(file) ? fs3.realpathSync.native(file) : path7.resolve(file);
+  }
+  static isNamed(file) {
+    try {
+      return fs3.realpathSync.native(file) === file;
+    } catch {
+      return false;
+    }
+  }
+  static #extensions = {
+    import: [".tsx", ".jsx", ".mts", ".ts", ".mjs", ".js", ".cts", ".cjs"],
+    require: [".tsx", ".ts", ".jsx", ".cts", ".cjs", ".js", ".mjs", ".mts"]
+  };
+  static resolveOnDisk(base, kind = "import") {
+    return CsrDevPaths.#asFile(base, kind) ?? CsrDevPaths.#asFolder(base, kind);
+  }
+  static resolveRelative(dir, specifier, kind = "import") {
+    const base = path7.resolve(dir, specifier);
+    const folder = /(^|[\\/])\.\.?$|[\\/]$/.test(specifier);
+    return folder ? CsrDevPaths.#asFolder(base, kind) : CsrDevPaths.resolveOnDisk(base, kind);
+  }
+  static #asFile(base, kind) {
+    const isFile = (candidate) => fs3.statSync(candidate, { throwIfNoEntry: false })?.isFile() ?? false;
+    return [base, ...CsrDevPaths.#extensions[kind].map((extension) => `${base}${extension}`)].find(isFile) ?? null;
+  }
+  static #asFolder(dir, kind) {
+    const entry = CsrDevPaths.#packageEntryOf(dir, kind);
+    const named = entry ? CsrDevPaths.#asFile(path7.join(dir, entry), kind) ?? CsrDevPaths.#indexOf(path7.join(dir, entry), kind) : null;
+    return named ?? CsrDevPaths.#indexOf(dir, kind);
+  }
+  static #indexOf(dir, kind) {
+    return CsrDevPaths.#asFile(path7.join(dir, "index"), kind);
+  }
+  static #packageEntryOf(dir, kind) {
+    try {
+      const pkg = JSON.parse(fs3.readFileSync(path7.join(dir, "package.json"), "utf8"));
+      const fields = kind === "require" ? [pkg.browser, pkg.main] : [pkg.browser, pkg.module, pkg.main];
+      const entry = fields.find((field) => typeof field === "string");
+      return typeof entry === "string" ? entry : null;
+    } catch {
+      return null;
+    }
+  }
+  static installedSince(specifier, from, since) {
+    const [first = "", second = ""] = specifier.split("/");
+    const name = first.startsWith("@") ? `${first}/${second}` : first;
+    if (!name || name.startsWith("."))
+      return false;
+    for (let dir = path7.resolve(from);; dir = path7.dirname(dir)) {
+      const pkgDir = path7.join(dir, "node_modules", name);
+      if (fs3.existsSync(path7.join(pkgDir, "package.json")))
+        return (fs3.statSync(pkgDir, { throwIfNoEntry: false })?.ctimeMs ?? 0) > since;
+      if (path7.dirname(dir) === dir)
+        return false;
+    }
+  }
+  static tryResolve(specifier, from) {
+    try {
+      return Bun.resolveSync(specifier, from);
+    } catch {
+      return null;
+    }
+  }
+  static lineCount(text) {
+    let count = 0;
+    for (let index = text.indexOf(`
+`);index !== -1; index = text.indexOf(`
+`, index + 1))
+      count += 1;
+    return count;
+  }
+}
+
+// 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",
+  "akanjs/fetch"
+];
+
+// pkgs/@akanjs/devkit/frontendBuild/routeClientBuilder.ts
+var SSR_CLIENT_ALIAS_EXTERNALS = [
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime"
+];
+var SSR_CLIENT_EXTERNALS = [...SSR_CLIENT_ALIAS_EXTERNALS, "akanjs/fetch"];
+
+class RouteClientBuilder {
+  #app;
+  #seeds;
+  #graphSeeds;
+  #knownEntries;
+  #command;
+  #discovery;
+  #entries;
+  #browser;
+  constructor(options) {
+    this.#app = options.app;
+    this.#seeds = options.seeds;
+    this.#graphSeeds = options.graphSeeds;
+    this.#knownEntries = options.knownEntries ?? new Set;
+    this.#command = options.command ?? "start";
+    this.#discovery = options.discovery;
+    this.#entries = options.entries;
+    this.#browser = options.browser ?? (this.#command === "start" ? "registry" : "chunks");
+  }
+  async build() {
+    const discovered = this.#entries ?? await (await this.#getDiscovery()).discover(this.#seeds);
+    if (discovered.every((e) => this.#knownEntries.has(e)))
+      return this.#emptyResult(discovered);
+    const entries = this.#graphSeeds ? [...new Set([...discovered, ...await (await this.#getDiscovery()).discover(this.#graphSeeds)])].sort() : discovered.filter((e) => !this.#knownEntries.has(e));
+    const bootstrapEntries = await this.#createBootstrapEntries(entries);
+    const registry = this.#browser === "registry" ? new CsrDevPaths(this.#app.workspace.workspaceRoot) : null;
+    const browserBundle = registry ? null : await this.#buildBrowserBundle(bootstrapEntries);
+    const ssrBundle = await this.#buildSsrBundle(bootstrapEntries);
+    const referenceBundle = browserBundle ?? ssrBundle;
+    const acceptedEntries = new Set(entries);
+    const routeEntries = new Set(discovered);
+    const manifestDelta = {};
+    const ssrModuleMap = {};
+    const clientDeps = new Set;
+    const clientDepsByEntry = {};
+    for (const [key, bundleRow] of Object.entries(referenceBundle.manifest)) {
+      const manifestEntry = RouteClientBuilder.resolveOriginalManifestEntry(key, bootstrapEntries.originalByBuildEntry, referenceBundle.clientReferenceIdByAbsPath, this.#app.workspace.workspaceRoot);
+      if (!manifestEntry)
+        continue;
+      if (!acceptedEntries.has(manifestEntry.originalEntry))
+        continue;
+      const row = registry ? RouteClientBuilder.#registryRow(registry, manifestEntry.originalEntry, bundleRow) : bundleRow;
+      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 = path8.resolve(entry);
+      const originalEntry = path8.resolve(bootstrapEntries.originalByBuildEntry.get(buildEntry) ?? buildEntry);
+      if (!acceptedEntries.has(originalEntry))
+        continue;
+      const deps = new Set([originalEntry]);
+      for (const dep of referenceBundle.entryDepsByAbsPath.get(buildEntry) ?? [])
+        deps.add(path8.resolve(dep));
+      const sortedDeps = [...deps].sort();
+      clientDepsByEntry[originalEntry] = sortedDeps;
+      if (routeEntries.has(originalEntry))
+        for (const dep of sortedDeps)
+          clientDeps.add(dep);
+    }
+    return {
+      manifestDelta,
+      ssrManifestDelta: { moduleLoading: null, moduleMap: ssrModuleMap },
+      newEntries: entries.filter((e) => !this.#knownEntries.has(e)),
+      discoveredEntries: discovered,
+      clientDeps: [...clientDeps].sort(),
+      clientDepsByEntry,
+      ...registry ? { registryEntries: [...acceptedEntries].sort() } : {}
+    };
+  }
+  static #registryRow(paths, entry, row) {
+    return {
+      id: `${SSR_DEV_ID_PREFIX}${paths.idOf(entry)}`,
+      chunks: [SSR_DEV_CHUNK, SSR_DEV_CHUNK],
+      name: row.name,
+      async: true
+    };
+  }
+  async#getDiscovery() {
+    this.#discovery ??= await GraphClientEntryDiscovery.create(this.#app);
+    return this.#discovery;
+  }
+  #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) {
+    return new ClientEntriesBundler({
+      app: this.#app,
+      entries: bootstrapEntries.buildEntries,
+      plugins: [await createBarrelImportsPlugin(this.#app)],
+      ...RouteClientBuilder.resolveSsrClientBundleOptions(this.#command),
+      outputSubdir: "client-ssr",
+      command: this.#command
+    }).bundle();
+  }
+  async#createBootstrapEntries(entries) {
+    if (!await Bun.file(path8.join(this.#app.cwdPath, "lib", "st.ts")).exists()) {
+      return { buildEntries: entries, originalByBuildEntry: new Map };
+    }
+    const outdir = path8.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 = path8.resolve(entry);
+      const hash = Bun.hash(`${this.#app.name}
+${absEntry}`).toString(36);
+      const base = path8.basename(absEntry).replace(/[^A-Za-z0-9._-]/g, "_");
+      const wrapperEntry = path8.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(path8.resolve(wrapperEntry), absEntry);
+      return wrapperEntry;
+    }));
+    return { buildEntries, originalByBuildEntry };
+  }
+  async#scanExportNames(absEntry) {
+    return scanUseClientExports(await Bun.file(absEntry).text(), absEntry, this.#app.workspace.workspaceRoot);
+  }
+  static normalizeNamedDefaultFunctionForFastRefresh(source, { path: filePath } = {}) {
+    const declared = RouteClientBuilder.#declaredNamedDefaultFunctions(source, filePath);
+    if (declared.length === 0)
+      return null;
+    let next = "";
+    let cursor = 0;
+    for (const { index, text, lineStart, indent, asyncKeyword, name } of declared) {
+      next += `${source.slice(cursor, index)}${lineStart}${indent}${asyncKeyword}function ${name}`;
+      cursor = index + text.length;
+    }
+    next += source.slice(cursor);
+    return `${next}
+${declared.map(({ name }) => `export default ${name};`).join(`
+`)}
+`;
+  }
+  static #declaredNamedDefaultFunctions(source, filePath) {
+    const candidates = [
+      ...source.matchAll(/(^|\n)(\s*)export\s+default\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)(?=\s*(?:<|\())/g)
+    ].map((match) => ({
+      index: match.index,
+      text: match[0],
+      lineStart: match[1] ?? "",
+      indent: match[2] ?? "",
+      asyncKeyword: match[3] ?? "",
+      name: match[4] ?? ""
+    }));
+    if (candidates.length === 0)
+      return [];
+    const probeName = (idx) => `__akanNamedDefault${idx}`;
+    let probe = "";
+    let cursor = 0;
+    candidates.forEach(({ index, text, lineStart, indent, asyncKeyword }, idx) => {
+      probe += `${source.slice(cursor, index)}${lineStart}${indent}export ${asyncKeyword}function ${probeName(idx)}`;
+      cursor = index + text.length;
+    });
+    probe += source.slice(cursor);
+    const exported = RouteClientBuilder.#scanExports(probe, filePath);
+    return candidates.filter((_, idx) => exported.has(probeName(idx)));
+  }
+  static #scanExports(source, filePath) {
+    try {
+      return new Set(new Bun.Transpiler({ loader: filePath ? loaderFor(filePath) : "tsx" }).scan(source).exports);
+    } catch {
+      return new Set;
+    }
+  }
+  static resolveSsrClientRuntimeAliases() {
+    const serverEntry = RouteClientBuilder.resolveAkanServerEntry();
+    return { [Bun.resolveSync("akanjs/fetch", serverEntry)]: "akanjs/fetch" };
+  }
+  static resolveSsrClientBundleOptions(command) {
+    if (command === "start") {
+      return {
+        target: "bun",
+        external: SSR_CLIENT_EXTERNALS,
+        externalSubpaths: ["akanjs/fetch"],
+        externalAliases: RouteClientBuilder.resolveSsrClientRuntimeAliases()
+      };
+    }
+    return { target: "bun", external: SSR_CLIENT_ALIAS_EXTERNALS };
+  }
+  static resolveAkanServerEntry() {
+    try {
+      return Bun.resolveSync("akanjs/server", import.meta.dir);
+    } catch {
+      return path8.resolve(import.meta.dir, "../../../server/index.ts");
+    }
+  }
+  static createStoreBootstrapEntrySource(args) {
+    const originalEntry = JSON.stringify(path8.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/autoImportSync.ts
+import { readdir, readFile, stat } from "fs/promises";
+import path9 from "path";
+import ts3 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 GLOBAL_NAMES = new Set(["fetch"]);
+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 = path9.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 = path9.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 = path9.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path9.isAbsolute(rel))
+      return null;
+    const base = path9.basename(abs);
+    if (TEST_FILE_RE.test(base) || base === "index.ts" || base === "index.tsx" || base.endsWith(".d.ts"))
+      return null;
+    const parts = rel.split(path9.sep).filter(Boolean);
+    const [scope, project, facet] = parts;
+    if (scope !== "apps" && scope !== "libs" || !project || !facet)
+      return null;
+    if (facet === "lib" && parts[3] === "__lib")
+      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 FileSys2.writeTextAtomic(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(path9.join(this.#workspaceRoot, ctx.scope, ctx.project));
+    const fileDir = path9.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 = path9.dirname(abs);
+    const libDir = path9.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(path9.join(libDir, `${barrel}.ts`)))
+        available.set(symbol, { specifier: relativeSpecifier(fileDir, path9.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(path9.join(pkgRoot, "lib"));
+    this.#domainCache.set(pkgRoot, index);
+    return index;
+  }
+  #domainPkgRootOf(file) {
+    const rel = path9.relative(this.#workspaceRoot, path9.resolve(file));
+    if (rel.startsWith("..") || path9.isAbsolute(rel))
+      return null;
+    const [scope, project, facet] = rel.split(path9.sep).filter(Boolean);
+    if (scope !== "apps" && scope !== "libs" || !project || facet !== "lib")
+      return null;
+    if (!domainKindOf(path9.basename(file)))
+      return null;
+    return path9.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 = ts3.createSourceFile(fileName, source, ts3.ScriptTarget.Latest, true, scriptKindFor(fileName));
+  const bound = collectBoundNames(sf);
+  const used = collectUsedReferences(sf);
+  const bareGlobals = collectBareGlobalReferences(sf);
+  const namedBySpecifier = new Map;
+  const namespaceImports = [];
+  for (const name of used) {
+    if (bound.has(name) || bareGlobals.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(ts3.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 (ts3.isImportClause(node)) {
+      if (node.name)
+        names.add(node.name.text);
+      const bindings = node.namedBindings;
+      if (bindings && ts3.isNamespaceImport(bindings))
+        names.add(bindings.name.text);
+      if (bindings && ts3.isNamedImports(bindings))
+        for (const el of bindings.elements)
+          names.add(el.name.text);
+    }
+    if ((ts3.isVariableDeclaration(node) || ts3.isFunctionDeclaration(node) || ts3.isClassDeclaration(node) || ts3.isParameter(node) || ts3.isBindingElement(node) || ts3.isEnumDeclaration(node) || ts3.isTypeAliasDeclaration(node) || ts3.isInterfaceDeclaration(node)) && node.name && ts3.isIdentifier(node.name))
+      names.add(node.name.text);
+    ts3.forEachChild(node, visit);
+  };
+  ts3.forEachChild(sf, visit);
+  return names;
+};
+var collectUsedReferences = (sf) => {
+  const used = new Set;
+  const visit = (node) => {
+    if (ts3.isIdentifier(node) && isReferencePosition(node))
+      used.add(node.text);
+    ts3.forEachChild(node, visit);
+  };
+  ts3.forEachChild(sf, visit);
+  return used;
+};
+var collectBareGlobalReferences = (sf) => {
+  const bare = new Set;
+  const visit = (node) => {
+    if (ts3.isIdentifier(node) && GLOBAL_NAMES.has(node.text) && isReferencePosition(node)) {
+      const parent = node.parent;
+      if (!(parent && ts3.isPropertyAccessExpression(parent) && parent.expression === node))
+        bare.add(node.text);
+    }
+    ts3.forEachChild(node, visit);
+  };
+  ts3.forEachChild(sf, visit);
+  return bare;
+};
+var isReferencePosition = (node) => {
+  const parent = node.parent;
+  if (!parent)
+    return true;
+  if (ts3.isPropertyAccessExpression(parent) && parent.name === node)
+    return false;
+  if (ts3.isQualifiedName(parent) && parent.right === node)
+    return false;
+  if (ts3.isPropertyAssignment(parent) && parent.name === node)
+    return false;
+  if (ts3.isPropertySignature(parent) && parent.name === node)
+    return false;
+  if (ts3.isBindingElement(parent) && parent.propertyName === node)
+    return false;
+  if (ts3.isImportSpecifier(parent) || ts3.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 || !ts3.isNamedImports(bindings))
+      continue;
+    if (!ts3.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 (ts3.isExpressionStatement(stmt) && ts3.isStringLiteral(stmt.expression))
+      end = stmt.getEnd();
+    else
+      break;
+  }
+  return end;
+};
+var scriptKindFor = (fileName) => fileName.endsWith(".tsx") ? ts3.ScriptKind.TSX : ts3.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(path9.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 = path9.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 = ts3.createSourceFile(fileName, source, ts3.ScriptTarget.Latest, true);
+  const isExported = (node) => ts3.canHaveModifiers(node) && (ts3.getModifiers(node) ?? []).some((m) => m.kind === ts3.SyntaxKind.ExportKeyword);
+  const names = [];
+  for (const stmt of sf.statements) {
+    if ((ts3.isClassDeclaration(stmt) || ts3.isFunctionDeclaration(stmt) || ts3.isEnumDeclaration(stmt)) && stmt.name) {
+      if (isExported(stmt))
+        names.push(stmt.name.text);
+    } else if (ts3.isVariableStatement(stmt) && isExported(stmt)) {
+      for (const decl of stmt.declarationList.declarations)
+        if (ts3.isIdentifier(decl.name))
+          names.push(decl.name.text);
+    } else if (ts3.isExportDeclaration(stmt) && stmt.exportClause && ts3.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 = path9.relative(fromDir, toFile).replace(/\.tsx?$/, "").split(path9.sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+};
+
+// pkgs/@akanjs/devkit/frontendBuild/serverGraphFile.ts
+import fs4 from "fs";
+import path10 from "path";
+class ServerGraphFile {
+  static fileName = "server-graph.json";
+  static #cache = null;
+  static async read(artifactDir) {
+    const file = path10.join(artifactDir, ServerGraphFile.fileName);
+    const stat = fs4.statSync(file, { throwIfNoEntry: false });
+    if (!stat)
+      return null;
+    const stamp = `${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+    const cached = ServerGraphFile.#cache;
+    if (cached?.file === file && cached.stamp === stamp)
+      return cached.graph;
+    const graph = await Bun.file(file).json().catch(() => null);
+    if (graph)
+      ServerGraphFile.#cache = { file, stamp, graph };
+    return graph;
+  }
+  static async write(artifactDir, graph) {
+    const file = path10.join(artifactDir, ServerGraphFile.fileName);
+    const temp = `${file}.${process.pid}.tmp`;
+    await Bun.write(temp, JSON.stringify(graph));
+    await FileSys2.replace(temp, file);
+  }
+  static async carry(artifactDir, files) {
+    const graph = await ServerGraphFile.read(artifactDir);
+    if (!graph || files.length === 0)
+      return;
+    const carried = [...new Set([...graph.carried ?? [], ...files.map((file) => CsrDevPaths.realpath(file))])];
+    await ServerGraphFile.write(artifactDir, { ...graph, carried });
+  }
+  static async touches(graph, files, exportsNow, next) {
+    if (!graph)
+      return true;
+    const inputs = new Set(graph.inputs);
+    const joined = new Set((next?.inputs ?? []).filter((input) => !inputs.has(input)));
+    for (const rawFile of files) {
+      const file = CsrDevPaths.realpath(rawFile);
+      if (joined.has(file))
+        return true;
+      if (!inputs.has(file))
+        continue;
+      const before = graph.clientExports[file];
+      if (!before)
+        return true;
+      const now = await exportsNow(file);
+      if (!now || ServerGraphFile.#names(now) !== ServerGraphFile.#names(before))
+        return true;
+    }
+    return false;
+  }
+  static async clientExportsOf(file) {
+    const source = await Bun.file(file).text().catch(() => null);
+    if (source === null || !hasUseClientDirective(source))
+      return null;
+    try {
+      return scanUseClientExports(source, file);
+    } catch {
+      return null;
+    }
+  }
+  static #names(exports) {
+    return [...exports].sort().join(",");
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
+import fs5 from "fs";
+import path13 from "path";
+
+// pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
+import path11 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",
+  "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 = path11.resolve(workspaceRoot, replPath + suffix);
+        const hit = await firstExisting(candidate);
+        if (hit)
+          return hit;
+      }
+    }
+    for (const { pkg, entryFile } of rootEntries) {
+      if (!spec.startsWith(`${pkg}/`))
+        continue;
+      const suffix = spec.slice(pkg.length + 1);
+      const pkgDir = path11.dirname(path11.resolve(workspaceRoot, entryFile));
+      const candidate = path11.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 };
+        }
+        if (!includePrefixes.some((prefix) => spec.startsWith(prefix)))
+          return;
+        const resolved = await resolveWorkspaceSubpath(spec);
+        return resolved ? { path: resolved } : undefined;
+      });
+    }
+  };
+}
+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 = path11.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,
+          onClientModule: options.onClientModule
+        });
+        if (stubbed === null)
+          return;
+        return { contents: stubbed, loader: loaderFor(args.path) };
+      });
+    }
+  };
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
+import path12 from "path";
+class PagesEntrySourceGenerator {
+  #pageEntries;
+  #asyncDefaults = new Map;
+  #detect;
+  constructor(pageEntries, { isAsyncDefault } = {}) {
+    this.#pageEntries = pageEntries;
+    this.#detect = isAsyncDefault ?? ((moduleAbsPath) => AsyncDefaultExportDetector.detect(moduleAbsPath));
+  }
+  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 async generateStatic(pageEntries, { fromDir } = {}) {
+    return await new PagesEntrySourceGenerator(pageEntries).generateStatic({ fromDir });
+  }
+  async generateStatic({ fromDir } = {}) {
+    const imports = this.#pageEntries.map(({ moduleAbsPath }, index) => {
+      const specifier = fromDir ? PagesEntrySourceGenerator.#toRelativeSpecifier(fromDir, moduleAbsPath) : PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
+      return `import * as page${index} from ${JSON.stringify(specifier)};`;
+    });
+    const entries = await Promise.all(this.#pageEntries.map(async ({ key, moduleAbsPath }, index) => {
+      const isAsyncDefault = await this.#isAsyncDefault(moduleAbsPath);
+      return `  ${JSON.stringify(key)}: { loader: async () => page${index}, isAsyncDefault: ${isAsyncDefault} },`;
+    }));
+    return `${imports.join(`
+`)}
+export const pages = {
+${entries.join(`
+`)}
+};
+`;
+  }
+  async generateHotReplace({
+    fromDir,
+    ownerId,
+    moduleIds
+  }) {
+    const entries = await Promise.all(this.#pageEntries.map(async ({ key, moduleAbsPath }) => {
+      const specifier = PagesEntrySourceGenerator.#toRelativeSpecifier(fromDir, moduleAbsPath);
+      const isAsyncDefault = await this.#isAsyncDefault(moduleAbsPath);
+      return `    ${JSON.stringify(key)}: { loader: async () => require(${JSON.stringify(specifier)}), isAsyncDefault: ${isAsyncDefault} },`;
+    }));
+    return `__akan.accept(${JSON.stringify(ownerId)}, ${JSON.stringify(moduleIds)}, async () => {
+  const replaced = await akanWebkit.replacePages({
+${entries.join(`
+`)}
+  });
+  if (!replaced) throw new Error("the route table no longer matches the pages it was built from");
+});
+`;
+  }
+  #isAsyncDefault(moduleAbsPath) {
+    const known = this.#asyncDefaults.get(moduleAbsPath);
+    if (known)
+      return known;
+    const detected = this.#detect(moduleAbsPath);
+    this.#asyncDefaults.set(moduleAbsPath, detected);
+    return detected;
+  }
+  static #toImportSpecifier(moduleAbsPath) {
+    return path12.resolve(moduleAbsPath).split(path12.sep).join("/");
+  }
+  static #toRelativeSpecifier(fromDir, moduleAbsPath) {
+    const relative = path12.relative(fromDir, path12.resolve(moduleAbsPath)).split(path12.sep).join("/");
+    return relative.startsWith(".") ? relative : `./${relative}`;
+  }
+}
+
+// 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 dev = this.#command === "start";
+    const clientExports = {};
+    const onClientModule = dev ? (file, exports) => {
+      clientExports[CsrDevPaths.realpath(file)] = exports;
+    } : undefined;
+    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: bundleDefine(this.#app, this.#command, "ssr"),
+      metafile: dev,
+      plugins: [
+        PagesBundleBuilder.createPagesEntryPlugin(entrySource),
+        PagesBundleBuilder.createCssStubPlugin(),
+        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,
+            onClientModule
+          })
+        }) : createUseClientBundlePlugin({ workspaceRoot, onClientModule })
+      ]
+    });
+    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 = path13.resolve(entryArtifact.path);
+    const buildId = Date.now();
+    if (dev && result.metafile)
+      await ServerGraphFile.write(this.#artifactDir, this.#serverGraph(result.metafile, clientExports));
+    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] ${path13.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
+    };
+  }
+  #serverGraph(metafile, clientExports) {
+    const inputs = Object.keys(metafile.inputs).filter((input) => !input.includes("node_modules")).map((input) => path13.resolve(input)).filter((input) => fs5.existsSync(input)).map((input) => CsrDevPaths.realpath(input));
+    return { inputs, clientExports };
+  }
+  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";
+  }
+  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 createCssStubPlugin() {
+    return {
+      name: "akan-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: loaderFor(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 });");
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevPatcher.ts
+import fs7 from "fs";
+import path15 from "path";
+import { appGenerationOf, CSR_DEV_MANIFEST_FILE } from "akanjs/server/hmr/csrDevManifest";
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevResolver.ts
+import fs6 from "fs";
+import path14 from "path";
+class CsrDevResolver {
+  static inline = "inline";
+  #paths;
+  #context;
+  #entryFiles;
+  #resolution = new Map;
+  #fallbacks = new Set;
+  #runtimeResolved = new Map;
+  #browserMaps = new Map;
+  #loaded = new Set;
+  #startedAt;
+  #prepassDone = false;
+  constructor({
+    paths,
+    context,
+    entryFiles,
+    resolution = {},
+    runtimeResolved = {},
+    startedAt = Date.now() - process.uptime() * 1000
+  }) {
+    this.#paths = paths;
+    this.#startedAt = startedAt;
+    this.#context = context;
+    this.#entryFiles = entryFiles;
+    for (const [importer, specifiers] of Object.entries(runtimeResolved))
+      this.#runtimeResolved.set(paths.fileOf(importer), new Set(specifiers));
+    for (const [importer, bySpecifier] of Object.entries(resolution))
+      this.#resolution.set(paths.fileOf(importer), new Map(Object.entries(bySpecifier).map(([specifier, target]) => [
+        specifier,
+        CsrDevPaths.isStub(target) ? target : paths.fileOf(target)
+      ])));
+  }
+  get prepassDone() {
+    return this.#prepassDone;
+  }
+  get fallbacks() {
+    return this.#fallbacks;
+  }
+  async prepass() {
+    const result = await Bun.build({
+      entrypoints: [...this.#entryFiles, ...this.#context.refreshFile ? [this.#context.refreshFile] : []],
+      target: "browser",
+      metafile: true,
+      external: [...this.#context.externals ?? []],
+      env: "AKAN_PUBLIC_*",
+      define: this.#context.define,
+      optimizeImports: this.#context.optimizeImports,
+      plugins: [PagesBundleBuilder.createCssStubPlugin()]
+    });
+    this.#record(result.metafile.inputs);
+    this.#prepassDone = true;
+  }
+  async cover(files) {
+    if (!this.#prepassDone)
+      return;
+    const pending = files.filter((file) => CsrDevPaths.isScript(file) && !this.#loaded.has(file));
+    if (pending.length === 0)
+      return;
+    for (const file of pending)
+      this.#loaded.add(file);
+    const entries = new Set(pending);
+    const result = await Bun.build({
+      entrypoints: pending,
+      target: "browser",
+      metafile: true,
+      throw: false,
+      external: [...this.#context.externals ?? []],
+      env: "AKAN_PUBLIC_*",
+      define: this.#context.define,
+      plugins: [
+        {
+          name: "akan-csr-cover",
+          setup: (build) => {
+            build.onLoad({ filter: /.*/ }, (args) => entries.has(CsrDevPaths.realpath(args.path)) ? undefined : { contents: "module.exports = {};", loader: "js" });
+          }
+        }
+      ]
+    });
+    if (result.metafile)
+      this.#record(result.metafile.inputs, entries);
+  }
+  #record(inputs, only) {
+    for (const [input, { imports }] of Object.entries(inputs)) {
+      const importer = CsrDevPaths.realpath(path14.resolve(input));
+      if (only && !only.has(importer))
+        continue;
+      if (imports.every((record) => record.original))
+        this.#loaded.add(importer);
+      for (const record of imports) {
+        if (!record.original)
+          continue;
+        if (record.external) {
+          if (record.original.startsWith("node:"))
+            this.#remember(importer, record.original, `${CsrDevPaths.stubPrefix}${record.original}`);
+          continue;
+        }
+        const target = path14.resolve(record.path);
+        if (!fs6.existsSync(target))
+          continue;
+        this.#remember(importer, record.original, CsrDevPaths.realpath(target));
+        this.#runtimeResolved.get(importer)?.delete(record.original);
+      }
+    }
+  }
+  resolve(importer, specifier, kind = "import") {
+    if (this.#isInlineSpecifier(specifier))
+      return CsrDevResolver.inline;
+    const disabled = this.#disabledInBrowser(importer, specifier, kind);
+    if (disabled)
+      return disabled;
+    const known = this.#resolution.get(importer)?.get(specifier);
+    const usable = known && this.#stillAnswers(importer, specifier, known, kind) ? known : null;
+    const target = usable ?? this.#resolveUnknown(importer, specifier, kind);
+    if (target === null || CsrDevPaths.isStub(target))
+      return target;
+    if (!CsrDevPaths.isScript(target))
+      return CsrDevResolver.inline;
+    if (!usable)
+      this.#remember(importer, specifier, target);
+    return target;
+  }
+  #stillAnswers(importer, specifier, known, kind) {
+    if (CsrDevPaths.isStub(known))
+      return true;
+    if (!fs6.existsSync(known))
+      return false;
+    if (!specifier.startsWith(".") || CsrDevPaths.isVendorFile(importer))
+      return true;
+    if (this.#hasBrowserMap(path14.dirname(importer)))
+      return true;
+    const onDisk = CsrDevPaths.resolveRelative(path14.dirname(importer), specifier, kind);
+    return onDisk !== null && CsrDevPaths.realpath(onDisk) === known;
+  }
+  isRegistryModule(file) {
+    if (!CsrDevPaths.isScript(file))
+      return false;
+    const packageName = CsrDevResolver.#packageNameOf(file);
+    if (packageName === null)
+      return true;
+    return !this.#context.optimizeImports.some((pattern) => {
+      const base = CsrDevResolver.#patternBase(pattern);
+      return base === packageName || base.startsWith(`${packageName}/`);
+    });
+  }
+  #disabledInBrowser(importer, specifier, kind) {
+    const map = this.#browserMapOf(path14.dirname(importer));
+    if (!map || map.offFiles.size === 0 && map.offNames.size === 0)
+      return null;
+    if (!specifier.startsWith(".") && !path14.isAbsolute(specifier))
+      return map.offNames.has(specifier) ? `${CsrDevPaths.emptyStubPrefix}${specifier}` : null;
+    const target = CsrDevPaths.resolveRelative(path14.dirname(importer), specifier, kind);
+    return target && map.offFiles.has(CsrDevPaths.realpath(target)) ? `${CsrDevPaths.emptyStubPrefix}${this.#paths.idOf(target)}` : null;
+  }
+  #hasBrowserMap(dir) {
+    return this.#browserMapOf(dir) !== null;
+  }
+  #browserMapOf(dir) {
+    const cached = this.#browserMaps.get(dir);
+    if (cached !== undefined)
+      return cached;
+    const pkgFile = path14.join(dir, "package.json");
+    const parent = path14.dirname(dir);
+    let map = null;
+    if (fs6.existsSync(pkgFile)) {
+      try {
+        const browser = JSON.parse(fs6.readFileSync(pkgFile, "utf8")).browser;
+        if (typeof browser === "object" && browser !== null) {
+          const off = Object.entries(browser).filter(([, target]) => target === false).map(([key]) => key);
+          const files = off.filter((key) => key.startsWith(".")).map((key) => CsrDevPaths.resolveRelative(dir, key)).filter((file) => !!file);
+          map = {
+            offFiles: new Set(files.map((file) => CsrDevPaths.realpath(file))),
+            offNames: new Set(off.filter((key) => !key.startsWith(".")))
+          };
+        }
+      } catch {}
+    } else if (parent !== dir)
+      map = this.#browserMapOf(parent);
+    this.#browserMaps.set(dir, map);
+    return map;
+  }
+  forget(importer) {
+    this.#resolution.delete(importer);
+    this.#runtimeResolved.delete(importer);
+  }
+  serializeRuntimeResolved() {
+    return Object.fromEntries([...this.#runtimeResolved].filter(([, specifiers]) => specifiers.size > 0).map(([importer, specifiers]) => [this.#paths.idOf(importer), [...specifiers].sort()]));
+  }
+  serialize() {
+    return Object.fromEntries([...this.#resolution].map(([importer, bySpecifier]) => [
+      this.#paths.idOf(importer),
+      Object.fromEntries([...bySpecifier].filter(([, target]) => CsrDevPaths.isStub(target) || fs6.existsSync(target)).map(([specifier, target]) => [specifier, CsrDevPaths.isStub(target) ? target : this.#paths.idOf(target)]))
+    ]));
+  }
+  #resolveUnknown(importer, specifier, kind) {
+    if (specifier.startsWith("node:"))
+      return `${CsrDevPaths.stubPrefix}${specifier}`;
+    const relative = specifier.startsWith(".") || path14.isAbsolute(specifier);
+    const cannotResolve = () => new Error(`[csr-dev] cannot resolve "${specifier}" from ${this.#paths.idOf(importer)}`);
+    if (relative) {
+      const onDisk = CsrDevPaths.resolveRelative(path14.dirname(importer), specifier, kind) ?? CsrDevResolver.#onDisk(CsrDevPaths.tryResolve(specifier, path14.dirname(importer)));
+      if (!onDisk)
+        throw cannotResolve();
+      return CsrDevPaths.realpath(onDisk);
+    }
+    const sibling = this.#resolvedBySibling(importer, specifier);
+    if (sibling)
+      return sibling;
+    const resolved = CsrDevPaths.tryResolve(specifier, path14.dirname(importer));
+    const moved = resolved !== null && path14.isAbsolute(resolved) && !fs6.existsSync(resolved);
+    const installed = resolved === null && CsrDevPaths.installedSince(specifier, path14.dirname(importer), this.#startedAt);
+    if (!this.#prepassDone || moved) {
+      if (resolved === null && !installed && !CsrDevPaths.isVendorFile(importer))
+        throw cannotResolve();
+      return null;
+    }
+    if (!resolved) {
+      if (installed)
+        return null;
+      throw cannotResolve();
+    }
+    if (!path14.isAbsolute(resolved))
+      return `${CsrDevPaths.stubPrefix}${specifier}`;
+    this.#fallbacks.add(specifier);
+    this.#runtimeResolved.set(importer, (this.#runtimeResolved.get(importer) ?? new Set).add(specifier));
+    return CsrDevPaths.realpath(resolved);
+  }
+  static #onDisk(resolved) {
+    return resolved && path14.isAbsolute(resolved) && fs6.existsSync(resolved) ? resolved : null;
+  }
+  #resolvedBySibling(importer, specifier) {
+    const scope = CsrDevResolver.#packageScopeOf(importer);
+    for (const [other, bySpecifier] of this.#resolution) {
+      const target = bySpecifier.get(specifier);
+      if (!target || other === importer || this.#runtimeResolved.get(other)?.has(specifier))
+        continue;
+      if (!CsrDevPaths.isStub(target) && !fs6.existsSync(target))
+        continue;
+      if (CsrDevResolver.#packageScopeOf(other) === scope)
+        return target;
+    }
+    return null;
+  }
+  #remember(importer, specifier, target) {
+    const byImporter = this.#resolution.get(importer) ?? new Map;
+    this.#resolution.set(importer, byImporter.set(specifier, target));
+  }
+  #isInlineSpecifier(specifier) {
+    if (specifier.startsWith(".") || path14.isAbsolute(specifier) || specifier.startsWith("node:"))
+      return false;
+    return this.#context.optimizeImports.some((pattern) => {
+      const base = CsrDevResolver.#patternBase(pattern);
+      return specifier === base || specifier.startsWith(`${base}/`);
+    });
+  }
+  static #patternBase(pattern) {
+    return pattern.endsWith("/*") ? pattern.slice(0, -2) : pattern;
+  }
+  static #packageNameOf(file) {
+    const marker = `${path14.sep}node_modules${path14.sep}`;
+    const index = file.lastIndexOf(marker);
+    if (index < 0)
+      return null;
+    const [scope, name] = file.slice(index + marker.length).split(path14.sep);
+    return (scope?.startsWith("@") ? `${scope}/${name}` : scope) || null;
+  }
+  static #packageScopeOf(file) {
+    const marker = `${path14.sep}node_modules${path14.sep}`;
+    const index = file.lastIndexOf(marker);
+    if (index < 0)
+      return "";
+    const [scope, name] = file.slice(index + marker.length).split(path14.sep);
+    return file.slice(0, index + marker.length) + (scope?.startsWith("@") ? `${scope}${path14.sep}${name}` : scope);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevPatcher.ts
+class CsrDevPatcher {
+  #bundler;
+  #resident;
+  #state = null;
+  #delegated = new Map;
+  constructor(bundler, { resident = false } = {}) {
+    this.#bundler = bundler;
+    this.#resident = resident;
+  }
+  forget() {
+    this.#state = null;
+  }
+  releaseHandedOver() {
+    for (const [id, handedOver] of this.#delegated)
+      if (!handedOver.failed)
+        this.#delegated.delete(id);
+  }
+  async update(changedFiles = [], { announce, roots = [], onlyRoots = false, allowWholeAppBuilds = false } = {}) {
+    const context = await this.#bundler.context();
+    if (!context)
+      return { kind: "unchanged" };
+    const resident = this.#state;
+    const state = resident ?? await this.#load();
+    if (!state) {
+      const manifest = await this.#bundler.writer.readJson(CSR_DEV_MANIFEST_FILE);
+      const reason = !manifest ? "first build" : await this.#bundler.writer.isBuilding() ? "the last whole build was cut short" : "the dev bundle config changed";
+      return this.#handBack(reason, (manifest?.generation ?? 0) + 1, context, { first: !manifest });
+    }
+    const generation = state.manifest.generation + 1;
+    if (state.graph.configKey !== context.configKey)
+      return this.#handBack("the dev bundle config changed", generation, context);
+    const metadataFile = changedFiles.find((file) => this.#bundler.isMetadataFile(file));
+    if (metadataFile)
+      return this.#handBack(`${path15.basename(metadataFile)} changed`, generation, context);
+    if (!resident && state.graph.metadata !== await this.#bundler.metadataFingerprint())
+      return this.#handBack("signal or dictionary metadata changed since the registry was built", generation, context);
+    this.#state = this.#resident ? state : null;
+    const healable = appGenerationOf(state.manifest) < state.manifest.generation && this.#withoutFactory(state, (file) => fs7.existsSync(file)).length === 0;
+    if (healable)
+      state.manifest = await this.#bundler.writer.healApp(state.graph, state.manifest, await this.#code(state));
+    return await this.#patch(context, state, changedFiles, generation, {
+      announce,
+      roots,
+      onlyRoots,
+      allowWholeAppBuilds
+    });
+  }
+  async#patch(context, state, changedFiles, generation, { announce, roots = [], onlyRoots = false, allowWholeAppBuilds }) {
+    const { paths, writer } = this.#bundler;
+    const { graph } = state;
+    const entries = await this.#bundler.writeEntries(context);
+    const entryIds = this.#bundler.entryIds(entries.files);
+    const present = CsrDevPatcher.#presence(changedFiles);
+    const forgotten = this.#forgetDeletedModules(state, present);
+    const changed = onlyRoots ? new Set : await this.#changedModules(graph, changedFiles, present);
+    for (const id of this.#withoutFactory(state, present))
+      changed.add(id);
+    for (const file of entries.changed)
+      changed.add(paths.idOf(file));
+    const rootFiles = [...Object.values(entries.files), ...roots.filter((file) => fs7.existsSync(file))];
+    for (const file of rootFiles) {
+      const id = paths.idOf(file);
+      if (!graph.modules[id] && !(onlyRoots && await this.#parked(graph, id)))
+        changed.add(id);
+    }
+    const carried = onlyRoots ? [] : await this.#carriedRoots(graph, changed, present);
+    const routesMoved = this.#bundler.reloadsOnEntryChange && (entries.changed.length > 0 || JSON.stringify(entryIds) !== JSON.stringify(graph.entries));
+    if (changed.size === 0) {
+      if (carried.length === 0)
+        return { kind: "unchanged" };
+      return await this.#retryCarried(context, state, carried, { announce, allowWholeAppBuilds });
+    }
+    const resolver = new CsrDevResolver({
+      paths,
+      context,
+      entryFiles: rootFiles.map((file) => CsrDevPaths.realpath(file)),
+      resolution: graph.resolution,
+      runtimeResolved: graph.runtimeResolved
+    });
+    const known = new Set(Object.keys(graph.modules).map((id) => paths.fileOf(id)));
+    const compile = async (ids) => await this.#bundler.compiler(context, resolver).compile(ids.map((id) => paths.fileOf(id)), known, { refuseNewVendor: !allowWholeAppBuilds, refusePrepass: !allowWholeAppBuilds });
+    let result;
+    let orphans;
+    try {
+      ({ result, orphans } = await this.#compileLeavingOrphans(compile, graph, changed));
+      for (const module of result.modules)
+        known.add(module.file);
+      result = await this.#withTwinImporters(compile, graph, result);
+    } catch (error) {
+      graph.pending = [...new Set([...graph.pending, ...changed, ...carried])];
+      if (!this.#resident)
+        graph.failed = {
+          roots: [...changed, ...carried],
+          files: await CsrDevPatcher.#hashesOf(paths, CsrDevPatcher.#implicatedFiles(error))
+        };
+      await writer.writeJson("graph.json", graph);
+      throw error;
+    }
+    const refusal = result.refusedVendors.length > 0 ? "an npm module joined the graph" : result.unresolved.length > 0 ? `a new import needs the resolution build: ${result.unresolved[0]}` : null;
+    if (refusal) {
+      if (routesMoved)
+        await writer.writeJson("graph.json", { ...graph, entries: {} });
+      if (onlyRoots) {
+        for (const id of changed)
+          if (!graph.modules[id])
+            this.#delegated.set(id, {
+              hash: await CsrDevPaths.hashOf(paths.fileOf(id)),
+              before: JSON.stringify(graph.failed ?? null)
+            });
+      }
+      return this.#handBack(refusal, generation, context);
+    }
+    const compiled = result.modules;
+    const vendorJoined = compiled.some((module) => module.vendor && !graph.modules[module.id]);
+    const code = await this.#code(state);
+    for (const id of [...orphans, ...this.#caseTwins(graph, compiled)]) {
+      delete graph.modules[id];
+      resolver.forget(paths.fileOf(id));
+      code?.modules.delete(id);
+      forgotten.push(id);
+    }
+    graph.pending = graph.pending.filter((id) => !orphans.includes(id));
+    this.#bundler.merge(graph, resolver, compiled);
+    if (!this.#resident)
+      delete graph.failed;
+    for (const module of compiled)
+      this.#delegated.delete(module.id);
+    graph.entries = entryIds;
+    for (const module of compiled) {
+      if (module.vendor || !code)
+        continue;
+      code.modules.set(module.id, module.factory);
+      if (module.helpers)
+        code.helpers.set(module.helpers.hash, module.helpers.definition);
+    }
+    const changedIds = compiled.filter((module) => !module.vendor).map((module) => module.id);
+    const constantId = changedIds.find((id) => id.endsWith(".constant.ts"));
+    const reason = vendorJoined ? "an npm module joined the graph" : routesMoved ? "the route table changed" : constantId ? `${path15.basename(constantId)} changed` : undefined;
+    if (compiled.length === 0 && !reason) {
+      await writer.writeJson("graph.json", graph);
+      await writer.forgetModules(forgotten);
+      if (carried.length === 0)
+        return { kind: "unchanged" };
+      return await this.#retryCarried(context, state, carried, { announce, allowWholeAppBuilds });
+    }
+    const previous = state.manifest;
+    const next = { ...previous, generation, entries: entryIds };
+    const update = (patchUrl) => ({
+      generation,
+      reload: !!reason,
+      reason,
+      patchUrl,
+      changedIds,
+      moduleCount: Object.keys(graph.modules).length,
+      epoch: previous.epoch
+    });
+    let outcome;
+    if (reason) {
+      await writer.forgetPatch(generation);
+      await writer.writeModules(compiled);
+      const vendorFile = vendorJoined ? await writer.writeVendor(graph) : previous.vendorFile;
+      await writer.writeApp(graph, { generation, vendorFile, epoch: previous.epoch }, code);
+      state.manifest = { ...next, vendorFile, appGeneration: generation };
+      await writer.writeState(graph, state.manifest);
+      await writer.prune(vendorFile, generation);
+      const reloaded = update();
+      announce?.(reloaded);
+      outcome = { kind: "update", update: reloaded };
+    } else {
+      const patched = update(await writer.writePatch(generation, compiled.filter((module) => !module.vendor)));
+      await writer.commitPatch(graph, { ...next, appGeneration: appGenerationOf(previous) }, () => announce?.(patched), { modules: compiled, code });
+      state.manifest = { ...next, appGeneration: generation };
+      await writer.prune(previous.vendorFile, generation);
+      outcome = { kind: "update", update: patched };
+    }
+    await writer.forgetModules(forgotten);
+    if (carried.length === 0)
+      return outcome;
+    const retried = await this.#retryCarried(context, state, carried, { announce, allowWholeAppBuilds });
+    return retried.kind === "delegate" ? retried : outcome;
+  }
+  async#retryCarried(context, state, carried, { announce, allowWholeAppBuilds }) {
+    const { paths, writer } = this.#bundler;
+    const retried = await this.#patch(context, state, [], state.manifest.generation + 1, {
+      announce,
+      roots: carried.map((id) => paths.fileOf(id)),
+      onlyRoots: true,
+      allowWholeAppBuilds
+    });
+    if (retried.kind === "delegate") {
+      state.graph.pending = [...new Set([...state.graph.pending, ...carried])];
+      await writer.writeJson("graph.json", state.graph);
+    }
+    return retried;
+  }
+  async#compileLeavingOrphans(compile, graph, changed) {
+    const { paths } = this.#bundler;
+    try {
+      return { result: await compile([...changed]), orphans: [] };
+    } catch (error) {
+      const failing = new Set(CsrDevPatcher.#failingFiles(error).map((file) => paths.idOf(file)));
+      const broken = [...changed].filter((id) => failing.has(id) && graph.modules[id]);
+      if (broken.length === 0)
+        throw error;
+      const rest = [...changed].filter((id) => !broken.includes(id));
+      const empty = { modules: [], refusedVendors: [], unresolved: [] };
+      const result = rest.length === 0 ? empty : await compile(rest).catch(() => {
+        throw error;
+      });
+      const modules = { ...graph.modules };
+      for (const module of result.modules)
+        modules[module.id] = {
+          vendor: module.vendor,
+          mtimeMs: module.mtimeMs,
+          hash: module.hash,
+          deps: module.deps.map((dep) => CsrDevPaths.isStub(dep) ? dep : paths.idOf(dep))
+        };
+      const reached = await this.#bundler.reachable({ ...graph, modules });
+      if (broken.some((id) => reached.has(id)))
+        throw error;
+      const orphans = Object.keys(modules).filter((id) => !reached.has(id) && !modules[id]?.vendor);
+      return { result, orphans };
+    }
+  }
+  #caseTwins(graph, compiled) {
+    const { paths } = this.#bundler;
+    const idsByFold = new Map;
+    for (const id of Object.keys(graph.modules))
+      idsByFold.set(id.toLowerCase(), [...idsByFold.get(id.toLowerCase()) ?? [], id]);
+    return compiled.flatMap((module) => (idsByFold.get(module.id.toLowerCase()) ?? []).filter((id) => id !== module.id && !graph.modules[id]?.vendor && !CsrDevPaths.isNamed(paths.fileOf(id))));
+  }
+  async#withTwinImporters(compile, graph, result) {
+    const twins = new Set(this.#caseTwins(graph, result.modules));
+    if (twins.size === 0)
+      return result;
+    const compiledIds = new Set(result.modules.map((module) => module.id));
+    const importers = Object.entries(graph.modules).filter(([id, module]) => !module.vendor && !compiledIds.has(id) && !twins.has(id)).filter(([, module]) => module.deps.some((dep) => twins.has(dep))).map(([id]) => id);
+    if (importers.length === 0)
+      return result;
+    const more = await compile(importers);
+    return {
+      modules: [...result.modules, ...more.modules],
+      refusedVendors: [...result.refusedVendors, ...more.refusedVendors],
+      unresolved: [...result.unresolved, ...more.unresolved]
+    };
+  }
+  static #implicatedFiles(error) {
+    const failing = CsrDevPatcher.#failingFiles(error);
+    const messages = error instanceof AggregateError ? error.errors : [];
+    const named = messages.flatMap((message) => {
+      const text = String(message.message ?? "");
+      const bases = [process.cwd(), ...failing.map((file) => path15.dirname(file))];
+      return [...text.matchAll(/"([^"\n]+)"/g)].flatMap(([, quoted = ""]) => {
+        const found = bases.map((base) => path15.resolve(base, quoted)).find((file) => CsrDevPaths.isScript(file) && fs7.existsSync(file));
+        return found ? [CsrDevPaths.realpath(found)] : [];
+      });
+    });
+    return [...new Set([...failing, ...named])];
+  }
+  static #failingFiles(error) {
+    const messages = error instanceof AggregateError ? error.errors : [];
+    return messages.map((message) => message.position?.file).filter((file) => typeof file === "string" && path15.isAbsolute(file)).map((file) => CsrDevPaths.realpath(file));
+  }
+  async#carriedRoots(graph, changed, present) {
+    const { paths } = this.#bundler;
+    const outside = graph.pending.filter((id) => !graph.modules[id] && !changed.has(id) && present(paths.fileOf(id)));
+    if (outside.length === 0)
+      return [];
+    const wanted = await this.#bundler.wantedRoots(outside.map((id) => paths.fileOf(id)), graph);
+    const kept = outside.filter((id) => wanted.has(paths.fileOf(id)));
+    graph.pending = graph.pending.filter((id) => graph.modules[id] || kept.includes(id));
+    const carried = [];
+    for (const id of kept)
+      if (!await this.#parked(graph, id))
+        carried.push(id);
+    return carried;
+  }
+  async#parked(graph, id) {
+    const { paths } = this.#bundler;
+    const handedOver = this.#delegated.get(id);
+    if (!handedOver || handedOver.hash !== await CsrDevPaths.hashOf(paths.fileOf(id)))
+      return false;
+    if (!handedOver.failed) {
+      if (JSON.stringify(graph.failed ?? null) === handedOver.before)
+        return true;
+      if (graph.failed?.roots.includes(id))
+        handedOver.failed = graph.failed.files;
+    }
+    if (!handedOver.failed)
+      return false;
+    for (const [failedId, hash] of Object.entries(handedOver.failed))
+      if (await CsrDevPaths.hashOf(paths.fileOf(failedId)) !== hash)
+        return false;
+    return true;
+  }
+  static async#hashesOf(paths, files) {
+    return Object.fromEntries(await Promise.all(files.map(async (file) => [paths.idOf(file), await CsrDevPaths.hashOf(file)])));
+  }
+  #withoutFactory({ graph, code }, present) {
+    const { paths, writer } = this.#bundler;
+    const hasFactory = (id) => code ? code.modules.has(id) : writer.hasModule(id);
+    return Object.entries(graph.modules).filter(([id, module]) => !module.vendor && !hasFactory(id) && present(paths.fileOf(id))).map(([id]) => id);
+  }
+  static #presence(changedFiles) {
+    const caseMoved = changedFiles.some((file) => fs7.existsSync(file) && !CsrDevPaths.isNamed(file));
+    return caseMoved ? (file) => CsrDevPaths.isNamed(file) : (file) => fs7.existsSync(file);
+  }
+  #handBack(reason, generation, context, { first = false } = {}) {
+    this.#state = null;
+    return { kind: "delegate", reason, generation, context, ...first ? { first } : {} };
+  }
+  async#load() {
+    const manifest = await this.#bundler.writer.readJson(CSR_DEV_MANIFEST_FILE);
+    const graph = await this.#bundler.writer.readJson("graph.json");
+    if (!manifest || !graph || graph.version !== 1 || await this.#bundler.writer.isBuilding())
+      return null;
+    return { graph, manifest, code: null };
+  }
+  async#code(state) {
+    if (!this.#resident)
+      return;
+    state.code ??= await this.#bundler.writer.readCode(state.graph);
+    return state.code;
+  }
+  async#changedModules(graph, changedFiles, present) {
+    const { paths } = this.#bundler;
+    const changed = new Set(graph.pending.filter((id) => graph.modules[id]));
+    for (const file of changedFiles) {
+      const id = paths.idOf(file);
+      if (graph.modules[id])
+        changed.add(id);
+    }
+    for (const id of this.#shadowedImporters(graph, changedFiles))
+      changed.add(id);
+    for (const [id, module] of Object.entries(graph.modules)) {
+      if (module.vendor || changed.has(id))
+        continue;
+      const file = paths.fileOf(id);
+      if (CsrDevPaths.mtimeOf(file) === module.mtimeMs)
+        continue;
+      if (await CsrDevPaths.hashOf(file) !== module.hash)
+        changed.add(id);
+    }
+    for (const [id, module] of Object.entries(graph.modules)) {
+      if (changed.has(id))
+        continue;
+      for (const dep of module.deps) {
+        if (graph.modules[dep] || CsrDevPaths.isStub(dep))
+          continue;
+        const file = paths.fileOf(dep);
+        if (present(file) && CsrDevPaths.isNamed(file))
+          changed.add(dep);
+        else if (!module.vendor)
+          changed.add(id);
+      }
+    }
+    return changed;
+  }
+  #shadowedImporters(graph, changedFiles) {
+    const { paths } = this.#bundler;
+    const bases = new Set(changedFiles.map((file) => CsrDevPaths.realpath(file)).filter((file) => !graph.modules[paths.idOf(file)] && CsrDevPaths.isScript(file) && fs7.existsSync(file)).flatMap((file) => {
+      const stem = file.slice(0, file.length - path15.extname(file).length);
+      return path15.basename(stem) === "index" ? [stem, path15.dirname(stem)] : [stem];
+    }));
+    if (bases.size === 0)
+      return [];
+    return Object.entries(graph.resolution).filter(([importer, bySpecifier]) => {
+      if (!graph.modules[importer] || graph.modules[importer]?.vendor)
+        return false;
+      const dir = path15.dirname(paths.fileOf(importer));
+      return Object.keys(bySpecifier).some((specifier) => specifier.startsWith(".") && bases.has(path15.resolve(dir, specifier)));
+    }).map(([importer]) => importer);
+  }
+  #forgetDeletedModules({ graph, code }, present) {
+    const { paths } = this.#bundler;
+    const deleted = Object.keys(graph.modules).filter((id) => !graph.modules[id]?.vendor && !present(paths.fileOf(id)));
+    for (const id of deleted) {
+      delete graph.modules[id];
+      code?.modules.delete(id);
+    }
+    return deleted;
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevBundler.ts
+import { mkdir as mkdir3 } from "fs/promises";
+import path21 from "path";
+import { CSR_DEV_DIRNAME, CSR_DEV_ROUTE_PREFIX } from "akanjs/server/hmr/csrDevManifest";
+
+// pkgs/@akanjs/devkit/frontendBuild/csrEntryFiles.ts
+import path16 from "path";
+
+class CsrEntryFiles {
+  static entryFilename(basePath) {
+    return `${basePath || "index"}.csr.tsx`;
+  }
+  static pageEntriesForBasePath(pageEntries, basePath, basePaths) {
+    return pageEntries.filter((entry) => {
+      const entryBasePath = CsrEntryFiles.basePathOfPageKey(entry.key, basePaths);
+      return entryBasePath === null || entryBasePath === basePath;
+    });
+  }
+  static basePathOfPageKey(pageKey, basePaths) {
+    const normalized = pageKey.split(path16.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/devRegistryBundler.ts
+import fs10 from "fs";
+import path20 from "path";
+import { isAkanRuntimeMetadataFile } from "akanjs/server/hmr/runtimeMetadataFile";
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevArtifactWriter.ts
+import fs8 from "fs";
+import { mkdir as mkdir2, readdir as readdir2, rm } from "fs/promises";
+import path17 from "path";
+import {
+  appGenerationOf as appGenerationOf2,
+  CSR_DEV_APP_FILE,
+  CSR_DEV_KEPT_PATCHES,
+  CSR_DEV_MANIFEST_FILE as CSR_DEV_MANIFEST_FILE2,
+  CSR_DEV_PATCHING_MARKER,
+  csrDevModuleFile
+} from "akanjs/server/hmr/csrDevManifest";
+class CsrDevArtifactWriter {
+  static #keptVendors = 3;
+  static #buildingMarker = ".building";
+  #outDir;
+  #routePrefix;
+  #library;
+  constructor(outDir, { routePrefix, library = false }) {
+    this.#outDir = outDir;
+    this.#routePrefix = routePrefix;
+    this.#library = library;
+  }
+  async markBuilding() {
+    await Bun.write(path17.join(this.#outDir, CsrDevArtifactWriter.#buildingMarker), String(process.pid));
+  }
+  async clearBuilding() {
+    await CsrDevArtifactWriter.#remove(path17.join(this.#outDir, CsrDevArtifactWriter.#buildingMarker));
+  }
+  async isBuilding() {
+    return await Bun.file(path17.join(this.#outDir, CsrDevArtifactWriter.#buildingMarker)).exists();
+  }
+  async forgetPatch(generation) {
+    await Promise.all([`patch-${generation}.js`, `patch-${generation}.js.layout.json`].map((name) => CsrDevArtifactWriter.#remove(path17.join(this.#outDir, name))));
+  }
+  async readJson(name) {
+    const file = Bun.file(path17.join(this.#outDir, name));
+    if (!await file.exists())
+      return null;
+    return await file.json().catch(() => null);
+  }
+  async writeJson(name, value) {
+    await this.#writeAtomic(name, JSON.stringify(value));
+  }
+  async writeModules(compiled) {
+    await mkdir2(path17.join(this.#outDir, "modules"), { recursive: true });
+    const helpers = new Map(compiled.flatMap((module) => module.helpers ? [[module.helpers.hash, module.helpers]] : []));
+    await Promise.all([
+      ...compiled.flatMap((module) => [
+        Bun.write(this.#modulePath(module.id, ".js"), module.factory),
+        ...module.sourceMap ? [Bun.write(this.#modulePath(module.id, ".js.map"), module.sourceMap)] : []
+      ]),
+      ...[...helpers.values()].map((shared) => Bun.write(this.#helpersPath(shared.hash), shared.definition))
+    ]);
+  }
+  async readCode(graph) {
+    const ids = Object.keys(graph.modules).filter((id) => !graph.modules[id]?.vendor && this.hasModule(id));
+    const hashes = [...new Set(ids.flatMap((id) => graph.modules[id]?.helpers ?? []))];
+    const [modules, helpers] = await Promise.all([
+      Promise.all(ids.map(async (id) => [id, await Bun.file(this.#modulePath(id, ".js")).text()])),
+      Promise.all(hashes.map(async (hash) => [hash, await Bun.file(this.#helpersPath(hash)).text()]))
+    ]);
+    return { modules: new Map(modules), helpers: new Map(helpers) };
+  }
+  hasModule(id) {
+    return fs8.existsSync(this.#modulePath(id, ".js"));
+  }
+  async forgetModules(ids) {
+    await Promise.all(ids.flatMap((id) => [
+      CsrDevArtifactWriter.#remove(this.#modulePath(id, ".js")),
+      CsrDevArtifactWriter.#remove(this.#modulePath(id, ".js.map"))
+    ]));
+  }
+  async writeVendor(graph) {
+    const ids = Object.keys(graph.modules).filter((id) => graph.modules[id]?.vendor).sort();
+    const stubs = new Set(Object.values(graph.modules).flatMap((module) => module.deps.filter(CsrDevPaths.isStub)));
+    const lines = [await this.#helperDefinitions(graph, ids), ...await this.#defineLines(ids)];
+    for (const stub of [...stubs].sort()) {
+      if (stub.startsWith(CsrDevPaths.emptyStubPrefix)) {
+        lines.push(`__akan.define(${JSON.stringify(stub)}, function () {});
+`);
+        continue;
+      }
+      const message = `[akan-csr] ${stub.slice(CsrDevPaths.stubPrefix.length)} is a Node built-in the browser does not have`;
+      lines.push(`__akan.define(${JSON.stringify(stub)}, function () {
+  throw new Error(${JSON.stringify(message)});
+});
+`);
+    }
+    const code = lines.join("");
+    const vendorFile = `vendor-${Bun.hash(code).toString(36)}.js`;
+    await this.#writeAtomic(vendorFile, code);
+    return vendorFile;
+  }
+  async writeApp(graph, { generation, vendorFile, epoch }, code) {
+    const ids = Object.keys(graph.modules).filter((id) => !graph.modules[id]?.vendor).sort();
+    const lines = await this.#defineLines(ids, code);
+    const blocks = ids.map((id, index) => [id, lines[index] ?? ""]);
+    const start = this.#library ? `__akan.startLibrary(${JSON.stringify({ generation, refresh: graph.refresh, bootstrap: graph.entries[""], vendorFile, epoch })});
+` : `__akan.start(${JSON.stringify({ generation, refresh: graph.refresh })});
+`;
+    await this.#writeWithSourceMap(CSR_DEV_APP_FILE, await this.#helperDefinitions(graph, ids, code), blocks, start);
+  }
+  async writePatch(generation, modules) {
+    const patchFile = `patch-${generation}.js`;
+    const blocks = modules.map((module, index) => [module.id, `${JSON.stringify(module.id)}: ${module.factory}${index < modules.length - 1 ? `,
+` : `
+`}`]);
+    const helpers = new Map(modules.flatMap((module) => module.helpers ? [[module.helpers.hash, module.helpers]] : []));
+    const header = `${[...helpers.values()].map((shared) => shared.definition).join("")}__akan.update(${generation}, {
+`;
+    await this.#writeWithSourceMap(patchFile, header, blocks, `});
+`);
+    return `${this.#routePrefix}${patchFile}`;
+  }
+  async writeState(graph, manifest) {
+    await this.writeJson("graph.json", graph);
+    await this.writeJson(CSR_DEV_MANIFEST_FILE2, manifest);
+  }
+  async commitPatch(graph, manifest, announce, { modules, code }) {
+    await this.writeJson(CSR_DEV_MANIFEST_FILE2, manifest);
+    announce();
+    await CsrDevArtifactWriter.#appWriteDelay();
+    await this.writeModules(modules);
+    await this.writeJson("graph.json", graph);
+    await this.writeApp(graph, manifest, code);
+    await this.writeJson(CSR_DEV_MANIFEST_FILE2, { ...manifest, appGeneration: manifest.generation });
+  }
+  async healApp(graph, manifest, code) {
+    if (appGenerationOf2(manifest) >= manifest.generation)
+      return manifest;
+    await this.writeApp(graph, manifest, code);
+    const healed = { ...manifest, appGeneration: manifest.generation };
+    await this.writeJson(CSR_DEV_MANIFEST_FILE2, healed);
+    return healed;
+  }
+  async prune(vendorFile, generation) {
+    const names = await readdir2(this.#outDir);
+    const stale = names.filter((name) => {
+      const patch = /^patch-(\d+)\.js(?:\.layout\.json)?$/.exec(name);
+      return patch ? Number(patch[1]) <= generation - CSR_DEV_KEPT_PATCHES : false;
+    });
+    const vendors = names.filter((name) => /^vendor-[\w-]+\.js$/.test(name) && name !== vendorFile).map((name) => ({ name, mtimeMs: CsrDevPaths.mtimeOf(path17.join(this.#outDir, name)) })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(CsrDevArtifactWriter.#keptVendors - 1).map(({ name }) => name);
+    await Promise.all([...stale, ...vendors].map((name) => CsrDevArtifactWriter.#remove(path17.join(this.#outDir, name))));
+  }
+  async pruneAfterFullBuild(graph, vendorFile, { generation, assets }) {
+    const kept = new Set(Object.keys(graph.modules).flatMap((id) => [this.#modulePath(id, ".js"), this.#modulePath(id, ".js.map")]));
+    for (const module of Object.values(graph.modules))
+      if (module.helpers)
+        kept.add(this.#helpersPath(module.helpers));
+    for (const asset of assets)
+      kept.add(path17.resolve(asset));
+    const listed = async (dir) => (await readdir2(path17.join(this.#outDir, dir)).catch(() => [])).map((name) => path17.join(this.#outDir, dir, name));
+    const stale = [
+      ...(await listed("modules")).filter((file) => !kept.has(file)),
+      ...(await listed("assets")).filter((file) => !kept.has(file)),
+      ...(await listed(".")).filter((file) => {
+        const name = path17.basename(file);
+        return /^patch-\d+\.js(?:\.layout\.json)?$/.test(name) || name.endsWith(".tmp");
+      }),
+      path17.join(this.#outDir, CSR_DEV_PATCHING_MARKER)
+    ];
+    await Promise.all(stale.map((file) => CsrDevArtifactWriter.#remove(file)));
+    await this.prune(vendorFile, generation);
+  }
+  async#helperDefinitions(graph, ids, code) {
+    const hashes = [...new Set(ids.flatMap((id) => graph.modules[id]?.helpers ?? []))].sort();
+    return (await Promise.all(hashes.map(async (hash) => code?.helpers.get(hash) ?? Bun.file(this.#helpersPath(hash)).text()))).join("");
+  }
+  async#defineLines(ids, code) {
+    return await Promise.all(ids.map(async (id) => {
+      const factory = code?.modules.get(id) ?? await Bun.file(this.#modulePath(id, ".js")).text();
+      return `__akan.define(${JSON.stringify(id)}, ${factory});
+`;
+    }));
+  }
+  async#writeWithSourceMap(name, header, blocks, footer) {
+    const layout = { lineCount: 0, modules: [] };
+    let line = CsrDevPaths.lineCount(header);
+    for (const [id, text] of blocks) {
+      layout.modules.push([id, line + 1]);
+      line += CsrDevPaths.lineCount(text);
+    }
+    const code = `${header}${blocks.map(([, text]) => text).join("")}${footer}//# sourceMappingURL=${name}.map
+`;
+    layout.lineCount = CsrDevPaths.lineCount(code);
+    await this.writeJson(`${name}.layout.json`, layout);
+    await this.#writeAtomic(name, code);
+  }
+  async#writeAtomic(name, content) {
+    const target = path17.join(this.#outDir, name);
+    const temp = `${target}.${process.pid}.tmp`;
+    await Bun.write(temp, content);
+    await FileSys2.replace(temp, target);
+  }
+  static async#remove(file) {
+    await rm(file, { force: true }).catch(() => {
+      return;
+    });
+  }
+  static async#appWriteDelay() {
+    const ms = Number(process.env.AKAN_CSR_DEV_APP_WRITE_DELAY_MS);
+    if (Number.isInteger(ms) && ms > 0)
+      await Bun.sleep(ms);
+  }
+  #modulePath(id, extension) {
+    return path17.join(this.#outDir, csrDevModuleFile(id, extension));
+  }
+  #helpersPath(hash) {
+    return path17.join(this.#outDir, "modules", `helpers-${hash}.js`);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevModuleCompiler.ts
+import path18 from "path";
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevFactoryCheck.ts
+class CsrDevFactoryCheck {
+  static #parsed = new Set;
+  static problemOf(factory, helperDefinition = "") {
+    const key = Bun.hash(`${helperDefinition}\x00${factory}`);
+    if (CsrDevFactoryCheck.#parsed.has(key))
+      return null;
+    const problem = CsrDevFactoryCheck.#syntaxError(`${helperDefinition}return (${factory});`);
+    if (problem === null) {
+      CsrDevFactoryCheck.#parsed.add(key);
+      return null;
+    }
+    if (problem.includes("import.meta")) {
+      const line = factory.split(`
+`).findIndex((text) => /(?<![\w$.])import\.meta\b/.test(text));
+      return `import.meta is left in it${line > 0 ? ` (compiled line ${line})` : ""}, which a classic script cannot hold: ${problem}`;
+    }
+    if (CsrDevFactoryCheck.#syntaxError(`${helperDefinition}return (async ${factory});`) === null)
+      return `a top-level await is left in it, which a CommonJS factory cannot wait on: ${problem}`;
+    return problem;
+  }
+  static thrower(id, problem) {
+    const message = `[akan-csr] ${id} was left out of the dev registry: ${problem}`;
+    return `function () {
+  throw new Error(${JSON.stringify(message)});
+}`;
+  }
+  static #syntaxError(source) {
+    try {
+      new Function(source);
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error.message : String(error);
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevModuleCompiler.ts
+class CsrDevModuleCompiler {
+  static #storeRoot = /(?:^|\/)lib\/st\.ts$/;
+  static #macroImport = /\b(?:with|assert)\s*\{\s*type\s*:\s*["']macro["']/;
+  static #factoryArgument = /(?<![\w$.])(?:require|module|exports|__akanImport|\$RefreshReg\$|\$RefreshSig\$)(?![\w$]|\s*:)/;
+  static #helperPatches = [
+    ["__toESM", "(mod, isNodeMode, target)", "toESM"],
+    ["__reExport", "(target, mod, secondTarget)", "reExport"]
+  ];
+  #app;
+  #paths;
+  #resolver;
+  #context;
+  #outDir;
+  #routePrefix;
+  #assets = new Set;
+  constructor({ app, paths, resolver, context, outDir, routePrefix }) {
+    this.#app = app;
+    this.#paths = paths;
+    this.#resolver = resolver;
+    this.#context = context;
+    this.#outDir = outDir;
+    this.#routePrefix = routePrefix;
+  }
+  get assets() {
+    return [...this.#assets];
+  }
+  async compile(startFiles, known, { refuseNewVendor = false, refusePrepass = false } = {}) {
+    const compiled = new Map;
+    const seen = new Set([...known, ...startFiles]);
+    let frontier = [...new Set(startFiles)];
+    while (frontier.length > 0) {
+      const refusedVendors = refuseNewVendor ? frontier.filter((file) => CsrDevPaths.isVendorFile(file)) : [];
+      if (refusedVendors.length > 0)
+        return { modules: [...compiled.values()], refusedVendors, unresolved: [] };
+      await this.#resolver.cover(frontier);
+      const round = await this.#compileRound(frontier);
+      if (round.misses.length > 0 && !this.#resolver.prepassDone && refusePrepass)
+        return { modules: [...compiled.values()], refusedVendors: [], unresolved: round.misses };
+      if (round.misses.length > 0 && !this.#resolver.prepassDone) {
+        this.#app.verbose(`[csr-dev] ${round.misses.length} unresolved import(s); rerunning the resolution build`);
+        await this.#resolver.prepass();
+        continue;
+      }
+      const next = [];
+      for (const module of round.modules) {
+        compiled.set(module.file, module);
+        for (const dep of module.deps) {
+          if (CsrDevPaths.isStub(dep) || seen.has(dep))
+            continue;
+          seen.add(dep);
+          next.push(dep);
+        }
+      }
+      frontier = next;
+    }
+    const { fallbacks } = this.#resolver;
+    if (fallbacks.size > 0)
+      this.#app.verbose(`[csr-dev] ${fallbacks.size} import(s) outside the browser build's graph resolved with Bun's runtime resolver: ${[...fallbacks].slice(0, 5).join(", ")}${fallbacks.size > 5 ? ", ..." : ""}`);
+    return { modules: [...compiled.values()], refusedVendors: [], unresolved: [] };
+  }
+  async#compileRound(files) {
+    const appFiles = files.filter((file) => !CsrDevPaths.isVendorFile(file));
+    const vendorFiles = files.filter((file) => CsrDevPaths.isVendorFile(file));
+    const rounds = await Promise.all([
+      appFiles.length > 0 ? this.#bunBuild(appFiles, false) : null,
+      vendorFiles.length > 0 ? this.#bunBuild(vendorFiles, true) : null
+    ]);
+    const modules = rounds.flatMap((round) => round?.modules ?? []);
+    const misses = rounds.flatMap((round) => round?.misses ?? []);
+    for (const file of rounds.flatMap((round) => round?.tangled ?? [])) {
+      const single = await this.#bunBuild([file], CsrDevPaths.isVendorFile(file));
+      if (single.tangled.length > 0)
+        throw new Error(`[csr-dev] ${this.#paths.idOf(file)} kept inlining another module`);
+      modules.push(...single.modules);
+      misses.push(...single.misses);
+    }
+    return { modules, misses };
+  }
+  async#bunBuild(files, vendor) {
+    const mtimes = new Map(files.map((file) => [CsrDevPaths.realpath(file), CsrDevPaths.mtimeOf(file)]));
+    const hashes = new Map(await Promise.all(files.map(async (file) => [CsrDevPaths.realpath(file), vendor ? "" : await CsrDevPaths.hashOf(file)])));
+    const misses = [];
+    const macroOutputs = vendor ? new Map : await this.#evaluateMacros(files);
+    let result;
+    try {
+      result = await Bun.build({
+        entrypoints: files,
+        root: this.#paths.root,
+        target: "browser",
+        format: "cjs",
+        reactFastRefresh: !vendor,
+        sourcemap: vendor ? "none" : "external",
+        naming: { entry: "[dir]/[name].[ext]", asset: "assets/[name]-[hash].[ext]" },
+        publicPath: this.#routePrefix,
+        metafile: true,
+        env: "AKAN_PUBLIC_*",
+        define: { ...this.#context.define, "import.meta": "__akanMeta" },
+        optimizeImports: this.#context.optimizeImports,
+        plugins: [this.#registryPlugin(vendor, misses, macroOutputs)]
+      });
+    } catch (error) {
+      if (vendor && error instanceof AggregateError)
+        return await this.#withoutFailed(files, error);
+      throw error;
+    }
+    const { outputs } = result.metafile;
+    const sourceMaps = new Map(result.outputs.filter((artifact) => artifact.kind === "sourcemap").map((artifact) => [artifact.path, artifact]));
+    const modules = [];
+    const tangled = [];
+    for (const artifact of result.outputs) {
+      if (artifact.kind === "asset") {
+        const assetPath = path18.join(this.#outDir, artifact.path);
+        await Bun.write(assetPath, artifact);
+        this.#assets.add(assetPath);
+        continue;
+      }
+      if (artifact.kind !== "entry-point")
+        continue;
+      const meta = outputs[artifact.path];
+      if (!meta?.entryPoint)
+        throw new Error(`[csr-dev] no entry point recorded for ${artifact.path}`);
+      const file = CsrDevPaths.realpath(path18.resolve(meta.entryPoint));
+      const inputs = Object.keys(meta.inputs).map((input) => CsrDevPaths.realpath(path18.resolve(input)));
+      if (inputs.some((input) => input !== file && this.#resolver.isRegistryModule(input))) {
+        tangled.push(file);
+        continue;
+      }
+      const code = await artifact.text();
+      const id = this.#paths.idOf(file);
+      const built = CsrDevModuleCompiler.#factory(id, code);
+      const problem = CsrDevFactoryCheck.problemOf(built.factory, built.helpers?.definition);
+      if (problem && !vendor)
+        throw new Error(`[csr-dev] ${id}: its factory does not parse as a classic script: ${problem}`);
+      if (problem) {
+        modules.push(this.#leftOut(file, problem));
+        continue;
+      }
+      const sourceMap = sourceMaps.get(`${artifact.path}.map`);
+      modules.push({
+        id,
+        file,
+        vendor,
+        ...built,
+        sourceMap: sourceMap ? this.#rebaseSourceMap(await sourceMap.text()) : undefined,
+        deps: this.#emittedDeps(code),
+        mtimeMs: mtimes.get(file) ?? CsrDevPaths.mtimeOf(file),
+        hash: hashes.get(file) ?? ""
+      });
+    }
+    return { modules, misses, tangled };
+  }
+  async#withoutFailed(files, error) {
+    const reasons = new Map;
+    for (const message of error.errors) {
+      const file = message.position?.file;
+      if (typeof file !== "string" || !path18.isAbsolute(file))
+        continue;
+      const real = CsrDevPaths.realpath(file);
+      const at = message.position?.line ? `:${message.position.line}` : "";
+      reasons.set(real, [...reasons.get(real) ?? [], `${String(message.message)} (${this.#paths.idOf(real)}${at})`]);
+    }
+    const failed = new Set(files.filter((file) => reasons.has(CsrDevPaths.realpath(file))));
+    if (failed.size === 0)
+      throw error;
+    const rest = files.filter((file) => !failed.has(file));
+    const round = rest.length > 0 ? await this.#bunBuild(rest, true) : { modules: [], misses: [], tangled: [] };
+    for (const file of failed) {
+      const text = (reasons.get(CsrDevPaths.realpath(file)) ?? []).join("; ");
+      const awaits = text.includes('"await" can only be used');
+      round.modules.push(this.#leftOut(file, awaits ? `a top-level await, which a CommonJS factory cannot wait on: ${text}` : text));
+    }
+    return round;
+  }
+  #leftOut(file, problem) {
+    const real = CsrDevPaths.realpath(file);
+    const id = this.#paths.idOf(real);
+    this.#app.logger.error(`[csr-dev] ${id} is left out of the dev registry: ${problem}`);
+    return {
+      id,
+      file: real,
+      vendor: true,
+      factory: CsrDevFactoryCheck.thrower(id, problem),
+      helpers: null,
+      deps: [],
+      mtimeMs: CsrDevPaths.mtimeOf(real),
+      hash: ""
+    };
+  }
+  async#evaluateMacros(files) {
+    const sources = await Promise.all(files.map(async (file) => [file, await Bun.file(file).text()]));
+    const importers = sources.filter(([, source]) => CsrDevModuleCompiler.#macroImport.test(source));
+    const outputs = await Promise.all(importers.map(async ([file]) => {
+      const result = await Bun.build({
+        entrypoints: [file],
+        target: "browser",
+        format: "esm",
+        plugins: [
+          {
+            name: "akan-csr-macro-pass",
+            setup: (build) => void build.onResolve({ filter: /.*/ }, (args) => args.importer ? { path: args.path, external: true } : undefined)
+          }
+        ]
+      });
+      const [output] = result.outputs;
+      if (!output)
+        throw new Error(`[csr-dev] ${this.#paths.idOf(file)}: its macro pass wrote no output`);
+      const text = await output.text();
+      return [
+        [file, text],
+        [CsrDevPaths.realpath(file), text]
+      ];
+    }));
+    return new Map(outputs.flat());
+  }
+  #registryPlugin(vendor, misses, macroOutputs) {
+    return {
+      name: "akan-csr-registry",
+      setup: (build) => {
+        build.onLoad({ filter: /\.css$/ }, () => ({ contents: "", loader: "js" }));
+        if (macroOutputs.size > 0) {
+          const exact = [...macroOutputs.keys()].map((file) => file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+          build.onLoad({ filter: new RegExp(`^(?:${exact.join("|")})$`) }, (args) => {
+            const contents = macroOutputs.get(args.path);
+            return contents === undefined ? undefined : { contents, loader: "js" };
+          });
+        }
+        if (!vendor)
+          build.onLoad({ filter: /\.tsx$/ }, async (args) => {
+            if (CsrDevPaths.isVendorFile(args.path))
+              return;
+            const normalized = RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh(await Bun.file(args.path).text(), { path: args.path });
+            return normalized ? { contents: normalized, loader: "tsx" } : undefined;
+          });
+        build.onResolve({ filter: /.*/ }, (args) => {
+          if (args.kind === "entry-point-build" || !args.importer)
+            return;
+          if (this.#context.externals?.includes(args.path))
+            return { path: `${CsrDevPaths.vendorPrefix}${args.path}`, external: true };
+          const importer = CsrDevPaths.realpath(args.importer);
+          const target = this.#resolver.resolve(importer, args.path, args.kind === "require-call" || args.kind === "require-resolve" ? "require" : "import");
+          if (target === CsrDevResolver.inline)
+            return;
+          if (target === null) {
+            misses.push(`${args.path} from ${this.#paths.idOf(importer)}`);
+            return { path: `akan-miss:${args.path}`, external: true };
+          }
+          const external = CsrDevPaths.isStub(target) ? target : `${CsrDevPaths.modulePrefix}${this.#paths.idOf(target)}`;
+          return { path: external, external: true };
+        });
+      }
+    };
+  }
+  #rebaseSourceMap(text) {
+    const map = JSON.parse(text);
+    const files = map.sources.map((source) => path18.resolve(source));
+    map.sources = files.map((file) => `/${this.#paths.idOf(file)}`);
+    map.sourcesContent = files.map((file, index) => CsrDevPaths.isVendorFile(file) ? null : map.sourcesContent?.[index] ?? null);
+    return JSON.stringify(map);
+  }
+  #emittedDeps(code) {
+    const deps = new Set;
+    const references = /\b(?:require|import|__akanImport)\("((?:akan-module|stub):[^"]+)"\)/g;
+    for (const [, reference] of code.matchAll(references)) {
+      if (!reference)
+        continue;
+      deps.add(CsrDevPaths.isStub(reference) ? reference : this.#paths.fileOf(reference.slice(CsrDevPaths.modulePrefix.length)));
+    }
+    return [...deps];
+  }
+  static #factory(id, code) {
+    const prefix = CsrDevPaths.modulePrefix;
+    let patched = code.replace(/^#!/, "//").replaceAll(`import("${prefix}`, `__akanImport("${prefix}`).replace(/^\/\/# debugId=.*$/m, "");
+    const marker = patched.search(/^\/\/ /m);
+    const body = marker < 0 ? "" : patched.slice(marker);
+    for (const [name, params, method] of CsrDevModuleCompiler.#helperPatches) {
+      const definition = `var ${name} = ${params} => {`;
+      if (patched.includes(definition))
+        patched = patched.replace(definition, `var ${name} = __akan.${method}, __bun${name} = ${params} => {`);
+      else if (patched.includes(`${name}(`) && !new RegExp(`\\b(?:var|let|const|function)\\s+${name}\\b`).test(body))
+        throw new Error(`[csr-dev] ${id}: Bun's ${name} helper no longer reads "${definition}"; CsrDevModuleCompiler must follow`);
+    }
+    if (CsrDevModuleCompiler.#storeRoot.test(id))
+      patched += `
+module.hot.accept();`;
+    const shared = CsrDevModuleCompiler.#shareHelpers(patched);
+    const meta = /(?<![\w$.])__akanMeta(?![\w$])/.test(patched) ? ` var __akanMeta = { url: new URL(${JSON.stringify(id.startsWith("/") ? id : `/${id}`)}, self.location.href).href };` : "";
+    return {
+      factory: `function (require, module, exports, $RefreshReg$, $RefreshSig$, __akanImport) {${meta}
+${shared?.code ?? patched}
+}`,
+      helpers: shared?.helpers ?? null
+    };
+  }
+  static #shareHelpers(code) {
+    const marker = code.search(/^\/\/ /m);
+    if (marker <= 0)
+      return null;
+    const preamble = code.slice(0, marker);
+    const names = [...preamble.matchAll(/^(?:var|let|const|function)\s+([\w$]+)/gm)].map(([, name]) => name).filter((name) => !!name);
+    if (names.length === 0 || CsrDevModuleCompiler.#factoryArgument.test(preamble))
+      return null;
+    const hash = Bun.hash(preamble).toString(36);
+    const binding = `var { ${names.join(", ")} } = __akan.helpers(${JSON.stringify(hash)});`;
+    return {
+      code: `${binding}${`
+`.repeat(CsrDevPaths.lineCount(preamble))}${code.slice(marker)}`,
+      helpers: {
+        hash,
+        definition: `__akan.defineHelpers(${JSON.stringify(hash)}, function () {
+${preamble}return { ${names.join(", ")} };
+});
+`
+      }
+    };
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/registryMetadataFingerprint.ts
+import fs9 from "fs";
+import path19 from "path";
+
+class RegistryMetadataFingerprint {
+  static #sources = new Bun.Glob("**/*.{signal,dictionary}.ts");
+  static #libFiles = ["sig.ts", "dict.ts", "useClient.ts"];
+  static async of(roots, isMetadataFile) {
+    const stamps = [];
+    for (const root of new Set(roots)) {
+      const libDir = path19.join(root, "lib");
+      if (!fs9.existsSync(libDir))
+        continue;
+      const files = RegistryMetadataFingerprint.#libFiles.map((name) => path19.join(libDir, name));
+      for await (const relative of RegistryMetadataFingerprint.#sources.scan({ cwd: libDir, onlyFiles: true }))
+        files.push(path19.join(libDir, relative));
+      for (const file of files) {
+        if (!isMetadataFile(file))
+          continue;
+        const stat = fs9.statSync(file, { throwIfNoEntry: false });
+        if (stat)
+          stamps.push(`${file}:${stat.mtimeMs}:${stat.size}`);
+      }
+    }
+    return Bun.hash(stamps.sort((a, b) => a.localeCompare(b)).join(`
+`)).toString(36);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/devRegistryBundler.ts
+class DevRegistryBundler {
+  outDir;
+  routePrefix;
+  paths;
+  writer;
+  app;
+  entryDir;
+  constructor(app, { dirName, routePrefix, library }) {
+    this.app = app;
+    this.routePrefix = routePrefix;
+    this.paths = new CsrDevPaths(app.workspace.workspaceRoot);
+    this.outDir = path20.join(app.cwdPath, ".akan/artifact", dirName);
+    this.entryDir = path20.join(app.cwdPath, ".akan/generated", dirName);
+    this.writer = new CsrDevArtifactWriter(this.outDir, { routePrefix, library });
+  }
+  async update(changedFiles = [], options = {}) {
+    const result = await new CsrDevPatcher(this).update(changedFiles, { ...options, allowWholeAppBuilds: true });
+    if (result.kind === "unchanged")
+      return null;
+    if (result.kind === "update")
+      return result.update;
+    const built = await this.fullBuild(result.context, result.generation, result.reason);
+    const update = result.first ? { ...built, first: true } : built;
+    options.announce?.(update);
+    return update;
+  }
+  async wantedRoots(files, graph) {
+    const reached = await this.reachable(graph);
+    return new Set(files.filter((file) => reached.has(this.paths.idOf(file))));
+  }
+  async reachable(graph) {
+    const roots = await this.rootFiles(Object.values(graph.entries).map((id) => this.paths.fileOf(id)));
+    const reached = new Set;
+    const stack = [graph.refresh, ...roots.map((file) => this.paths.idOf(file))];
+    for (let id = stack.pop();id !== undefined; id = stack.pop()) {
+      if (reached.has(id))
+        continue;
+      reached.add(id);
+      stack.push(...graph.modules[id]?.deps ?? []);
+    }
+    return reached;
+  }
+  async holds(files) {
+    const graph = await this.writer.readJson("graph.json");
+    return graph !== null && files.every((file) => graph.modules[this.paths.idOf(file)] !== undefined);
+  }
+  isMetadataFile(file) {
+    return isAkanRuntimeMetadataFile(file);
+  }
+  async metadataFingerprint() {
+    const libsContainer = path20.resolve(this.app.workspace.workspaceRoot, "libs");
+    const roots = await new WatchRootResolver(this.app).resolve();
+    const libRoots = roots.includes(libsContainer) ? fs10.readdirSync(libsContainer).map((name) => path20.join(libsContainer, name)) : roots.filter((root) => path20.dirname(root) === libsContainer);
+    return await RegistryMetadataFingerprint.of([path20.resolve(this.app.cwdPath), ...libRoots], (file) => this.isMetadataFile(file));
+  }
+  async fullBuild(context, generation, reason) {
+    const metadata = await this.metadataFingerprint();
+    const entries = await this.writeEntries(context);
+    const roots = await this.rootFiles(Object.values(entries.files));
+    const resolver = new CsrDevResolver({ paths: this.paths, context, entryFiles: roots });
+    await resolver.prepass();
+    const compiler = this.compiler(context, resolver);
+    const { modules: compiled } = await compiler.compile([...roots, ...context.refreshFile ? [context.refreshFile] : []], new Set);
+    const graph = {
+      version: 1,
+      configKey: context.configKey,
+      refresh: context.refreshFile ? this.paths.idOf(context.refreshFile) : `${CsrDevPaths.vendorPrefix}react-refresh/runtime`,
+      entries: this.entryIds(entries.files),
+      modules: {},
+      resolution: {},
+      pending: [],
+      metadata
+    };
+    this.merge(graph, resolver, compiled);
+    await this.writer.markBuilding();
+    await this.writer.writeModules(compiled);
+    const vendorFile = await this.writer.writeVendor(graph);
+    const epoch = Date.now();
+    await this.writer.writeApp(graph, { generation, vendorFile, epoch });
+    await this.writer.writeState(graph, { version: 1, generation, vendorFile, entries: graph.entries, epoch });
+    await this.writer.pruneAfterFullBuild(graph, vendorFile, { generation, assets: compiler.assets });
+    await this.writer.clearBuilding();
+    return { generation, reload: true, reason, changedIds: [], moduleCount: Object.keys(graph.modules).length, epoch };
+  }
+  compiler(context, resolver) {
+    return new CsrDevModuleCompiler({
+      app: this.app,
+      paths: this.paths,
+      resolver,
+      context,
+      outDir: this.outDir,
+      routePrefix: this.routePrefix
+    });
+  }
+  merge(graph, resolver, compiled) {
+    for (const module of compiled)
+      graph.modules[module.id] = {
+        vendor: module.vendor,
+        mtimeMs: module.mtimeMs,
+        hash: module.hash,
+        deps: module.deps.map((dep) => CsrDevPaths.isStub(dep) ? dep : this.paths.idOf(dep)),
+        ...module.helpers ? { helpers: module.helpers.hash } : {}
+      };
+    const compiledIds = new Set(compiled.map((module) => module.id));
+    graph.pending = graph.pending.filter((id) => !compiledIds.has(id));
+    graph.resolution = resolver.serialize();
+    graph.runtimeResolved = resolver.serializeRuntimeResolved();
+  }
+  entryIds(files) {
+    return Object.fromEntries(Object.entries(files).map(([key, file]) => [key, this.paths.idOf(file)]));
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevBundler.ts
+class CsrDevBundler extends DevRegistryBundler {
+  static #formatVersion = 4;
+  reloadsOnEntryChange = true;
+  #asyncDefaults = new Map;
+  constructor(app) {
+    super(app, { dirName: CSR_DEV_DIRNAME, routePrefix: CSR_DEV_ROUTE_PREFIX, library: false });
+  }
+  async context() {
+    const akanConfig = await this.app.getConfig();
+    const pageEntries = await resolveSsrPageEntriesForApp(this.app, await this.app.getPageKeys());
+    if (pageEntries.length === 0)
+      return null;
+    const basePaths = [...akanConfig.basePaths];
+    const htmlBasePaths = basePaths.length > 0 ? basePaths : [""];
+    const define = bundleDefine(this.app, "start", "csr");
+    const optimizeImports = [...akanConfig.optimizeImports];
+    const configKey = Bun.hash(JSON.stringify([CsrDevBundler.#formatVersion, Bun.version, define, optimizeImports, htmlBasePaths])).toString(36);
+    return {
+      pageEntries,
+      basePaths,
+      htmlBasePaths,
+      define,
+      optimizeImports,
+      configKey,
+      refreshFile: this.#resolveRefreshRuntime()
+    };
+  }
+  async writeEntries(context) {
+    await mkdir3(this.entryDir, { recursive: true });
+    const files = {};
+    const changed = [];
+    for (const basePath of context.htmlBasePaths) {
+      const file = path21.join(this.entryDir, CsrEntryFiles.entryFilename(basePath));
+      const entryPages = CsrEntryFiles.pageEntriesForBasePath(context.pageEntries, basePath, context.basePaths);
+      const generator = new PagesEntrySourceGenerator(entryPages, {
+        isAsyncDefault: (moduleAbsPath) => this.#isAsyncDefault(moduleAbsPath)
+      });
+      const pages = await generator.generateStatic({ fromDir: this.entryDir });
+      const hot = await generator.generateHotReplace({
+        fromDir: this.entryDir,
+        ownerId: this.paths.idOf(file),
+        moduleIds: entryPages.map(({ moduleAbsPath }) => this.paths.idOf(moduleAbsPath))
+      });
+      const source = `import * as akanWebkit from "akanjs/webkit";
+${pages}
+void akanWebkit.bootCsr(pages);
+${hot}`;
+      const unchanged = await Bun.file(file).exists() && await Bun.file(file).text() === source;
+      if (!unchanged)
+        await Bun.write(file, source);
+      const entryFile = CsrDevPaths.realpath(file);
+      files[basePath] = entryFile;
+      if (!unchanged)
+        changed.push(entryFile);
+    }
+    return { files, changed };
+  }
+  async rootFiles(entryFiles) {
+    return entryFiles;
+  }
+  #isAsyncDefault(moduleAbsPath) {
+    const mtimeMs = CsrDevPaths.mtimeOf(moduleAbsPath);
+    const cached = this.#asyncDefaults.get(moduleAbsPath);
+    if (cached?.mtimeMs === mtimeMs)
+      return cached.detected;
+    const detected = AsyncDefaultExportDetector.detect(moduleAbsPath);
+    this.#asyncDefaults.set(moduleAbsPath, { mtimeMs, detected });
+    return detected;
+  }
+  #resolveRefreshRuntime() {
+    const akanWebkit = CsrDevPaths.tryResolve("akanjs/webkit", this.app.cwdPath);
+    const bases = [this.app.cwdPath, this.paths.root, ...akanWebkit ? [path21.dirname(path21.dirname(akanWebkit))] : []];
+    for (const base of bases) {
+      const resolved = CsrDevPaths.tryResolve("react-refresh/runtime", base);
+      if (resolved)
+        return CsrDevPaths.realpath(resolved);
+    }
+    throw new Error(`[csr-dev] react-refresh/runtime is not resolvable from ${bases.join(", ")}`);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/devChangePlanner.ts
+import path22 from "path";
+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 = path22.resolve(workspaceRoot);
+  }
+  plan({ generation, files, kinds, generatedFiles = [] }) {
+    const fileList = uniqueResolved([...files, ...generatedFiles]);
+    const generatedSet = new Set(generatedFiles.map((file) => path22.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(path22.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[path22.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 = path22.resolve(file);
+    const base = path22.basename(abs);
+    const ext = path22.extname(abs).toLowerCase();
+    const isSource = SOURCE_EXTS.has(ext);
+    const rel = path22.relative(this.#workspaceRoot, abs);
+    const parts = rel.split(path22.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(base, parts)) {
+      roles.add("server");
+      reasons.add("server-path");
+    }
+    if (isSource && this.#isClientBiased(base, parts)) {
+      roles.add("client");
+      reasons.add("client-path");
+    }
+    if (isSource && this.#isSharedBiased(base, 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_EXTS.has(ext) && this.#isWorkspaceSource(rel)) {
+      roles.add("shared");
+      reasons.add("workspace-source-fallback");
+    }
+    return roles;
+  }
+  #isServerBiased(base, parts) {
+    return parts.includes("srvkit") || SERVER_SUFFIXES.some((suffix) => base.endsWith(suffix)) || base === "main.ts" || base === "server.ts";
+  }
+  #isClientBiased(base, parts) {
+    return parts.includes("ui") || parts.includes("webkit") || parts.includes("page") || CLIENT_SUFFIXES.some((suffix) => base.endsWith(suffix));
+  }
+  #isSharedBiased(base, parts) {
+    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("..") || path22.isAbsolute(rel))
+      return false;
+    const [scope] = rel.split(path22.sep);
+    return scope === "apps" || scope === "libs" || scope === "pkgs";
+  }
+}
+var uniqueResolved = (files) => [...new Set(files.map((file) => path22.resolve(file)))].sort();
+
+// pkgs/@akanjs/devkit/frontendBuild/devGeneratedIndexSync.ts
+import { mkdir as mkdir4, readdir as readdir3, readFile as readFile2, rm as rm2, stat as stat2 } from "fs/promises";
+import path23 from "path";
+import { capitalize } from "akanjs/common";
+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 = path23.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 = path23.resolve(file);
+    const rel = path23.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path23.isAbsolute(rel))
+      return null;
+    const parts = rel.split(path23.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 path23.join(this.#workspaceRoot, scope, project, facet, "index.ts");
+  }
+  async#moduleIndexForDirectoryEvent(file) {
+    const abs = path23.resolve(file);
+    const rel = path23.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path23.isAbsolute(rel))
+      return null;
+    const parts = rel.split(path23.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 = !path23.extname(abs);
+    if (!isExistingDirectory && !looksLikeDeletedDirectory)
+      return null;
+    if (moduleSegment === "__scalar" && scalarSegment) {
+      return path23.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
+    }
+    if (!moduleSegment || moduleSegment === "__scalar")
+      return null;
+    return path23.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
+  }
+  async#syncIndex(indexPath) {
+    const dir = path23.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 FileSys2.writeTextAtomic(indexPath, content);
+    return true;
+  }
+  async#contentForIndex(indexPath) {
+    const parts = path23.relative(this.#workspaceRoot, indexPath).split(path23.sep).filter(Boolean);
+    const facet = parts.at(-2);
+    if (facet && BARREL_FACETS2.has(facet))
+      return this.#facetContent(path23.dirname(indexPath));
+    return this.#moduleContent(path23.dirname(indexPath));
+  }
+  async#facetContent(dir) {
+    const nameCasePattern = path23.basename(dir) === "ui" ? FACET_PASCAL_CASE_RE : FACET_CAMEL_CASE_RE;
+    const entries = await readdir3(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 = path23.relative(this.#workspaceRoot, dir);
+    const parts = rel.split(path23.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(path23.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 formatError2 = (err) => err instanceof Error ? err.message : String(err);
+
+// pkgs/@akanjs/devkit/frontendBuild/ssrDevBundler.ts
+import { mkdir as mkdir5 } from "fs/promises";
+import path24 from "path";
+import { SSR_DEV_DIRNAME, SSR_DEV_ROUTE_PREFIX } from "akanjs/server/hmr/csrDevManifest";
+class SsrDevBundler extends DevRegistryBundler {
+  static #formatVersion = 2;
+  static bootstrapKey = "";
+  reloadsOnEntryChange = false;
+  #discovery = null;
+  #sharedDiscovery;
+  constructor(app, { discovery } = {}) {
+    super(app, { dirName: SSR_DEV_DIRNAME, routePrefix: SSR_DEV_ROUTE_PREFIX, library: true });
+    this.#sharedDiscovery = discovery ?? null;
+  }
+  async context() {
+    const akanConfig = await this.app.getConfig();
+    const define = bundleDefine(this.app, "start", "ssr");
+    const optimizeImports = [...akanConfig.optimizeImports];
+    const configKey = Bun.hash(JSON.stringify(["ssr", SsrDevBundler.#formatVersion, Bun.version, define, optimizeImports, VENDOR_SPECIFIERS])).toString(36);
+    return {
+      pageEntries: [],
+      basePaths: [...akanConfig.basePaths],
+      htmlBasePaths: [],
+      define,
+      optimizeImports,
+      configKey,
+      refreshFile: null,
+      externals: VENDOR_SPECIFIERS
+    };
+  }
+  isMetadataFile(file) {
+    return super.isMetadataFile(file) && !file.endsWith(".dictionary.ts") && path24.basename(file) !== "dict.ts";
+  }
+  async writeEntries() {
+    await mkdir5(this.entryDir, { recursive: true });
+    const file = path24.join(this.entryDir, "bootstrap.ts");
+    const hasStore = await Bun.file(path24.join(this.app.cwdPath, "lib", "st.ts")).exists();
+    const source = hasStore ? `import ${JSON.stringify(`@apps/${this.app.name}/client`)};
+` : `export {};
+`;
+    const unchanged = await Bun.file(file).exists() && await Bun.file(file).text() === source;
+    if (!unchanged)
+      await Bun.write(file, source);
+    const entryFile = CsrDevPaths.realpath(file);
+    return { files: { [SsrDevBundler.bootstrapKey]: entryFile }, changed: unchanged ? [] : [entryFile] };
+  }
+  async clientEntries() {
+    const pageEntries = await resolveSsrPageEntriesForApp(this.app, await this.app.getPageKeys());
+    const seedIndex = computeRouteSeedIndex(pageEntries);
+    const seeds = [...new Set([...seedIndex.globalLayoutFiles, ...seedIndex.entries.flatMap((entry) => entry.seeds)])];
+    const discovery = this.#sharedDiscovery?.() ?? await this.#ownDiscovery();
+    return (await discovery.discover(seeds)).map((file) => CsrDevPaths.realpath(file));
+  }
+  async#ownDiscovery() {
+    this.#discovery ??= await GraphClientEntryDiscovery.create(this.app);
+    return this.#discovery;
+  }
+  async rootFiles(entryFiles) {
+    return [...entryFiles, ...await this.clientEntries()];
+  }
+}
+
+export { computeRouteSeedIndex, saveRouteSeedIndex, BarrelAnalyzer, createTsconfigPackageResolver, rewriteBarrelImports, GraphClientEntryDiscovery, bundleDefine, ClientEntriesBundler, VENDOR_SPECIFIERS, RouteClientBuilder, AutoImportSync, CsrEntryFiles, PagesEntrySourceGenerator, ServerGraphFile, PagesBundleBuilder, CsrDevPatcher, CsrDevBundler, DevChangePlanner, DevGeneratedIndexSync, SsrDevBundler };