@akanjs/cli 2.4.1-rc.6 → 2.4.1

package/index-rh16j3c7.js

@@ -0,0 +1,2166 @@
+// @bun
+// pkgs/@akanjs/devkit/frontendBuild/clientEntryDiscovery.ts
+import path3 from "path";
+
+// pkgs/@akanjs/devkit/transforms/barrelAnalyzer.ts
+import path from "path";
+import { Logger } from "akanjs/common";
+var REEXPORT_RE = /(?:^|\n)\s*export\s+(?:type\s+)?(?:(\*)(?:\s+as\s+(\w+))?|\{\s*([^}]*?)\s*\})\s+from\s+(["'])([^"']+)\4;?/g;
+var LOCAL_NAMED_RE = /(?:^|\n)\s*export\s+\{\s*([^}]*?)\s*\}(?!\s*from)/g;
+var CANDIDATE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+
+class BarrelAnalyzer {
+  #logger = new Logger("BarrelAnalyzer");
+  #opts;
+  #cache = new Map;
+  #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
+  #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
+  constructor(opts) {
+    this.#opts = opts;
+  }
+  analyze(pkgName) {
+    const cached = this.#cache.get(pkgName);
+    if (cached)
+      return cached;
+    const promise = this.#analyzeSafe(pkgName);
+    this.#cache.set(pkgName, promise);
+    return promise;
+  }
+  async#analyzeSafe(pkgName) {
+    try {
+      return await this.#analyzeUncached(pkgName);
+    } catch (err) {
+      this.#logger.error(`analyze failed for ${pkgName}: ${err.message}`);
+      return null;
+    }
+  }
+  async#analyzeUncached(pkgName) {
+    const pkg = await this.#opts.resolvePackage(pkgName);
+    if (!pkg)
+      return null;
+    const map = new Map;
+    const visited = new Set;
+    await this.#walk(pkg.entryFile, pkg, map, visited);
+    return map;
+  }
+  async#walk(absFile, pkg, map, visited) {
+    if (visited.has(absFile))
+      return;
+    visited.add(absFile);
+    const source = await readIfExists(absFile);
+    if (source === null)
+      return;
+    const currentSubpath = this.#subpathFor(pkg, absFile);
+    if (!currentSubpath)
+      return;
+    const authoritative = this.#scanExports(source, absFile);
+    authoritative.delete("default");
+    const attributed = new Set;
+    REEXPORT_RE.lastIndex = 0;
+    let m = REEXPORT_RE.exec(source);
+    while (m !== null) {
+      const star = m[1];
+      const nsAs = m[2];
+      const namedList = m[3];
+      const spec = m[5] ?? "";
+      m = REEXPORT_RE.exec(source);
+      if (!isRelative(spec))
+        continue;
+      if (star) {
+        if (nsAs) {
+          authoritative.delete(nsAs);
+          continue;
+        }
+        const targetAbs = await this.#resolveRel(absFile, spec);
+        if (!targetAbs)
+          continue;
+        await this.#walk(targetAbs, pkg, map, visited);
+        continue;
+      }
+      if (namedList !== undefined) {
+        const targetAbs = await this.#resolveRel(absFile, spec);
+        if (!targetAbs)
+          continue;
+        const targetSubpath = this.#subpathFor(pkg, targetAbs);
+        if (!targetSubpath)
+          continue;
+        for (const item of parseNamedList(namedList)) {
+          if (item.isType)
+            continue;
+          if (item.imported === "default")
+            continue;
+          if (!authoritative.has(item.local))
+            continue;
+          attributed.add(item.local);
+          if (!map.has(item.local)) {
+            map.set(item.local, { subpath: targetSubpath, originalName: item.imported });
+          }
+        }
+      }
+    }
+    LOCAL_NAMED_RE.lastIndex = 0;
+    let n = LOCAL_NAMED_RE.exec(source);
+    while (n !== null) {
+      const body = n[1] ?? "";
+      n = LOCAL_NAMED_RE.exec(source);
+      for (const item of parseNamedList(body)) {
+        if (item.isType)
+          continue;
+        if (item.imported === "default")
+          continue;
+        if (!authoritative.has(item.local))
+          continue;
+        attributed.add(item.local);
+        if (!map.has(item.local)) {
+          map.set(item.local, { subpath: currentSubpath, originalName: item.imported });
+        }
+      }
+    }
+    for (const name of authoritative) {
+      if (attributed.has(name))
+        continue;
+      if (map.has(name))
+        continue;
+      map.set(name, { subpath: currentSubpath, originalName: name });
+    }
+  }
+  #scanExports(source, absFile) {
+    try {
+      const transpiler = [".tsx", ".jsx"].includes(path.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
+      const { exports } = transpiler.scan(source);
+      return new Set(exports);
+    } catch (err) {
+      this.#logger.error(`scan failed: ${err.message}`);
+      return new Set;
+    }
+  }
+  #subpathFor(pkg, absFile) {
+    const rel = path.relative(pkg.pkgDir, absFile);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel))
+      return null;
+    if (pkg.preserveFilePath)
+      return `${pkg.pkgName}/${rel.split(path.sep).join("/")}`;
+    const noExt = stripKnownExt(rel);
+    const tail = collapseIndex(noExt);
+    if (tail === "")
+      return pkg.pkgName;
+    return `${pkg.pkgName}/${tail.split(path.sep).join("/")}`;
+  }
+  async#resolveRel(fromFile, relSpec) {
+    if (this.#opts.resolveRelative)
+      return this.#opts.resolveRelative(fromFile, relSpec);
+    return defaultResolveRelative(fromFile, relSpec);
+  }
+}
+var parseNamedList = (listBody) => {
+  const out = [];
+  for (const raw of listBody.split(",")) {
+    const s = raw.trim();
+    if (!s)
+      continue;
+    let rest = s;
+    let isType = false;
+    if (rest.startsWith("type ")) {
+      isType = true;
+      rest = rest.slice(5).trim();
+    }
+    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
+    if (asMatch) {
+      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
+      continue;
+    }
+    if (/^\w+$/.test(rest)) {
+      out.push({ imported: rest, local: rest, isType });
+    }
+  }
+  return out;
+};
+var isRelative = (spec) => {
+  return spec.startsWith("./") || spec.startsWith("../") || spec === "." || spec === "..";
+};
+var readIfExists = async (absFile) => {
+  const file = Bun.file(absFile);
+  if (!await file.exists())
+    return null;
+  return file.text();
+};
+var defaultResolveRelative = async (fromFile, relSpec) => {
+  const baseDir = path.dirname(fromFile);
+  const joined = path.resolve(baseDir, relSpec);
+  if (path.extname(joined)) {
+    if (await Bun.file(joined).exists())
+      return joined;
+    return null;
+  }
+  for (const ext of CANDIDATE_EXTS) {
+    const cand = joined + ext;
+    if (await Bun.file(cand).exists())
+      return cand;
+  }
+  for (const ext of CANDIDATE_EXTS) {
+    const cand = path.join(joined, `index${ext}`);
+    if (await Bun.file(cand).exists())
+      return cand;
+  }
+  return null;
+};
+var stripKnownExt = (relPath) => {
+  for (const ext of CANDIDATE_EXTS) {
+    if (relPath.endsWith(ext))
+      return relPath.slice(0, -ext.length);
+  }
+  return relPath;
+};
+var collapseIndex = (relPathNoExt) => {
+  const parts = relPathNoExt.split(path.sep);
+  if (parts[parts.length - 1] === "index")
+    parts.pop();
+  return parts.join(path.sep);
+};
+
+// pkgs/@akanjs/devkit/transforms/barrelImportsPlugin.ts
+import path2 from "path";
+import ts from "typescript";
+var createBarrelImportsPlugin = async (app, { skipPath = defaultSkipPath, pipeAfter } = {}) => {
+  const akanConfig = await app.getConfig();
+  const barrels = [...new Set(akanConfig.barrelImports)].filter(Boolean);
+  const analyzer = new BarrelAnalyzer({
+    resolvePackage: await createTsconfigPackageResolver(app)
+  });
+  return {
+    name: "barrel-imports",
+    setup(build) {
+      build.onLoad({
+        filter: /^(?:(?!.*[\\/]node_modules[\\/]).*|.*[\\/]node_modules[\\/]akanjs[\\/].*)\.(tsx|ts|jsx|js)(\?v=\d+)?$/
+      }, async (args) => {
+        const realPath = args.path.replace(/\?v=\d+$/, "");
+        const loader = loaderFor(realPath);
+        if (skipPath(realPath)) {
+          const raw = await Bun.file(realPath).text();
+          return { contents: raw, loader };
+        }
+        let source = await Bun.file(realPath).text();
+        const hasMacroAttr = MACRO_ATTR_RE.test(source);
+        if (!hasMacroAttr && barrels.length > 0) {
+          const rewritten = await rewriteBarrelImports(source, barrels, analyzer);
+          if (rewritten !== null)
+            source = rewritten;
+        }
+        if (pipeAfter) {
+          const piped = await pipeAfter(source, { path: realPath });
+          if (piped !== null)
+            source = piped;
+        }
+        return { contents: source, loader };
+      });
+    }
+  };
+};
+var createTsconfigPackageResolver = async (app) => {
+  const tsconfig = await app.getTsConfig();
+  const tsconfigPaths = tsconfig.compilerOptions.paths ?? {};
+  const wildcardEntries = Object.entries(tsconfigPaths).filter(([k]) => k.endsWith("/*")).map(([k, v]) => ({
+    prefix: k.slice(0, -1),
+    replacements: v
+  })).sort((a, b) => b.prefix.length - a.prefix.length);
+  return async (pkgName) => {
+    const exact = tsconfigPaths[pkgName];
+    if (exact && exact.length > 0) {
+      const raw = exact[0];
+      if (!raw)
+        return null;
+      const entryFile = path2.resolve(app.workspace.workspaceRoot, raw);
+      if (!await Bun.file(entryFile).exists())
+        return null;
+      const parsed = path2.parse(entryFile);
+      const lastSlash = pkgName.lastIndexOf("/");
+      if (parsed.name !== "index" && lastSlash !== -1) {
+        const facet = pkgName.slice(lastSlash + 1);
+        const parentSpec = pkgName.slice(0, lastSlash);
+        if (facet === parsed.name && parentSpec.length > 0) {
+          return { pkgName: parentSpec, entryFile, pkgDir: parsed.dir };
+        }
+      }
+      return { pkgName, entryFile, pkgDir: path2.dirname(entryFile) };
+    }
+    for (const { prefix, replacements } of wildcardEntries) {
+      if (!pkgName.startsWith(prefix))
+        continue;
+      const suffix = pkgName.slice(prefix.length);
+      for (const repl of replacements) {
+        if (!repl)
+          continue;
+        const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
+        const candidate = path2.resolve(app.workspace.workspaceRoot, replPath + suffix);
+        for (const ext of CANDIDATE_EXTS2) {
+          const file = `${candidate}${ext}`;
+          if (await Bun.file(file).exists()) {
+            const lastSlash = pkgName.lastIndexOf("/");
+            if (lastSlash !== -1) {
+              const parentSpec = pkgName.slice(0, lastSlash);
+              if (parentSpec.length > 0) {
+                return { pkgName: parentSpec, entryFile: file, pkgDir: path2.dirname(file) };
+              }
+            }
+            return { pkgName, entryFile: file, pkgDir: path2.dirname(file) };
+          }
+        }
+        for (const ext of CANDIDATE_EXTS2) {
+          const file = path2.join(candidate, `index${ext}`);
+          if (await Bun.file(file).exists()) {
+            return { pkgName, entryFile: file, pkgDir: candidate };
+          }
+        }
+      }
+      return null;
+    }
+    const exported = await resolveNodePackageExport(app.workspace.workspaceRoot, pkgName);
+    if (exported)
+      return exported;
+    const pkgJsonPath = path2.join(app.workspace.workspaceRoot, "node_modules", pkgName, "package.json");
+    if (!await Bun.file(pkgJsonPath).exists())
+      return null;
+    try {
+      const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
+      const rel = pkgJson.module ?? pkgJson.main ?? "index.js";
+      const entryFile = path2.resolve(path2.dirname(pkgJsonPath), rel);
+      if (!await Bun.file(entryFile).exists())
+        return null;
+      return { pkgName, entryFile, pkgDir: path2.dirname(pkgJsonPath) };
+    } catch {
+      return null;
+    }
+  };
+};
+var CANDIDATE_EXTS2 = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
+var AKANJS_NODE_MODULE_RE = /[\\/]node_modules[\\/]akanjs[\\/]/;
+var defaultSkipPath = (absPath) => NODE_MODULES_RE.test(absPath) && !AKANJS_NODE_MODULE_RE.test(absPath);
+var resolveNodePackageExport = async (workspaceRoot, specifier) => {
+  const packageName = getPackageName(specifier);
+  if (!packageName)
+    return null;
+  const pkgJsonPath = path2.join(workspaceRoot, "node_modules", packageName, "package.json");
+  if (!await Bun.file(pkgJsonPath).exists())
+    return null;
+  try {
+    const pkgDir = path2.dirname(pkgJsonPath);
+    const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
+    const subpath = specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
+    const exported = resolvePackageExport(pkgJson.exports, subpath);
+    const rel = exported ?? (subpath === "." ? pkgJson.module ?? pkgJson.main ?? "index.js" : null);
+    if (!rel || !rel.startsWith("."))
+      return null;
+    const entryFile = await resolveFileCandidate(path2.resolve(pkgDir, rel));
+    if (!entryFile)
+      return null;
+    const pkgEntryName = specifier;
+    return { pkgName: pkgEntryName, entryFile, pkgDir: path2.dirname(entryFile), preserveFilePath: true };
+  } catch {
+    return null;
+  }
+};
+var resolveExportValue = (value) => {
+  if (!value)
+    return null;
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const resolved = resolveExportValue(item);
+      if (resolved)
+        return resolved;
+    }
+    return null;
+  }
+  for (const condition of ["source", "import", "default", "types"]) {
+    const resolved = resolveExportValue(value[condition]);
+    if (resolved)
+      return resolved;
+  }
+  return null;
+};
+var resolvePackageExport = (exportsMap, subpath) => {
+  if (!exportsMap)
+    return null;
+  const exact = resolveExportValue(exportsMap[subpath]);
+  if (exact)
+    return exact;
+  for (const [key, value] of Object.entries(exportsMap)) {
+    const starIdx = key.indexOf("*");
+    if (starIdx === -1)
+      continue;
+    const prefix = key.slice(0, starIdx);
+    const suffix = key.slice(starIdx + 1);
+    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+      continue;
+    const wildcard = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const resolved = resolveExportValue(value);
+    if (resolved)
+      return resolved.replace("*", wildcard);
+  }
+  return null;
+};
+var getPackageName = (specifier) => {
+  const parts = specifier.split("/");
+  if (!parts[0])
+    return null;
+  if (specifier.startsWith("@"))
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+  return parts[0];
+};
+var resolveFileCandidate = async (candidate) => {
+  if (await Bun.file(candidate).exists())
+    return candidate;
+  if (path2.extname(candidate))
+    return null;
+  for (const ext of CANDIDATE_EXTS2) {
+    const file = `${candidate}${ext}`;
+    if (await Bun.file(file).exists())
+      return file;
+  }
+  for (const ext of CANDIDATE_EXTS2) {
+    const file = path2.join(candidate, `index${ext}`);
+    if (await Bun.file(file).exists())
+      return file;
+  }
+  return null;
+};
+var MACRO_ATTR_RE = /with\s*\{\s*type\s*:\s*["']macro["']\s*\}/;
+var rewriteBarrelImports = async (source, barrels, analyzer) => {
+  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;
+    const statementStart = statement.getStart(sourceFile);
+    const statementEnd = statement.end;
+    statements.push({
+      start: statementStart,
+      end: statementEnd,
+      clause: source.slice(importClause.getStart(sourceFile), importClause.end).trim(),
+      specifier: statement.moduleSpecifier.text,
+      trailingSemicolon: source.slice(statement.moduleSpecifier.end, statement.end).includes(";"),
+      raw: source.slice(statementStart, statementEnd)
+    });
+  }
+  return statements;
+};
+var parseImportClause = (clause) => {
+  let rest = clause.trim();
+  let typeOnly = false;
+  if (rest.startsWith("type ")) {
+    typeOnly = true;
+    rest = rest.slice(5).trim();
+  }
+  const parsed = { typeOnly };
+  const commaMatch = /^(\w+)\s*,\s*(.+)$/.exec(rest);
+  if (commaMatch) {
+    parsed.defaultImport = commaMatch[1];
+    rest = commaMatch[2] ?? "";
+  } else if (/^\w+$/.test(rest)) {
+    parsed.defaultImport = rest;
+    return parsed;
+  }
+  if (rest.startsWith("*")) {
+    const ns = /^\*\s+as\s+(\w+)$/.exec(rest);
+    if (!ns)
+      return null;
+    parsed.namespaceImport = ns[1];
+    return parsed;
+  }
+  if (rest.startsWith("{")) {
+    const close = rest.indexOf("}");
+    if (close === -1)
+      return null;
+    const inner = rest.slice(1, close);
+    parsed.named = parseNamedImportList(inner);
+    return parsed;
+  }
+  return parsed;
+};
+var parseNamedImportList = (body) => {
+  const out = [];
+  for (const raw of body.split(",")) {
+    const s = raw.trim();
+    if (!s)
+      continue;
+    let isType = false;
+    let rest = s;
+    if (rest.startsWith("type ")) {
+      isType = true;
+      rest = rest.slice(5).trim();
+    }
+    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
+    if (asMatch) {
+      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
+      continue;
+    }
+    if (/^\w+$/.test(rest)) {
+      out.push({ imported: rest, local: rest, isType });
+    }
+  }
+  return out;
+};
+var rewriteSingleStatement = (stmt, map) => {
+  const clause = parseImportClause(stmt.clause);
+  if (!clause)
+    return null;
+  if (clause.namespaceImport)
+    return null;
+  if (clause.typeOnly && !clause.defaultImport)
+    return null;
+  if (!clause.named || clause.named.length === 0) {
+    return null;
+  }
+  const remaining = [];
+  const rewrites = new Map;
+  for (const item of clause.named) {
+    if (item.isType) {
+      remaining.push(item);
+      continue;
+    }
+    const target = map.get(item.imported);
+    if (!target) {
+      remaining.push(item);
+      continue;
+    }
+    const list = rewrites.get(target.subpath) ?? [];
+    list.push({ imported: target.originalName, local: item.local, isType: false });
+    rewrites.set(target.subpath, list);
+  }
+  if (rewrites.size === 0)
+    return null;
+  const lines = [];
+  const tail = ";";
+  if (shouldPreserveBarrelSideEffects(stmt.specifier)) {
+    lines.push(`import "${stmt.specifier}"${tail}`);
+  }
+  if (clause.defaultImport || remaining.length > 0) {
+    const parts = [];
+    if (clause.defaultImport)
+      parts.push(clause.defaultImport);
+    if (remaining.length > 0) {
+      parts.push(`{ ${remaining.map(serializeNamedItem).join(", ")} }`);
+    }
+    lines.push(`import ${parts.join(", ")} from "${stmt.specifier}"${tail}`);
+  }
+  for (const [subpath, items] of rewrites) {
+    lines.push(`import { ${items.map(serializeNamedItem).join(", ")} } from "${subpath}"${tail}`);
+  }
+  return lines.join(`
+`);
+};
+var shouldPreserveBarrelSideEffects = (specifier) => /^@(apps|libs)\/[^/]+\/client$/.test(specifier);
+var serializeNamedItem = (item) => {
+  const prefix = item.isType ? "type " : "";
+  if (item.imported === item.local)
+    return `${prefix}${item.imported}`;
+  return `${prefix}${item.imported} as ${item.local}`;
+};
+var loaderFor = (absPath) => {
+  if (absPath.endsWith(".tsx"))
+    return "tsx";
+  if (absPath.endsWith(".jsx"))
+    return "jsx";
+  if (absPath.endsWith(".ts"))
+    return "ts";
+  return "js";
+};
+
+// pkgs/@akanjs/devkit/frontendBuild/clientEntryDiscovery.ts
+var USE_CLIENT_RE = /^\s*(?:\/\*[\s\S]*?\*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
+var SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var NODE_MODULES_RE2 = /[\\/]node_modules[\\/]/;
+var AKANJS_NODE_MODULE_RE2 = /[\\/]node_modules[\\/]akanjs[\\/]/;
+var NON_SOURCE_EXT_RE = /\.(css|scss|sass|less|json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav)$/i;
+var shouldSkipNodeModule = (absPath) => NODE_MODULES_RE2.test(absPath) && !AKANJS_NODE_MODULE_RE2.test(absPath);
+
+class GraphClientEntryDiscovery {
+  #akanConfig;
+  #resolvePackage;
+  #analyzer;
+  #tsTranspiler = new Bun.Transpiler({ loader: "tsx" });
+  #fileExistsCache = new Map;
+  #factsCache = new Map;
+  #resolvedFileCache = new Map;
+  #resolvedSpecifierCache = new Map;
+  #reachableEntriesCache = new Map;
+  #missingFiles = new Set;
+  #unresolvedPaths = new Set;
+  #unresolvedSpecifiers = new Set;
+  constructor(akanConfig, resolvePackage) {
+    this.#akanConfig = akanConfig;
+    this.#resolvePackage = resolvePackage;
+    this.#analyzer = new BarrelAnalyzer({ resolvePackage });
+  }
+  static async create(app) {
+    return new GraphClientEntryDiscovery(await app.getConfig(), await createTsconfigPackageResolver(app));
+  }
+  async discover(seeds) {
+    const entries = new Set;
+    for (const seed of seeds) {
+      for (const entry of await this.#discoverFromFile(seed, new Set))
+        entries.add(entry);
+    }
+    return Array.from(entries).sort();
+  }
+  invalidate(files) {
+    for (const file of files) {
+      const absPath = path3.resolve(file);
+      this.#factsCache.delete(absPath);
+      this.#fileExistsCache.delete(absPath);
+      this.#reachableEntriesCache.delete(absPath);
+    }
+    if (files.length === 0)
+      return;
+    this.#reachableEntriesCache.clear();
+    this.#forgetMissing();
+  }
+  #forgetMissing() {
+    for (const key of this.#missingFiles)
+      this.#fileExistsCache.delete(key);
+    for (const key of this.#unresolvedPaths)
+      this.#resolvedFileCache.delete(key);
+    for (const key of this.#unresolvedSpecifiers)
+      this.#resolvedSpecifierCache.delete(key);
+    this.#missingFiles.clear();
+    this.#unresolvedPaths.clear();
+    this.#unresolvedSpecifiers.clear();
+  }
+  async#fileExists(p) {
+    const absPath = path3.resolve(p);
+    let cached = this.#fileExistsCache.get(absPath);
+    if (!cached) {
+      cached = Bun.file(absPath).exists().then((exists) => {
+        if (!exists)
+          this.#missingFiles.add(absPath);
+        return exists;
+      });
+      this.#fileExistsCache.set(absPath, cached);
+    }
+    return cached;
+  }
+  #facts(file) {
+    const absPath = path3.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;
+        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 = path3.resolve(absPathNoExt);
+    let cached = this.#resolvedFileCache.get(cacheKey);
+    if (cached)
+      return cached;
+    cached = (async () => {
+      if (await this.#fileExists(cacheKey))
+        return cacheKey;
+      for (const ext of SOURCE_EXTS) {
+        const f = `${cacheKey}${ext}`;
+        if (await this.#fileExists(f))
+          return f;
+      }
+      for (const ext of SOURCE_EXTS) {
+        const f = path3.join(cacheKey, `index${ext}`);
+        if (await this.#fileExists(f))
+          return f;
+      }
+      this.#unresolvedPaths.add(cacheKey);
+      return null;
+    })();
+    this.#resolvedFileCache.set(cacheKey, cached);
+    return cached;
+  }
+  async#resolveSpecifier(spec, importerDir) {
+    const cacheKey = `${importerDir}\x00${spec}`;
+    let cached = this.#resolvedSpecifierCache.get(cacheKey);
+    if (cached)
+      return cached;
+    cached = (async () => {
+      if (spec.startsWith(".") || spec.startsWith("/")) {
+        const abs = spec.startsWith("/") ? spec : path3.resolve(importerDir, spec);
+        return this.#resolveFileCandidate(abs);
+      }
+      const pkg = await this.#resolvePackage(spec);
+      if (pkg)
+        return pkg.entryFile;
+      this.#unresolvedSpecifiers.add(cacheKey);
+      return null;
+    })();
+    this.#resolvedSpecifierCache.set(cacheKey, cached);
+    return cached;
+  }
+  async#discoverFromFile(file, visiting) {
+    const absPath = path3.resolve(file);
+    const cached = this.#reachableEntriesCache.get(absPath);
+    if (cached)
+      return new Set(cached);
+    if (visiting.has(absPath) || shouldSkipNodeModule(absPath))
+      return new Set;
+    visiting.add(absPath);
+    const entries = new Set;
+    const facts = await this.#facts(absPath);
+    if (!facts)
+      return this.#finishDiscovery(absPath, visiting, entries);
+    if (facts.isClientEntry) {
+      entries.add(absPath);
+      return this.#finishDiscovery(absPath, visiting, entries);
+    }
+    const importerDir = path3.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, visiting))
+        entries.add(entry);
+    }
+    return this.#finishDiscovery(absPath, visiting, entries);
+  }
+  #finishDiscovery(absPath, visiting, entries) {
+    visiting.delete(absPath);
+    this.#reachableEntriesCache.set(absPath, entries);
+    return new Set(entries);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/routeClientBuilder.ts
+import { mkdir } from "fs/promises";
+import path6 from "path";
+
+// pkgs/@akanjs/devkit/transforms/rscUseClientTransform.ts
+import path4 from "path";
+var USE_CLIENT_RE2 = /^\s*(?:\/\*[\s\S]*?\*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
+var IMPLICIT_ROOT_LAYOUT_RE = /[/\\]\.akan[/\\]generated[/\\](?:implicit-root-layout|root-layouts[/\\].*__root_layout)\.(tsx|ts|jsx|js)$/;
+function toClientReferencePath(absPath, workspaceRoot) {
+  return path4.relative(path4.resolve(workspaceRoot), path4.resolve(absPath)).split(path4.sep).join("/");
+}
+function transformUseClient(source, args) {
+  if (!USE_CLIENT_RE2.test(source))
+    return null;
+  if (IMPLICIT_ROOT_LAYOUT_RE.test(args.path))
+    return null;
+  const transpiler = new Bun.Transpiler({ loader: loaderFor2(args.path) });
+  const { exports } = transpiler.scan(source);
+  if (exports.length === 0)
+    return null;
+  const referencePath = args.workspaceRoot ? toClientReferencePath(args.path, args.workspaceRoot) : args.path;
+  const filePathLit = JSON.stringify(referencePath);
+  const lines = [`import { registerClientReference } from "react-server-dom-webpack/server.node";`];
+  for (const name of exports) {
+    const nameLit = JSON.stringify(name);
+    const errMsg = JSON.stringify(`Attempted to call '${name}' from '${referencePath}' on the server, but it is a client-only export.`);
+    const proxy = `() => { throw new Error(${errMsg}); }`;
+    const binding = name === "default" ? `export default registerClientReference(${proxy}, ${filePathLit}, ${nameLit});` : `export const ${name} = registerClientReference(${proxy}, ${filePathLit}, ${nameLit});`;
+    lines.push(binding);
+  }
+  return lines.join(`
+`);
+}
+function loaderFor2(absPath) {
+  if (absPath.endsWith(".tsx"))
+    return "tsx";
+  if (absPath.endsWith(".jsx"))
+    return "jsx";
+  if (absPath.endsWith(".ts"))
+    return "ts";
+  return "js";
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/clientEntriesBundler.ts
+import fs from "fs";
+import path5 from "path";
+
+// pkgs/@akanjs/devkit/frontendBuild/clientBuildTypes.ts
+var CLIENT_BUNDLE_NAMING = {
+  entry: "[name]-[hash].[ext]",
+  chunk: "chunks/[hash].[ext]",
+  asset: "assets/[hash].[ext]"
+};
+
+// pkgs/@akanjs/devkit/frontendBuild/clientEntriesBundler.ts
+class ClientEntriesBundler {
+  #app;
+  #entries;
+  #plugins;
+  #external;
+  #externalSubpaths;
+  #externalAliases;
+  #command;
+  #outputSubdir;
+  #reactFastRefresh;
+  #artifactDir;
+  #outdir;
+  #servePrefix;
+  #manifest = {};
+  #ssrManifest = { moduleLoading: null, moduleMap: {} };
+  #entryUrlsByAbsPath = new Map;
+  #entryOutputAbsByAbsPath = new Map;
+  #entryDepsByAbsPath = new Map;
+  #clientReferenceIdByAbsPath = new Map;
+  #opaqueEntries = null;
+  #metafileOutputsByAbs = new Map;
+  constructor(options) {
+    this.#app = options.app;
+    this.#entries = options.entries;
+    this.#plugins = options.plugins ?? [];
+    this.#external = options.external ?? [];
+    this.#externalSubpaths = options.externalSubpaths ?? [];
+    this.#externalAliases = options.externalAliases ?? {};
+    this.#command = options.command ?? "start";
+    this.#outputSubdir = options.outputSubdir ?? "client";
+    this.#reactFastRefresh = options.reactFastRefresh ?? false;
+    this.#artifactDir = `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
+    this.#outdir = `${this.#artifactDir}/${this.#outputSubdir}`;
+    this.#servePrefix = `/_akan/${this.#outputSubdir}`;
+  }
+  async bundle() {
+    const akanConfig = await this.#app.getConfig();
+    this.#opaqueEntries = await this.#createOpaqueEntryAliases();
+    const result = await Bun.build({
+      entrypoints: this.#opaqueEntries.entries,
+      outdir: this.#outdir,
+      splitting: true,
+      target: "browser",
+      format: "esm",
+      naming: CLIENT_BUNDLE_NAMING,
+      metafile: true,
+      define: this.#getDefine(),
+      minify: this.#command === "build",
+      optimizeImports: akanConfig.optimizeImports,
+      reactFastRefresh: this.#command === "start" && this.#outputSubdir === "client" && this.#reactFastRefresh,
+      plugins: this.#external.length > 0 || this.#externalSubpaths.length > 0 || Object.keys(this.#externalAliases).length > 0 ? [...this.#plugins, this.#createExternalSpecifiersPlugin()] : this.#plugins
+    });
+    if (!result.success)
+      throw new AggregateError(result.logs, "[ClientEntriesBundler] Bun.build failed");
+    await this.#rewriteExternalImportSpecifiers(result.outputs);
+    const metafile = result.metafile;
+    if (!metafile)
+      throw new Error("[ClientEntriesBundler] metafile is missing");
+    this.#metafileOutputsByAbs = new Map(Object.entries(metafile.outputs).map(([k, v]) => [this.#absFromOutdir(k), v]));
+    for (const artifact of result.outputs.filter((a) => a.kind === "entry-point"))
+      this.#addEntryArtifact(artifact.path);
+    return {
+      manifest: this.#manifest,
+      ssrManifest: this.#ssrManifest,
+      entryUrlsByAbsPath: this.#entryUrlsByAbsPath,
+      entryOutputAbsByAbsPath: this.#entryOutputAbsByAbsPath,
+      entryDepsByAbsPath: this.#entryDepsByAbsPath,
+      clientReferenceIdByAbsPath: this.#clientReferenceIdByAbsPath
+    };
+  }
+  #getDefine() {
+    const nodeEnv = this.#command === "build" ? "production" : "development";
+    return {
+      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("ssr"),
+      ...Object.fromEntries(Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
+    };
+  }
+  async#createOpaqueEntryAliases() {
+    const aliasDir = path5.join(this.#app.cwdPath, ".akan", "generated", "client-entry-alias", this.#outputSubdir);
+    fs.mkdirSync(aliasDir, { recursive: true });
+    const originalByAlias = new Map;
+    const aliasedEntries = await Promise.all(this.#entries.map(async (entry) => {
+      const absEntry = path5.resolve(entry);
+      const hash = Bun.hash(`${this.#app.name}
+${this.#outputSubdir}
+${absEntry}`).toString(36);
+      const aliasPath = path5.join(aliasDir, `${hash}.tsx`);
+      await Bun.write(aliasPath, this.#createOpaqueEntryAliasSource(absEntry, await this.#scanEntryExportNames(absEntry)));
+      originalByAlias.set(path5.resolve(aliasPath), absEntry);
+      return aliasPath;
+    }));
+    return { entries: aliasedEntries, originalByAlias, aliasDir };
+  }
+  #createOpaqueEntryAliasSource(absEntry, exportNames) {
+    const entryLit = JSON.stringify(path5.resolve(absEntry));
+    if (exportNames.length === 0)
+      return `export * from ${entryLit};
+`;
+    const namedExports = exportNames.filter((name) => name !== "default");
+    const lines = namedExports.length > 0 ? [`export { ${namedExports.join(", ")} } from ${entryLit};`] : [];
+    if (exportNames.includes("default"))
+      lines.push(`export { default } from ${entryLit};`);
+    return `${lines.join(`
+`)}
+`;
+  }
+  async#scanEntryExportNames(absEntry) {
+    const source = await Bun.file(absEntry).text();
+    const transpiler = new Bun.Transpiler({ loader: this.#loaderForEntry(absEntry) });
+    return transpiler.scan(source).exports;
+  }
+  #loaderForEntry(absPath) {
+    if (absPath.endsWith(".tsx"))
+      return "tsx";
+    if (absPath.endsWith(".jsx"))
+      return "jsx";
+    if (absPath.endsWith(".ts"))
+      return "ts";
+    return "js";
+  }
+  #createExternalSpecifiersPlugin() {
+    const set = new Set(this.#external);
+    const subpathSet = new Set(this.#externalSubpaths);
+    const aliases = this.#externalAliases;
+    const specifiers = [...new Set([...this.#external, ...this.#externalSubpaths, ...Object.keys(aliases)])];
+    const escaped = specifiers.map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    const filter = new RegExp(`^(${escaped.join("|")})(?:/.*)?$`);
+    return {
+      name: "akan-externalize-specifiers",
+      setup(build) {
+        build.onResolve({ filter }, (args) => {
+          const alias = aliases[args.path];
+          if (alias)
+            return { path: alias, external: true };
+          if (!ClientEntriesBundler.#matchesExternalSpecifier(args.path, set, subpathSet))
+            return;
+          return { path: args.path, external: true };
+        });
+      }
+    };
+  }
+  static #matchesExternalSpecifier(specifier, exactExternals, subpathExternals) {
+    if (exactExternals.has(specifier))
+      return true;
+    if (subpathExternals.has(specifier))
+      return true;
+    for (const external of subpathExternals) {
+      if (specifier.startsWith(`${external}/`))
+        return true;
+    }
+    return false;
+  }
+  async#rewriteExternalImportSpecifiers(outputs) {
+    if (Object.keys(this.#externalAliases).length === 0)
+      return;
+    await Promise.all(outputs.filter((output) => output.path.endsWith(".js")).map(async (output) => {
+      const source = await Bun.file(output.path).text();
+      const rewritten = ClientEntriesBundler.rewriteExternalImportSpecifiers(source, this.#externalAliases);
+      if (rewritten !== source)
+        await Bun.write(output.path, rewritten);
+    }));
+  }
+  static rewriteExternalImportSpecifiers(source, aliases) {
+    let rewritten = source;
+    for (const [specifier, alias] of Object.entries(aliases)) {
+      if (!alias)
+        continue;
+      const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      rewritten = rewritten.replace(new RegExp(`(\\bfrom\\s*["'])${escaped}(["'])`, "g"), (_match, prefix, suffix) => {
+        return `${prefix}${alias}${suffix}`;
+      }).replace(new RegExp(`(\\bimport\\s*["'])${escaped}(["'])`, "g"), (_match, prefix, suffix) => {
+        return `${prefix}${alias}${suffix}`;
+      });
+    }
+    return rewritten;
+  }
+  #toServeUrl(absOutPath) {
+    const rel = path5.relative(this.#outdir, absOutPath).split(path5.sep).join("/");
+    return `${this.#servePrefix}/${rel}`;
+  }
+  #absFromOutdir(p) {
+    return path5.isAbsolute(p) ? p : path5.resolve(this.#outdir, p);
+  }
+  #absFromEntryPoint(p) {
+    if (path5.isAbsolute(p))
+      return path5.resolve(p);
+    const candidates = [path5.resolve(process.cwd(), p), path5.resolve(this.#app.cwdPath, p)];
+    return candidates.find((candidate) => fs.existsSync(candidate)) ?? candidates[0];
+  }
+  #collectChunkUrls(absOutPath, visited = new Set) {
+    if (visited.has(absOutPath))
+      return [];
+    visited.add(absOutPath);
+    const info = this.#metafileOutputsByAbs.get(absOutPath);
+    if (!info)
+      return [this.#toServeUrl(absOutPath)];
+    const urls = [this.#toServeUrl(absOutPath)];
+    for (const imp of info.imports) {
+      if (imp.kind === "dynamic-import")
+        continue;
+      const absImp = this.#absFromOutdir(imp.path);
+      if (!absImp.endsWith(".js"))
+        continue;
+      urls.push(...this.#collectChunkUrls(absImp, visited));
+    }
+    return urls;
+  }
+  #collectClientDeps(absOutPath, visited = new Set) {
+    if (visited.has(absOutPath))
+      return new Set;
+    visited.add(absOutPath);
+    const deps = new Set;
+    const info = this.#metafileOutputsByAbs.get(absOutPath);
+    if (!info)
+      return deps;
+    if (!this.#opaqueEntries)
+      throw new Error("[ClientEntriesBundler] opaque entries are missing");
+    for (const input of Object.keys(info.inputs ?? {})) {
+      const absInput = this.#absFromEntryPoint(input);
+      if (!absInput.includes("node_modules") && !absInput.startsWith(this.#opaqueEntries.aliasDir))
+        deps.add(absInput);
+    }
+    for (const imp of info.imports) {
+      if (imp.kind === "dynamic-import")
+        continue;
+      const absImp = this.#absFromOutdir(imp.path);
+      if (!absImp.endsWith(".js"))
+        continue;
+      for (const dep of this.#collectClientDeps(absImp, visited))
+        deps.add(dep);
+    }
+    return deps;
+  }
+  #addEntryArtifact(absOut) {
+    if (!this.#opaqueEntries)
+      throw new Error("[ClientEntriesBundler] opaque entries are missing");
+    const info = this.#metafileOutputsByAbs.get(absOut);
+    const buildEntryPointAbs = info?.entryPoint ? this.#absFromEntryPoint(info.entryPoint) : null;
+    const entryPointAbs = buildEntryPointAbs ? this.#opaqueEntries.originalByAlias.get(buildEntryPointAbs) ?? buildEntryPointAbs : null;
+    if (!entryPointAbs)
+      return;
+    const chunkUrls = this.#collectChunkUrls(absOut);
+    const entryUrl = chunkUrls[0] ?? this.#toServeUrl(absOut);
+    this.#entryUrlsByAbsPath.set(entryPointAbs, entryUrl);
+    this.#entryOutputAbsByAbsPath.set(entryPointAbs, absOut);
+    this.#entryDepsByAbsPath.set(entryPointAbs, [...this.#collectClientDeps(absOut)].sort());
+    const clientReferenceId = toClientReferencePath(entryPointAbs, this.#app.workspace.workspaceRoot);
+    this.#clientReferenceIdByAbsPath.set(entryPointAbs, clientReferenceId);
+    const flatChunks = [];
+    for (const url of chunkUrls)
+      flatChunks.push(url, url);
+    const exportNames = info?.exports && info.exports.length > 0 ? info.exports : ["default"];
+    const ssrEntriesByName = {};
+    for (const name of exportNames) {
+      const key = `${clientReferenceId}#${name}`;
+      this.#manifest[key] = { id: entryUrl, chunks: flatChunks, name, async: true };
+      ssrEntriesByName[name] = { id: absOut, chunks: [absOut, absOut], name, async: true };
+    }
+    this.#ssrManifest.moduleMap[entryUrl] = ssrEntriesByName;
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/vendorSpecifiers.ts
+var VENDOR_SPECIFIERS = [
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "react-refresh/runtime",
+  "scheduler",
+  "react-server-dom-webpack/client.browser",
+  "akanjs/store",
+  "akanjs/base",
+  "akanjs/common",
+  "akanjs/constant"
+];
+
+// pkgs/@akanjs/devkit/frontendBuild/routeClientBuilder.ts
+var SSR_CLIENT_EXTERNALS = [
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "akanjs/fetch"
+];
+var SSR_CLIENT_ALIAS_EXTERNALS = [
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime"
+];
+
+class RouteClientBuilder {
+  #app;
+  #seeds;
+  #knownEntries;
+  #command;
+  #discovery;
+  constructor(options) {
+    this.#app = options.app;
+    this.#seeds = options.seeds;
+    this.#knownEntries = options.knownEntries ?? new Set;
+    this.#command = options.command ?? "start";
+    this.#discovery = options.discovery;
+  }
+  async build() {
+    const discovery = this.#discovery ?? await GraphClientEntryDiscovery.create(this.#app);
+    const discovered = await discovery.discover(this.#seeds);
+    const entries = discovered.filter((e) => !this.#knownEntries.has(e));
+    if (entries.length === 0)
+      return this.#emptyResult(discovered);
+    const bootstrapEntries = await this.#createBootstrapEntries(entries);
+    const browserBundle = await this.#buildBrowserBundle(bootstrapEntries);
+    const ssrBundle = await this.#buildSsrBundle(bootstrapEntries);
+    const acceptedEntries = new Set(entries);
+    const manifestDelta = {};
+    const ssrModuleMap = {};
+    const clientDeps = new Set;
+    const clientDepsByEntry = {};
+    for (const [key, row] of Object.entries(browserBundle.manifest)) {
+      const manifestEntry = RouteClientBuilder.resolveOriginalManifestEntry(key, bootstrapEntries.originalByBuildEntry, browserBundle.clientReferenceIdByAbsPath, this.#app.workspace.workspaceRoot);
+      if (!manifestEntry)
+        continue;
+      if (!acceptedEntries.has(manifestEntry.originalEntry))
+        continue;
+      manifestDelta[manifestEntry.key] = row;
+      const ssrOutput = ssrBundle.entryOutputAbsByAbsPath.get(manifestEntry.buildEntry);
+      if (!ssrOutput)
+        continue;
+      ssrModuleMap[row.id] ??= {};
+      ssrModuleMap[row.id][row.name] = { id: ssrOutput, chunks: [ssrOutput, ssrOutput], name: row.name, async: true };
+    }
+    for (const entry of bootstrapEntries.buildEntries) {
+      const buildEntry = path6.resolve(entry);
+      const originalEntry = path6.resolve(bootstrapEntries.originalByBuildEntry.get(buildEntry) ?? buildEntry);
+      if (!acceptedEntries.has(originalEntry))
+        continue;
+      const deps = new Set([originalEntry]);
+      for (const dep of browserBundle.entryDepsByAbsPath.get(buildEntry) ?? [])
+        deps.add(path6.resolve(dep));
+      const sortedDeps = [...deps].sort();
+      clientDepsByEntry[originalEntry] = sortedDeps;
+      for (const dep of sortedDeps)
+        clientDeps.add(dep);
+    }
+    return {
+      manifestDelta,
+      ssrManifestDelta: { moduleLoading: null, moduleMap: ssrModuleMap },
+      newEntries: entries,
+      discoveredEntries: discovered,
+      clientDeps: [...clientDeps].sort(),
+      clientDepsByEntry
+    };
+  }
+  #emptyResult(discoveredEntries = []) {
+    return {
+      manifestDelta: {},
+      ssrManifestDelta: { moduleLoading: null, moduleMap: {} },
+      newEntries: [],
+      discoveredEntries,
+      clientDeps: [],
+      clientDepsByEntry: {}
+    };
+  }
+  async#buildBrowserBundle(bootstrapEntries) {
+    const reactFastRefresh = process.env.AKAN_REACT_FAST_REFRESH !== "0";
+    return new ClientEntriesBundler({
+      app: this.#app,
+      entries: bootstrapEntries.buildEntries,
+      plugins: [
+        await createBarrelImportsPlugin(this.#app, {
+          pipeAfter: reactFastRefresh ? RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh : undefined
+        })
+      ],
+      external: VENDOR_SPECIFIERS,
+      command: this.#command,
+      reactFastRefresh
+    }).bundle();
+  }
+  async#buildSsrBundle(bootstrapEntries) {
+    const externalOptions = RouteClientBuilder.resolveSsrClientExternalOptions(this.#command);
+    return new ClientEntriesBundler({
+      app: this.#app,
+      entries: bootstrapEntries.buildEntries,
+      plugins: [await createBarrelImportsPlugin(this.#app)],
+      ...externalOptions,
+      outputSubdir: "client-ssr",
+      command: this.#command
+    }).bundle();
+  }
+  async#createBootstrapEntries(entries) {
+    if (!await Bun.file(path6.join(this.#app.cwdPath, "lib", "st.ts")).exists()) {
+      return { buildEntries: entries, originalByBuildEntry: new Map };
+    }
+    const outdir = path6.join(this.#app.cwdPath, ".akan", "generated", "client-entry-bootstrap");
+    await mkdir(outdir, { recursive: true });
+    const originalByBuildEntry = new Map;
+    const buildEntries = await Promise.all(entries.map(async (entry) => {
+      const absEntry = path6.resolve(entry);
+      const hash = Bun.hash(`${this.#app.name}
+${absEntry}`).toString(36);
+      const base = path6.basename(absEntry).replace(/[^A-Za-z0-9._-]/g, "_");
+      const wrapperEntry = path6.join(outdir, `${base}-${hash}.tsx`);
+      const exportNames = await this.#scanExportNames(absEntry);
+      await Bun.write(wrapperEntry, RouteClientBuilder.createStoreBootstrapEntrySource({
+        appName: this.#app.name,
+        originalEntry: absEntry,
+        exportNames
+      }));
+      originalByBuildEntry.set(path6.resolve(wrapperEntry), absEntry);
+      return wrapperEntry;
+    }));
+    return { buildEntries, originalByBuildEntry };
+  }
+  async#scanExportNames(absEntry) {
+    const source = await Bun.file(absEntry).text();
+    const transpiler = new Bun.Transpiler({ loader: this.#loaderFor(absEntry) });
+    return transpiler.scan(source).exports;
+  }
+  #loaderFor(absPath) {
+    if (absPath.endsWith(".tsx"))
+      return "tsx";
+    if (absPath.endsWith(".jsx"))
+      return "jsx";
+    if (absPath.endsWith(".ts"))
+      return "ts";
+    return "js";
+  }
+  static normalizeNamedDefaultFunctionForFastRefresh(source) {
+    let changed = false;
+    const defaultNames = [];
+    const next = source.replace(/(^|\n)(\s*)export\s+default\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)(?=\s*(?:<|\())/g, (match, lineStart, indent, asyncKeyword, name) => {
+      changed = true;
+      defaultNames.push(name);
+      return `${lineStart}${indent}${asyncKeyword ?? ""}function ${name}`;
+    });
+    if (!changed)
+      return null;
+    return `${next}
+${defaultNames.map((name) => `export default ${name};`).join(`
+`)}
+`;
+  }
+  static resolveSsrClientRuntimeAliases() {
+    const serverEntry = RouteClientBuilder.resolveAkanServerEntry();
+    return { [Bun.resolveSync("akanjs/fetch", serverEntry)]: "akanjs/fetch" };
+  }
+  static resolveSsrClientExternalOptions(command) {
+    if (command === "start") {
+      return {
+        external: SSR_CLIENT_EXTERNALS,
+        externalSubpaths: ["akanjs/fetch"],
+        externalAliases: RouteClientBuilder.resolveSsrClientRuntimeAliases()
+      };
+    }
+    return { external: SSR_CLIENT_ALIAS_EXTERNALS };
+  }
+  static resolveAkanServerEntry() {
+    try {
+      return Bun.resolveSync("akanjs/server", import.meta.dir);
+    } catch {
+      return path6.resolve(import.meta.dir, "../../../server/index.ts");
+    }
+  }
+  static createStoreBootstrapEntrySource(args) {
+    const originalEntry = JSON.stringify(path6.resolve(args.originalEntry));
+    const namedExports = args.exportNames.filter((name) => name !== "default");
+    const lines = [
+      `import ${JSON.stringify(`@apps/${args.appName}/client`)};`,
+      ...namedExports.length > 0 ? [`export { ${namedExports.join(", ")} } from ${originalEntry};`] : []
+    ];
+    if (args.exportNames.includes("default"))
+      lines.push(`export { default } from ${originalEntry};`);
+    return `${lines.join(`
+`)}
+`;
+  }
+  static resolveOriginalManifestEntry(manifestKey, originalByBuildEntry, clientReferenceIdByBuildEntry = new Map, workspaceRoot = process.cwd()) {
+    const hashIdx = manifestKey.lastIndexOf("#");
+    if (hashIdx < 0)
+      return null;
+    const buildReferenceId = manifestKey.slice(0, hashIdx);
+    const name = manifestKey.slice(hashIdx + 1);
+    const buildEntry = [...clientReferenceIdByBuildEntry.entries()].find(([, referenceId]) => referenceId === buildReferenceId)?.[0] ?? buildReferenceId;
+    const originalEntry = originalByBuildEntry.get(buildEntry) ?? buildEntry;
+    const originalReferenceId = toClientReferencePath(originalEntry, workspaceRoot);
+    return { buildEntry, originalEntry, name, key: `${originalReferenceId}#${name}` };
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/autoImportSync.ts
+import { readdir, readFile, stat, writeFile } from "fs/promises";
+import path7 from "path";
+import ts2 from "typescript";
+var TEST_FILE_RE = /\.(test|spec)\.(ts|tsx)$/;
+var AKAN_BASE = {
+  names: ["Int", "Float", "ID", "Any", "Upload", "enumOf", "dayjs"],
+  specifier: "akanjs/base",
+  kind: "named"
+};
+var AKAN_BASE_TYPES = { names: ["Dayjs"], specifier: "akanjs/base", kind: "named", typeOnly: true };
+var CNST_NS = { names: ["cnst"], specifier: "../cnst", kind: "namespace" };
+var DB_NS = { names: ["db"], specifier: "../db", kind: "namespace" };
+var SRV_NS = { names: ["srv"], specifier: "../srv", kind: "namespace" };
+var ERR_DICT = { names: ["Err"], specifier: "../dict", kind: "named" };
+var RULES = {
+  constant: [AKAN_BASE, AKAN_BASE_TYPES, { names: ["via"], specifier: "akanjs/constant", kind: "named" }],
+  document: [
+    AKAN_BASE,
+    AKAN_BASE_TYPES,
+    CNST_NS,
+    DB_NS,
+    ERR_DICT,
+    {
+      names: ["by", "from", "into", "SchemaOf", "DataInputOf", "DocumentUpdateHelper", "documentQueryHelper", "Mdl"],
+      specifier: "akanjs/document",
+      kind: "named"
+    }
+  ],
+  service: [
+    AKAN_BASE,
+    AKAN_BASE_TYPES,
+    DB_NS,
+    SRV_NS,
+    CNST_NS,
+    ERR_DICT,
+    { names: ["serve"], specifier: "akanjs/service", kind: "named" },
+    {
+      names: ["DataInputOf", "ListQueryOption", "DatabaseRegistry", "getFilterInfoByKey"],
+      specifier: "akanjs/document",
+      kind: "named"
+    }
+  ],
+  signal: [
+    AKAN_BASE,
+    AKAN_BASE_TYPES,
+    SRV_NS,
+    CNST_NS,
+    ERR_DICT,
+    {
+      names: ["endpoint", "internal", "slice", "Public", "Req", "Ws", "None", "Res"],
+      specifier: "akanjs/signal",
+      kind: "named"
+    }
+  ],
+  dictionary: [
+    {
+      names: ["modelDictionary", "scalarDictionary", "serviceDictionary"],
+      specifier: "akanjs/dictionary",
+      kind: "named"
+    }
+  ],
+  srvkit: [
+    AKAN_BASE,
+    AKAN_BASE_TYPES,
+    { names: ["Logger", "HttpClient", "sleep"], specifier: "akanjs/common", kind: "named" },
+    { names: ["adapt"], specifier: "akanjs/service", kind: "named" },
+    { names: ["SignalContext", "Guard", "InternalArg", "Middleware"], specifier: "akanjs/signal", kind: "named" }
+  ],
+  common: [AKAN_BASE, AKAN_BASE_TYPES],
+  store: [
+    CNST_NS,
+    { names: ["store"], specifier: "akanjs/store", kind: "named" },
+    { names: ["fetch", "usePage", "sig"], specifier: "../useClient", kind: "named" },
+    { names: ["st"], specifier: "../st", kind: "named" },
+    { names: ["RootStore"], specifier: "../st", kind: "named", typeOnly: true }
+  ],
+  client: [
+    {
+      names: ["cnst", "fetch", "st", "usePage"],
+      specifier: (ctx) => `@${ctx.scope}/${ctx.project}/client`,
+      kind: "named"
+    }
+  ]
+};
+var PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9]*$/;
+var DOMAIN_ROLE_KINDS = {
+  constant: ["constant"],
+  dictionary: ["constant", "document", "signal"],
+  common: ["constant"]
+};
+var LIB_BARRELS = {
+  Err: { barrel: "dict", kind: "named" },
+  db: { barrel: "db", kind: "namespace" },
+  cnst: { barrel: "cnst", kind: "namespace" },
+  srv: { barrel: "srv", kind: "namespace" }
+};
+var DOMAIN_DENYLIST = new Set([
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "Promise",
+  "Array",
+  "Object",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "RegExp",
+  "Symbol",
+  "Proxy",
+  "Reflect",
+  "JSON",
+  "Math",
+  "Number",
+  "BigInt",
+  "Function",
+  "Boolean",
+  "String",
+  "Record",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "ReturnType",
+  "Parameters",
+  "Awaited",
+  "InstanceType"
+]);
+
+class AutoImportSync {
+  #workspaceRoot;
+  #domainCache = new Map;
+  constructor({ workspaceRoot }) {
+    this.#workspaceRoot = path7.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 = path7.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 = path7.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path7.isAbsolute(rel))
+      return null;
+    const base = path7.basename(abs);
+    if (TEST_FILE_RE.test(base) || base === "index.ts" || base === "index.tsx" || base.endsWith(".d.ts"))
+      return null;
+    const parts = rel.split(path7.sep).filter(Boolean);
+    const [scope, project, facet] = parts;
+    if (scope !== "apps" && scope !== "libs" || !project || !facet)
+      return null;
+    const role = roleFor(facet, base);
+    if (!role)
+      return null;
+    return { role, scope, project };
+  }
+  async#syncFile(abs, ctx) {
+    const stats = await stat(abs).catch(() => null);
+    if (!stats?.isFile())
+      return false;
+    const source = await readFile(abs, "utf8");
+    const resolveExtra = await this.#extraResolverFor(abs, ctx);
+    const next = transformSource(source, abs, ctx, resolveExtra);
+    if (next === null || next === source)
+      return false;
+    await writeFile(abs, next);
+    return true;
+  }
+  async#extraResolverFor(abs, ctx) {
+    const resolvers = [];
+    if (ctx.role === "srvkit" || ctx.role === "common")
+      resolvers.push(await this.#libBarrelResolver(abs, ctx));
+    const kinds = DOMAIN_ROLE_KINDS[ctx.role];
+    if (kinds)
+      resolvers.push(await this.#domainResolver(abs, ctx, kinds));
+    if (resolvers.length === 0)
+      return;
+    return (symbol) => {
+      for (const resolve of resolvers) {
+        const target = resolve(symbol);
+        if (target)
+          return target;
+      }
+      return null;
+    };
+  }
+  async#domainResolver(abs, ctx, kinds) {
+    const index = await this.#domainIndex(path7.join(this.#workspaceRoot, ctx.scope, ctx.project));
+    const fileDir = path7.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 = path7.dirname(abs);
+    const libDir = path7.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(path7.join(libDir, `${barrel}.ts`)))
+        available.set(symbol, { specifier: relativeSpecifier(fileDir, path7.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(path7.join(pkgRoot, "lib"));
+    this.#domainCache.set(pkgRoot, index);
+    return index;
+  }
+  #domainPkgRootOf(file) {
+    const rel = path7.relative(this.#workspaceRoot, path7.resolve(file));
+    if (rel.startsWith("..") || path7.isAbsolute(rel))
+      return null;
+    const [scope, project, facet] = rel.split(path7.sep).filter(Boolean);
+    if (scope !== "apps" && scope !== "libs" || !project || facet !== "lib")
+      return null;
+    if (!domainKindOf(path7.basename(file)))
+      return null;
+    return path7.join(this.#workspaceRoot, scope, project);
+  }
+}
+var roleFor = (facet, base) => {
+  if (facet === "lib") {
+    if (base.endsWith(".constant.ts"))
+      return "constant";
+    if (base.endsWith(".document.ts"))
+      return "document";
+    if (base.endsWith(".service.ts"))
+      return "service";
+    if (base.endsWith(".signal.ts"))
+      return "signal";
+    if (base.endsWith(".dictionary.ts"))
+      return "dictionary";
+    if (base.endsWith(".store.ts"))
+      return "store";
+    if (base.endsWith(".tsx"))
+      return "client";
+    return null;
+  }
+  if (facet === "ui" || facet === "page")
+    return base.endsWith(".tsx") ? "client" : null;
+  if (facet === "webkit")
+    return base.endsWith(".ts") || base.endsWith(".tsx") ? "client" : null;
+  if (facet === "srvkit")
+    return base.endsWith(".ts") ? "srvkit" : null;
+  if (facet === "common")
+    return base.endsWith(".ts") || base.endsWith(".tsx") ? "common" : null;
+  return null;
+};
+var targetFor = (symbol, ctx) => {
+  for (const rule of RULES[ctx.role]) {
+    if (!rule.names.includes(symbol))
+      continue;
+    const specifier = typeof rule.specifier === "function" ? rule.specifier(ctx) : rule.specifier;
+    return { specifier, kind: rule.kind, typeOnly: rule.typeOnly };
+  }
+  return null;
+};
+var transformSource = (source, fileName, ctx, resolveExtra) => {
+  const sf = ts2.createSourceFile(fileName, source, ts2.ScriptTarget.Latest, true, scriptKindFor(fileName));
+  const bound = collectBoundNames(sf);
+  const used = collectUsedReferences(sf);
+  const namedBySpecifier = new Map;
+  const namespaceImports = [];
+  for (const name of used) {
+    if (bound.has(name))
+      continue;
+    const target = targetFor(name, ctx) ?? resolveExtra?.(name) ?? null;
+    if (!target)
+      continue;
+    if (target.kind === "namespace")
+      namespaceImports.push({ name, specifier: target.specifier });
+    else {
+      const names = namedBySpecifier.get(target.specifier) ?? new Map;
+      names.set(name, target.typeOnly ?? false);
+      namedBySpecifier.set(target.specifier, names);
+    }
+  }
+  if (namedBySpecifier.size === 0 && namespaceImports.length === 0)
+    return null;
+  const importDecls = sf.statements.filter(ts2.isImportDeclaration);
+  const anchor = importDecls.at(-1) ?? null;
+  const namedImportsBySpecifier = collectExistingNamedImports(importDecls);
+  const edits = [];
+  const newStatements = [];
+  for (const [specifier, names] of namedBySpecifier) {
+    const existing = namedImportsBySpecifier.get(specifier);
+    if (existing) {
+      const merged = new Map(existing.names);
+      for (const [name, isType] of names)
+        if (!merged.has(name))
+          merged.set(name, isType);
+      edits.push({
+        start: existing.decl.getStart(sf),
+        end: existing.decl.getEnd(),
+        text: formatNamedImport(specifier, merged)
+      });
+    } else
+      newStatements.push(formatNamedImport(specifier, names));
+  }
+  for (const ns of namespaceImports)
+    newStatements.push(`import * as ${ns.name} from "${ns.specifier}";`);
+  if (newStatements.length > 0) {
+    const anchorEdit = anchor ? edits.find((edit) => edit.start === anchor.getStart(sf)) : undefined;
+    if (anchorEdit)
+      anchorEdit.text = `${anchorEdit.text}
+${newStatements.join(`
+`)}`;
+    else if (anchor)
+      edits.push({ start: anchor.getEnd(), end: anchor.getEnd(), text: `
+${newStatements.join(`
+`)}` });
+    else {
+      const prologueEnd = directivePrologueEnd(sf);
+      if (prologueEnd >= 0)
+        edits.push({ start: prologueEnd, end: prologueEnd, text: `
+${newStatements.join(`
+`)}` });
+      else
+        edits.push({ start: 0, end: 0, text: `${newStatements.join(`
+`)}
+
+` });
+    }
+  }
+  if (edits.length === 0)
+    return null;
+  edits.sort((a, b) => b.start - a.start);
+  let out = source;
+  for (const edit of edits)
+    out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+  return out === source ? null : out;
+};
+var collectBoundNames = (sf) => {
+  const names = new Set;
+  const visit = (node) => {
+    if (ts2.isImportClause(node)) {
+      if (node.name)
+        names.add(node.name.text);
+      const bindings = node.namedBindings;
+      if (bindings && ts2.isNamespaceImport(bindings))
+        names.add(bindings.name.text);
+      if (bindings && ts2.isNamedImports(bindings))
+        for (const el of bindings.elements)
+          names.add(el.name.text);
+    }
+    if ((ts2.isVariableDeclaration(node) || ts2.isFunctionDeclaration(node) || ts2.isClassDeclaration(node) || ts2.isParameter(node) || ts2.isBindingElement(node) || ts2.isEnumDeclaration(node) || ts2.isTypeAliasDeclaration(node) || ts2.isInterfaceDeclaration(node)) && node.name && ts2.isIdentifier(node.name))
+      names.add(node.name.text);
+    ts2.forEachChild(node, visit);
+  };
+  ts2.forEachChild(sf, visit);
+  return names;
+};
+var collectUsedReferences = (sf) => {
+  const used = new Set;
+  const visit = (node) => {
+    if (ts2.isIdentifier(node) && isReferencePosition(node))
+      used.add(node.text);
+    ts2.forEachChild(node, visit);
+  };
+  ts2.forEachChild(sf, visit);
+  return used;
+};
+var isReferencePosition = (node) => {
+  const parent = node.parent;
+  if (!parent)
+    return true;
+  if (ts2.isPropertyAccessExpression(parent) && parent.name === node)
+    return false;
+  if (ts2.isQualifiedName(parent) && parent.right === node)
+    return false;
+  if (ts2.isPropertyAssignment(parent) && parent.name === node)
+    return false;
+  if (ts2.isPropertySignature(parent) && parent.name === node)
+    return false;
+  if (ts2.isBindingElement(parent) && parent.propertyName === node)
+    return false;
+  if (ts2.isImportSpecifier(parent) || ts2.isExportSpecifier(parent))
+    return false;
+  return true;
+};
+var collectExistingNamedImports = (importDecls) => {
+  const map = new Map;
+  for (const decl of importDecls) {
+    const clause = decl.importClause;
+    const bindings = clause?.namedBindings;
+    if (!clause || !bindings || !ts2.isNamedImports(bindings))
+      continue;
+    if (!ts2.isStringLiteral(decl.moduleSpecifier))
+      continue;
+    const specifier = decl.moduleSpecifier.text;
+    if (map.has(specifier))
+      continue;
+    const names = new Map;
+    for (const el of bindings.elements)
+      names.set(el.name.text, clause.isTypeOnly || el.isTypeOnly);
+    map.set(specifier, { decl, names });
+  }
+  return map;
+};
+var formatNamedImport = (specifier, names) => {
+  const entries = [...names.entries()].sort((a, b) => compareNames(a[0], b[0]));
+  if (entries.every(([, isType]) => isType))
+    return `import type { ${entries.map(([name]) => name).join(", ")} } from "${specifier}";`;
+  const parts = entries.map(([name, isType]) => isType ? `type ${name}` : name);
+  return `import { ${parts.join(", ")} } from "${specifier}";`;
+};
+var directivePrologueEnd = (sf) => {
+  let end = -1;
+  for (const stmt of sf.statements) {
+    if (ts2.isExpressionStatement(stmt) && ts2.isStringLiteral(stmt.expression))
+      end = stmt.getEnd();
+    else
+      break;
+  }
+  return end;
+};
+var scriptKindFor = (fileName) => fileName.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS;
+var compareNames = (a, b) => {
+  const [la, lb] = [a.toLowerCase(), b.toLowerCase()];
+  if (la !== lb)
+    return la < lb ? -1 : 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+};
+var formatError = (err) => err instanceof Error ? err.message : String(err);
+var fileExists = async (file) => stat(file).then((s) => s.isFile()).catch(() => false);
+var domainKindOf = (base) => {
+  if (base.endsWith(".constant.ts"))
+    return "constant";
+  if (base.endsWith(".document.ts"))
+    return "document";
+  if (base.endsWith(".signal.ts"))
+    return "signal";
+  return null;
+};
+var buildDomainIndex = async (libDir) => {
+  const index = new Map;
+  for (const file of await collectDomainFiles(libDir)) {
+    const kind = domainKindOf(path7.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 = path7.join(dir, entry.name);
+    if (entry.isDirectory())
+      files.push(...await collectDomainFiles(full));
+    else if (domainKindOf(entry.name) && !TEST_FILE_RE.test(entry.name))
+      files.push(full);
+  }
+  return files;
+};
+var exportedPascalNames = (source, fileName) => {
+  const sf = ts2.createSourceFile(fileName, source, ts2.ScriptTarget.Latest, true);
+  const isExported = (node) => ts2.canHaveModifiers(node) && (ts2.getModifiers(node) ?? []).some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
+  const names = [];
+  for (const stmt of sf.statements) {
+    if ((ts2.isClassDeclaration(stmt) || ts2.isFunctionDeclaration(stmt) || ts2.isEnumDeclaration(stmt)) && stmt.name) {
+      if (isExported(stmt))
+        names.push(stmt.name.text);
+    } else if (ts2.isVariableStatement(stmt) && isExported(stmt)) {
+      for (const decl of stmt.declarationList.declarations)
+        if (ts2.isIdentifier(decl.name))
+          names.push(decl.name.text);
+    } else if (ts2.isExportDeclaration(stmt) && stmt.exportClause && ts2.isNamedExports(stmt.exportClause)) {
+      for (const el of stmt.exportClause.elements)
+        names.push(el.name.text);
+    }
+  }
+  return names.filter((name) => PASCAL_CASE_RE.test(name));
+};
+var relativeSpecifier = (fromDir, toFile) => {
+  const rel = path7.relative(fromDir, toFile).replace(/\.tsx?$/, "").split(path7.sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+};
+
+// pkgs/@akanjs/devkit/frontendBuild/devChangePlanner.ts
+import path8 from "path";
+var SOURCE_EXTS2 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
+var BARREL_FACETS = new Set(["common", "srvkit", "ui", "webkit", "plugin"]);
+var CLIENT_SUFFIXES = [".Template.tsx", ".Unit.tsx", ".Util.tsx", ".View.tsx", ".Zone.tsx", ".store.ts"];
+var SHARED_SUFFIXES = [".constant.ts", ".dictionary.ts", ".signal.ts"];
+var SERVER_SUFFIXES = [".service.ts", ".document.ts"];
+var RUNTIME_METADATA_BASENAMES = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
+
+class DevChangePlanner {
+  #workspaceRoot;
+  constructor({ workspaceRoot }) {
+    this.#workspaceRoot = path8.resolve(workspaceRoot);
+  }
+  plan({ generation, files, kinds, generatedFiles = [] }) {
+    const fileList = uniqueResolved([...files, ...generatedFiles]);
+    const generatedSet = new Set(generatedFiles.map((file) => path8.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(path8.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[path8.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 = path8.resolve(file);
+    const base = path8.basename(abs);
+    const ext = path8.extname(abs).toLowerCase();
+    const isSource = SOURCE_EXTS2.has(ext);
+    const rel = path8.relative(this.#workspaceRoot, abs);
+    const parts = rel.split(path8.sep).filter(Boolean);
+    if (CONFIG_BASENAMES.has(base)) {
+      roles.add("config");
+      reasons.add("config-file");
+    }
+    if (ext === ".css") {
+      roles.add("css");
+      reasons.add("css-file");
+    }
+    if (isGenerated || isSource && this.#isBarrelFacetChild(parts)) {
+      roles.add("barrel");
+      reasons.add(isGenerated ? "generated-index" : "barrel-facet-child");
+    }
+    if (isSource && this.#isServerBiased(abs, parts)) {
+      roles.add("server");
+      reasons.add("server-path");
+    }
+    if (isSource && this.#isClientBiased(abs, parts)) {
+      roles.add("client");
+      reasons.add("client-path");
+    }
+    if (isSource && this.#isSharedBiased(abs, parts)) {
+      roles.add("shared");
+      reasons.add("shared-path");
+    }
+    if (isSource && this.#isRuntimeMetadataFile(parts, base)) {
+      reasons.add("runtime-metadata");
+    }
+    if (roles.has("server") && roles.has("client")) {
+      roles.delete("server");
+      roles.delete("client");
+      roles.add("shared");
+      reasons.add("server-client-overlap");
+    }
+    if (roles.size === 0 && SOURCE_EXTS2.has(ext) && this.#isWorkspaceSource(rel)) {
+      roles.add("shared");
+      reasons.add("workspace-source-fallback");
+    }
+    return roles;
+  }
+  #isServerBiased(abs, parts) {
+    const base = path8.basename(abs);
+    return parts.includes("srvkit") || SERVER_SUFFIXES.some((suffix) => base.endsWith(suffix)) || base === "main.ts" || base === "server.ts";
+  }
+  #isClientBiased(abs, parts) {
+    const base = path8.basename(abs);
+    return parts.includes("ui") || parts.includes("webkit") || parts.includes("page") || CLIENT_SUFFIXES.some((suffix) => base.endsWith(suffix));
+  }
+  #isSharedBiased(abs, parts) {
+    const base = path8.basename(abs);
+    return parts.includes("common") || SHARED_SUFFIXES.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES.has(base);
+  }
+  #isRuntimeMetadataFile(parts, base) {
+    const parent = parts.at(-2);
+    if (parent === "lib" && RUNTIME_METADATA_BASENAMES.has(base))
+      return true;
+    const libIndex = parts.lastIndexOf("lib");
+    if (libIndex < 0 || parts.length <= libIndex + 1)
+      return false;
+    return base.endsWith(".dictionary.ts") || base.endsWith(".signal.ts");
+  }
+  #isBarrelFacetChild(parts) {
+    if (parts.length < 4)
+      return false;
+    const [scope, , facet, child] = parts;
+    if (scope !== "apps" && scope !== "libs")
+      return false;
+    if (!facet || !BARREL_FACETS.has(facet))
+      return false;
+    if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx")
+      return false;
+    return true;
+  }
+  #isWorkspaceSource(rel) {
+    if (!rel || rel.startsWith("..") || path8.isAbsolute(rel))
+      return false;
+    const [scope] = rel.split(path8.sep);
+    return scope === "apps" || scope === "libs" || scope === "pkgs";
+  }
+}
+var uniqueResolved = (files) => [...new Set(files.map((file) => path8.resolve(file)))].sort();
+
+// pkgs/@akanjs/devkit/frontendBuild/devGeneratedIndexSync.ts
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile2, rm, stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import path9 from "path";
+var BARREL_FACETS2 = new Set(["common", "srvkit", "ui", "webkit", "plugin"]);
+var FACET_SOURCE_FILE_RE = /\.(ts|tsx)$/;
+var FACET_EXCLUDED_FILE_RE = /(^index\.tsx?$|\.d\.ts$|\.(test|spec)\.(ts|tsx)$|\.css$|\.scss$|\.sass$)/;
+var FACET_PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9]*$/;
+var FACET_CAMEL_CASE_RE = /^[a-z][A-Za-z0-9]*$/;
+var MODULE_UI_TYPES = ["Template", "Unit", "Util", "View", "Zone"];
+var SERVICE_UI_TYPES = ["Util", "Zone"];
+var SCALAR_UI_TYPES = ["Template", "Unit"];
+
+class DevGeneratedIndexSync {
+  #workspaceRoot;
+  constructor({ workspaceRoot }) {
+    this.#workspaceRoot = path9.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 = path9.resolve(file);
+    const rel = path9.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path9.isAbsolute(rel))
+      return null;
+    const parts = rel.split(path9.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 path9.join(this.#workspaceRoot, scope, project, facet, "index.ts");
+  }
+  async#moduleIndexForDirectoryEvent(file) {
+    const abs = path9.resolve(file);
+    const rel = path9.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path9.isAbsolute(rel))
+      return null;
+    const parts = rel.split(path9.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 = !path9.extname(abs);
+    if (!isExistingDirectory && !looksLikeDeletedDirectory)
+      return null;
+    if (moduleSegment === "__scalar" && scalarSegment) {
+      return path9.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
+    }
+    if (!moduleSegment || moduleSegment === "__scalar")
+      return null;
+    return path9.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
+  }
+  async#syncIndex(indexPath) {
+    const dir = path9.dirname(indexPath);
+    const content = await this.#contentForIndex(indexPath);
+    if (content === null) {
+      if (!await exists(indexPath))
+        return false;
+      await rm(indexPath, { force: true });
+      return true;
+    }
+    const current = await readFile2(indexPath, "utf8").catch(() => null);
+    if (current === content)
+      return false;
+    await mkdir2(dir, { recursive: true });
+    await writeFile2(indexPath, content);
+    return true;
+  }
+  async#contentForIndex(indexPath) {
+    const parts = path9.relative(this.#workspaceRoot, indexPath).split(path9.sep).filter(Boolean);
+    const facet = parts.at(-2);
+    if (facet && BARREL_FACETS2.has(facet))
+      return this.#facetContent(path9.dirname(indexPath));
+    return this.#moduleContent(path9.dirname(indexPath));
+  }
+  async#facetContent(dir) {
+    const nameCasePattern = path9.basename(dir) === "ui" ? FACET_PASCAL_CASE_RE : FACET_CAMEL_CASE_RE;
+    const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
+    const exportNames = entries.flatMap((entry) => {
+      const name = entry.name;
+      if (name.startsWith("."))
+        return [];
+      if (entry.isDirectory())
+        return nameCasePattern.test(name) ? [name] : [];
+      if (!entry.isFile())
+        return [];
+      if (!FACET_SOURCE_FILE_RE.test(name) || FACET_EXCLUDED_FILE_RE.test(name))
+        return [];
+      const exportName = name.replace(FACET_SOURCE_FILE_RE, "");
+      return nameCasePattern.test(exportName) ? [exportName] : [];
+    }).sort();
+    if (exportNames.length === 0)
+      return null;
+    return `${exportNames.map((name) => `export * from "./${name}";`).join(`
+`)}
+`;
+  }
+  async#moduleContent(dir) {
+    const rel = path9.relative(this.#workspaceRoot, dir);
+    const parts = rel.split(path9.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(path9.join(dir, `${modelName}.${type}.tsx`)))
+        fileTypes.push(type);
+    }
+    if (fileTypes.length === 0)
+      return null;
+    return `
+${fileTypes.map((type) => `import * as ${type} from "./${modelName}.${type}";`).join(`
+`)}
+
+export const ${modelName} = { ${fileTypes.join(", ")} };`;
+  }
+}
+var exists = async (file) => stat2(file).then(() => true).catch(() => false);
+var capitalize = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+var formatError2 = (err) => err instanceof Error ? err.message : String(err);
+
+export { BarrelAnalyzer, createBarrelImportsPlugin, createTsconfigPackageResolver, rewriteBarrelImports, GraphClientEntryDiscovery, transformUseClient, ClientEntriesBundler, VENDOR_SPECIFIERS, RouteClientBuilder, AutoImportSync, DevChangePlanner, DevGeneratedIndexSync };