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

package/{index-ne50hc2m.js → index-wvebzf0y.js}

@@ -1,95 +1,29 @@
 // @bun
 import {
-  AsyncDefaultExportDetector,
   resolveSsrPageEntriesForApp
-} from "./index-ga6hygxr.js";
+} from "./index-0n9q1f23.js";
 import {
-  SOURCE_EXTS
-} from "./index-khpfpcsd.js";
-import {
-  loaderFor,
+  computeRouteSeedIndex,
+  saveRouteSeedIndex,
   BarrelAnalyzer,
-  createBarrelImportsPlugin,
   createTsconfigPackageResolver,
   rewriteBarrelImports,
   GraphClientEntryDiscovery,
-  transformUseClient,
   bundleDefine,
   ClientEntriesBundler,
   VENDOR_SPECIFIERS,
-  RouteClientBuilder
-} from "./index-fgq75haa.js";
-var __require = import.meta.require;
-
-// pkgs/@akanjs/devkit/artifact/routeSeedIndex.ts
-import path from "path";
-import { assertUniqueRoutePatterns, compareRouteSpecificity, parseRouteModuleKey } from "akanjs/common";
+  RouteClientBuilder,
+  CsrEntryFiles,
+  PagesEntrySourceGenerator,
+  PagesBundleBuilder
+} from "./index-cd9qt2t6.js";
 import {
-  ROUTE_SEED_INDEX_JSON
-} from "akanjs/server/artifact/routeSeedIndexStore";
-function computeRouteSeedIndex(pageEntries) {
-  const layoutsByPrefix = new Map;
-  const pagesBySegments = [];
-  for (const { key, moduleAbsPath, seedAbsPaths } of pageEntries) {
-    const parsed = parseRouteModuleKey(key);
-    const files = [path.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path.resolve(seed))];
-    if (parsed.kind === "layout" || parsed.kind === "overrides") {
-      layoutsByPrefix.getOrInsert(parsed.routeSegments.join("/"), []).push(...files);
-    } else if (parsed.kind === "page") {
-      pagesBySegments.push({
-        key,
-        pattern: parsed.pattern,
-        segments: parsed.routeSegments,
-        files,
-        includeOwnLayout: parsed.leaf === "_index"
-      });
-    }
-  }
-  assertUniqueRoutePatterns(pagesBySegments);
-  const globalLayoutFiles = layoutsByPrefix.get("") ?? [];
-  const seedEntries = [];
-  for (const { pattern, segments, files, includeOwnLayout } of pagesBySegments) {
-    const layouts = [];
-    const maxPrefixLength = includeOwnLayout ? segments.length : Math.max(segments.length - 1, 0);
-    for (let i = 0;i <= maxPrefixLength; i++) {
-      const prefix = segments.slice(0, i).join("/");
-      const layoutFiles = layoutsByPrefix.get(prefix);
-      if (layoutFiles)
-        layouts.push(...layoutFiles);
-    }
-    const seeds = Array.from(new Set([...layouts, ...files]));
-    const routeId = pattern || "/";
-    seedEntries.push({ routeId, pattern: routeId, seeds });
-  }
-  seedEntries.sort((a, b) => compareRouteSpecificity(a.pattern, b.pattern));
-  return { entries: seedEntries, globalLayoutFiles };
-}
-function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
-  const normalizedArtifactDir = path.resolve(artifactDir);
-  if (options.production)
-    return { entries: index.entries.map((entry) => ({ routeId: entry.routeId })) };
-  return {
-    entries: index.entries.map((entry) => ({
-      ...entry,
-      seeds: entry.seeds.map((seed) => serializeArtifactPath(seed, normalizedArtifactDir))
-    })),
-    globalLayoutFiles: index.globalLayoutFiles.map((file) => serializeArtifactPath(file, normalizedArtifactDir))
-  };
-}
-async function saveRouteSeedIndex(artifactDir, index, options = {}) {
-  const absPath = path.join(path.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
-  await Bun.write(absPath, `${JSON.stringify(serializeRouteSeedIndexForArtifact(index, artifactDir, options), null, 2)}
-`);
-  return absPath;
-}
-function serializeArtifactPath(artifactPath, artifactDir) {
-  if (!path.isAbsolute(artifactPath))
-    return artifactPath;
-  return path.relative(artifactDir, artifactPath).split(path.sep).join("/");
-}
+  SOURCE_EXTS
+} from "./index-48k96p55.js";
+var __require = import.meta.require;
 
 // pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
-import path2 from "path";
+import path from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/routesManifestArtifactSerializer.ts
 import { RoutesManifestStore } from "akanjs/server/artifact/routesManifestStore";
@@ -155,7 +89,7 @@ class AllRoutesBuilder {
       routeIds: this.#routeIds,
       ...this.#merged
     };
-    const manifestPath = path2.join(path2.resolve(this.#artifactDir), "routes-manifest.json");
+    const manifestPath = path.join(path.resolve(this.#artifactDir), "routes-manifest.json");
     await Bun.write(manifestPath, `${JSON.stringify(RoutesManifestArtifactSerializer.serialize(manifest, this.#artifactDir, {
       production: this.#command === "build"
     }), null, 2)}
@@ -194,6 +128,222 @@ class AllRoutesBuilder {
   }
 }
 
+// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
+import { mkdir, rm, unlink } from "fs/promises";
+import path2 from "path";
+class CsrArtifactBuilder {
+  #app;
+  #command;
+  #lang;
+  constructor(app, command = "start", lang = "en") {
+    this.#app = app;
+    this.#command = command;
+    this.#lang = lang;
+  }
+  async build() {
+    const pageKeys = await this.#app.getPageKeys();
+    if (pageKeys.length === 0) {
+      this.#app.log(`[cli] no route files under ${this.#app.cwdPath}/page \u2014 skipping CSR build`);
+      return null;
+    }
+    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
+    const akanConfig = await this.#app.getConfig();
+    const cssAssets = await this.#loadCssAssets();
+    const basePaths = [...akanConfig.basePaths];
+    const htmlBasePaths = basePaths.length > 0 ? basePaths : [""];
+    await rm(this.#outputDir, { recursive: true, force: true });
+    await mkdir(this.#generatedDir, { recursive: true });
+    const generatedFiles = Object.fromEntries((await Promise.all(htmlBasePaths.map(async (basePath) => [
+      this.#createHtmlFile(basePath),
+      await this.#createEntryFile(basePath, CsrArtifactBuilder.pageEntriesForBasePath(pageEntries, basePath, basePaths))
+    ]))).flat());
+    const result = await Bun.build({
+      target: "browser",
+      entrypoints: htmlBasePaths.map((basePath) => this.#generatedPath(CsrArtifactBuilder.htmlFilename(basePath))),
+      files: generatedFiles,
+      root: this.#generatedDir,
+      outdir: this.#outputDir,
+      splitting: false,
+      minify: true,
+      env: "AKAN_PUBLIC_*",
+      define: bundleDefine(this.#app, this.#command, "csr"),
+      optimizeImports: akanConfig.optimizeImports,
+      plugins: [PagesBundleBuilder.createCssStubPlugin()]
+    });
+    if (!result.success) {
+      const logs = result.logs.map((log) => log.message).join(`
+`);
+      throw new Error(`[csr-build] failed${logs ? `
+${logs}` : ""}`);
+    }
+    await this.#inlineCsrArtifacts(cssAssets);
+    this.#app.verbose(`[csr-build] output -> ${this.#outputDir}`);
+    return { outputDir: this.#outputDir };
+  }
+  static pageEntriesForBasePath(pageEntries, basePath, basePaths) {
+    return CsrEntryFiles.pageEntriesForBasePath(pageEntries, basePath, basePaths);
+  }
+  static htmlFilename(basePath) {
+    return `${basePath || "index"}.html`;
+  }
+  static entryFilename(basePath) {
+    return CsrEntryFiles.entryFilename(basePath);
+  }
+  static basePathOfHtml(htmlPath) {
+    const name = path2.basename(htmlPath, ".html");
+    return name === "index" ? "" : name;
+  }
+  get #outputDir() {
+    return path2.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
+  }
+  get #generatedDir() {
+    return path2.join(this.#app.cwdPath, ".akan/generated/csr");
+  }
+  get #artifactDir() {
+    return path2.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
+  }
+  #generatedPath(filename) {
+    return path2.join(this.#generatedDir, filename);
+  }
+  async#createEntryFile(basePath, pageEntries) {
+    return [
+      this.#generatedPath(CsrArtifactBuilder.entryFilename(basePath)),
+      `import { bootCsr } from "akanjs/webkit";
+${await PagesEntrySourceGenerator.generateStatic(pageEntries)}
+void bootCsr(pages);
+`
+    ];
+  }
+  #createHtmlFile(basePath) {
+    return [
+      this.#generatedPath(CsrArtifactBuilder.htmlFilename(basePath)),
+      `<!doctype html>
+<html lang="${this.#lang}">
+  <head>
+    <meta charset="utf-8" />
+    <title>${this.#app.name}</title>
+    <base href="/" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./${CsrArtifactBuilder.entryFilename(basePath)}"></script>
+  </body>
+</html>
+  `
+    ];
+  }
+  async#loadCssAssets() {
+    const artifactFile = Bun.file(path2.join(this.#artifactDir, "base-artifact.json"));
+    if (!await artifactFile.exists())
+      return {};
+    const artifact = await artifactFile.json();
+    return artifact.cssAssets ?? {};
+  }
+  async#inlineCsrArtifacts(cssAssets) {
+    const jsFiles = new Set;
+    for (const htmlPath of await this.#listOutputFiles((filePath) => filePath.endsWith(".html"))) {
+      const htmlFile = Bun.file(htmlPath);
+      if (!await htmlFile.exists())
+        continue;
+      const basePath = CsrArtifactBuilder.basePathOfHtml(htmlPath);
+      const cssAsset = cssAssets[basePath];
+      if (!cssAsset) {
+        this.#app.logger.warn(`[csr-build] base-artifact.json has no compiled stylesheet for ${basePath || "root"}; ${path2.basename(htmlPath)} ships without CSS`);
+      }
+      const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAsset);
+      for (const filePath of inlined.jsFiles)
+        jsFiles.add(filePath);
+      await Bun.write(htmlPath, inlined.html);
+    }
+    for (const filePath of jsFiles)
+      await unlink(filePath).catch(() => {
+        return;
+      });
+    const remainingAssets = await this.#listOutputFiles((filePath) => filePath.endsWith(".js") || filePath.endsWith(".css"));
+    if (remainingAssets.length > 0) {
+      throw new Error(`[csr-build] expected single-file HTML, but CSR assets remain:
+${remainingAssets.join(`
+`)}`);
+    }
+  }
+  async#inlineHtmlAssets(html, htmlPath, cssAsset) {
+    let next = html;
+    if (cssAsset) {
+      const css = await Bun.file(path2.join(this.#artifactDir, cssAsset.cssRelPath)).text();
+      next = CsrArtifactBuilder.injectBeforeHeadEnd(next, CsrArtifactBuilder.createInlineStyle(css));
+    }
+    const jsFiles = [];
+    next = await CsrArtifactBuilder.replaceModuleScriptSrc(next, async (src) => {
+      const jsPath = CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, src);
+      jsFiles.push(jsPath);
+      return await Bun.file(jsPath).text();
+    });
+    return { html: next, jsFiles };
+  }
+  async#listOutputFiles(predicate) {
+    const glob = new Bun.Glob("**/*");
+    const files = [];
+    for await (const filePath of glob.scan({ cwd: this.#outputDir, absolute: true })) {
+      if (predicate(filePath))
+        files.push(filePath);
+    }
+    return files.sort();
+  }
+  static injectBeforeHeadEnd(html, snippet) {
+    const scannable = CsrArtifactBuilder.blankEmbeddedContent(html);
+    const headEnd = scannable.search(/<\/head\s*>/i);
+    if (headEnd !== -1)
+      return `${html.slice(0, headEnd)}${snippet}
+${html.slice(headEnd)}`;
+    const bodyStart = scannable.search(/<body(?:\s|>)/i);
+    if (bodyStart !== -1)
+      return `${html.slice(0, bodyStart)}${snippet}
+${html.slice(bodyStart)}`;
+    return `${html}
+${snippet}`;
+  }
+  static blankEmbeddedContent(html) {
+    return html.replace(/<script\b[^>]*>[\s\S]*?<\/script\s*>|<style\b[^>]*>[\s\S]*?<\/style\s*>|<!--[\s\S]*?-->/gi, (match) => " ".repeat(match.length));
+  }
+  static createInlineStyle(css) {
+    return `<style data-akan-css="active">
+${css.replace(/<\/style/gi, "<\\/style")}
+</style>`;
+  }
+  static async replaceModuleScriptSrc(html, loadScript) {
+    const scriptRe = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>\s*<\/script>/gi;
+    let result = "";
+    let lastIndex = 0;
+    let matched = false;
+    for (const match of html.matchAll(scriptRe)) {
+      const full = match[0];
+      const src = match[1];
+      if (match.index === undefined || !src)
+        continue;
+      matched = true;
+      result += html.slice(lastIndex, match.index);
+      result += `<script type="module">
+${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
+</script>`;
+      lastIndex = match.index + full.length;
+    }
+    if (!matched)
+      return html;
+    return result + html.slice(lastIndex);
+  }
+  static escapeInlineScript(source) {
+    return source.replace(/<\/script/gi, "<\\/script");
+  }
+  static resolveHtmlAssetPath(htmlPath, src) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(src) || src.startsWith("//")) {
+      throw new Error(`[csr-build] cannot inline external script: ${src}`);
+    }
+    const normalized = src.startsWith("/") ? src.slice(1) : src;
+    return path2.resolve(path2.dirname(htmlPath), normalized);
+  }
+}
+
 // pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
 import path4 from "path";
 import { Logger } from "akanjs/common";
@@ -526,1524 +676,207 @@ class CssCompiler {
       }
       let source = content;
       if (akanConfig.barrelImports.length > 0) {
-        try {
-          const rewritten = await rewriteBarrelImports(content, akanConfig.barrelImports, analyzer);
-          if (rewritten !== null)
-            source = rewritten;
-        } catch {}
-      }
-      let imports;
-      try {
-        imports = this.#transpiler.scanImports(source);
-      } catch {
-        continue;
-      }
-      const importerDir = path4.dirname(filePath);
-      for (const imp of imports) {
-        const spec = imp.path;
-        if (!spec)
-          continue;
-        if (spec.endsWith(".css")) {
-          const cssPath = await this.#resolveCssImport(spec, importerDir);
-          cssFiles.add(cssPath);
-          continue;
-        }
-        if (NON_SOURCE_EXT_RE.test(spec))
-          continue;
-        const resolved = await this.#resolveSourceImport(spec, importerDir, resolvePackage);
-        if (!resolved || sourceFiles.has(resolved) || isIgnoredNodeModuleSource(resolved))
-          continue;
-        queue.push(resolved);
-      }
-    }
-    const tokenPaths = await this.#libTokenStylesheets(sourceFiles);
-    const cssPaths = [...new Set([...tokenPaths, ...cssFiles])];
-    for (const cssPath of cssPaths)
-      this.#discoveredCssPaths.add(cssPath);
-    return { cssPaths, sourcePaths: [...sourceFiles] };
-  }
-  async#libTokenStylesheets(sourceFiles) {
-    const libsRoot = path4.join(this.#app.workspace.workspaceRoot, "libs");
-    const libNames = new Set;
-    for (const filePath of sourceFiles) {
-      const relPath = path4.relative(libsRoot, filePath);
-      if (relPath.startsWith("..") || path4.isAbsolute(relPath))
-        continue;
-      const [libName] = relPath.split(path4.sep);
-      if (libName)
-        libNames.add(libName);
-    }
-    const tokenPaths = await Promise.all([...libNames].sort().map(async (libName) => {
-      const tokensPath = path4.join(libsRoot, libName, "ui/tokens.css");
-      return await this.#fileExists(tokensPath) ? tokensPath : null;
-    }));
-    return tokenPaths.filter((tokensPath) => !!tokensPath);
-  }
-  async compileCss(cssPaths, sourcePaths) {
-    const { css } = await this.#compileWithImports(cssPaths, sourcePaths);
-    return css;
-  }
-  async#compileWithImports(cssPaths, sourcePaths) {
-    if (cssPaths.length === 0)
-      return { css: "", imported: [] };
-    const compileStarted = Date.now();
-    const compilers = await Promise.all(cssPaths.map(async (cssPath) => {
-      const css = await Bun.file(cssPath).text();
-      const base = path4.dirname(cssPath);
-      const imported = new Map;
-      const compiler = await compile(css, {
-        base,
-        loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase, imported),
-        loadModule: (id, fromBase) => this.#loadModule(id, fromBase)
-      });
-      return { cssPath, compiler, imported };
-    }));
-    const sourceDirs = new Set;
-    for (const entry of compilers) {
-      for (const s of entry.compiler.sources)
-        sourceDirs.add(s.base);
-    }
-    const scanStarted = Date.now();
-    const candidates = await this.#scanCandidates(sourcePaths, [...sourceDirs]);
-    this.#logger.verbose(`css candidates scanned count=${candidates.length} sources=${sourcePaths.length} dirs=${sourceDirs.size} in ${Date.now() - scanStarted}ms`);
-    const parts = [];
-    const imported = [];
-    for (const entry of compilers) {
-      const part = entry.compiler.build(candidates);
-      parts.push(part);
-      for (const [cssPath, content] of entry.imported) {
-        const declaredNames = declaredCustomProperties(content);
-        imported.push({ cssPath, declaredNames });
-        if (declaredNames.length === 0 || declaredNames.some((name) => part.includes(`${name}:`)))
-          continue;
-        this.#logger.warn(`css @import ${cssPath} was loaded by ${entry.cssPath} but none of its ${declaredNames.length} declaration(s) reached the compiled CSS`);
-      }
-    }
-    this.#logger.verbose(`css compiled paths=${cssPaths.length} candidates=${candidates.length} in ${Date.now() - compileStarted}ms`);
-    return { css: parts.join(`
-`), imported };
-  }
-  async#loadStylesheet(id, fromBase, imported) {
-    const p = await this.#resolveCssImport(id, fromBase);
-    this.#discoveredCssPaths.add(p);
-    const content = await Bun.file(p).text();
-    imported?.set(p, content);
-    this.#logger.verbose(`css import "${id}" from ${fromBase} -> ${p} (${content.length} bytes)`);
-    return { path: p, base: path4.dirname(p), content };
-  }
-  async#resolveCssImport(id, fromBase) {
-    if (id.startsWith(".") || id.startsWith("/")) {
-      const filePath = path4.resolve(fromBase, id);
-      if (await this.#fileExists(filePath))
-        return filePath;
-      throw new Error(`[css] failed to resolve stylesheet import "${id}" from ${fromBase} (no file at ${filePath})`);
-    }
-    this.#cssImportResolver ??= await CssImportResolver.create(this.#app);
-    const resolved = await this.#cssImportResolver.resolve(id, fromBase);
-    if (resolved)
-      return resolved;
-    throw new Error(`[css] failed to resolve stylesheet import "${id}" from ${fromBase}`);
-  }
-  async#loadModule(id, fromBase) {
-    const p = __require.resolve(id, { paths: [fromBase] });
-    const mod = await import(p);
-    return { path: p, base: path4.dirname(p), module: mod.default ?? mod };
-  }
-  #resolveSourceImport(id, fromBase, resolvePackage) {
-    const cacheKey = `${fromBase}\x00${id}`;
-    let cached = this.#resolvedSpecifierCache.get(cacheKey);
-    if (cached)
-      return cached;
-    cached = this.#resolveSourceImportUncached(id, fromBase, resolvePackage);
-    this.#resolvedSpecifierCache.set(cacheKey, cached);
-    return cached;
-  }
-  async#resolveSourceImportUncached(id, fromBase, resolvePackage) {
-    if (id.startsWith(".") || id.startsWith("/")) {
-      const abs = id.startsWith("/") ? id : path4.resolve(fromBase, id);
-      return this.#resolveSourceFileCandidate(abs);
-    }
-    const pkg = await resolvePackage(id);
-    if (pkg)
-      return pkg.entryFile;
-    for (const resolve of [() => resolveSourceWithBun(id, fromBase), () => resolveSourceWithRequire(id, fromBase)]) {
-      const resolved = await resolve();
-      if (resolved)
-        return resolved;
-    }
-    return null;
-  }
-  async#scanCandidates(sourcePaths, dirs) {
-    const candidates = new Set;
-    const glob = new Bun.Glob("**/*.{tsx,ts,jsx,js,html}");
-    const files = new Set(sourcePaths);
-    await Promise.all(dirs.map(async (dir) => {
-      for await (const file of glob.scan({ cwd: dir, absolute: true })) {
-        if (isIgnoredNodeModuleSource(file))
-          continue;
-        files.add(file);
-      }
-    }));
-    const cache = await new CssCandidateCache(this.#candidateCachePath).load();
-    await Promise.all([...files].map(async (file) => {
-      for (const candidate of await cache.candidatesFor(file))
-        candidates.add(candidate);
-    }));
-    await cache.save(files);
-    this.#logger.verbose(`css candidate cache reused=${cache.reused} rescanned=${cache.rescanned}`);
-    return [...candidates];
-  }
-}
-function resolveSourceWithBun(id, fromBase) {
-  try {
-    const resolved = Bun.resolveSync(id, fromBase);
-    return isSourceFile(resolved) ? resolved : null;
-  } catch {
-    return null;
-  }
-}
-function resolveSourceWithRequire(id, fromBase) {
-  try {
-    const resolved = __require.resolve(id, { paths: [fromBase] });
-    return isSourceFile(resolved) ? resolved : null;
-  } catch {
-    return null;
-  }
-}
-function isSourceFile(filePath) {
-  return SOURCE_EXTS.has(path4.extname(filePath));
-}
-function isIgnoredNodeModuleSource(filePath) {
-  return NODE_MODULES_RE.test(filePath) && !AKANJS_NODE_MODULE_RE.test(filePath);
-}
-function declaredCustomProperties(css) {
-  const withoutThemeBlocks = css.replace(/@theme[^{]*\{[^}]*\}/g, "");
-  return [...new Set([...withoutThemeBlocks.matchAll(/(?:^|[\s;{])(--[\w-]+)\s*:/g)].map(([, name]) => name))].filter((name) => !!name);
-}
-function getPageKeyBasePath(pageKey, basePaths) {
-  const normalized = pageKey.split(path4.sep).join("/").replace(/^\.\//, "");
-  const segments = normalized.split("/");
-  const firstPublicSegment = segments.find((segment) => segment !== "[lang]" && !/^\(.+\)$/.test(segment));
-  return firstPublicSegment && basePaths.includes(firstPublicSegment) ? firstPublicSegment : null;
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-import path7 from "path";
-
-// pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
-import path5 from "path";
-var DEFAULT_INCLUDE = ["akanjs/", "@apps/", "@libs/"];
-var DEFAULT_EXCLUDE_EXACT = new Set(["akanjs/webkit", "@akanjs/cli", "@akanjs/devkit"]);
-var DEFAULT_EXCLUDE_PREFIX = ["@akanjs/cli/", "@akanjs/devkit/"];
-var OPTIONAL_BACKEND_EXTERNAL_EXACT = new Set([
-  "@libsql/client",
-  "bullmq",
-  "ioredis",
-  "postgres",
-  "protobufjs"
-]);
-var RUNTIME_EXTERNAL_EXACT = new Set([
-  "react",
-  "react-dom",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime",
-  "react-server-dom-webpack",
-  "react-server-dom-webpack/server.node",
-  "react-server-dom-webpack/client.node",
-  "react-server-dom-webpack/client.browser"
-]);
-var RUNTIME_EXTERNAL_PREFIX = ["react-dom/", "react-server-dom-webpack/"];
-var CANDIDATE_EXTS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
-async function createExternalizeFrameworkPlugin(options) {
-  const tsconfig = await options.app.getTsConfig();
-  const includePrefixes = options.include ?? DEFAULT_INCLUDE;
-  const extraExact = new Set(options.extra ?? []);
-  const workspaceRoot = options.app.workspace.workspaceRoot;
-  const tsconfigPaths = tsconfig.compilerOptions.paths ?? {};
-  const rootEntries = Object.entries(tsconfigPaths).filter(([k]) => !k.endsWith("/*")).map(([k, v]) => ({ pkg: k, entryFile: v[0] ?? null })).filter((e) => e.entryFile !== null);
-  const wildcardEntries = Object.entries(tsconfigPaths).filter(([k]) => k.endsWith("/*")).map(([k, v]) => ({ prefix: k.slice(0, -1), replacements: v })).sort((a, b) => b.prefix.length - a.prefix.length);
-  async function resolveWorkspaceSubpath(spec) {
-    if (!workspaceRoot)
-      return null;
-    for (const { prefix, replacements } of wildcardEntries) {
-      if (!spec.startsWith(prefix))
-        continue;
-      const suffix = spec.slice(prefix.length);
-      for (const repl of replacements) {
-        const replPath = repl?.endsWith("/*") ? repl.slice(0, -1) : repl ?? "";
-        if (!replPath)
-          continue;
-        const candidate = path5.resolve(workspaceRoot, replPath + suffix);
-        const hit = await firstExisting(candidate);
-        if (hit)
-          return hit;
-      }
-    }
-    for (const { pkg, entryFile } of rootEntries) {
-      if (!spec.startsWith(`${pkg}/`))
-        continue;
-      const suffix = spec.slice(pkg.length + 1);
-      const pkgDir = path5.dirname(path5.resolve(workspaceRoot, entryFile));
-      const candidate = path5.join(pkgDir, suffix);
-      const hit = await firstExisting(candidate);
-      if (hit)
-        return hit;
-    }
-    return null;
-  }
-  return {
-    name: "akan-externalize-framework",
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, async (args) => {
-        const spec = args.path;
-        if (spec === "." || spec === ".." || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/"))
-          return;
-        if (extraExact.has(spec) || DEFAULT_EXCLUDE_EXACT.has(spec))
-          return { path: spec, external: true };
-        for (const prefix of DEFAULT_EXCLUDE_PREFIX) {
-          if (spec.startsWith(prefix))
-            return { path: spec, external: true };
-        }
-        if (OPTIONAL_BACKEND_EXTERNAL_EXACT.has(spec))
-          return { path: spec, external: true };
-        if (RUNTIME_EXTERNAL_EXACT.has(spec))
-          return { path: spec, external: true };
-        for (const prefix of RUNTIME_EXTERNAL_PREFIX) {
-          if (spec.startsWith(prefix))
-            return { path: spec, external: true };
-        }
-        if (!includePrefixes.some((prefix) => spec.startsWith(prefix)))
-          return;
-        const resolved = await resolveWorkspaceSubpath(spec);
-        return resolved ? { path: resolved } : undefined;
-      });
-    }
-  };
-}
-async function firstExisting(basePath) {
-  if (await Bun.file(basePath).exists())
-    return basePath;
-  for (const ext of CANDIDATE_EXTS) {
-    const candidate = `${basePath}${ext}`;
-    if (await Bun.file(candidate).exists())
-      return candidate;
-  }
-  for (const ext of CANDIDATE_EXTS) {
-    const candidate = path5.join(basePath, `index${ext}`);
-    if (await Bun.file(candidate).exists())
-      return candidate;
-  }
-  return null;
-}
-
-// pkgs/@akanjs/devkit/transforms/useClientBundlePlugin.ts
-function createUseClientBundlePlugin(options = {}) {
-  return {
-    name: "akan-use-client-bundle",
-    setup(build) {
-      build.onLoad({ filter: /\.(tsx|ts|jsx|js)$/ }, async (args) => {
-        if (args.path.includes("/node_modules/"))
-          return;
-        let source;
-        try {
-          source = await Bun.file(args.path).text();
-        } catch {
-          return;
-        }
-        const stubbed = transformUseClient(source, {
-          path: args.path,
-          workspaceRoot: options.workspaceRoot
-        });
-        if (stubbed === null)
-          return;
-        return { contents: stubbed, loader: loaderFor(args.path) };
-      });
-    }
-  };
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
-import path6 from "path";
-class PagesEntrySourceGenerator {
-  #pageEntries;
-  #asyncDefaults = new Map;
-  constructor(pageEntries) {
-    this.#pageEntries = pageEntries;
-  }
-  static generate(pageEntries) {
-    return new PagesEntrySourceGenerator(pageEntries).generate();
-  }
-  generate() {
-    const lines = this.#pageEntries.map(({ key, moduleAbsPath }) => {
-      const specifier = PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
-      return `  ${JSON.stringify(key)}: () => import(${JSON.stringify(specifier)}),`;
-    });
-    return `export const pages = {
-${lines.join(`
-`)}
-};
-`;
-  }
-  static async generateStatic(pageEntries, { fromDir } = {}) {
-    return await new PagesEntrySourceGenerator(pageEntries).generateStatic({ fromDir });
-  }
-  async generateStatic({ fromDir } = {}) {
-    const imports = this.#pageEntries.map(({ moduleAbsPath }, index) => {
-      const specifier = fromDir ? PagesEntrySourceGenerator.#toRelativeSpecifier(fromDir, moduleAbsPath) : PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
-      return `import * as page${index} from ${JSON.stringify(specifier)};`;
-    });
-    const entries = await Promise.all(this.#pageEntries.map(async ({ key, moduleAbsPath }, index) => {
-      const isAsyncDefault = await this.#isAsyncDefault(moduleAbsPath);
-      return `  ${JSON.stringify(key)}: { loader: async () => page${index}, isAsyncDefault: ${isAsyncDefault} },`;
-    }));
-    return `${imports.join(`
-`)}
-export const pages = {
-${entries.join(`
-`)}
-};
-`;
-  }
-  async generateHotReplace({
-    fromDir,
-    ownerId,
-    moduleIds
-  }) {
-    const entries = await Promise.all(this.#pageEntries.map(async ({ key, moduleAbsPath }) => {
-      const specifier = PagesEntrySourceGenerator.#toRelativeSpecifier(fromDir, moduleAbsPath);
-      const isAsyncDefault = await this.#isAsyncDefault(moduleAbsPath);
-      return `    ${JSON.stringify(key)}: { loader: async () => require(${JSON.stringify(specifier)}), isAsyncDefault: ${isAsyncDefault} },`;
-    }));
-    return `__akan.accept(${JSON.stringify(ownerId)}, ${JSON.stringify(moduleIds)}, async () => {
-  const replaced = await akanWebkit.replacePages({
-${entries.join(`
-`)}
-  });
-  if (!replaced) throw new Error("the route table no longer matches the pages it was built from");
-});
-`;
-  }
-  #isAsyncDefault(moduleAbsPath) {
-    const known = this.#asyncDefaults.get(moduleAbsPath);
-    if (known)
-      return known;
-    const detected = AsyncDefaultExportDetector.detect(moduleAbsPath);
-    this.#asyncDefaults.set(moduleAbsPath, detected);
-    return detected;
-  }
-  static #toImportSpecifier(moduleAbsPath) {
-    return path6.resolve(moduleAbsPath).split(path6.sep).join("/");
-  }
-  static #toRelativeSpecifier(fromDir, moduleAbsPath) {
-    const relative = path6.relative(fromDir, path6.resolve(moduleAbsPath)).split(path6.sep).join("/");
-    return relative.startsWith(".") ? relative : `./${relative}`;
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-var VIRTUAL_PAGES_ENTRY = "akan-pages-entry";
-
-class PagesBundleBuilder {
-  #app;
-  #command;
-  #pageEntries;
-  #started = Date.now();
-  constructor(app, command = "start", pageEntries) {
-    this.#app = app;
-    this.#command = command;
-    this.#pageEntries = pageEntries;
-  }
-  async build() {
-    const akanConfig = await this.#app.getConfig();
-    const resolvedEntries = this.#pageEntries ?? await resolveSsrPageEntriesForApp(this.#app, await this.#app.getPageKeys());
-    const entrySource = PagesEntrySourceGenerator.generate(resolvedEntries);
-    const workspaceRoot = this.#app.workspace.workspaceRoot;
-    const result = await Bun.build({
-      entrypoints: [VIRTUAL_PAGES_ENTRY],
-      outdir: `${this.#artifactDir}/server`,
-      target: "bun",
-      format: "esm",
-      splitting: this.#splitting,
-      minify: this.#command === "build",
-      naming: {
-        entry: "pages-[hash].[ext]",
-        chunk: "chunks/[name]-[hash].[ext]",
-        asset: "assets/[name]-[hash].[ext]"
-      },
-      define: bundleDefine(this.#app, this.#command, "ssr"),
-      plugins: [
-        PagesBundleBuilder.createPagesEntryPlugin(entrySource),
-        PagesBundleBuilder.createCssStubPlugin(),
-        PagesBundleBuilder.createServerUseClientFetchPlugin(),
-        await createExternalizeFrameworkPlugin({ app: this.#app, extra: akanConfig.externalLibs }),
-        akanConfig.barrelImports.length > 0 ? await createBarrelImportsPlugin(this.#app, {
-          pipeAfter: (source, args) => transformUseClient(source, {
-            path: args.path,
-            workspaceRoot
-          })
-        }) : createUseClientBundlePlugin({ workspaceRoot })
-      ]
-    });
-    if (!result.success)
-      throw new AggregateError(result.logs, "[PagesBundleBuilder] Bun.build failed");
-    const entryArtifact = result.outputs.find((a) => a.kind === "entry-point");
-    if (!entryArtifact)
-      throw new Error("[PagesBundleBuilder] Bun.build emitted no entry-point artifact");
-    const bundlePath = path7.resolve(entryArtifact.path);
-    const buildId = Date.now();
-    const outputBytes = result.outputs.reduce((sum, output) => sum + output.size, 0);
-    const chunkCount = result.outputs.filter((output) => output.kind === "chunk").length;
-    this.#app.verbose(`[PagesBundleBuilder] ${path7.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
-    return {
-      bundlePath,
-      buildId,
-      splitting: this.#splitting,
-      entryBytes: entryArtifact.size,
-      outputBytes,
-      outputCount: result.outputs.length,
-      chunkCount
-    };
-  }
-  get #artifactDir() {
-    return `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
-  }
-  get #splitting() {
-    return process.env.AKAN_SERVER_PAGES_SPLITTING === "1";
-  }
-  static createPagesEntryPlugin(source) {
-    return {
-      name: "akan-pages-entry",
-      setup(build) {
-        build.onResolve({ filter: /^akan-pages-entry$/ }, () => ({
-          path: VIRTUAL_PAGES_ENTRY,
-          namespace: "akan-virtual"
-        }));
-        build.onLoad({ filter: /^akan-pages-entry$/, namespace: "akan-virtual" }, () => ({
-          contents: source,
-          loader: "tsx"
-        }));
-      }
-    };
-  }
-  static createCssStubPlugin() {
-    return {
-      name: "akan-css-stub",
-      setup(build) {
-        build.onLoad({ filter: /\.css$/ }, () => ({
-          contents: "",
-          loader: "js"
-        }));
-      }
-    };
-  }
-  static createServerUseClientFetchPlugin() {
-    return {
-      name: "akan-server-use-client-fetch",
-      setup(build) {
-        build.onLoad({ filter: /[/\\]lib[/\\]useClient\.(ts|tsx|js|jsx)$/ }, async (args) => {
-          const source = await Bun.file(args.path).text();
-          const transformed = PagesBundleBuilder.transformServerUseClientFetchSource(source);
-          if (transformed === source)
-            return;
-          return { contents: transformed, loader: loaderFor(args.path) };
-        });
-      }
-    };
-  }
-  static transformServerUseClientFetchSource(source) {
-    if (!source.includes(`with { type: "macro" }`) || !source.includes("FetchClient.build"))
-      return source;
-    return source.replace(/import\s+\{\s*getSerializedSignal\s*\}\s+from\s+["']\.\/sig["']\s+with\s+\{\s*type\s*:\s*["']macro["']\s*\};/, `import { fetch as serverFetch } from "./sig";`).replace(/const\s+fetchProto\s*=\s*FetchClient\.build<[^;]+;/, "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });");
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
-import { mkdir, rm, unlink } from "fs/promises";
-import path8 from "path";
-class CsrArtifactBuilder {
-  #app;
-  #command;
-  #lang;
-  constructor(app, command = "start", lang = "en") {
-    this.#app = app;
-    this.#command = command;
-    this.#lang = lang;
-  }
-  async build() {
-    const pageKeys = await this.#app.getPageKeys();
-    if (pageKeys.length === 0) {
-      this.#app.log(`[cli] no route files under ${this.#app.cwdPath}/page \u2014 skipping CSR build`);
-      return null;
-    }
-    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
-    const akanConfig = await this.#app.getConfig();
-    const cssAssets = await this.#loadCssAssets();
-    const basePaths = [...akanConfig.basePaths];
-    const htmlBasePaths = basePaths.length > 0 ? basePaths : [""];
-    await rm(this.#outputDir, { recursive: true, force: true });
-    await mkdir(this.#generatedDir, { recursive: true });
-    const generatedFiles = Object.fromEntries((await Promise.all(htmlBasePaths.map(async (basePath) => [
-      this.#createHtmlFile(basePath),
-      await this.#createEntryFile(basePath, CsrArtifactBuilder.pageEntriesForBasePath(pageEntries, basePath, basePaths))
-    ]))).flat());
-    const result = await Bun.build({
-      target: "browser",
-      entrypoints: htmlBasePaths.map((basePath) => this.#generatedPath(CsrArtifactBuilder.htmlFilename(basePath))),
-      files: generatedFiles,
-      root: this.#generatedDir,
-      outdir: this.#outputDir,
-      splitting: false,
-      minify: true,
-      env: "AKAN_PUBLIC_*",
-      define: bundleDefine(this.#app, this.#command, "csr"),
-      optimizeImports: akanConfig.optimizeImports,
-      plugins: [PagesBundleBuilder.createCssStubPlugin()]
-    });
-    if (!result.success) {
-      const logs = result.logs.map((log) => log.message).join(`
-`);
-      throw new Error(`[csr-build] failed${logs ? `
-${logs}` : ""}`);
-    }
-    await this.#inlineCsrArtifacts(cssAssets);
-    this.#app.verbose(`[csr-build] output -> ${this.#outputDir}`);
-    return { outputDir: this.#outputDir };
-  }
-  static pageEntriesForBasePath(pageEntries, basePath, basePaths) {
-    return pageEntries.filter((entry) => {
-      const entryBasePath = getPageKeyBasePath(entry.key, basePaths);
-      return entryBasePath === null || entryBasePath === basePath;
-    });
-  }
-  static htmlFilename(basePath) {
-    return `${basePath || "index"}.html`;
-  }
-  static entryFilename(basePath) {
-    return `${basePath || "index"}.csr.tsx`;
-  }
-  static basePathOfHtml(htmlPath) {
-    const name = path8.basename(htmlPath, ".html");
-    return name === "index" ? "" : name;
-  }
-  get #outputDir() {
-    return path8.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
-  }
-  get #generatedDir() {
-    return path8.join(this.#app.cwdPath, ".akan/generated/csr");
-  }
-  get #artifactDir() {
-    return path8.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
-  }
-  #generatedPath(filename) {
-    return path8.join(this.#generatedDir, filename);
-  }
-  async#createEntryFile(basePath, pageEntries) {
-    return [
-      this.#generatedPath(CsrArtifactBuilder.entryFilename(basePath)),
-      `import { bootCsr } from "akanjs/webkit";
-${await PagesEntrySourceGenerator.generateStatic(pageEntries)}
-void bootCsr(pages);
-`
-    ];
-  }
-  #createHtmlFile(basePath) {
-    return [
-      this.#generatedPath(CsrArtifactBuilder.htmlFilename(basePath)),
-      `<!doctype html>
-<html lang="${this.#lang}">
-  <head>
-    <meta charset="utf-8" />
-    <title>${this.#app.name}</title>
-    <base href="/" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="./${CsrArtifactBuilder.entryFilename(basePath)}"></script>
-  </body>
-</html>
-  `
-    ];
-  }
-  async#loadCssAssets() {
-    const artifactFile = Bun.file(path8.join(this.#artifactDir, "base-artifact.json"));
-    if (!await artifactFile.exists())
-      return {};
-    const artifact = await artifactFile.json();
-    return artifact.cssAssets ?? {};
-  }
-  async#inlineCsrArtifacts(cssAssets) {
-    const jsFiles = new Set;
-    for (const htmlPath of await this.#listOutputFiles((filePath) => filePath.endsWith(".html"))) {
-      const htmlFile = Bun.file(htmlPath);
-      if (!await htmlFile.exists())
-        continue;
-      const basePath = CsrArtifactBuilder.basePathOfHtml(htmlPath);
-      const cssAsset = cssAssets[basePath];
-      if (!cssAsset) {
-        this.#app.logger.warn(`[csr-build] base-artifact.json has no compiled stylesheet for ${basePath || "root"}; ${path8.basename(htmlPath)} ships without CSS`);
-      }
-      const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAsset);
-      for (const filePath of inlined.jsFiles)
-        jsFiles.add(filePath);
-      await Bun.write(htmlPath, inlined.html);
-    }
-    for (const filePath of jsFiles)
-      await unlink(filePath).catch(() => {
-        return;
-      });
-    const remainingAssets = await this.#listOutputFiles((filePath) => filePath.endsWith(".js") || filePath.endsWith(".css"));
-    if (remainingAssets.length > 0) {
-      throw new Error(`[csr-build] expected single-file HTML, but CSR assets remain:
-${remainingAssets.join(`
-`)}`);
-    }
-  }
-  async#inlineHtmlAssets(html, htmlPath, cssAsset) {
-    let next = html;
-    if (cssAsset) {
-      const css = await Bun.file(path8.join(this.#artifactDir, cssAsset.cssRelPath)).text();
-      next = CsrArtifactBuilder.injectBeforeHeadEnd(next, CsrArtifactBuilder.createInlineStyle(css));
-    }
-    const jsFiles = [];
-    next = await CsrArtifactBuilder.replaceModuleScriptSrc(next, async (src) => {
-      const jsPath = CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, src);
-      jsFiles.push(jsPath);
-      return await Bun.file(jsPath).text();
-    });
-    return { html: next, jsFiles };
-  }
-  async#listOutputFiles(predicate) {
-    const glob = new Bun.Glob("**/*");
-    const files = [];
-    for await (const filePath of glob.scan({ cwd: this.#outputDir, absolute: true })) {
-      if (predicate(filePath))
-        files.push(filePath);
-    }
-    return files.sort();
-  }
-  static injectBeforeHeadEnd(html, snippet) {
-    const scannable = CsrArtifactBuilder.blankEmbeddedContent(html);
-    const headEnd = scannable.search(/<\/head\s*>/i);
-    if (headEnd !== -1)
-      return `${html.slice(0, headEnd)}${snippet}
-${html.slice(headEnd)}`;
-    const bodyStart = scannable.search(/<body(?:\s|>)/i);
-    if (bodyStart !== -1)
-      return `${html.slice(0, bodyStart)}${snippet}
-${html.slice(bodyStart)}`;
-    return `${html}
-${snippet}`;
-  }
-  static blankEmbeddedContent(html) {
-    return html.replace(/<script\b[^>]*>[\s\S]*?<\/script\s*>|<style\b[^>]*>[\s\S]*?<\/style\s*>|<!--[\s\S]*?-->/gi, (match) => " ".repeat(match.length));
-  }
-  static createInlineStyle(css) {
-    return `<style data-akan-css="active">
-${css.replace(/<\/style/gi, "<\\/style")}
-</style>`;
-  }
-  static async replaceModuleScriptSrc(html, loadScript) {
-    const scriptRe = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>\s*<\/script>/gi;
-    let result = "";
-    let lastIndex = 0;
-    let matched = false;
-    for (const match of html.matchAll(scriptRe)) {
-      const full = match[0];
-      const src = match[1];
-      if (match.index === undefined || !src)
-        continue;
-      matched = true;
-      result += html.slice(lastIndex, match.index);
-      result += `<script type="module">
-${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
-</script>`;
-      lastIndex = match.index + full.length;
-    }
-    if (!matched)
-      return html;
-    return result + html.slice(lastIndex);
-  }
-  static escapeInlineScript(source) {
-    return source.replace(/<\/script/gi, "<\\/script");
-  }
-  static resolveHtmlAssetPath(htmlPath, src) {
-    if (/^[a-z][a-z0-9+.-]*:/i.test(src) || src.startsWith("//")) {
-      throw new Error(`[csr-build] cannot inline external script: ${src}`);
-    }
-    const normalized = src.startsWith("/") ? src.slice(1) : src;
-    return path8.resolve(path8.dirname(htmlPath), normalized);
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/csrDevBundler.ts
-import fs3 from "fs";
-import { mkdir as mkdir3 } from "fs/promises";
-import path13 from "path";
-import { CSR_DEV_DIRNAME, CSR_DEV_MANIFEST_FILE as CSR_DEV_MANIFEST_FILE2 } from "akanjs/server/hmr/csrDevManifest";
-import { isAkanRuntimeMetadataFile } from "akanjs/server/hmr/runtimeMetadataFile";
-
-// pkgs/@akanjs/devkit/frontendBuild/csrDevArtifactWriter.ts
-import { mkdir as mkdir2, readdir, rename, rm as rm2 } from "fs/promises";
-import path10 from "path";
-import {
-  CSR_DEV_APP_FILE,
-  CSR_DEV_MANIFEST_FILE,
-  CSR_DEV_ROUTE_PREFIX,
-  csrDevModuleFile
-} from "akanjs/server/hmr/csrDevManifest";
-
-// pkgs/@akanjs/devkit/frontendBuild/csrDevPaths.ts
-import fs from "fs";
-import path9 from "path";
-
-class CsrDevPaths {
-  static modulePrefix = "akan-module:";
-  static stubPrefix = "stub:";
-  root;
-  constructor(workspaceRoot) {
-    this.root = CsrDevPaths.realpath(workspaceRoot);
-  }
-  idOf(file) {
-    const real = CsrDevPaths.realpath(file);
-    const relative = path9.relative(this.root, real);
-    const id = relative.startsWith("..") || path9.isAbsolute(relative) ? real : relative;
-    return id.split(path9.sep).join("/");
-  }
-  fileOf(id) {
-    return path9.isAbsolute(id) ? id : path9.join(this.root, id);
-  }
-  static isStub(target) {
-    return target.startsWith(CsrDevPaths.stubPrefix);
-  }
-  static isVendorFile(file) {
-    return file.includes(`${path9.sep}node_modules${path9.sep}`);
-  }
-  static isScript(file) {
-    return /\.[cm]?[jt]sx?$/.test(file);
-  }
-  static mtimeOf(file) {
-    return fs.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? -1;
-  }
-  static async hashOf(file) {
-    const source = Bun.file(file);
-    return await source.exists() ? Bun.hash(await source.arrayBuffer()).toString(36) : "";
-  }
-  static realpath(file) {
-    return fs.existsSync(file) ? fs.realpathSync(file) : path9.resolve(file);
-  }
-  static tryResolve(specifier, from) {
-    try {
-      return Bun.resolveSync(specifier, from);
-    } catch {
-      return null;
-    }
-  }
-  static lineCount(text) {
-    let count = 0;
-    for (let index = text.indexOf(`
-`);index !== -1; index = text.indexOf(`
-`, index + 1))
-      count += 1;
-    return count;
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/csrDevArtifactWriter.ts
-class CsrDevArtifactWriter {
-  static #keptPatches = 40;
-  static #keptVendors = 3;
-  #outDir;
-  constructor(outDir) {
-    this.#outDir = outDir;
-  }
-  async reset() {
-    await rm2(this.#outDir, { recursive: true, force: true });
-    await mkdir2(path10.join(this.#outDir, "modules"), { recursive: true });
-  }
-  async readJson(name) {
-    const file = Bun.file(path10.join(this.#outDir, name));
-    if (!await file.exists())
-      return null;
-    return await file.json().catch(() => null);
-  }
-  async writeJson(name, value) {
-    await this.#writeAtomic(name, JSON.stringify(value));
-  }
-  async writeModules(compiled) {
-    await mkdir2(path10.join(this.#outDir, "modules"), { recursive: true });
-    const helpers = new Map(compiled.flatMap((module) => module.helpers ? [[module.helpers.hash, module.helpers]] : []));
-    await Promise.all([
-      ...compiled.flatMap((module) => [
-        Bun.write(this.#modulePath(module.id, ".js"), module.factory),
-        ...module.sourceMap ? [Bun.write(this.#modulePath(module.id, ".js.map"), module.sourceMap)] : []
-      ]),
-      ...[...helpers.values()].map((shared) => Bun.write(this.#helpersPath(shared.hash), shared.definition))
-    ]);
-  }
-  async forgetModules(ids) {
-    await Promise.all(ids.flatMap((id) => [
-      rm2(this.#modulePath(id, ".js"), { force: true }),
-      rm2(this.#modulePath(id, ".js.map"), { force: true })
-    ]));
-  }
-  async writeVendor(graph) {
-    const ids = Object.keys(graph.modules).filter((id) => graph.modules[id]?.vendor).sort();
-    const stubs = new Set(Object.values(graph.modules).flatMap((module) => module.deps.filter(CsrDevPaths.isStub)));
-    const lines = [await this.#helperDefinitions(graph, ids), ...await this.#defineLines(ids)];
-    for (const stub of [...stubs].sort()) {
-      const message = `[akan-csr] ${stub.slice(CsrDevPaths.stubPrefix.length)} is a Node built-in the browser does not have`;
-      lines.push(`__akan.define(${JSON.stringify(stub)}, function () {
-  throw new Error(${JSON.stringify(message)});
-});
-`);
-    }
-    const code = lines.join("");
-    const vendorFile = `vendor-${Bun.hash(code).toString(36)}.js`;
-    await this.#writeAtomic(vendorFile, code);
-    return vendorFile;
-  }
-  async writeApp(graph, generation) {
-    const ids = Object.keys(graph.modules).filter((id) => !graph.modules[id]?.vendor).sort();
-    const lines = await this.#defineLines(ids);
-    const blocks = ids.map((id, index) => [id, lines[index] ?? ""]);
-    const start = `__akan.start(${JSON.stringify({ generation, refresh: graph.refresh })});
-`;
-    await this.#writeWithSourceMap(CSR_DEV_APP_FILE, await this.#helperDefinitions(graph, ids), blocks, start);
-  }
-  async writePatch(generation, modules) {
-    const patchFile = `patch-${generation}.js`;
-    const blocks = modules.map((module, index) => [module.id, `${JSON.stringify(module.id)}: ${module.factory}${index < modules.length - 1 ? `,
-` : `
-`}`]);
-    const helpers = new Map(modules.flatMap((module) => module.helpers ? [[module.helpers.hash, module.helpers]] : []));
-    const header = `${[...helpers.values()].map((shared) => shared.definition).join("")}__akan.update(${generation}, {
-`;
-    await this.#writeWithSourceMap(patchFile, header, blocks, `});
-`);
-    return `${CSR_DEV_ROUTE_PREFIX}${patchFile}`;
-  }
-  async writeState(graph, manifest) {
-    await this.writeJson("graph.json", graph);
-    await this.writeJson(CSR_DEV_MANIFEST_FILE, manifest);
-  }
-  async prune(vendorFile, generation) {
-    const names = await readdir(this.#outDir);
-    const stale = names.filter((name) => {
-      const patch = /^patch-(\d+)\.js(?:\.layout\.json)?$/.exec(name);
-      return patch ? Number(patch[1]) <= generation - CsrDevArtifactWriter.#keptPatches : false;
-    });
-    const vendors = names.filter((name) => /^vendor-[\w-]+\.js$/.test(name) && name !== vendorFile).map((name) => ({ name, mtimeMs: CsrDevPaths.mtimeOf(path10.join(this.#outDir, name)) })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(CsrDevArtifactWriter.#keptVendors - 1).map(({ name }) => name);
-    await Promise.all([...stale, ...vendors].map((name) => rm2(path10.join(this.#outDir, name), { force: true })));
-  }
-  async#helperDefinitions(graph, ids) {
-    const hashes = [...new Set(ids.flatMap((id) => graph.modules[id]?.helpers ?? []))].sort();
-    return (await Promise.all(hashes.map((hash) => Bun.file(this.#helpersPath(hash)).text()))).join("");
-  }
-  async#defineLines(ids) {
-    return await Promise.all(ids.map(async (id) => `__akan.define(${JSON.stringify(id)}, ${await Bun.file(this.#modulePath(id, ".js")).text()});
-`));
-  }
-  async#writeWithSourceMap(name, header, blocks, footer) {
-    const layout = { lineCount: 0, modules: [] };
-    let line = CsrDevPaths.lineCount(header);
-    for (const [id, text] of blocks) {
-      layout.modules.push([id, line + 1]);
-      line += CsrDevPaths.lineCount(text);
-    }
-    const code = `${header}${blocks.map(([, text]) => text).join("")}${footer}//# sourceMappingURL=${name}.map
-`;
-    layout.lineCount = CsrDevPaths.lineCount(code);
-    await this.writeJson(`${name}.layout.json`, layout);
-    await this.#writeAtomic(name, code);
-  }
-  async#writeAtomic(name, content) {
-    const target = path10.join(this.#outDir, name);
-    const temp = `${target}.${process.pid}.tmp`;
-    await Bun.write(temp, content);
-    await rename(temp, target);
-  }
-  #modulePath(id, extension) {
-    return path10.join(this.#outDir, csrDevModuleFile(id, extension));
-  }
-  #helpersPath(hash) {
-    return path10.join(this.#outDir, "modules", `helpers-${hash}.js`);
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/csrDevModuleCompiler.ts
-import path12 from "path";
-import { CSR_DEV_ROUTE_PREFIX as CSR_DEV_ROUTE_PREFIX2 } from "akanjs/server/hmr/csrDevManifest";
-
-// pkgs/@akanjs/devkit/frontendBuild/csrDevResolver.ts
-import fs2 from "fs";
-import path11 from "path";
-class CsrDevResolver {
-  static inline = "inline";
-  #paths;
-  #context;
-  #entryFiles;
-  #resolution = new Map;
-  #fallbacks = new Set;
-  #prepassDone = false;
-  constructor({ paths, context, entryFiles, resolution = {} }) {
-    this.#paths = paths;
-    this.#context = context;
-    this.#entryFiles = entryFiles;
-    for (const [importer, bySpecifier] of Object.entries(resolution))
-      this.#resolution.set(paths.fileOf(importer), new Map(Object.entries(bySpecifier).map(([specifier, target]) => [
-        specifier,
-        CsrDevPaths.isStub(target) ? target : paths.fileOf(target)
-      ])));
-  }
-  get prepassDone() {
-    return this.#prepassDone;
-  }
-  get fallbacks() {
-    return this.#fallbacks;
-  }
-  async prepass() {
-    const result = await Bun.build({
-      entrypoints: [...this.#entryFiles, this.#context.refreshFile],
-      target: "browser",
-      metafile: true,
-      env: "AKAN_PUBLIC_*",
-      define: this.#context.define,
-      optimizeImports: this.#context.optimizeImports,
-      plugins: [PagesBundleBuilder.createCssStubPlugin()]
-    });
-    const { inputs } = result.metafile;
-    for (const [input, { imports }] of Object.entries(inputs)) {
-      const importer = CsrDevPaths.realpath(path11.resolve(input));
-      for (const record of imports) {
-        if (!record.original)
+        try {
+          const rewritten = await rewriteBarrelImports(content, akanConfig.barrelImports, analyzer);
+          if (rewritten !== null)
+            source = rewritten;
+        } catch {}
+      }
+      let imports;
+      try {
+        imports = this.#transpiler.scanImports(source);
+      } catch {
+        continue;
+      }
+      const importerDir = path4.dirname(filePath);
+      for (const imp of imports) {
+        const spec = imp.path;
+        if (!spec)
           continue;
-        if (record.external) {
-          if (record.original.startsWith("node:"))
-            this.#remember(importer, record.original, `${CsrDevPaths.stubPrefix}${record.original}`);
+        if (spec.endsWith(".css")) {
+          const cssPath = await this.#resolveCssImport(spec, importerDir);
+          cssFiles.add(cssPath);
           continue;
         }
-        const target = path11.resolve(record.path);
-        if (fs2.existsSync(target))
-          this.#remember(importer, record.original, CsrDevPaths.realpath(target));
+        if (NON_SOURCE_EXT_RE.test(spec))
+          continue;
+        const resolved = await this.#resolveSourceImport(spec, importerDir, resolvePackage);
+        if (!resolved || sourceFiles.has(resolved) || isIgnoredNodeModuleSource(resolved))
+          continue;
+        queue.push(resolved);
       }
     }
-    this.#prepassDone = true;
-  }
-  resolve(importer, specifier) {
-    if (this.#isInlineSpecifier(specifier))
-      return CsrDevResolver.inline;
-    const known = this.#resolution.get(importer)?.get(specifier);
-    const usable = known && (CsrDevPaths.isStub(known) || fs2.existsSync(known)) ? known : null;
-    const target = usable ?? this.#resolveUnknown(importer, specifier);
-    if (target === null || CsrDevPaths.isStub(target))
-      return target;
-    if (!CsrDevPaths.isScript(target))
-      return CsrDevResolver.inline;
-    if (!usable)
-      this.#remember(importer, specifier, target);
-    return target;
-  }
-  isRegistryModule(file) {
-    if (!CsrDevPaths.isScript(file))
-      return false;
-    const packageName = CsrDevResolver.#packageNameOf(file);
-    if (packageName === null)
-      return true;
-    return !this.#context.optimizeImports.some((pattern) => {
-      const base = CsrDevResolver.#patternBase(pattern);
-      return base === packageName || base.startsWith(`${packageName}/`);
-    });
+    const tokenPaths = await this.#libTokenStylesheets(sourceFiles);
+    const cssPaths = [...new Set([...tokenPaths, ...cssFiles])];
+    for (const cssPath of cssPaths)
+      this.#discoveredCssPaths.add(cssPath);
+    return { cssPaths, sourcePaths: [...sourceFiles] };
   }
-  serialize() {
-    return Object.fromEntries([...this.#resolution].map(([importer, bySpecifier]) => [
-      this.#paths.idOf(importer),
-      Object.fromEntries([...bySpecifier].map(([specifier, target]) => [
-        specifier,
-        CsrDevPaths.isStub(target) ? target : this.#paths.idOf(target)
-      ]))
-    ]));
-  }
-  #resolveUnknown(importer, specifier) {
-    if (specifier.startsWith("node:"))
-      return `${CsrDevPaths.stubPrefix}${specifier}`;
-    const relative = specifier.startsWith(".") || path11.isAbsolute(specifier);
-    if (!relative && !this.#prepassDone)
-      return null;
-    if (!relative) {
-      const sibling = this.#resolvedBySibling(importer, specifier);
-      if (sibling)
-        return sibling;
-    }
-    const resolved = CsrDevPaths.tryResolve(specifier, path11.dirname(importer));
-    if (!resolved)
-      throw new Error(`[csr-dev] cannot resolve "${specifier}" from ${this.#paths.idOf(importer)}`);
-    if (!path11.isAbsolute(resolved))
-      return `${CsrDevPaths.stubPrefix}${specifier}`;
-    if (!relative)
-      this.#fallbacks.add(specifier);
-    return CsrDevPaths.realpath(resolved);
-  }
-  #resolvedBySibling(importer, specifier) {
-    const scope = CsrDevResolver.#packageScopeOf(importer);
-    for (const [other, bySpecifier] of this.#resolution) {
-      const target = bySpecifier.get(specifier);
-      if (target && CsrDevResolver.#packageScopeOf(other) === scope)
-        return target;
+  async#libTokenStylesheets(sourceFiles) {
+    const libsRoot = path4.join(this.#app.workspace.workspaceRoot, "libs");
+    const libNames = new Set;
+    for (const filePath of sourceFiles) {
+      const relPath = path4.relative(libsRoot, filePath);
+      if (relPath.startsWith("..") || path4.isAbsolute(relPath))
+        continue;
+      const [libName] = relPath.split(path4.sep);
+      if (libName)
+        libNames.add(libName);
     }
-    return null;
-  }
-  #remember(importer, specifier, target) {
-    const byImporter = this.#resolution.get(importer) ?? new Map;
-    this.#resolution.set(importer, byImporter.set(specifier, target));
-  }
-  #isInlineSpecifier(specifier) {
-    if (specifier.startsWith(".") || path11.isAbsolute(specifier) || specifier.startsWith("node:"))
-      return false;
-    return this.#context.optimizeImports.some((pattern) => {
-      const base = CsrDevResolver.#patternBase(pattern);
-      return specifier === base || specifier.startsWith(`${base}/`);
-    });
-  }
-  static #patternBase(pattern) {
-    return pattern.endsWith("/*") ? pattern.slice(0, -2) : pattern;
-  }
-  static #packageNameOf(file) {
-    const marker = `${path11.sep}node_modules${path11.sep}`;
-    const index = file.lastIndexOf(marker);
-    if (index < 0)
-      return null;
-    const [scope, name] = file.slice(index + marker.length).split(path11.sep);
-    return (scope?.startsWith("@") ? `${scope}/${name}` : scope) || null;
+    const tokenPaths = await Promise.all([...libNames].sort().map(async (libName) => {
+      const tokensPath = path4.join(libsRoot, libName, "ui/tokens.css");
+      return await this.#fileExists(tokensPath) ? tokensPath : null;
+    }));
+    return tokenPaths.filter((tokensPath) => !!tokensPath);
   }
-  static #packageScopeOf(file) {
-    const marker = `${path11.sep}node_modules${path11.sep}`;
-    const index = file.lastIndexOf(marker);
-    if (index < 0)
-      return "";
-    const [scope, name] = file.slice(index + marker.length).split(path11.sep);
-    return file.slice(0, index + marker.length) + (scope?.startsWith("@") ? `${scope}${path11.sep}${name}` : scope);
+  async compileCss(cssPaths, sourcePaths) {
+    const { css } = await this.#compileWithImports(cssPaths, sourcePaths);
+    return css;
   }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/csrDevModuleCompiler.ts
-class CsrDevModuleCompiler {
-  static #storeRoot = /(?:^|\/)lib\/st\.ts$/;
-  static #factoryArgument = /(?<![\w$.])(?:require|module|exports|__akanImport|\$RefreshReg\$|\$RefreshSig\$)(?![\w$]|\s*:)/;
-  static #helperPatches = [
-    ["__toESM", "(mod, isNodeMode, target)", "toESM"],
-    ["__reExport", "(target, mod, secondTarget)", "reExport"]
-  ];
-  #app;
-  #paths;
-  #resolver;
-  #context;
-  #outDir;
-  constructor({ app, paths, resolver, context, outDir }) {
-    this.#app = app;
-    this.#paths = paths;
-    this.#resolver = resolver;
-    this.#context = context;
-    this.#outDir = outDir;
-  }
-  async compile(startFiles, known) {
-    const compiled = new Map;
-    const seen = new Set([...known, ...startFiles]);
-    let frontier = [...new Set(startFiles)];
-    while (frontier.length > 0) {
-      const round = await this.#compileRound(frontier);
-      if (round.misses.length > 0 && !this.#resolver.prepassDone) {
-        this.#app.verbose(`[csr-dev] ${round.misses.length} unresolved import(s); rerunning the resolution build`);
-        await this.#resolver.prepass();
-        continue;
-      }
-      const next = [];
-      for (const module of round.modules) {
-        compiled.set(module.file, module);
-        for (const dep of module.deps) {
-          if (CsrDevPaths.isStub(dep) || seen.has(dep))
-            continue;
-          seen.add(dep);
-          next.push(dep);
-        }
-      }
-      frontier = next;
-    }
-    const { fallbacks } = this.#resolver;
-    if (fallbacks.size > 0)
-      this.#app.verbose(`[csr-dev] ${fallbacks.size} import(s) outside the browser build's graph resolved with Bun's runtime resolver: ${[...fallbacks].slice(0, 5).join(", ")}${fallbacks.size > 5 ? ", ..." : ""}`);
-    return [...compiled.values()];
-  }
-  async#compileRound(files) {
-    const appFiles = files.filter((file) => !CsrDevPaths.isVendorFile(file));
-    const vendorFiles = files.filter((file) => CsrDevPaths.isVendorFile(file));
-    const rounds = await Promise.all([
-      appFiles.length > 0 ? this.#bunBuild(appFiles, false) : null,
-      vendorFiles.length > 0 ? this.#bunBuild(vendorFiles, true) : null
-    ]);
-    const modules = rounds.flatMap((round) => round?.modules ?? []);
-    const misses = rounds.flatMap((round) => round?.misses ?? []);
-    for (const file of rounds.flatMap((round) => round?.tangled ?? [])) {
-      const single = await this.#bunBuild([file], CsrDevPaths.isVendorFile(file));
-      if (single.tangled.length > 0)
-        throw new Error(`[csr-dev] ${this.#paths.idOf(file)} kept inlining another module`);
-      modules.push(...single.modules);
-      misses.push(...single.misses);
+  async#compileWithImports(cssPaths, sourcePaths) {
+    if (cssPaths.length === 0)
+      return { css: "", imported: [] };
+    const compileStarted = Date.now();
+    const compilers = await Promise.all(cssPaths.map(async (cssPath) => {
+      const css = await Bun.file(cssPath).text();
+      const base = path4.dirname(cssPath);
+      const imported = new Map;
+      const compiler = await compile(css, {
+        base,
+        loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase, imported),
+        loadModule: (id, fromBase) => this.#loadModule(id, fromBase)
+      });
+      return { cssPath, compiler, imported };
+    }));
+    const sourceDirs = new Set;
+    for (const entry of compilers) {
+      for (const s of entry.compiler.sources)
+        sourceDirs.add(s.base);
     }
-    return { modules, misses };
-  }
-  async#bunBuild(files, vendor) {
-    const mtimes = new Map(files.map((file) => [file, CsrDevPaths.mtimeOf(file)]));
-    const hashes = new Map(await Promise.all(files.map(async (file) => [file, vendor ? "" : await CsrDevPaths.hashOf(file)])));
-    const misses = [];
-    const result = await Bun.build({
-      entrypoints: files,
-      root: this.#paths.root,
-      target: "browser",
-      format: "cjs",
-      reactFastRefresh: !vendor,
-      sourcemap: vendor ? "none" : "external",
-      naming: { entry: "[dir]/[name].[ext]", asset: "assets/[name]-[hash].[ext]" },
-      publicPath: CSR_DEV_ROUTE_PREFIX2,
-      metafile: true,
-      env: "AKAN_PUBLIC_*",
-      define: this.#context.define,
-      optimizeImports: this.#context.optimizeImports,
-      plugins: [this.#registryPlugin(vendor, misses)]
-    });
-    const { outputs } = result.metafile;
-    const sourceMaps = new Map(result.outputs.filter((artifact) => artifact.kind === "sourcemap").map((artifact) => [artifact.path, artifact]));
-    const modules = [];
-    const tangled = [];
-    for (const artifact of result.outputs) {
-      if (artifact.kind === "asset") {
-        await Bun.write(path12.join(this.#outDir, artifact.path), artifact);
-        continue;
-      }
-      if (artifact.kind !== "entry-point")
-        continue;
-      const meta = outputs[artifact.path];
-      if (!meta?.entryPoint)
-        throw new Error(`[csr-dev] no entry point recorded for ${artifact.path}`);
-      const file = CsrDevPaths.realpath(path12.resolve(meta.entryPoint));
-      const inputs = Object.keys(meta.inputs).map((input) => CsrDevPaths.realpath(path12.resolve(input)));
-      if (inputs.some((input) => input !== file && this.#resolver.isRegistryModule(input))) {
-        tangled.push(file);
-        continue;
+    const scanStarted = Date.now();
+    const candidates = await this.#scanCandidates(sourcePaths, [...sourceDirs]);
+    this.#logger.verbose(`css candidates scanned count=${candidates.length} sources=${sourcePaths.length} dirs=${sourceDirs.size} in ${Date.now() - scanStarted}ms`);
+    const parts = [];
+    const imported = [];
+    for (const entry of compilers) {
+      const part = entry.compiler.build(candidates);
+      parts.push(part);
+      for (const [cssPath, content] of entry.imported) {
+        const declaredNames = declaredCustomProperties(content);
+        imported.push({ cssPath, declaredNames });
+        if (declaredNames.length === 0 || declaredNames.some((name) => part.includes(`${name}:`)))
+          continue;
+        this.#logger.warn(`css @import ${cssPath} was loaded by ${entry.cssPath} but none of its ${declaredNames.length} declaration(s) reached the compiled CSS`);
       }
-      const code = await artifact.text();
-      const id = this.#paths.idOf(file);
-      const sourceMap = sourceMaps.get(`${artifact.path}.map`);
-      modules.push({
-        id,
-        file,
-        vendor,
-        ...CsrDevModuleCompiler.#factory(id, code),
-        sourceMap: sourceMap ? this.#rebaseSourceMap(await sourceMap.text()) : undefined,
-        deps: this.#emittedDeps(code),
-        mtimeMs: mtimes.get(file) ?? CsrDevPaths.mtimeOf(file),
-        hash: hashes.get(file) ?? ""
-      });
     }
-    return { modules, misses, tangled };
+    this.#logger.verbose(`css compiled paths=${cssPaths.length} candidates=${candidates.length} in ${Date.now() - compileStarted}ms`);
+    return { css: parts.join(`
+`), imported };
   }
-  #registryPlugin(vendor, misses) {
-    return {
-      name: "akan-csr-registry",
-      setup: (build) => {
-        build.onLoad({ filter: /\.css$/ }, () => ({ contents: "", loader: "js" }));
-        if (!vendor)
-          build.onLoad({ filter: /\.tsx$/ }, async (args) => {
-            if (CsrDevPaths.isVendorFile(args.path))
-              return;
-            const normalized = RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh(await Bun.file(args.path).text());
-            return normalized ? { contents: normalized, loader: "tsx" } : undefined;
-          });
-        build.onResolve({ filter: /.*/ }, (args) => {
-          if (args.kind === "entry-point-build" || !args.importer)
-            return;
-          const importer = CsrDevPaths.realpath(args.importer);
-          const target = this.#resolver.resolve(importer, args.path);
-          if (target === CsrDevResolver.inline)
-            return;
-          if (target === null) {
-            misses.push(`${args.path} from ${this.#paths.idOf(importer)}`);
-            return { path: `akan-miss:${args.path}`, external: true };
-          }
-          const external = CsrDevPaths.isStub(target) ? target : `${CsrDevPaths.modulePrefix}${this.#paths.idOf(target)}`;
-          return { path: external, external: true };
-        });
-      }
-    };
+  async#loadStylesheet(id, fromBase, imported) {
+    const p = await this.#resolveCssImport(id, fromBase);
+    this.#discoveredCssPaths.add(p);
+    const content = await Bun.file(p).text();
+    imported?.set(p, content);
+    this.#logger.verbose(`css import "${id}" from ${fromBase} -> ${p} (${content.length} bytes)`);
+    return { path: p, base: path4.dirname(p), content };
   }
-  #rebaseSourceMap(text) {
-    const map = JSON.parse(text);
-    const files = map.sources.map((source) => path12.resolve(source));
-    map.sources = files.map((file) => `/${this.#paths.idOf(file)}`);
-    map.sourcesContent = files.map((file, index) => CsrDevPaths.isVendorFile(file) ? null : map.sourcesContent?.[index] ?? null);
-    return JSON.stringify(map);
-  }
-  #emittedDeps(code) {
-    const deps = new Set;
-    const references = /\b(?:require|import|__akanImport)\("((?:akan-module|stub):[^"]+)"\)/g;
-    for (const [, reference] of code.matchAll(references)) {
-      if (!reference)
-        continue;
-      deps.add(CsrDevPaths.isStub(reference) ? reference : this.#paths.fileOf(reference.slice(CsrDevPaths.modulePrefix.length)));
-    }
-    return [...deps];
-  }
-  static #factory(id, code) {
-    const prefix = CsrDevPaths.modulePrefix;
-    let patched = code.replaceAll(`import("${prefix}`, `__akanImport("${prefix}`).replace(/^\/\/# debugId=.*$/m, "");
-    for (const [name, params, method] of CsrDevModuleCompiler.#helperPatches) {
-      const definition = `var ${name} = ${params} => {`;
-      if (patched.includes(definition))
-        patched = patched.replace(definition, `var ${name} = __akan.${method}, __bun${name} = ${params} => {`);
-      else if (patched.includes(`${name}(`))
-        throw new Error(`[csr-dev] ${id}: Bun's ${name} helper no longer reads "${definition}"; CsrDevModuleCompiler must follow`);
+  async#resolveCssImport(id, fromBase) {
+    if (id.startsWith(".") || id.startsWith("/")) {
+      const filePath = path4.resolve(fromBase, id);
+      if (await this.#fileExists(filePath))
+        return filePath;
+      throw new Error(`[css] failed to resolve stylesheet import "${id}" from ${fromBase} (no file at ${filePath})`);
     }
-    if (CsrDevModuleCompiler.#storeRoot.test(id))
-      patched += `
-module.hot.accept();`;
-    const shared = CsrDevModuleCompiler.#shareHelpers(patched);
-    return {
-      factory: `function (require, module, exports, $RefreshReg$, $RefreshSig$, __akanImport) {
-${shared?.code ?? patched}
-}`,
-      helpers: shared?.helpers ?? null
-    };
-  }
-  static #shareHelpers(code) {
-    const marker = code.search(/^\/\/ /m);
-    if (marker <= 0)
-      return null;
-    const preamble = code.slice(0, marker);
-    const names = [...preamble.matchAll(/^(?:var|let|const|function)\s+([\w$]+)/gm)].map(([, name]) => name).filter((name) => !!name);
-    if (names.length === 0 || CsrDevModuleCompiler.#factoryArgument.test(preamble))
-      return null;
-    const hash = Bun.hash(preamble).toString(36);
-    const binding = `var { ${names.join(", ")} } = __akan.helpers(${JSON.stringify(hash)});`;
-    return {
-      code: `${binding}${`
-`.repeat(CsrDevPaths.lineCount(preamble))}${code.slice(marker)}`,
-      helpers: {
-        hash,
-        definition: `__akan.defineHelpers(${JSON.stringify(hash)}, function () {
-${preamble}return { ${names.join(", ")} };
-});
-`
-      }
-    };
+    this.#cssImportResolver ??= await CssImportResolver.create(this.#app);
+    const resolved = await this.#cssImportResolver.resolve(id, fromBase);
+    if (resolved)
+      return resolved;
+    throw new Error(`[css] failed to resolve stylesheet import "${id}" from ${fromBase}`);
   }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/csrDevBundler.ts
-class CsrDevBundler {
-  static #formatVersion = 3;
-  #app;
-  #paths;
-  #outDir;
-  #entryDir;
-  #writer;
-  constructor(app) {
-    this.#app = app;
-    this.#paths = new CsrDevPaths(app.workspace.workspaceRoot);
-    this.#outDir = path13.join(app.cwdPath, ".akan/artifact", CSR_DEV_DIRNAME);
-    this.#entryDir = path13.join(app.cwdPath, ".akan/generated", CSR_DEV_DIRNAME);
-    this.#writer = new CsrDevArtifactWriter(this.#outDir);
-  }
-  async update(changedFiles = []) {
-    const context = await this.#context();
-    if (context.pageEntries.length === 0)
-      return null;
-    const manifest = await this.#writer.readJson(CSR_DEV_MANIFEST_FILE2);
-    const graph = await this.#writer.readJson("graph.json");
-    const generation = (manifest?.generation ?? 0) + 1;
-    if (!manifest || !graph || graph.version !== 1 || graph.configKey !== context.configKey)
-      return await this.#fullBuild(context, generation, manifest ? "the dev bundle config changed" : "first build");
-    const metadataFile = changedFiles.find(isAkanRuntimeMetadataFile);
-    if (metadataFile)
-      return await this.#fullBuild(context, generation, `${path13.basename(metadataFile)} changed`);
-    return await this.#incrementalBuild(context, graph, manifest, changedFiles, generation);
-  }
-  async#context() {
-    const akanConfig = await this.#app.getConfig();
-    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, await this.#app.getPageKeys());
-    const basePaths = [...akanConfig.basePaths];
-    const htmlBasePaths = basePaths.length > 0 ? basePaths : [""];
-    const define = bundleDefine(this.#app, "start", "csr");
-    const optimizeImports = [...akanConfig.optimizeImports];
-    const configKey = Bun.hash(JSON.stringify([CsrDevBundler.#formatVersion, Bun.version, define, optimizeImports, htmlBasePaths])).toString(36);
-    return {
-      pageEntries,
-      basePaths,
-      htmlBasePaths,
-      define,
-      optimizeImports,
-      configKey,
-      refreshFile: this.#resolveRefreshRuntime()
-    };
+  async#loadModule(id, fromBase) {
+    const p = __require.resolve(id, { paths: [fromBase] });
+    const mod = await import(p);
+    return { path: p, base: path4.dirname(p), module: mod.default ?? mod };
   }
-  #resolveRefreshRuntime() {
-    const akanWebkit = CsrDevPaths.tryResolve("akanjs/webkit", this.#app.cwdPath);
-    const bases = [
-      this.#app.cwdPath,
-      this.#paths.root,
-      ...akanWebkit ? [path13.dirname(path13.dirname(akanWebkit))] : []
-    ];
-    for (const base of bases) {
-      const resolved = CsrDevPaths.tryResolve("react-refresh/runtime", base);
-      if (resolved)
-        return CsrDevPaths.realpath(resolved);
-    }
-    throw new Error(`[csr-dev] react-refresh/runtime is not resolvable from ${bases.join(", ")}`);
-  }
-  async#fullBuild(context, generation, reason) {
-    await this.#writer.reset();
-    const entries = await this.#writeEntries(context);
-    const entryFiles = Object.values(entries.files);
-    const resolver = new CsrDevResolver({ paths: this.#paths, context, entryFiles });
-    await resolver.prepass();
-    const compiled = await this.#compiler(context, resolver).compile([...entryFiles, context.refreshFile], new Set);
-    const graph = {
-      version: 1,
-      configKey: context.configKey,
-      refresh: this.#paths.idOf(context.refreshFile),
-      entries: this.#entryIds(entries.files),
-      modules: {},
-      resolution: {},
-      pending: []
-    };
-    this.#merge(graph, resolver, compiled);
-    await this.#writer.writeModules(compiled);
-    const vendorFile = await this.#writer.writeVendor(graph);
-    await this.#writer.writeApp(graph, generation);
-    await this.#writer.writeState(graph, { version: 1, generation, vendorFile, entries: graph.entries });
-    await this.#writer.prune(vendorFile, generation);
-    return { generation, reload: true, reason, changedIds: [], moduleCount: Object.keys(graph.modules).length };
-  }
-  async#incrementalBuild(context, graph, manifest, changedFiles, generation) {
-    const entries = await this.#writeEntries(context);
-    const entryIds = this.#entryIds(entries.files);
-    await this.#forgetDeletedModules(graph);
-    const changed = await this.#changedModules(graph, changedFiles);
-    for (const file of entries.changed)
-      changed.add(this.#paths.idOf(file));
-    const routesMoved = entries.changed.length > 0 || JSON.stringify(entryIds) !== JSON.stringify(graph.entries);
-    if (changed.size === 0)
-      return null;
-    const resolver = new CsrDevResolver({
-      paths: this.#paths,
-      context,
-      entryFiles: Object.values(entries.files),
-      resolution: graph.resolution
-    });
-    const known = new Set(Object.keys(graph.modules).map((id) => this.#paths.fileOf(id)));
-    let compiled;
-    try {
-      compiled = await this.#compiler(context, resolver).compile([...changed].map((id) => this.#paths.fileOf(id)), known);
-    } catch (error) {
-      graph.pending = [...changed];
-      await this.#writer.writeJson("graph.json", graph);
-      throw error;
-    }
-    const vendorJoined = compiled.some((module) => module.vendor && !graph.modules[module.id]);
-    this.#merge(graph, resolver, compiled);
-    graph.entries = entryIds;
-    await this.#writer.writeModules(compiled);
-    const vendorFile = vendorJoined ? await this.#writer.writeVendor(graph) : manifest.vendorFile;
-    await this.#writer.writeApp(graph, generation);
-    const changedIds = compiled.filter((module) => !module.vendor).map((module) => module.id);
-    const constantId = changedIds.find((id) => id.endsWith(".constant.ts"));
-    const reason = vendorJoined ? "an npm module joined the graph" : routesMoved ? "the route table changed" : constantId ? `${path13.basename(constantId)} changed` : undefined;
-    const patchUrl = reason ? undefined : await this.#writer.writePatch(generation, compiled.filter((module) => !module.vendor));
-    await this.#writer.writeState(graph, { ...manifest, generation, vendorFile, entries: entryIds });
-    await this.#writer.prune(vendorFile, generation);
-    return {
-      generation,
-      reload: !!reason,
-      reason,
-      patchUrl,
-      changedIds,
-      moduleCount: Object.keys(graph.modules).length
-    };
+  #resolveSourceImport(id, fromBase, resolvePackage) {
+    const cacheKey = `${fromBase}\x00${id}`;
+    let cached = this.#resolvedSpecifierCache.get(cacheKey);
+    if (cached)
+      return cached;
+    cached = this.#resolveSourceImportUncached(id, fromBase, resolvePackage);
+    this.#resolvedSpecifierCache.set(cacheKey, cached);
+    return cached;
   }
-  async#changedModules(graph, changedFiles) {
-    const changed = new Set(graph.pending.filter((id) => graph.modules[id]));
-    for (const file of changedFiles) {
-      const id = this.#paths.idOf(file);
-      if (graph.modules[id])
-        changed.add(id);
+  async#resolveSourceImportUncached(id, fromBase, resolvePackage) {
+    if (id.startsWith(".") || id.startsWith("/")) {
+      const abs = id.startsWith("/") ? id : path4.resolve(fromBase, id);
+      return this.#resolveSourceFileCandidate(abs);
     }
-    for (const [id, module] of Object.entries(graph.modules)) {
-      if (module.vendor || changed.has(id))
-        continue;
-      const file = this.#paths.fileOf(id);
-      if (CsrDevPaths.mtimeOf(file) === module.mtimeMs)
-        continue;
-      if (await CsrDevPaths.hashOf(file) !== module.hash)
-        changed.add(id);
+    const pkg = await resolvePackage(id);
+    if (pkg)
+      return pkg.entryFile;
+    for (const resolve of [() => resolveSourceWithBun(id, fromBase), () => resolveSourceWithRequire(id, fromBase)]) {
+      const resolved = await resolve();
+      if (resolved)
+        return resolved;
     }
-    return changed;
+    return null;
   }
-  async#forgetDeletedModules(graph) {
-    const deleted = Object.keys(graph.modules).filter((id) => !graph.modules[id]?.vendor && !fs3.existsSync(this.#paths.fileOf(id)));
-    for (const id of deleted)
-      delete graph.modules[id];
-    await this.#writer.forgetModules(deleted);
+  async#scanCandidates(sourcePaths, dirs) {
+    const candidates = new Set;
+    const glob = new Bun.Glob("**/*.{tsx,ts,jsx,js,html}");
+    const files = new Set(sourcePaths);
+    await Promise.all(dirs.map(async (dir) => {
+      for await (const file of glob.scan({ cwd: dir, absolute: true })) {
+        if (isIgnoredNodeModuleSource(file))
+          continue;
+        files.add(file);
+      }
+    }));
+    const cache = await new CssCandidateCache(this.#candidateCachePath).load();
+    await Promise.all([...files].map(async (file) => {
+      for (const candidate of await cache.candidatesFor(file))
+        candidates.add(candidate);
+    }));
+    await cache.save(files);
+    this.#logger.verbose(`css candidate cache reused=${cache.reused} rescanned=${cache.rescanned}`);
+    return [...candidates];
   }
-  async#writeEntries(context) {
-    await mkdir3(this.#entryDir, { recursive: true });
-    const files = {};
-    const changed = [];
-    for (const basePath of context.htmlBasePaths) {
-      const file = path13.join(this.#entryDir, CsrArtifactBuilder.entryFilename(basePath));
-      const entryPages = CsrArtifactBuilder.pageEntriesForBasePath(context.pageEntries, basePath, context.basePaths);
-      const generator = new PagesEntrySourceGenerator(entryPages);
-      const pages = await generator.generateStatic({ fromDir: this.#entryDir });
-      const hot = await generator.generateHotReplace({
-        fromDir: this.#entryDir,
-        ownerId: this.#paths.idOf(file),
-        moduleIds: entryPages.map(({ moduleAbsPath }) => this.#paths.idOf(moduleAbsPath))
-      });
-      const source = `import * as akanWebkit from "akanjs/webkit";
-${pages}
-void akanWebkit.bootCsr(pages);
-${hot}`;
-      const unchanged = await Bun.file(file).exists() && await Bun.file(file).text() === source;
-      if (!unchanged)
-        await Bun.write(file, source);
-      const entryFile = CsrDevPaths.realpath(file);
-      files[basePath] = entryFile;
-      if (!unchanged)
-        changed.push(entryFile);
-    }
-    return { files, changed };
-  }
-  #compiler(context, resolver) {
-    return new CsrDevModuleCompiler({ app: this.#app, paths: this.#paths, resolver, context, outDir: this.#outDir });
-  }
-  #merge(graph, resolver, compiled) {
-    for (const module of compiled)
-      graph.modules[module.id] = {
-        vendor: module.vendor,
-        mtimeMs: module.mtimeMs,
-        hash: module.hash,
-        deps: module.deps.map((dep) => CsrDevPaths.isStub(dep) ? dep : this.#paths.idOf(dep)),
-        ...module.helpers ? { helpers: module.helpers.hash } : {}
-      };
-    graph.pending = [];
-    graph.resolution = resolver.serialize();
+}
+function resolveSourceWithBun(id, fromBase) {
+  try {
+    const resolved = Bun.resolveSync(id, fromBase);
+    return isSourceFile(resolved) ? resolved : null;
+  } catch {
+    return null;
   }
-  #entryIds(files) {
-    return Object.fromEntries(Object.entries(files).map(([basePath, file]) => [basePath, this.#paths.idOf(file)]));
+}
+function resolveSourceWithRequire(id, fromBase) {
+  try {
+    const resolved = __require.resolve(id, { paths: [fromBase] });
+    return isSourceFile(resolved) ? resolved : null;
+  } catch {
+    return null;
   }
 }
+function isSourceFile(filePath) {
+  return SOURCE_EXTS.has(path4.extname(filePath));
+}
+function isIgnoredNodeModuleSource(filePath) {
+  return NODE_MODULES_RE.test(filePath) && !AKANJS_NODE_MODULE_RE.test(filePath);
+}
+function declaredCustomProperties(css) {
+  const withoutThemeBlocks = css.replace(/@theme[^{]*\{[^}]*\}/g, "");
+  return [...new Set([...withoutThemeBlocks.matchAll(/(?:^|[\s;{])(--[\w-]+)\s*:/g)].map(([, name]) => name))].filter((name) => !!name);
+}
+function getPageKeyBasePath(pageKey, basePaths) {
+  return CsrEntryFiles.basePathOfPageKey(pageKey, basePaths);
+}
 
 // pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
-import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
-import path14 from "path";
+import { mkdir as mkdir2, stat as stat2 } from "fs/promises";
+import path5 from "path";
 import ts from "typescript";
 var FONT_URL_PREFIX = "/_akan/fonts";
 var DEFAULT_FONT_SUBSETS = ["latin"];
@@ -2060,7 +893,7 @@ class FontOptimizer {
   constructor(app, command = "start") {
     this.#app = app;
     this.#command = command;
-    this.#artifactRoot = path14.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
+    this.#artifactRoot = path5.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
   }
   async optimize() {
     const fonts = await this.discoverFonts();
@@ -2085,7 +918,7 @@ class FontOptimizer {
     return result;
   }
   get #cachePath() {
-    return path14.join(this.#artifactRoot, "fontCache.json");
+    return path5.join(this.#artifactRoot, "fontCache.json");
   }
   async#buildCacheKey(fonts) {
     const sources = [];
@@ -2100,7 +933,7 @@ class FontOptimizer {
         sources.push({ optimizedSrc: face.optimizedSrc, ...stamp });
       }
       for (const filePath of font.subsetFiles ?? []) {
-        const abs = path14.isAbsolute(filePath) ? filePath : path14.join(this.#app.cwdPath, filePath);
+        const abs = path5.isAbsolute(filePath) ? filePath : path5.join(this.#app.cwdPath, filePath);
         const stamp = await this.#fileStamp(abs);
         if (!stamp)
           return null;
@@ -2126,7 +959,7 @@ class FontOptimizer {
     const cache = await Bun.file(this.#cachePath).json().catch(() => null);
     if (cache?.version !== FontOptimizer.#cacheVersion || cache.key !== key)
       return null;
-    const files = cache.files.map((relativePath) => path14.join(this.#artifactRoot, relativePath));
+    const files = cache.files.map((relativePath) => path5.join(this.#artifactRoot, relativePath));
     for (const filePath of files) {
       if (!await Bun.file(filePath).exists())
         return null;
@@ -2138,7 +971,7 @@ class FontOptimizer {
       version: FontOptimizer.#cacheVersion,
       key,
       css: result.css,
-      files: result.files.map((filePath) => path14.relative(this.#artifactRoot, filePath))
+      files: result.files.map((filePath) => path5.relative(this.#artifactRoot, filePath))
     };
     await Bun.write(this.#cachePath, JSON.stringify(cache));
   }
@@ -2146,7 +979,7 @@ class FontOptimizer {
     const pageKeys = await this.#app.getPageKeys();
     const fonts = [];
     await Promise.all(pageKeys.map(async (key) => {
-      const filePath = path14.resolve(this.#app.cwdPath, "page", key);
+      const filePath = path5.resolve(this.#app.cwdPath, "page", key);
       const file = Bun.file(filePath);
       if (!await file.exists())
         return;
@@ -2165,8 +998,8 @@ class FontOptimizer {
         this.#app.logger.warn(`[font] source not found: ${face.src}`);
         continue;
       }
-      const outputPath = path14.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
-      await mkdir4(path14.dirname(outputPath), { recursive: true });
+      const outputPath = path5.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
+      await mkdir2(path5.dirname(outputPath), { recursive: true });
       const sourceBuffer = Buffer.from(await Bun.file(sourcePath).arrayBuffer());
       const outputBuffer = await this.#buildFontBuffer(font, sourceBuffer, sourcePath);
       await Bun.write(outputPath, outputBuffer);
@@ -2188,7 +1021,7 @@ class FontOptimizer {
     const entries = Array.isArray(value) ? value : [];
     const fonts = entries.filter((entry) => this.#isReadableFont(entry));
     if (fonts.length !== entries.length || !Array.isArray(value))
-      this.#app.logger.warn(`[font] ${path14.relative(this.#app.cwdPath, filePath)} declares fonts the build cannot read without evaluating the module \u2014 write the list inline, or nothing is subset for it and every /_akan/fonts request 404s`);
+      this.#app.logger.warn(`[font] ${path5.relative(this.#app.cwdPath, filePath)} declares fonts the build cannot read without evaluating the module \u2014 write the list inline, or nothing is subset for it and every /_akan/fonts request 404s`);
     return fonts.map((font) => ({ ...font, subsets: font.subsets ?? [...DEFAULT_FONT_SUBSETS] }));
   }
   #isReadableFont(value) {
@@ -2346,8 +1179,8 @@ class FontOptimizer {
       return null;
     const rel = src.replace(/^\//, "");
     const candidates = [
-      this.#command === "build" ? path14.join(this.#app.dist.cwdPath, "public", rel) : null,
-      path14.join(this.#app.cwdPath, "public", rel),
+      this.#command === "build" ? path5.join(this.#app.dist.cwdPath, "public", rel) : null,
+      path5.join(this.#app.cwdPath, "public", rel),
       this.#resolveWorkspacePublicPath(rel)
     ].filter(Boolean);
     for (const candidate of candidates) {
@@ -2379,7 +1212,7 @@ class FontOptimizer {
       return "woff2";
     if (signature === "OTTO")
       return "otf";
-    const ext = path14.extname(sourcePath).slice(1).toLowerCase();
+    const ext = path5.extname(sourcePath).slice(1).toLowerCase();
     if (ext === "otf" || ext === "woff" || ext === "woff2")
       return ext;
     return "ttf";
@@ -2388,7 +1221,7 @@ class FontOptimizer {
     const [root, dep, ...rest] = rel.split("/");
     if (root !== "libs" || !dep || rest.length === 0)
       return null;
-    return path14.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
+    return path5.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
   }
   async#getSubsetText(font) {
     const parts = new Set;
@@ -2398,7 +1231,7 @@ class FontOptimizer {
     if (font.subsetText)
       parts.add(font.subsetText);
     for (const filePath of font.subsetFiles ?? []) {
-      const abs = path14.isAbsolute(filePath) ? filePath : path14.join(this.#app.cwdPath, filePath);
+      const abs = path5.isAbsolute(filePath) ? filePath : path5.join(this.#app.cwdPath, filePath);
       const file = Bun.file(abs);
       if (await file.exists())
         parts.add(await file.text());
@@ -2418,7 +1251,7 @@ class FontOptimizer {
   }
   async#collectAutoSubsetText() {
     const libPageRoots = (await this.#app.getPageRoots()).filter((root) => root.keyPrefix).map((root) => root.dir);
-    const roots = [...["page", "ui", "lib"].map((dir) => path14.join(this.#app.cwdPath, dir)), ...libPageRoots];
+    const roots = [...["page", "ui", "lib"].map((dir) => path5.join(this.#app.cwdPath, dir)), ...libPageRoots];
     const glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,html,md}");
     const parts = [];
     for (const root of [...new Set(roots)].sort()) {
@@ -2531,8 +1364,8 @@ ${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/fontPruner.ts
-import { rm as rm3, rmdir, stat as stat3 } from "fs/promises";
-import path15 from "path";
+import { rm as rm2, rmdir, stat as stat3 } from "fs/promises";
+import path6 from "path";
 import { isFontOptimizationEnabled } from "akanjs/client";
 var FONT_GLOB = "**/*.{woff2,woff,ttf,otf,ttc,eot}";
 var REFERRER_GLOB = "**/*.{css,js,mjs,cjs,json,html,htm,svg,xml,webmanifest}";
@@ -2545,8 +1378,8 @@ class FontPruner {
   constructor(app, { keepFonts = [] } = {}) {
     this.#app = app;
     this.#keepGlobs = keepFonts;
-    this.#publicRoot = path15.join(app.dist.cwdPath, "public");
-    this.#artifactRoot = path15.join(app.dist.cwdPath, ".akan/artifact");
+    this.#publicRoot = path6.join(app.dist.cwdPath, "public");
+    this.#artifactRoot = path6.join(app.dist.cwdPath, ".akan/artifact");
   }
   async prune() {
     const empty = { removed: [], kept: [], freedBytes: 0 };
@@ -2561,7 +1394,7 @@ class FontPruner {
     for (const font of fonts) {
       const target = isFontOptimizationEnabled(font) ? optimizedSrcs : unoptimizedSrcs;
       for (const fontPath of font.paths)
-        target.add(path15.posix.basename(fontPath.src));
+        target.add(path6.posix.basename(fontPath.src));
     }
     const result = { removed: [], kept: [], freedBytes: 0 };
     const undecided = [];
@@ -2599,10 +1432,10 @@ class FontPruner {
   async#collectCandidates() {
     const candidates = [];
     for await (const rel of new Bun.Glob(FONT_GLOB).scan({ cwd: this.#publicRoot, dot: false })) {
-      const entry = await stat3(path15.join(this.#publicRoot, rel)).catch(() => null);
+      const entry = await stat3(path6.join(this.#publicRoot, rel)).catch(() => null);
       if (!entry?.isFile())
         continue;
-      candidates.push({ rel: rel.split(path15.sep).join("/"), basename: path15.basename(rel), bytes: entry.size });
+      candidates.push({ rel: rel.split(path6.sep).join("/"), basename: path6.basename(rel), bytes: entry.size });
     }
     return candidates;
   }
@@ -2612,11 +1445,11 @@ class FontPruner {
     const bundled = candidates.filter((candidate) => !optimizedSrcs.has(candidate.basename));
     const roots = [
       { dir: this.#publicRoot, label: "public", needles: authoritative },
-      { dir: path15.join(this.#artifactRoot, "styles"), label: ".akan/artifact/styles", needles: authoritative },
-      { dir: path15.join(this.#artifactRoot, "client"), label: ".akan/artifact/client", needles: bundled },
-      { dir: path15.join(this.#artifactRoot, "client-ssr"), label: ".akan/artifact/client-ssr", needles: bundled },
-      { dir: path15.join(this.#artifactRoot, "server"), label: ".akan/artifact/server", needles: bundled },
-      { dir: path15.join(this.#app.dist.cwdPath, "csr"), label: "csr", needles: bundled }
+      { dir: path6.join(this.#artifactRoot, "styles"), label: ".akan/artifact/styles", needles: authoritative },
+      { dir: path6.join(this.#artifactRoot, "client"), label: ".akan/artifact/client", needles: bundled },
+      { dir: path6.join(this.#artifactRoot, "client-ssr"), label: ".akan/artifact/client-ssr", needles: bundled },
+      { dir: path6.join(this.#artifactRoot, "server"), label: ".akan/artifact/server", needles: bundled },
+      { dir: path6.join(this.#app.dist.cwdPath, "csr"), label: "csr", needles: bundled }
     ];
     for (const root of roots) {
       const pending = root.needles.filter((candidate) => !referrers.has(candidate.rel));
@@ -2635,20 +1468,20 @@ class FontPruner {
       const remaining = needles.filter((needle) => !referrers.has(needle.rel));
       if (!remaining.length)
         return;
-      const text = await Bun.file(path15.join(root.dir, rel)).text().catch(() => "");
+      const text = await Bun.file(path6.join(root.dir, rel)).text().catch(() => "");
       if (!text)
         continue;
       for (const needle of remaining) {
         if (needle.forms.some((form) => text.includes(form)))
-          referrers.set(needle.rel, `${root.label}/${rel.split(path15.sep).join("/")}`);
+          referrers.set(needle.rel, `${root.label}/${rel.split(path6.sep).join("/")}`);
       }
     }
   }
   async#remove(files) {
-    await Promise.all(files.map((file) => rm3(path15.join(this.#publicRoot, file), { force: true })));
-    const dirs = [...new Set(files.map((file) => path15.posix.dirname(file)))].filter((dir) => dir !== "." && dir !== "/").sort((a, b) => b.length - a.length);
+    await Promise.all(files.map((file) => rm2(path6.join(this.#publicRoot, file), { force: true })));
+    const dirs = [...new Set(files.map((file) => path6.posix.dirname(file)))].filter((dir) => dir !== "." && dir !== "/").sort((a, b) => b.length - a.length);
     for (const dir of dirs)
-      await rmdir(path15.join(this.#publicRoot, dir)).catch(() => {
+      await rmdir(path6.join(this.#publicRoot, dir)).catch(() => {
         return;
       });
   }
@@ -2695,8 +1528,8 @@ class FontPruner {
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/precompressArtifacts.ts
-import fs4 from "fs";
-import path16 from "path";
+import fs from "fs";
+import path7 from "path";
 import zlib from "zlib";
 var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
 var MIN_COMPRESS_BYTES = 1024;
@@ -2706,8 +1539,8 @@ var GZIP_LEVEL = 9;
 var { formatBytes } = FontPruner;
 async function precompressArtifacts(app) {
   const roots = [
-    path16.join(app.dist.cwdPath, ".akan/artifact/client"),
-    path16.join(app.dist.cwdPath, ".akan/artifact/styles")
+    path7.join(app.dist.cwdPath, ".akan/artifact/client"),
+    path7.join(app.dist.cwdPath, ".akan/artifact/styles")
   ];
   const result = { files: 0, inputBytes: 0, outputBytes: 0, brotliBytes: 0 };
   await Promise.all(roots.map((root) => precompressRoot(root, result)));
@@ -2717,7 +1550,7 @@ async function precompressArtifacts(app) {
   return result;
 }
 async function precompressRoot(root, result) {
-  if (!fs4.existsSync(root) || !fs4.statSync(root).isDirectory())
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory())
     return;
   const glob = new Bun.Glob("**/*");
   for await (const filePath of glob.scan({ cwd: root, absolute: true })) {
@@ -2726,7 +1559,7 @@ async function precompressRoot(root, result) {
     const bytes = await Bun.file(filePath).bytes();
     const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
     const gz = Bun.gzipSync(buffer, { level: GZIP_LEVEL });
-    const br = brotliCompress(buffer, path16.extname(filePath).toLowerCase());
+    const br = brotliCompress(buffer, path7.extname(filePath).toLowerCase());
     await Promise.all([Bun.write(`${filePath}.gz`, gz), Bun.write(`${filePath}.br`, br)]);
     result.files += 1;
     result.inputBytes += bytes.byteLength;
@@ -2746,7 +1579,7 @@ function brotliCompress(buffer, ext) {
 async function shouldPrecompress(filePath) {
   if (filePath.endsWith(".gz") || filePath.endsWith(".br"))
     return false;
-  if (!COMPRESSIBLE_EXTS.has(path16.extname(filePath).toLowerCase()))
+  if (!COMPRESSIBLE_EXTS.has(path7.extname(filePath).toLowerCase()))
     return false;
   const file = Bun.file(filePath);
   if (!await file.exists())
@@ -2755,7 +1588,7 @@ async function shouldPrecompress(filePath) {
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/ssrBaseArtifactBuilder.ts
-import path17 from "path";
+import path8 from "path";
 import { optimize } from "@tailwindcss/node";
 function prepareCssAsset(command, basePath, cssText) {
   return optimize(cssText, { file: `${basePath || "root"}.css`, minify: command === "build" }).code;
@@ -2771,7 +1604,7 @@ class SsrBaseArtifactBuilder {
     this.#app = app;
     this.#command = command;
     this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
-    this.#absArtifactDir = path17.resolve(this.#artifactDir);
+    this.#absArtifactDir = path8.resolve(this.#artifactDir);
   }
   static servedWeb(command, web) {
     return command === "start" ? { ssr: true, csr: true } : web;
@@ -2796,7 +1629,7 @@ class SsrBaseArtifactBuilder {
       rscRuntimeSsrManifest,
       vendorMap,
       cssAssets,
-      pagesBundlePath: this.#command === "build" ? path17.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
+      pagesBundlePath: this.#command === "build" ? path8.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
       pagesBundleBuildId: pagesBundle.buildId,
       domains: [...akanConfig.domains],
       subRoutes: Object.fromEntries(Array.from(akanConfig.subRoutes.entries()).map(([basePath, domains]) => [basePath, [...domains]])),
@@ -2813,18 +1646,18 @@ class SsrBaseArtifactBuilder {
         androidSha256CertFingerprints: target.deepLinks?.android?.sha256CertFingerprints
       }))
     };
-    await Bun.write(path17.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
+    await Bun.write(path8.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
 `);
     this.#app.verbose(`[base-artifact] complete in ${Date.now() - this.#started}ms`);
     return { artifact, seedIndex, cssCompiler, optimizedFonts };
   }
   async#buildRuntimeClientEntries() {
     const akanServerPath = await this.#resolveAkanServerPath();
-    const rscClientEntry = path17.resolve(akanServerPath, "rscClient.tsx");
-    const rscSegmentOutletEntry = path17.resolve(akanServerPath, "rscSegmentOutlet.tsx");
+    const rscClientEntry = path8.resolve(akanServerPath, "rscClient.tsx");
+    const rscSegmentOutletEntry = path8.resolve(akanServerPath, "rscSegmentOutlet.tsx");
     const vendorEntries = VENDOR_SPECIFIERS.map((specifier) => ({
       specifier,
-      absPath: path17.resolve(akanServerPath, "vendor", `${specifier.replaceAll("/", "-").replaceAll(".", "-")}.ts`)
+      absPath: path8.resolve(akanServerPath, "vendor", `${specifier.replaceAll("/", "-").replaceAll(".", "-")}.ts`)
     }));
     const entries = [rscClientEntry, rscSegmentOutletEntry, ...vendorEntries.map((v) => v.absPath)];
     const clientBundle = await new ClientEntriesBundler({ app: this.#app, entries, command: this.#command }).bundle();
@@ -2861,15 +1694,15 @@ class SsrBaseArtifactBuilder {
   async#resolveAkanServerPath() {
     const candidates = [];
     try {
-      candidates.push(path17.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
+      candidates.push(path8.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
     } catch {}
-    candidates.push(path17.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path17.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
+    candidates.push(path8.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path8.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
     try {
-      candidates.push(path17.dirname(Bun.resolveSync("akanjs/server", path17.dirname(Bun.main))));
+      candidates.push(path8.dirname(Bun.resolveSync("akanjs/server", path8.dirname(Bun.main))));
     } catch {}
-    candidates.push(path17.join(path17.dirname(Bun.main), "node_modules/akanjs/server"), path17.join(path17.dirname(Bun.main), "../../akanjs/server"), path17.resolve(import.meta.dir, "../../server"), path17.resolve(import.meta.dir, "../server"));
+    candidates.push(path8.join(path8.dirname(Bun.main), "node_modules/akanjs/server"), path8.join(path8.dirname(Bun.main), "../../akanjs/server"), path8.resolve(import.meta.dir, "../../server"), path8.resolve(import.meta.dir, "../server"));
     for (const candidate of candidates) {
-      if (await Bun.file(path17.join(candidate, "rscClient.tsx")).exists())
+      if (await Bun.file(path8.join(candidate, "rscClient.tsx")).exists())
         return candidate;
     }
     throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
@@ -2898,7 +1731,7 @@ ${preparedCssText}`).toString(36);
       `styles/${cssAssetName}-${cssHash}.css`,
       `/_akan/styles/${cssAssetName}-${cssHash}.css`
     ];
-    await Bun.write(path17.join(this.#absArtifactDir, cssRelPath), preparedCssText);
+    await Bun.write(path8.join(this.#absArtifactDir, cssRelPath), preparedCssText);
     SsrBaseArtifactBuilder.#warnDroppedImports(this.#app, cssRelPath, preparedCssText, imported);
     this.#app.verbose(`[base-artifact] wrote ${preparedCssText.length} bytes of CSS for ${basePath} -> ${cssRelPath}`);
     return [basePath, { cssUrl, cssRelPath }];
@@ -2911,4 +1744,4 @@ ${preparedCssText}`).toString(36);
     }
   }
 }
-export { computeRouteSeedIndex, saveRouteSeedIndex, AllRoutesBuilder, CssCompiler, PagesBundleBuilder, CsrArtifactBuilder, CsrDevBundler, FontOptimizer, FontPruner, precompressArtifacts, SsrBaseArtifactBuilder };
+export { AllRoutesBuilder, CsrArtifactBuilder, CssCompiler, FontOptimizer, FontPruner, precompressArtifacts, SsrBaseArtifactBuilder };