@akanjs/cli 3.0.0-beta.24 → 3.0.0-beta.26

package/index-fgq75haa.js

@@ -1,2084 +0,0 @@
-// @bun
-import {
-  SOURCE_EXTS
-} from "./index-khpfpcsd.js";
-import {
-  FileSys2
-} from "./index-5b6tavv3.js";
-
-// pkgs/@akanjs/devkit/frontendBuild/clientEntryDiscovery.ts
-import path3 from "path";
-
-// pkgs/@akanjs/devkit/transforms/barrelAnalyzer.ts
-import path from "path";
-import { Logger } from "akanjs/common";
-
-// 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(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 ext = CANDIDATE_EXTS.find((candidate) => rel.endsWith(candidate));
-    const parts = (ext ? rel.slice(0, -ext.length) : rel).split(path.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 = 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;
-};
-
-// 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);
-        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 = 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 > 0 && pkgName.slice(lastSlash + 1) === parsed.name)
-        return { pkgName: pkgName.slice(0, lastSlash), 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("/");
-            const parentSpec = lastSlash > 0 ? pkgName.slice(0, lastSlash) : pkgName;
-            return { pkgName: parentSpec, 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?.startsWith("."))
-      return null;
-    const entryFile = await resolveFileCandidate(path2.resolve(pkgDir, rel));
-    if (!entryFile)
-      return null;
-    return { pkgName: specifier, 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;
-    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;
-  #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";
-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/;
-function toClientReferencePath(absPath, workspaceRoot) {
-  return path4.relative(path4.resolve(workspaceRoot), path4.resolve(absPath)).split(path4.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;
-  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 fs from "fs";
-import path5 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()).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 = 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) {
-    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 = 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",
-  "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;
-  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;
-  }
-  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 browserBundle = await this.#buildBrowserBundle(bootstrapEntries);
-    const ssrBundle = await this.#buildSsrBundle(bootstrapEntries);
-    const acceptedEntries = new Set(entries);
-    const routeEntries = new Set(discovered);
-    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;
-      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
-    };
-  }
-  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(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) {
-    return scanUseClientExports(await Bun.file(absEntry).text(), absEntry, this.#app.workspace.workspaceRoot);
-  }
-  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 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 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 } from "fs/promises";
-import path7 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 = 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;
-    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(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 = 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(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 = 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 = 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 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_EXTS.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(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("..") || 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 } from "fs/promises";
-import path9 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 = 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 FileSys2.writeTextAtomic(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 formatError2 = (err) => err instanceof Error ? err.message : String(err);
-
-export { loaderFor, BarrelAnalyzer, createBarrelImportsPlugin, createTsconfigPackageResolver, rewriteBarrelImports, GraphClientEntryDiscovery, transformUseClient, bundleDefine, ClientEntriesBundler, VENDOR_SPECIFIERS, RouteClientBuilder, AutoImportSync, DevChangePlanner, DevGeneratedIndexSync };