@akanjs/cli 3.0.0-alpha.74 → 3.0.0-alpha.76

package/{index-61x7qthy.js → index-25qfm3at.js}

@@ -11,8 +11,9 @@ import {
   transformUseClient
 } from "./index-jcm6zr20.js";
 import {
+  AsyncDefaultExportDetector,
   resolveSsrPageEntriesForApp
-} from "./index-f39512t6.js";
+} from "./index-dp66vwr6.js";
 import {
   __require
 } from "./index-yb2wsc7f.js";
@@ -227,334 +228,8 @@ class AllRoutesBuilder {
   }
 }
 
-// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
-import { mkdir, rm, unlink } from "fs/promises";
-import path5 from "path";
-
-// pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
-import fs from "fs";
-import path4 from "path";
-import ts from "typescript";
-
-class PagesEntrySourceGenerator {
-  #pageEntries;
-  constructor(pageEntries) {
-    this.#pageEntries = pageEntries;
-  }
-  static generate(pageEntries) {
-    return new PagesEntrySourceGenerator(pageEntries).generate();
-  }
-  generate() {
-    const lines = this.#pageEntries.map(({ key, moduleAbsPath }) => {
-      const specifier = PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
-      return `  ${JSON.stringify(key)}: () => import(${JSON.stringify(specifier)}),`;
-    });
-    return `export const pages = {
-${lines.join(`
-`)}
-};
-`;
-  }
-  static generateStatic(pageEntries) {
-    return new PagesEntrySourceGenerator(pageEntries).generateStatic();
-  }
-  generateStatic() {
-    const imports = this.#pageEntries.map(({ moduleAbsPath }, index) => {
-      const specifier = PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
-      return `import * as page${index} from ${JSON.stringify(specifier)};`;
-    });
-    const entries = this.#pageEntries.map(({ key, moduleAbsPath }, index) => {
-      const isAsyncDefault = PagesEntrySourceGenerator.#hasAsyncDefaultExport(moduleAbsPath);
-      return `  ${JSON.stringify(key)}: { loader: async () => page${index}, isAsyncDefault: ${isAsyncDefault} },`;
-    });
-    return `${imports.join(`
-`)}
-export const pages = {
-${entries.join(`
-`)}
-};
-`;
-  }
-  static #toImportSpecifier(moduleAbsPath) {
-    return path4.resolve(moduleAbsPath).split(path4.sep).join("/");
-  }
-  static #hasAsyncDefaultExport(moduleAbsPath) {
-    try {
-      const source = fs.readFileSync(path4.resolve(moduleAbsPath), "utf8");
-      const sourceFile = ts.createSourceFile(moduleAbsPath, source, ts.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
-      return PagesEntrySourceGenerator.#sourceFileHasAsyncDefaultExport(sourceFile);
-    } catch {
-      return false;
-    }
-  }
-  static #sourceFileHasAsyncDefaultExport(sourceFile) {
-    const asyncBindings = new Map;
-    let defaultIdentifier = null;
-    for (const statement of sourceFile.statements) {
-      if (ts.isFunctionDeclaration(statement)) {
-        if (PagesEntrySourceGenerator.#hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
-          return PagesEntrySourceGenerator.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword);
-        }
-        if (statement.name) {
-          asyncBindings.set(statement.name.text, PagesEntrySourceGenerator.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword));
-        }
-        continue;
-      }
-      if (ts.isVariableStatement(statement)) {
-        for (const declaration of statement.declarationList.declarations) {
-          if (!ts.isIdentifier(declaration.name))
-            continue;
-          asyncBindings.set(declaration.name.text, PagesEntrySourceGenerator.#isAsyncFunctionExpression(declaration.initializer));
-        }
-        continue;
-      }
-      if (ts.isExportAssignment(statement)) {
-        if (PagesEntrySourceGenerator.#isAsyncFunctionExpression(statement.expression))
-          return true;
-        if (ts.isIdentifier(statement.expression))
-          defaultIdentifier = statement.expression.text;
-        continue;
-      }
-      if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
-        const exportClause = statement.exportClause;
-        for (const specifier of exportClause.elements) {
-          if (specifier.name.text !== "default")
-            continue;
-          defaultIdentifier = specifier.propertyName?.text ?? specifier.name.text;
-        }
-      }
-    }
-    return defaultIdentifier ? asyncBindings.get(defaultIdentifier) === true : false;
-  }
-  static #hasModifier(node, kind) {
-    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
-  }
-  static #isAsyncFunctionExpression(node) {
-    return Boolean(node && (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && PagesEntrySourceGenerator.#hasModifier(node, ts.SyntaxKind.AsyncKeyword));
-  }
-  static #scriptKind(moduleAbsPath) {
-    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
-  }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
-class CsrArtifactBuilder {
-  #app;
-  #command;
-  #lang;
-  constructor(app, command = "start", lang = "en") {
-    this.#app = app;
-    this.#command = command;
-    this.#lang = lang;
-  }
-  async build() {
-    const pageKeys = await this.#app.getPageKeys();
-    if (pageKeys.length === 0) {
-      this.#app.log(`[cli] no route files under ${this.#app.cwdPath}/page \u2014 skipping CSR build`);
-      return null;
-    }
-    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
-    const akanConfig = await this.#app.getConfig();
-    const artifact = await this.#loadCsrArtifact();
-    const csrBasePaths = [...akanConfig.basePaths];
-    const htmlEntries = csrBasePaths.length > 0 ? csrBasePaths : ["index"];
-    await rm(this.#outputDir, { recursive: true, force: true });
-    await mkdir(path5.join(this.#app.cwdPath, ".akan/generated/csr"), { recursive: true });
-    const generatedHtmlFiles = Object.fromEntries(htmlEntries.map((basePath) => this.#createHtmlFile(basePath)));
-    const result = await Bun.build({
-      target: "browser",
-      entrypoints: Object.keys(generatedHtmlFiles),
-      files: {
-        ...generatedHtmlFiles,
-        [`${this.#app.cwdPath}/.akan/generated/csr/csr.tsx`]: `
-import { bootCsr } from "akanjs/webkit";
-${PagesEntrySourceGenerator.generateStatic(pageEntries)}
-void bootCsr(pages);
-  `
-      },
-      root: `${this.#app.cwdPath}/.akan/generated/csr`,
-      outdir: this.#outputDir,
-      splitting: false,
-      minify: true,
-      env: "AKAN_PUBLIC_*",
-      define: this.#define(),
-      optimizeImports: akanConfig.optimizeImports
-    });
-    if (!result.success) {
-      const logs = result.logs.map((log) => log.message).join(`
-`);
-      throw new Error(`[csr-build] failed${logs ? `
-${logs}` : ""}`);
-    }
-    await this.#inlineCsrArtifacts(artifact.cssAssets ?? {});
-    this.#app.verbose(`[csr-build] output -> ${this.#outputDir}`);
-    return { outputDir: this.#outputDir };
-  }
-  get #outputDir() {
-    return path5.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
-  }
-  #define() {
-    const nodeEnv = this.#command === "build" ? "production" : "development";
-    return {
-      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
-      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("csr"),
-      ...Object.fromEntries(Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
-    };
-  }
-  #createHtmlFile(basePath) {
-    const filename = `${basePath}.html`;
-    return [
-      `${this.#app.cwdPath}/.akan/generated/csr/${filename}`,
-      `<!doctype html>
-<html lang="${this.#lang}">
-  <head>
-    <meta charset="utf-8" />
-    <title>${this.#app.name}</title>
-    <base href="/" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="./csr.tsx"></script>
-  </body>
-</html>
-  `
-    ];
-  }
-  async#loadCsrArtifact() {
-    const artifactDir = path5.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
-    const artifactFile = Bun.file(path5.join(artifactDir, "base-artifact.json"));
-    if (!await artifactFile.exists())
-      return { cssAssets: {} };
-    const artifact = await artifactFile.json();
-    return { cssAssets: artifact.cssAssets ?? {} };
-  }
-  async#inlineCsrArtifacts(cssAssets) {
-    const jsFiles = new Set;
-    const cssFiles = new Set;
-    for (const htmlPath of await this.#htmlOutputPaths()) {
-      const htmlFile = Bun.file(htmlPath);
-      if (!await htmlFile.exists())
-        continue;
-      const basePath = path5.basename(htmlPath, ".html") === "index" ? "" : path5.basename(htmlPath, ".html");
-      const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAssets[basePath]);
-      for (const filePath of inlined.jsFiles)
-        jsFiles.add(filePath);
-      for (const filePath of inlined.cssFiles)
-        cssFiles.add(filePath);
-      await Bun.write(htmlPath, inlined.html);
-    }
-    for (const filePath of jsFiles)
-      await unlink(filePath).catch(() => {
-        return;
-      });
-    for (const filePath of cssFiles)
-      await unlink(filePath).catch(() => {
-        return;
-      });
-    const remainingJs = await this.#listOutputFiles((filePath) => filePath.endsWith(".js"));
-    const remainingCss = await this.#listOutputFiles((filePath) => filePath.endsWith(".css"));
-    const remainingAssets = [...remainingJs, ...remainingCss];
-    if (remainingAssets.length > 0) {
-      throw new Error(`[csr-build] expected single-file HTML, but CSR assets remain:
-${remainingAssets.join(`
-`)}`);
-    }
-  }
-  async#inlineHtmlAssets(html, htmlPath, cssAsset) {
-    const jsFiles = [];
-    const cssFiles = CsrArtifactBuilder.collectStylesheetHrefs(html).map((href) => CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, href));
-    let next = CsrArtifactBuilder.stripBundledStylesheetLinks(html);
-    next = await CsrArtifactBuilder.replaceModuleScriptSrc(next, async (src) => {
-      const jsPath = CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, src);
-      jsFiles.push(jsPath);
-      return await Bun.file(jsPath).text();
-    });
-    const bundledCss = (await Promise.all(cssFiles.map((cssFile) => Bun.file(cssFile).text().catch(() => "")))).filter(Boolean).join(`
-`);
-    if (bundledCss) {
-      const style = CsrArtifactBuilder.createInlineStyle(bundledCss);
-      if (!next.includes(style))
-        next = CsrArtifactBuilder.injectBeforeHeadEnd(next, style);
-    }
-    if (cssAsset) {
-      const cssPath = path5.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact", cssAsset.cssRelPath);
-      const css = await Bun.file(cssPath).text();
-      const style = CsrArtifactBuilder.createInlineStyle(css);
-      if (!next.includes(style))
-        next = CsrArtifactBuilder.injectBeforeHeadEnd(next, style);
-    }
-    return { html: next, jsFiles, cssFiles };
-  }
-  async#htmlOutputPaths() {
-    return await this.#listOutputFiles((filePath) => filePath.endsWith(".html"));
-  }
-  async#listOutputFiles(predicate) {
-    const glob = new Bun.Glob("**/*");
-    const files = [];
-    for await (const filePath of glob.scan({ cwd: this.#outputDir, absolute: true })) {
-      if (predicate(filePath))
-        files.push(filePath);
-    }
-    return files.sort();
-  }
-  static injectBeforeHeadEnd(html, snippet) {
-    const matches = [...html.matchAll(/<\/head\s*>/gi)];
-    const bodyStart = html.search(/<body(?:\s|>)/i);
-    const headEnd = matches.filter((match) => match.index !== undefined && (bodyStart === -1 || match.index < bodyStart)).at(-1);
-    if (!headEnd || headEnd.index === undefined)
-      return `${snippet}
-${html}`;
-    return `${html.slice(0, headEnd.index)}${snippet}
-${html.slice(headEnd.index)}`;
-  }
-  static stripBundledStylesheetLinks(html) {
-    return html.replace(/<link\b(?=[^>]*\brel=["']stylesheet["'])[^>]*>\s*/gi, "");
-  }
-  static collectStylesheetHrefs(html) {
-    const linkRe = /<link\b(?=[^>]*\brel=["']stylesheet["'])(?=[^>]*\bhref=["']([^"']+)["'])[^>]*>/gi;
-    return [...html.matchAll(linkRe)].map((match) => match[1]).filter((href) => !!href);
-  }
-  static createInlineStyle(css) {
-    return `<style data-akan-css="active">
-${css.replace(/<\/style/gi, "<\\/style")}
-</style>`;
-  }
-  static async replaceModuleScriptSrc(html, loadScript) {
-    const scriptRe = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>\s*<\/script>/gi;
-    let result = "";
-    let lastIndex = 0;
-    let matched = false;
-    for (const match of html.matchAll(scriptRe)) {
-      const full = match[0];
-      const src = match[1];
-      if (match.index === undefined || !src)
-        continue;
-      matched = true;
-      result += html.slice(lastIndex, match.index);
-      result += `<script type="module">
-${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
-</script>`;
-      lastIndex = match.index + full.length;
-    }
-    if (!matched)
-      return html;
-    return result + html.slice(lastIndex);
-  }
-  static escapeInlineScript(source) {
-    return source.replace(/<\/script/gi, "<\\/script");
-  }
-  static resolveHtmlAssetPath(htmlPath, src) {
-    if (/^[a-z][a-z0-9+.-]*:/i.test(src) || src.startsWith("//")) {
-      throw new Error(`[csr-build] cannot inline external script: ${src}`);
-    }
-    const normalized = src.startsWith("/") ? src.slice(1) : src;
-    return path5.resolve(path5.dirname(htmlPath), normalized);
-  }
-}
-
 // pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
-import path7 from "path";
+import path5 from "path";
 import { Logger } from "akanjs/common";
 import { compile } from "tailwindcss";
 
@@ -625,7 +300,7 @@ class CssCandidateCache {
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/cssImportResolver.ts
-import path6 from "path";
+import path4 from "path";
 var CSS_IMPORT_EXTS = ["", ".css", "/styles.css", "/index.css"];
 
 class CssImportResolver {
@@ -678,7 +353,7 @@ class CssImportResolver {
     const exact = this.#paths[id];
     if (exact) {
       for (const repl of exact) {
-        const resolved = await this.#firstExisting(path6.resolve(this.#workspaceRoot, repl));
+        const resolved = await this.#firstExisting(path4.resolve(this.#workspaceRoot, repl));
         if (resolved)
           return resolved;
       }
@@ -689,7 +364,7 @@ class CssImportResolver {
       const suffix = id.slice(prefix.length);
       for (const repl of replacements) {
         const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
-        const resolved = await this.#firstExisting(path6.resolve(this.#workspaceRoot, replPath + suffix));
+        const resolved = await this.#firstExisting(path4.resolve(this.#workspaceRoot, replPath + suffix));
         if (resolved)
           return resolved;
       }
@@ -719,29 +394,29 @@ class CssImportResolver {
     try {
       if (!await Bun.file(pkgPath).exists())
         return null;
-      const pkgDir = path6.dirname(pkgPath);
+      const pkgDir = path4.dirname(pkgPath);
       const pkg = await Bun.file(pkgPath).json();
       const subpath = id === pkgName ? "." : `.${id.slice(pkgName.length)}`;
       const exportValue = pkg.exports?.[subpath];
       const exportedEntry = typeof exportValue === "string" ? exportValue : exportValue?.style || exportValue?.import || exportValue?.default;
       if (exportedEntry)
-        return await this.#firstExisting(path6.resolve(pkgDir, exportedEntry));
+        return await this.#firstExisting(path4.resolve(pkgDir, exportedEntry));
       if (subpath !== ".")
-        return await this.#firstExisting(path6.resolve(pkgDir, subpath));
-      return await this.#firstExisting(path6.resolve(pkgDir, pkg.exports?.["."]?.style || pkg.style || "index.css"));
+        return await this.#firstExisting(path4.resolve(pkgDir, subpath));
+      return await this.#firstExisting(path4.resolve(pkgDir, pkg.exports?.["."]?.style || pkg.style || "index.css"));
     } catch {
       return null;
     }
   }
   #resolutionBases(fromBase) {
-    return [fromBase, this.#workspaceRoot, path6.dirname(Bun.main), path6.resolve(path6.dirname(Bun.main), "../..")];
+    return [fromBase, this.#workspaceRoot, path4.dirname(Bun.main), path4.resolve(path4.dirname(Bun.main), "../..")];
   }
   #packageJsonCandidates(pkgName) {
     return [
-      path6.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
-      path6.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
-      path6.join(path6.dirname(Bun.main), "node_modules", pkgName, "package.json"),
-      path6.join(path6.dirname(Bun.main), "../../", pkgName, "package.json")
+      path4.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
+      path4.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
+      path4.join(path4.dirname(Bun.main), "node_modules", pkgName, "package.json"),
+      path4.join(path4.dirname(Bun.main), "../../", pkgName, "package.json")
     ];
   }
   async#firstExisting(basePath) {
@@ -759,7 +434,7 @@ class CssImportResolver {
     return parts[0] ?? null;
   }
   static isCssFile(filePath) {
-    return path6.extname(filePath) === ".css";
+    return path4.extname(filePath) === ".css";
   }
 }
 
@@ -778,7 +453,7 @@ class CssCompiler {
     this.#app = app;
   }
   get #candidateCachePath() {
-    return path7.join(this.#app.cwdPath, ".akan/cache/cssCandidates.json");
+    return path5.join(this.#app.cwdPath, ".akan/cache/cssCandidates.json");
   }
   #cssText = null;
   #cssTextByBasePath = null;
@@ -808,7 +483,7 @@ class CssCompiler {
           return filePath;
       }
       for (const ext of SOURCE_EXTS) {
-        const filePath = path7.join(absPathNoExt, `index${ext}`);
+        const filePath = path5.join(absPathNoExt, `index${ext}`);
         if (await this.#fileExists(filePath))
           return filePath;
       }
@@ -866,14 +541,14 @@ class CssCompiler {
     return this.#cssTextByBasePath;
   }
   async#warnUnreachableStylesheets() {
-    const pageDir = path7.join(this.#app.cwdPath, "page");
+    const pageDir = path5.join(this.#app.cwdPath, "page");
     const glob = new Bun.Glob("**/*.css");
     for await (const cssPath of glob.scan({ cwd: pageDir, absolute: true })) {
-      if (cssPath.includes(`${path7.sep}(libs)${path7.sep}`))
+      if (cssPath.includes(`${path5.sep}(libs)${path5.sep}`))
         continue;
       if (this.#discoveredCssPaths.has(cssPath))
         continue;
-      this.#logger.warn(`css ${path7.relative(this.#app.cwdPath, cssPath)} is imported by no route and never compiled`);
+      this.#logger.warn(`css ${path5.relative(this.#app.cwdPath, cssPath)} is imported by no route and never compiled`);
     }
   }
   async discoverCss({ refresh } = {}) {
@@ -885,7 +560,7 @@ class CssCompiler {
     pageKeys
   } = {}) {
     pageKeys ??= await this.#app.getPageKeys({ refresh });
-    const seeds = pageKeys.map((key) => path7.resolve(this.#app.cwdPath, "page", key));
+    const seeds = pageKeys.map((key) => path5.resolve(this.#app.cwdPath, "page", key));
     const cssFiles = new Set;
     const sourceFiles = new Set;
     const queue = [...seeds];
@@ -917,7 +592,7 @@ class CssCompiler {
       } catch {
         continue;
       }
-      const importerDir = path7.dirname(filePath);
+      const importerDir = path5.dirname(filePath);
       for (const imp of imports) {
         const spec = imp.path;
         if (!spec)
@@ -942,18 +617,18 @@ class CssCompiler {
     return { cssPaths, sourcePaths: [...sourceFiles] };
   }
   async#libTokenStylesheets(sourceFiles) {
-    const libsRoot = path7.join(this.#app.workspace.workspaceRoot, "libs");
+    const libsRoot = path5.join(this.#app.workspace.workspaceRoot, "libs");
     const libNames = new Set;
     for (const filePath of sourceFiles) {
-      const relPath = path7.relative(libsRoot, filePath);
-      if (relPath.startsWith("..") || path7.isAbsolute(relPath))
+      const relPath = path5.relative(libsRoot, filePath);
+      if (relPath.startsWith("..") || path5.isAbsolute(relPath))
         continue;
-      const [libName] = relPath.split(path7.sep);
+      const [libName] = relPath.split(path5.sep);
       if (libName)
         libNames.add(libName);
     }
     const tokenPaths = await Promise.all([...libNames].sort().map(async (libName) => {
-      const tokensPath = path7.join(libsRoot, libName, "ui/tokens.css");
+      const tokensPath = path5.join(libsRoot, libName, "ui/tokens.css");
       return await this.#fileExists(tokensPath) ? tokensPath : null;
     }));
     return tokenPaths.filter((tokensPath) => !!tokensPath);
@@ -968,7 +643,7 @@ class CssCompiler {
     const compileStarted = Date.now();
     const compilers = await Promise.all(cssPaths.map(async (cssPath) => {
       const css = await Bun.file(cssPath).text();
-      const base = path7.dirname(cssPath);
+      const base = path5.dirname(cssPath);
       const imported2 = new Map;
       const compiler = await compile(css, {
         base,
@@ -1012,11 +687,11 @@ class CssCompiler {
     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: path7.dirname(p), content };
+    return { path: p, base: path5.dirname(p), content };
   }
   async#resolveCssImport(id, fromBase) {
     if (id.startsWith(".") || id.startsWith("/")) {
-      const filePath = path7.resolve(fromBase, id);
+      const filePath = path5.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})`);
@@ -1036,7 +711,7 @@ class CssCompiler {
   async#loadModule(id, fromBase) {
     const p = __require.resolve(id, { paths: [fromBase] });
     const mod = await import(p);
-    return { path: p, base: path7.dirname(p), module: mod.default ?? mod };
+    return { path: p, base: path5.dirname(p), module: mod.default ?? mod };
   }
   #resolveSourceImport(id, fromBase, resolvePackage) {
     const cacheKey = `${fromBase}\x00${id}`;
@@ -1049,7 +724,7 @@ class CssCompiler {
   }
   async#resolveSourceImportUncached(id, fromBase, resolvePackage) {
     if (id.startsWith(".") || id.startsWith("/")) {
-      const abs = id.startsWith("/") ? id : path7.resolve(fromBase, id);
+      const abs = id.startsWith("/") ? id : path5.resolve(fromBase, id);
       return this.#resolveSourceFileCandidate(abs);
     }
     const pkg = await resolvePackage(id);
@@ -1100,7 +775,7 @@ function resolveSourceWithRequire(id, fromBase) {
   }
 }
 function isSourceFile(filePath) {
-  return SOURCE_EXTS.includes(path7.extname(filePath));
+  return SOURCE_EXTS.includes(path5.extname(filePath));
 }
 function isIgnoredNodeModuleSource(filePath) {
   return NODE_MODULES_RE.test(filePath) && !AKANJS_NODE_MODULE_RE.test(filePath);
@@ -1110,928 +785,1204 @@ function declaredCustomProperties(css) {
   return [...new Set([...withoutThemeBlocks.matchAll(/(?:^|[\s;{])(--[\w-]+)\s*:/g)].map(([, name]) => name))].filter((name) => !!name);
 }
 function getPageKeyBasePath(pageKey, basePaths) {
-  const normalized = pageKey.split(path7.sep).join("/").replace(/^\.\//, "");
+  const normalized = pageKey.split(path5.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/fontOptimizer.ts
-import { mkdir as mkdir2, stat as stat2 } from "fs/promises";
+// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
 import path8 from "path";
-import ts2 from "typescript";
-var FONT_URL_PREFIX = "/_akan/fonts";
-var DEFAULT_FONT_SUBSETS = ["latin"];
 
-class FontOptimizer {
-  #app;
-  #command;
-  #artifactRoot;
-  #files = [];
-  #cssParts = [];
-  #woff2Ready = null;
-  static #ksX1001Text = null;
-  static #cacheVersion = 2;
-  constructor(app, command = "start") {
-    this.#app = app;
-    this.#command = command;
-    this.#artifactRoot = path8.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
-  }
-  async optimize() {
-    const fonts = await this.discoverFonts();
-    const cacheKey = await this.#buildCacheKey(fonts);
-    const cached = cacheKey ? await this.#readCache(cacheKey) : null;
-    if (cached) {
-      this.#app.verbose(`[font] reused ${cached.files.length} cached file(s); skipped subsetting`);
-      return { css: cached.css, fonts, files: cached.files };
+// pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
+import path6 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 = path6.resolve(workspaceRoot, replPath + suffix);
+        const hit = await firstExisting(candidate);
+        if (hit)
+          return hit;
+      }
     }
-    for (const font of fonts) {
-      if (!this.#isFontOptimizationEnabled(font))
+    for (const { pkg, entryFile } of rootEntries) {
+      if (spec !== pkg && !spec.startsWith(`${pkg}/`))
         continue;
-      await this.#optimizeFont(font);
+      if (spec === pkg)
+        continue;
+      const suffix = spec.slice(pkg.length + 1);
+      const pkgDir = path6.dirname(path6.resolve(workspaceRoot, entryFile));
+      const candidate = path6.join(pkgDir, suffix);
+      const hit = await firstExisting(candidate);
+      if (hit)
+        return hit;
     }
-    const fontUtilityCss = this.#buildFontUtilityRules(fonts);
-    if (fontUtilityCss)
-      this.#cssParts.push(fontUtilityCss);
-    const result = { css: this.#cssParts.join(`
-`), fonts, files: this.#files };
-    if (cacheKey)
-      await this.#writeCache(cacheKey, result);
-    return result;
-  }
-  get #cachePath() {
-    return path8.join(this.#artifactRoot, "fontCache.json");
+    return null;
   }
-  async#buildCacheKey(fonts) {
-    const sources = [];
-    for (const font of fonts) {
-      if (!this.#isFontOptimizationEnabled(font))
-        continue;
-      for (const face of this.#getFontFaces(font)) {
-        const sourcePath = await this.#resolveFontSourcePath(face.src);
-        const stamp = sourcePath ? await this.#fileStamp(sourcePath) : null;
-        if (!stamp)
-          return null;
-        sources.push({ optimizedSrc: face.optimizedSrc, ...stamp });
-      }
-      for (const filePath of font.subsetFiles ?? []) {
-        const abs = path8.isAbsolute(filePath) ? filePath : path8.join(this.#app.cwdPath, filePath);
-        const stamp = await this.#fileStamp(abs);
-        if (!stamp)
-          return null;
-        sources.push({ subsetFile: filePath, ...stamp });
-      }
-      if (this.#getFontSubsets(font).includes("auto"))
-        sources.push({ autoSubsetText: this.#cacheDigest(await this.#collectAutoSubsetText()) });
+  return {
+    name: "akan-externalize-framework",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, async (args) => {
+        const spec = args.path;
+        if (spec === "." || spec === ".." || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/"))
+          return;
+        if (extraExact.has(spec) || DEFAULT_EXCLUDE_EXACT.has(spec))
+          return { path: spec, external: true };
+        for (const prefix of DEFAULT_EXCLUDE_PREFIX) {
+          if (spec.startsWith(prefix))
+            return { path: spec, external: true };
+        }
+        if (OPTIONAL_BACKEND_EXTERNAL_EXACT.has(spec))
+          return { path: spec, external: true };
+        if (RUNTIME_EXTERNAL_EXACT.has(spec))
+          return { path: spec, external: true };
+        for (const prefix of RUNTIME_EXTERNAL_PREFIX) {
+          if (spec.startsWith(prefix))
+            return { path: spec, external: true };
+        }
+        for (const prefix of includePrefixes) {
+          if (!spec.startsWith(prefix))
+            continue;
+          const resolved = await resolveWorkspaceSubpath(spec);
+          if (resolved)
+            return { path: resolved };
+          return;
+        }
+        return;
+      });
     }
-    return this.#cacheDigest({ version: FontOptimizer.#cacheVersion, fonts, sources });
+  };
+}
+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;
   }
-  #cacheDigest(value) {
-    return new Bun.CryptoHasher("sha256").update(this.#stableStringify(value)).digest("hex");
+  for (const ext of CANDIDATE_EXTS) {
+    const candidate = path6.join(basePath, `index${ext}`);
+    if (await Bun.file(candidate).exists())
+      return candidate;
   }
-  async#fileStamp(filePath) {
-    try {
-      const stats = await stat2(filePath);
-      return { mtimeMs: Math.round(stats.mtimeMs), size: stats.size };
-    } catch {
-      return null;
+  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) };
+      });
     }
+  };
+}
+function loaderFor(absPath) {
+  if (absPath.endsWith(".tsx"))
+    return "tsx";
+  if (absPath.endsWith(".jsx"))
+    return "jsx";
+  if (absPath.endsWith(".ts"))
+    return "ts";
+  return "js";
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
+import path7 from "path";
+class PagesEntrySourceGenerator {
+  #pageEntries;
+  constructor(pageEntries) {
+    this.#pageEntries = pageEntries;
   }
-  async#readCache(key) {
-    const cache = await Bun.file(this.#cachePath).json().catch(() => null);
-    if (cache?.version !== FontOptimizer.#cacheVersion || cache.key !== key)
-      return null;
-    const files = cache.files.map((relativePath) => path8.join(this.#artifactRoot, relativePath));
-    for (const filePath of files) {
-      if (!await Bun.file(filePath).exists())
-        return null;
-    }
-    return { css: cache.css, files };
+  static generate(pageEntries) {
+    return new PagesEntrySourceGenerator(pageEntries).generate();
   }
-  async#writeCache(key, result) {
-    const cache = {
-      version: FontOptimizer.#cacheVersion,
-      key,
-      css: result.css,
-      files: result.files.map((filePath) => path8.relative(this.#artifactRoot, filePath))
-    };
-    await Bun.write(this.#cachePath, JSON.stringify(cache));
+  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(`
+`)}
+};
+`;
   }
-  async discoverFonts() {
-    const pageKeys = await this.#app.getPageKeys();
-    const fonts = [];
-    await Promise.all(pageKeys.map(async (key) => {
-      const filePath = path8.resolve(this.#app.cwdPath, "page", key);
-      const file = Bun.file(filePath);
-      if (!await file.exists())
-        return;
-      const source = await file.text();
-      if (!source.includes("fonts"))
-        return;
-      fonts.push(...this.#extractFontsExport(source, filePath));
+  static async generateStatic(pageEntries) {
+    return await new PagesEntrySourceGenerator(pageEntries).generateStatic();
+  }
+  async generateStatic() {
+    const imports = this.#pageEntries.map(({ moduleAbsPath }, index) => {
+      const specifier = 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 AsyncDefaultExportDetector.detect(moduleAbsPath);
+      return `  ${JSON.stringify(key)}: { loader: async () => page${index}, isAsyncDefault: ${isAsyncDefault} },`;
     }));
-    return this.#dedupeFonts(fonts);
+    return `${imports.join(`
+`)}
+export const pages = {
+${entries.join(`
+`)}
+};
+`;
   }
-  async#optimizeFont(font) {
-    const faceCss = [];
-    for (const face of this.#getFontFaces(font)) {
-      const sourcePath = await this.#resolveFontSourcePath(face.src);
-      if (!sourcePath) {
-        this.#app.logger.warn(`[font] source not found: ${face.src}`);
-        continue;
-      }
-      const outputPath = path8.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
-      await mkdir2(path8.dirname(outputPath), { recursive: true });
-      const sourceBuffer = Buffer.from(await Bun.file(sourcePath).arrayBuffer());
-      const outputBuffer = await this.#buildFontBuffer(font, sourceBuffer, sourcePath);
-      await Bun.write(outputPath, outputBuffer);
-      this.#files.push(outputPath);
-      faceCss.push(this.#buildOptimizedFontFaceRule(font, face));
-      const fallbackCss = await this.#buildFontaineFallbackCss(font, face, outputPath);
-      if (fallbackCss)
-        faceCss.push(fallbackCss);
-    }
-    if (faceCss.length > 0)
-      this.#cssParts.push(...faceCss, this.#buildRootVariableRule(font));
+  static #toImportSpecifier(moduleAbsPath) {
+    return path7.resolve(moduleAbsPath).split(path7.sep).join("/");
   }
-  #extractFontsExport(source, filePath) {
-    const sourceFile = ts2.createSourceFile(filePath, source, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TSX);
-    const fonts = [];
-    for (const statement of sourceFile.statements) {
-      if (!ts2.isVariableStatement(statement))
-        continue;
-      const modifiers = ts2.canHaveModifiers(statement) ? ts2.getModifiers(statement) : undefined;
-      const isExported = modifiers?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword) ?? false;
-      if (!isExported)
-        continue;
-      for (const declaration of statement.declarationList.declarations) {
-        if (!ts2.isIdentifier(declaration.name) || declaration.name.text !== "fonts")
-          continue;
-        const value = declaration.initializer ? this.#literalToValue(declaration.initializer) : null;
-        if (Array.isArray(value)) {
-          fonts.push(...value.map((font) => this.#withFontDefaults(font)));
-        }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
+var VIRTUAL_PAGES_ENTRY = "akan-pages-entry";
+
+class PagesBundleBuilder {
+  #app;
+  #command;
+  #pageEntries;
+  #started = Date.now();
+  constructor(app, command = "start", pageEntries) {
+    this.#app = app;
+    this.#command = command;
+    this.#pageEntries = pageEntries;
+  }
+  async build() {
+    const akanConfig = await this.#app.getConfig();
+    const resolvedEntries = this.#pageEntries ?? await resolveSsrPageEntriesForApp(this.#app, await this.#app.getPageKeys());
+    const entrySource = PagesEntrySourceGenerator.generate(resolvedEntries);
+    const workspaceRoot = this.#app.workspace.workspaceRoot;
+    const result = await Bun.build({
+      entrypoints: [VIRTUAL_PAGES_ENTRY],
+      outdir: `${this.#artifactDir}/server`,
+      target: "bun",
+      format: "esm",
+      splitting: this.#splitting,
+      minify: this.#command === "build",
+      naming: {
+        entry: "pages-[hash].[ext]",
+        chunk: "chunks/[name]-[hash].[ext]",
+        asset: "assets/[name]-[hash].[ext]"
+      },
+      define: this.#define(),
+      plugins: [
+        PagesBundleBuilder.createPagesEntryPlugin(entrySource),
+        PagesBundleBuilder.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 = path8.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] ${path8.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
+    return {
+      bundlePath,
+      buildId,
+      splitting: this.#splitting,
+      entryBytes: entryArtifact.size,
+      outputBytes,
+      outputCount: result.outputs.length,
+      chunkCount
+    };
+  }
+  get #artifactDir() {
+    return `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
+  }
+  get #splitting() {
+    return process.env.AKAN_SERVER_PAGES_SPLITTING === "1";
+  }
+  #define() {
+    const nodeEnv = this.#command === "build" ? "production" : "development";
+    return {
+      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("ssr"),
+      ...Object.fromEntries(Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
+    };
+  }
+  static createPagesEntryPlugin(source) {
+    return {
+      name: "akan-pages-entry",
+      setup(build) {
+        build.onResolve({ filter: /^akan-pages-entry$/ }, () => ({
+          path: VIRTUAL_PAGES_ENTRY,
+          namespace: "akan-virtual"
+        }));
+        build.onLoad({ filter: /^akan-pages-entry$/, namespace: "akan-virtual" }, () => ({
+          contents: source,
+          loader: "tsx"
+        }));
       }
-    }
-    return fonts;
+    };
   }
-  #literalToValue(node) {
-    if (ts2.isStringLiteralLike(node))
-      return node.text;
-    if (ts2.isNumericLiteral(node))
-      return Number(node.text);
-    if (node.kind === ts2.SyntaxKind.TrueKeyword)
-      return true;
-    if (node.kind === ts2.SyntaxKind.FalseKeyword)
-      return false;
-    if (ts2.isArrayLiteralExpression(node))
-      return node.elements.map((element) => this.#literalToValue(element));
-    if (ts2.isObjectLiteralExpression(node)) {
-      const obj = {};
-      for (const prop of node.properties) {
-        if (!ts2.isPropertyAssignment(prop))
-          continue;
-        const name = this.#getPropertyName(prop.name);
-        if (!name)
-          continue;
-        obj[name] = this.#literalToValue(prop.initializer);
+  static createCssStubPlugin() {
+    return {
+      name: "akan-css-stub",
+      setup(build) {
+        build.onLoad({ filter: /\.css$/ }, () => ({
+          contents: "",
+          loader: "js"
+        }));
       }
-      return obj;
-    }
-    if (ts2.isAsExpression(node) || ts2.isSatisfiesExpression(node) || ts2.isParenthesizedExpression(node)) {
-      return this.#literalToValue(node.expression);
-    }
-    return;
+    };
   }
-  #getPropertyName(name) {
-    if (ts2.isIdentifier(name) || ts2.isStringLiteral(name) || ts2.isNumericLiteral(name))
-      return name.text;
-    return null;
+  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: loaderFor2(args.path) };
+        });
+      }
+    };
   }
-  #dedupeFonts(fonts) {
-    const map = new Map;
-    for (const font of fonts)
-      map.set(JSON.stringify(font), font);
-    return [...map.values()];
+  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 });");
   }
-  #withFontDefaults(font) {
-    return { ...font, subsets: font.subsets ?? [...DEFAULT_FONT_SUBSETS] };
+}
+function loaderFor2(absPath) {
+  if (absPath.endsWith(".tsx"))
+    return "tsx";
+  if (absPath.endsWith(".jsx"))
+    return "jsx";
+  if (absPath.endsWith(".ts"))
+    return "ts";
+  return "js";
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
+import { mkdir, rm, unlink } from "fs/promises";
+import path9 from "path";
+class CsrArtifactBuilder {
+  #app;
+  #command;
+  #lang;
+  constructor(app, command = "start", lang = "en") {
+    this.#app = app;
+    this.#command = command;
+    this.#lang = lang;
   }
-  #getFontSubsets(font) {
-    return font.subsets ?? DEFAULT_FONT_SUBSETS;
+  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: this.#define(),
+      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 };
   }
-  #getFontVariableName(font) {
-    return font.variable ?? `--font-${font.name}`;
+  static pageEntriesForBasePath(pageEntries, basePath, basePaths) {
+    return pageEntries.filter((entry) => {
+      const entryBasePath = getPageKeyBasePath(entry.key, basePaths);
+      return entryBasePath === null || entryBasePath === basePath;
+    });
   }
-  #getFontFallbackName(font) {
-    return font.fallbackName ?? `${font.name} fallback`;
+  static htmlFilename(basePath) {
+    return `${basePath || "index"}.html`;
   }
-  #isFontOptimizationEnabled(font) {
-    return font.optimize !== false;
+  static entryFilename(basePath) {
+    return `${basePath || "index"}.csr.tsx`;
   }
-  #getFontStyles(font) {
-    return font.styles?.length ? font.styles : ["normal"];
+  static basePathOfHtml(htmlPath) {
+    const name = path9.basename(htmlPath, ".html");
+    return name === "index" ? "" : name;
   }
-  #getFontFaces(font) {
-    const enabledStyles = new Set(this.#getFontStyles(font));
-    return font.paths.map((fontPath) => {
-      const style = fontPath.style ?? "normal";
-      return {
-        font,
-        path: fontPath,
-        src: fontPath.src,
-        weight: fontPath.weight,
-        style,
-        optimizedSrc: this.#getOptimizedFontSrc(font, fontPath)
-      };
-    }).filter((face) => enabledStyles.has(face.style));
+  get #outputDir() {
+    return path9.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
   }
-  #getOptimizedFontSrc(font, fontPath) {
-    const style = fontPath.style ?? "normal";
-    const hash = this.#hashFontConfig({
-      name: font.name,
-      src: fontPath.src,
-      weight: fontPath.weight,
-      style,
-      display: font.display,
-      subset: font.subset,
-      subsets: this.#getFontSubsets(font),
-      subsetText: font.subsetText,
-      subsetFiles: font.subsetFiles,
-      declarations: [...font.declarations ?? [], ...fontPath.declarations ?? []]
-    });
-    return `${FONT_URL_PREFIX}/${this.#slugFontPart(font.name)}-${this.#slugFontPart(String(fontPath.weight))}-${style}-${hash}.woff2`;
+  get #generatedDir() {
+    return path9.join(this.#app.cwdPath, ".akan/generated/csr");
   }
-  #hashFontConfig(value) {
-    const input = this.#stableStringify(value);
-    let hash = 2166136261;
-    for (let i = 0;i < input.length; i++) {
-      hash ^= input.charCodeAt(i);
-      hash = Math.imul(hash, 16777619);
-    }
-    return (hash >>> 0).toString(36);
+  get #artifactDir() {
+    return path9.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
   }
-  #stableStringify(value) {
-    if (Array.isArray(value))
-      return `[${value.map((item) => this.#stableStringify(item)).join(",")}]`;
-    if (value && typeof value === "object") {
-      const entries = Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b));
-      return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${this.#stableStringify(v)}`).join(",")}}`;
-    }
-    return JSON.stringify(value);
-  }
-  #slugFontPart(value) {
-    return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "font";
-  }
-  async#resolveFontSourcePath(src) {
-    if (!src.startsWith("/"))
-      return null;
-    const rel = src.replace(/^\//, "");
-    const candidates = [
-      this.#command === "build" ? path8.join(this.#app.dist.cwdPath, "public", rel) : null,
-      path8.join(this.#app.cwdPath, "public", rel),
-      this.#resolveWorkspacePublicPath(rel)
-    ].filter(Boolean);
-    for (const candidate of candidates) {
-      if (await Bun.file(candidate).exists())
-        return candidate;
-    }
-    return null;
-  }
-  async#buildFontBuffer(font, sourceBuffer, sourcePath) {
-    if (font.subset === false)
-      return this.#convertToWoff2(sourceBuffer, sourcePath);
-    const { default: subsetFont } = await import("subset-font");
-    return subsetFont(sourceBuffer, await this.#getSubsetText(font), { targetFormat: "woff2" });
+  #generatedPath(filename) {
+    return path9.join(this.#generatedDir, filename);
   }
-  async#convertToWoff2(buffer, sourcePath) {
-    const { createFont } = await import("fonteditor-core");
-    await this.#initWoff2();
-    const font = createFont(buffer, { type: this.#getFontType(sourcePath, buffer) });
-    return font.write({ type: "woff2", toBuffer: true });
+  #define() {
+    const nodeEnv = this.#command === "build" ? "production" : "development";
+    return {
+      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("csr"),
+      ...Object.fromEntries(Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
+    };
   }
-  async#initWoff2() {
-    this.#woff2Ready ??= import("fonteditor-core").then(({ woff2 }) => woff2.init()).then(() => {
-      return;
-    });
-    return this.#woff2Ready;
+  async#createEntryFile(basePath, pageEntries) {
+    return [
+      this.#generatedPath(CsrArtifactBuilder.entryFilename(basePath)),
+      `import { bootCsr } from "akanjs/webkit";
+${await PagesEntrySourceGenerator.generateStatic(pageEntries)}
+void bootCsr(pages);
+`
+    ];
   }
-  #getFontType(sourcePath, buffer) {
-    const signature = buffer.toString("ascii", 0, 4);
-    if (signature === "wOFF")
-      return "woff";
-    if (signature === "wOF2")
-      return "woff2";
-    if (signature === "OTTO")
-      return "otf";
-    const ext = path8.extname(sourcePath).slice(1).toLowerCase();
-    if (ext === "otf" || ext === "woff" || ext === "woff2")
-      return ext;
-    return "ttf";
+  #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>
+  `
+    ];
   }
-  #resolveWorkspacePublicPath(rel) {
-    const [root, dep, ...rest] = rel.split("/");
-    if (root !== "libs" || !dep || rest.length === 0)
-      return null;
-    return path8.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
+  async#loadCssAssets() {
+    const artifactFile = Bun.file(path9.join(this.#artifactDir, "base-artifact.json"));
+    if (!await artifactFile.exists())
+      return {};
+    const artifact = await artifactFile.json();
+    return artifact.cssAssets ?? {};
   }
-  async#getSubsetText(font) {
-    const parts = new Set;
-    const subsets = this.#getFontSubsets(font);
-    for (const subset of subsets)
-      parts.add(await this.#getSubsetPresetText(subset));
-    if (font.subsetText)
-      parts.add(font.subsetText);
-    for (const filePath of font.subsetFiles ?? []) {
-      const abs = path8.isAbsolute(filePath) ? filePath : path8.join(this.#app.cwdPath, filePath);
-      const file = Bun.file(abs);
-      if (await file.exists())
-        parts.add(await file.text());
+  async#inlineCsrArtifacts(cssAssets) {
+    const jsFiles = new Set;
+    for (const htmlPath of await this.#htmlOutputPaths()) {
+      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"}; ${path9.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(`
+`)}`);
     }
-    return [...parts].join("");
-  }
-  async#getSubsetPresetText(subset) {
-    if (subset === "latin")
-      return this.#rangeText(32, 126);
-    if (subset === "latin-ext")
-      return `${this.#rangeText(32, 126)}${this.#rangeText(160, 591)}`;
-    if (subset === "ks-x-1001")
-      return FontOptimizer.#getKsX1001Text();
-    if (subset === "auto")
-      return this.#collectAutoSubsetText();
-    return "";
   }
-  async#collectAutoSubsetText() {
-    const libPageRoots = (await this.#app.getPageRoots()).filter((root) => root.keyPrefix).map((root) => root.dir);
-    const roots = [...["page", "ui", "lib"].map((dir) => path8.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()) {
-      const isDir = await stat2(root).then((entry) => entry.isDirectory(), () => false);
-      if (!isDir)
-        continue;
-      const filePaths = [];
-      for await (const filePath of glob.scan({ cwd: root, absolute: true }))
-        filePaths.push(filePath);
-      for (const filePath of filePaths.sort())
-        parts.push(await Bun.file(filePath).text());
+  async#inlineHtmlAssets(html, htmlPath, cssAsset) {
+    let next = html;
+    if (cssAsset) {
+      const css = await Bun.file(path9.join(this.#artifactDir, cssAsset.cssRelPath)).text();
+      next = CsrArtifactBuilder.injectBeforeHeadEnd(next, CsrArtifactBuilder.createInlineStyle(css));
     }
-    return parts.join("");
+    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 };
   }
-  #rangeText(start, end) {
-    let text = "";
-    for (let code = start;code <= end; code++)
-      text += String.fromCodePoint(code);
-    return text;
+  async#htmlOutputPaths() {
+    return await this.#listOutputFiles((filePath) => filePath.endsWith(".html"));
   }
-  static #getKsX1001Text() {
-    if (FontOptimizer.#ksX1001Text)
-      return FontOptimizer.#ksX1001Text;
-    try {
-      const decoder = new TextDecoder("euc-kr");
-      const chars = new Set;
-      for (let lead = 161;lead <= 254; lead++) {
-        for (let trail = 161;trail <= 254; trail++) {
-          const char = decoder.decode(Uint8Array.of(lead, trail));
-          if (char && char !== "\uFFFD")
-            chars.add(char);
-        }
-      }
-      FontOptimizer.#ksX1001Text = [...chars].join("");
-    } catch {
-      FontOptimizer.#ksX1001Text = FontOptimizer.#rangeTextStatic(44032, 55203);
+  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 FontOptimizer.#ksX1001Text;
+    return files.sort();
   }
-  static #rangeTextStatic(start, end) {
-    let text = "";
-    for (let code = start;code <= end; code++)
-      text += String.fromCodePoint(code);
-    return text;
+  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));
   }
-  #buildOptimizedFontFaceRule(font, face) {
-    const declarations = [
-      ["font-family", this.#quote(font.name)],
-      ["src", `url(${this.#quote(face.optimizedSrc)}) format("woff2")`],
-      ["font-weight", String(face.weight)],
-      ["font-style", face.style],
-      ["font-display", font.display ?? "swap"],
-      ...this.#toDeclarationEntries(font.declarations),
-      ...this.#toDeclarationEntries(face.path.declarations)
-    ];
-    return `@font-face {
-${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
-`)}
-}`;
+  static createInlineStyle(css) {
+    return `<style data-akan-css="active">
+${css.replace(/<\/style/gi, "<\\/style")}
+</style>`;
   }
-  async#buildFontaineFallbackCss(font, face, outputPath) {
-    if (font.adjustFontFallback === false)
-      return "";
-    const { generateFontFace, getMetricsForFamily, readMetrics, resolveCategoryFallbacks } = await import("fontaine");
-    const metrics = await readMetrics(outputPath).catch(() => null);
-    if (!metrics)
-      return "";
-    const fallbacks = resolveCategoryFallbacks({
-      fontFamily: font.name,
-      fallbacks: font.fallbacks ?? {},
-      metrics: { ...metrics, category: font.category }
-    });
-    const css = [];
-    for (let i = fallbacks.length - 1;i >= 0; i--) {
-      const fallback = fallbacks[i];
-      const fallbackMetrics = await getMetricsForFamily(fallback);
-      if (!fallbackMetrics)
+  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;
-      css.push(generateFontFace({ ...metrics, category: font.category }, {
-        name: this.#getFontFallbackName(font),
-        font: fallback,
-        metrics: fallbackMetrics,
-        "font-weight": String(face.weight),
-        "font-style": face.style
-      }));
+      matched = true;
+      result += html.slice(lastIndex, match.index);
+      result += `<script type="module">
+${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
+</script>`;
+      lastIndex = match.index + full.length;
     }
-    return css.join("");
+    if (!matched)
+      return html;
+    return result + html.slice(lastIndex);
   }
-  #buildRootVariableRule(font) {
-    return `:root { ${this.#getFontVariableName(font)}: ${this.#quote(font.name)}, ${this.#quote(this.#getFontFallbackName(font))}; }`;
+  static escapeInlineScript(source) {
+    return source.replace(/<\/script/gi, "<\\/script");
   }
-  #buildFontUtilityRules(fonts) {
-    const rules = [];
-    const seen = new Set;
-    for (const font of fonts) {
-      const className = font.className || `font-${font.name}`;
-      const selector = `.${this.#escapeCssClassName(className)}`;
-      const rule = `${selector} { font-family: var(${this.#getFontVariableName(font)}); }`;
-      if (seen.has(rule))
-        continue;
-      seen.add(rule);
-      rules.push(rule);
+  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}`);
     }
-    return rules.join(`
-`);
-  }
-  #escapeCssClassName(value) {
-    return value.replace(/^-?\d|[^a-zA-Z0-9_-]/g, (part) => [...part].map((char) => `\\${char.codePointAt(0)?.toString(16)} `).join(""));
-  }
-  #toDeclarationEntries(declarations = []) {
-    return declarations.map((declaration) => [declaration.prop, declaration.value]);
-  }
-  #quote(value) {
-    return JSON.stringify(value);
+    const normalized = src.startsWith("/") ? src.slice(1) : src;
+    return path9.resolve(path9.dirname(htmlPath), normalized);
   }
 }
 
-// pkgs/@akanjs/devkit/frontendBuild/fontPruner.ts
-import { rm as rm2, rmdir, stat as stat3 } from "fs/promises";
-import path9 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}";
+// pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
+import { mkdir as mkdir2, stat as stat2 } from "fs/promises";
+import path10 from "path";
+import ts from "typescript";
+var FONT_URL_PREFIX = "/_akan/fonts";
+var DEFAULT_FONT_SUBSETS = ["latin"];
 
-class FontPruner {
+class FontOptimizer {
   #app;
-  #keepGlobs;
-  #publicRoot;
+  #command;
   #artifactRoot;
-  constructor(app, { keepFonts = [] } = {}) {
+  #files = [];
+  #cssParts = [];
+  #woff2Ready = null;
+  static #ksX1001Text = null;
+  static #cacheVersion = 2;
+  constructor(app, command = "start") {
     this.#app = app;
-    this.#keepGlobs = keepFonts;
-    this.#publicRoot = path9.join(app.dist.cwdPath, "public");
-    this.#artifactRoot = path9.join(app.dist.cwdPath, ".akan/artifact");
+    this.#command = command;
+    this.#artifactRoot = path10.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
   }
-  async prune() {
-    const empty = { removed: [], kept: [], freedBytes: 0 };
-    if (!await this.#isDirectory(this.#publicRoot))
-      return empty;
-    const candidates = await this.#collectCandidates();
-    if (!candidates.length)
-      return empty;
-    const fonts = await new FontOptimizer(this.#app, "build").discoverFonts();
-    const unoptimizedSrcs = new Set;
-    const optimizedSrcs = new Set;
-    for (const font of fonts) {
-      const target = isFontOptimizationEnabled(font) ? optimizedSrcs : unoptimizedSrcs;
-      for (const fontPath of font.paths)
-        target.add(path9.posix.basename(fontPath.src));
-    }
-    const result = { removed: [], kept: [], freedBytes: 0 };
-    const undecided = [];
-    for (const candidate of candidates) {
-      const reason = this.#staticKeepReason(candidate, unoptimizedSrcs);
-      if (reason)
-        result.kept.push({ file: candidate.rel, bytes: candidate.bytes, reason });
-      else
-        undecided.push(candidate);
+  async optimize() {
+    const fonts = await this.discoverFonts();
+    const cacheKey = await this.#buildCacheKey(fonts);
+    const cached = cacheKey ? await this.#readCache(cacheKey) : null;
+    if (cached) {
+      this.#app.verbose(`[font] reused ${cached.files.length} cached file(s); skipped subsetting`);
+      return { css: cached.css, fonts, files: cached.files };
     }
-    if (undecided.length) {
-      const referrers = await this.#findReferrers(undecided, optimizedSrcs);
-      for (const candidate of undecided) {
-        const referrer = referrers.get(candidate.rel);
-        if (referrer)
-          result.kept.push({ file: candidate.rel, bytes: candidate.bytes, reason: { kind: "referenced", referrer } });
-        else
-          result.removed.push({ file: candidate.rel, bytes: candidate.bytes });
-      }
+    for (const font of fonts) {
+      if (!this.#isFontOptimizationEnabled(font))
+        continue;
+      await this.#optimizeFont(font);
     }
-    await this.#remove(result.removed.map(({ file }) => file));
-    result.freedBytes = result.removed.reduce((total, { bytes }) => total + bytes, 0);
-    this.#report(result);
+    const fontUtilityCss = this.#buildFontUtilityRules(fonts);
+    if (fontUtilityCss)
+      this.#cssParts.push(fontUtilityCss);
+    const result = { css: this.#cssParts.join(`
+`), fonts, files: this.#files };
+    if (cacheKey)
+      await this.#writeCache(cacheKey, result);
     return result;
   }
-  #staticKeepReason(candidate, unoptimizedSrcs) {
-    if (unoptimizedSrcs.has(candidate.basename))
-      return { kind: "unoptimized" };
-    for (const glob of this.#keepGlobs) {
-      if (new Bun.Glob(glob).match(candidate.rel))
-        return { kind: "declared", glob };
-    }
-    return null;
+  get #cachePath() {
+    return path10.join(this.#artifactRoot, "fontCache.json");
   }
-  async#collectCandidates() {
-    const candidates = [];
-    for await (const rel of new Bun.Glob(FONT_GLOB).scan({ cwd: this.#publicRoot, dot: false })) {
-      const entry = await stat3(path9.join(this.#publicRoot, rel)).catch(() => null);
-      if (!entry?.isFile())
+  async#buildCacheKey(fonts) {
+    const sources = [];
+    for (const font of fonts) {
+      if (!this.#isFontOptimizationEnabled(font))
         continue;
-      candidates.push({ rel: rel.split(path9.sep).join("/"), basename: path9.basename(rel), bytes: entry.size });
+      for (const face of this.#getFontFaces(font)) {
+        const sourcePath = await this.#resolveFontSourcePath(face.src);
+        const stamp = sourcePath ? await this.#fileStamp(sourcePath) : null;
+        if (!stamp)
+          return null;
+        sources.push({ optimizedSrc: face.optimizedSrc, ...stamp });
+      }
+      for (const filePath of font.subsetFiles ?? []) {
+        const abs = path10.isAbsolute(filePath) ? filePath : path10.join(this.#app.cwdPath, filePath);
+        const stamp = await this.#fileStamp(abs);
+        if (!stamp)
+          return null;
+        sources.push({ subsetFile: filePath, ...stamp });
+      }
+      if (this.#getFontSubsets(font).includes("auto"))
+        sources.push({ autoSubsetText: this.#cacheDigest(await this.#collectAutoSubsetText()) });
     }
-    return candidates;
+    return this.#cacheDigest({ version: FontOptimizer.#cacheVersion, fonts, sources });
   }
-  async#findReferrers(candidates, optimizedSrcs) {
-    const referrers = new Map;
-    const authoritative = candidates;
-    const bundled = candidates.filter((candidate) => !optimizedSrcs.has(candidate.basename));
-    const roots = [
-      { dir: this.#publicRoot, label: "public", needles: authoritative },
-      { dir: path9.join(this.#artifactRoot, "styles"), label: ".akan/artifact/styles", needles: authoritative },
-      { dir: path9.join(this.#artifactRoot, "client"), label: ".akan/artifact/client", needles: bundled },
-      { dir: path9.join(this.#artifactRoot, "client-ssr"), label: ".akan/artifact/client-ssr", needles: bundled },
-      { dir: path9.join(this.#artifactRoot, "server"), label: ".akan/artifact/server", needles: bundled },
-      { dir: path9.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));
-      if (!pending.length || !await this.#isDirectory(root.dir))
-        continue;
-      await this.#scanRoot(root, pending, referrers);
+  #cacheDigest(value) {
+    return new Bun.CryptoHasher("sha256").update(this.#stableStringify(value)).digest("hex");
+  }
+  async#fileStamp(filePath) {
+    try {
+      const stats = await stat2(filePath);
+      return { mtimeMs: Math.round(stats.mtimeMs), size: stats.size };
+    } catch {
+      return null;
     }
-    return referrers;
   }
-  async#scanRoot(root, pending, referrers) {
-    const needles = pending.map((candidate) => ({
-      rel: candidate.rel,
-      forms: [...new Set([candidate.basename, encodeURIComponent(candidate.basename)])]
-    }));
-    for await (const rel of new Bun.Glob(REFERRER_GLOB).scan({ cwd: root.dir, dot: false })) {
-      const remaining = needles.filter((needle) => !referrers.has(needle.rel));
-      if (!remaining.length)
-        return;
-      const text = await Bun.file(path9.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(path9.sep).join("/")}`);
-      }
+  async#readCache(key) {
+    const cache = await Bun.file(this.#cachePath).json().catch(() => null);
+    if (cache?.version !== FontOptimizer.#cacheVersion || cache.key !== key)
+      return null;
+    const files = cache.files.map((relativePath) => path10.join(this.#artifactRoot, relativePath));
+    for (const filePath of files) {
+      if (!await Bun.file(filePath).exists())
+        return null;
     }
+    return { css: cache.css, files };
   }
-  async#remove(files) {
-    await Promise.all(files.map((file) => rm2(path9.join(this.#publicRoot, file), { force: true })));
-    const dirs = [...new Set(files.map((file) => path9.posix.dirname(file)))].filter((dir) => dir !== "." && dir !== "/").sort((a, b) => b.length - a.length);
-    for (const dir of dirs)
-      await rmdir(path9.join(this.#publicRoot, dir)).catch(() => {
+  async#writeCache(key, result) {
+    const cache = {
+      version: FontOptimizer.#cacheVersion,
+      key,
+      css: result.css,
+      files: result.files.map((filePath) => path10.relative(this.#artifactRoot, filePath))
+    };
+    await Bun.write(this.#cachePath, JSON.stringify(cache));
+  }
+  async discoverFonts() {
+    const pageKeys = await this.#app.getPageKeys();
+    const fonts = [];
+    await Promise.all(pageKeys.map(async (key) => {
+      const filePath = path10.resolve(this.#app.cwdPath, "page", key);
+      const file = Bun.file(filePath);
+      if (!await file.exists())
         return;
-      });
+      const source = await file.text();
+      if (!source.includes("fonts"))
+        return;
+      fonts.push(...this.#extractFontsExport(source, filePath));
+    }));
+    return this.#dedupeFonts(fonts);
   }
-  #report(result) {
-    if (!result.removed.length && !result.kept.length)
-      return;
-    for (const { file, bytes } of result.removed)
-      this.#app.verbose(`[font-prune] dropped public/${file} (${FontPruner.formatBytes(bytes)})`);
-    for (const { file, reason } of result.kept)
-      this.#app.verbose(`[font-prune] kept public/${file} \u2014 ${FontPruner.describe(reason)}`);
-    const byReferrer = new Map;
-    for (const { bytes, reason } of result.kept) {
-      if (reason.kind !== "referenced")
+  async#optimizeFont(font) {
+    const faceCss = [];
+    for (const face of this.#getFontFaces(font)) {
+      const sourcePath = await this.#resolveFontSourcePath(face.src);
+      if (!sourcePath) {
+        this.#app.logger.warn(`[font] source not found: ${face.src}`);
         continue;
-      const entry = byReferrer.get(reason.referrer) ?? { files: 0, bytes: 0 };
-      entry.files += 1;
-      entry.bytes += bytes;
-      byReferrer.set(reason.referrer, entry);
+      }
+      const outputPath = path10.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
+      await mkdir2(path10.dirname(outputPath), { recursive: true });
+      const sourceBuffer = Buffer.from(await Bun.file(sourcePath).arrayBuffer());
+      const outputBuffer = await this.#buildFontBuffer(font, sourceBuffer, sourcePath);
+      await Bun.write(outputPath, outputBuffer);
+      this.#files.push(outputPath);
+      faceCss.push(this.#buildOptimizedFontFaceRule(font, face));
+      const fallbackCss = await this.#buildFontaineFallbackCss(font, face, outputPath);
+      if (fallbackCss)
+        faceCss.push(fallbackCss);
     }
-    if (!byReferrer.size)
-      return;
-    const ranked = [...byReferrer.entries()].sort(([, a], [, b]) => b.bytes - a.bytes);
-    const named = ranked.slice(0, 3).map(([referrer, { files, bytes }]) => `${referrer} (${files}, ${FontPruner.formatBytes(bytes)})`);
-    const rest = ranked.length - named.length;
-    this.#app.logger.info(`[font-prune] kept ${FontPruner.formatBytes(ranked.reduce((total, [, entry]) => total + entry.bytes, 0))} of fonts in public/ because these reference them: ${named.join(", ")}${rest > 0 ? ` and ${rest} more` : ""}`);
+    if (faceCss.length > 0)
+      this.#cssParts.push(...faceCss, this.#buildRootVariableRule(font));
   }
-  static describe(reason) {
-    if (reason.kind === "unoptimized")
-      return "declared with optimize: false, so the runtime CSS serves it";
-    if (reason.kind === "declared")
-      return `kept by assets.keepFonts "${reason.glob}"`;
-    return `referenced by ${reason.referrer}`;
+  #extractFontsExport(source, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const fonts = [];
+    for (const statement of sourceFile.statements) {
+      if (!ts.isVariableStatement(statement))
+        continue;
+      const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
+      const isExported = modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+      if (!isExported)
+        continue;
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(declaration.name) || declaration.name.text !== "fonts")
+          continue;
+        const value = declaration.initializer ? this.#literalToValue(declaration.initializer) : null;
+        if (Array.isArray(value)) {
+          fonts.push(...value.map((font) => this.#withFontDefaults(font)));
+        }
+      }
+    }
+    return fonts;
   }
-  static formatBytes(bytes) {
-    if (bytes < 1024)
-      return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-      return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+  #literalToValue(node) {
+    if (ts.isStringLiteralLike(node))
+      return node.text;
+    if (ts.isNumericLiteral(node))
+      return Number(node.text);
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+      return true;
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+      return false;
+    if (ts.isArrayLiteralExpression(node))
+      return node.elements.map((element) => this.#literalToValue(element));
+    if (ts.isObjectLiteralExpression(node)) {
+      const obj = {};
+      for (const prop of node.properties) {
+        if (!ts.isPropertyAssignment(prop))
+          continue;
+        const name = this.#getPropertyName(prop.name);
+        if (!name)
+          continue;
+        obj[name] = this.#literalToValue(prop.initializer);
+      }
+      return obj;
+    }
+    if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node)) {
+      return this.#literalToValue(node.expression);
+    }
+    return;
   }
-  async#isDirectory(dir) {
-    return await stat3(dir).then((entry) => entry.isDirectory(), () => false);
+  #getPropertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+      return name.text;
+    return null;
   }
-}
-
-// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-import path11 from "path";
-
-// pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
-import path10 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)
+  #dedupeFonts(fonts) {
+    const map = new Map;
+    for (const font of fonts)
+      map.set(JSON.stringify(font), font);
+    return [...map.values()];
+  }
+  #withFontDefaults(font) {
+    return { ...font, subsets: font.subsets ?? [...DEFAULT_FONT_SUBSETS] };
+  }
+  #getFontSubsets(font) {
+    return font.subsets ?? DEFAULT_FONT_SUBSETS;
+  }
+  #getFontVariableName(font) {
+    return font.variable ?? `--font-${font.name}`;
+  }
+  #getFontFallbackName(font) {
+    return font.fallbackName ?? `${font.name} fallback`;
+  }
+  #isFontOptimizationEnabled(font) {
+    return font.optimize !== false;
+  }
+  #getFontStyles(font) {
+    return font.styles?.length ? font.styles : ["normal"];
+  }
+  #getFontFaces(font) {
+    const enabledStyles = new Set(this.#getFontStyles(font));
+    return font.paths.map((fontPath) => {
+      const style = fontPath.style ?? "normal";
+      return {
+        font,
+        path: fontPath,
+        src: fontPath.src,
+        weight: fontPath.weight,
+        style,
+        optimizedSrc: this.#getOptimizedFontSrc(font, fontPath)
+      };
+    }).filter((face) => enabledStyles.has(face.style));
+  }
+  #getOptimizedFontSrc(font, fontPath) {
+    const style = fontPath.style ?? "normal";
+    const hash = this.#hashFontConfig({
+      name: font.name,
+      src: fontPath.src,
+      weight: fontPath.weight,
+      style,
+      display: font.display,
+      subset: font.subset,
+      subsets: this.#getFontSubsets(font),
+      subsetText: font.subsetText,
+      subsetFiles: font.subsetFiles,
+      declarations: [...font.declarations ?? [], ...fontPath.declarations ?? []]
+    });
+    return `${FONT_URL_PREFIX}/${this.#slugFontPart(font.name)}-${this.#slugFontPart(String(fontPath.weight))}-${style}-${hash}.woff2`;
+  }
+  #hashFontConfig(value) {
+    const input = this.#stableStringify(value);
+    let hash = 2166136261;
+    for (let i = 0;i < input.length; i++) {
+      hash ^= input.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+  }
+  #stableStringify(value) {
+    if (Array.isArray(value))
+      return `[${value.map((item) => this.#stableStringify(item)).join(",")}]`;
+    if (value && typeof value === "object") {
+      const entries = Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b));
+      return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${this.#stableStringify(v)}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+  }
+  #slugFontPart(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "font";
+  }
+  async#resolveFontSourcePath(src) {
+    if (!src.startsWith("/"))
       return null;
-    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 = path10.resolve(workspaceRoot, replPath + suffix);
-        const hit = await firstExisting(candidate);
-        if (hit)
-          return hit;
-      }
+    const rel = src.replace(/^\//, "");
+    const candidates = [
+      this.#command === "build" ? path10.join(this.#app.dist.cwdPath, "public", rel) : null,
+      path10.join(this.#app.cwdPath, "public", rel),
+      this.#resolveWorkspacePublicPath(rel)
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+      if (await Bun.file(candidate).exists())
+        return candidate;
     }
-    for (const { pkg, entryFile } of rootEntries) {
-      if (spec !== pkg && !spec.startsWith(`${pkg}/`))
-        continue;
-      if (spec === pkg)
+    return null;
+  }
+  async#buildFontBuffer(font, sourceBuffer, sourcePath) {
+    if (font.subset === false)
+      return this.#convertToWoff2(sourceBuffer, sourcePath);
+    const { default: subsetFont } = await import("subset-font");
+    return subsetFont(sourceBuffer, await this.#getSubsetText(font), { targetFormat: "woff2" });
+  }
+  async#convertToWoff2(buffer, sourcePath) {
+    const { createFont } = await import("fonteditor-core");
+    await this.#initWoff2();
+    const font = createFont(buffer, { type: this.#getFontType(sourcePath, buffer) });
+    return font.write({ type: "woff2", toBuffer: true });
+  }
+  async#initWoff2() {
+    this.#woff2Ready ??= import("fonteditor-core").then(({ woff2 }) => woff2.init()).then(() => {
+      return;
+    });
+    return this.#woff2Ready;
+  }
+  #getFontType(sourcePath, buffer) {
+    const signature = buffer.toString("ascii", 0, 4);
+    if (signature === "wOFF")
+      return "woff";
+    if (signature === "wOF2")
+      return "woff2";
+    if (signature === "OTTO")
+      return "otf";
+    const ext = path10.extname(sourcePath).slice(1).toLowerCase();
+    if (ext === "otf" || ext === "woff" || ext === "woff2")
+      return ext;
+    return "ttf";
+  }
+  #resolveWorkspacePublicPath(rel) {
+    const [root, dep, ...rest] = rel.split("/");
+    if (root !== "libs" || !dep || rest.length === 0)
+      return null;
+    return path10.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
+  }
+  async#getSubsetText(font) {
+    const parts = new Set;
+    const subsets = this.#getFontSubsets(font);
+    for (const subset of subsets)
+      parts.add(await this.#getSubsetPresetText(subset));
+    if (font.subsetText)
+      parts.add(font.subsetText);
+    for (const filePath of font.subsetFiles ?? []) {
+      const abs = path10.isAbsolute(filePath) ? filePath : path10.join(this.#app.cwdPath, filePath);
+      const file = Bun.file(abs);
+      if (await file.exists())
+        parts.add(await file.text());
+    }
+    return [...parts].join("");
+  }
+  async#getSubsetPresetText(subset) {
+    if (subset === "latin")
+      return this.#rangeText(32, 126);
+    if (subset === "latin-ext")
+      return `${this.#rangeText(32, 126)}${this.#rangeText(160, 591)}`;
+    if (subset === "ks-x-1001")
+      return FontOptimizer.#getKsX1001Text();
+    if (subset === "auto")
+      return this.#collectAutoSubsetText();
+    return "";
+  }
+  async#collectAutoSubsetText() {
+    const libPageRoots = (await this.#app.getPageRoots()).filter((root) => root.keyPrefix).map((root) => root.dir);
+    const roots = [...["page", "ui", "lib"].map((dir) => path10.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()) {
+      const isDir = await stat2(root).then((entry) => entry.isDirectory(), () => false);
+      if (!isDir)
         continue;
-      const suffix = spec.slice(pkg.length + 1);
-      const pkgDir = path10.dirname(path10.resolve(workspaceRoot, entryFile));
-      const candidate = path10.join(pkgDir, suffix);
-      const hit = await firstExisting(candidate);
-      if (hit)
-        return hit;
+      const filePaths = [];
+      for await (const filePath of glob.scan({ cwd: root, absolute: true }))
+        filePaths.push(filePath);
+      for (const filePath of filePaths.sort())
+        parts.push(await Bun.file(filePath).text());
     }
-    return null;
+    return parts.join("");
   }
-  return {
-    name: "akan-externalize-framework",
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, async (args) => {
-        const spec = args.path;
-        if (spec === "." || spec === ".." || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/"))
-          return;
-        if (extraExact.has(spec) || DEFAULT_EXCLUDE_EXACT.has(spec))
-          return { path: spec, external: true };
-        for (const prefix of DEFAULT_EXCLUDE_PREFIX) {
-          if (spec.startsWith(prefix))
-            return { path: spec, external: true };
-        }
-        if (OPTIONAL_BACKEND_EXTERNAL_EXACT.has(spec))
-          return { path: spec, external: true };
-        if (RUNTIME_EXTERNAL_EXACT.has(spec))
-          return { path: spec, external: true };
-        for (const prefix of RUNTIME_EXTERNAL_PREFIX) {
-          if (spec.startsWith(prefix))
-            return { path: spec, external: true };
-        }
-        for (const prefix of includePrefixes) {
-          if (!spec.startsWith(prefix))
-            continue;
-          const resolved = await resolveWorkspaceSubpath(spec);
-          if (resolved)
-            return { path: resolved };
-          return;
+  #rangeText(start, end) {
+    let text = "";
+    for (let code = start;code <= end; code++)
+      text += String.fromCodePoint(code);
+    return text;
+  }
+  static #getKsX1001Text() {
+    if (FontOptimizer.#ksX1001Text)
+      return FontOptimizer.#ksX1001Text;
+    try {
+      const decoder = new TextDecoder("euc-kr");
+      const chars = new Set;
+      for (let lead = 161;lead <= 254; lead++) {
+        for (let trail = 161;trail <= 254; trail++) {
+          const char = decoder.decode(Uint8Array.of(lead, trail));
+          if (char && char !== "\uFFFD")
+            chars.add(char);
         }
-        return;
-      });
+      }
+      FontOptimizer.#ksX1001Text = [...chars].join("");
+    } catch {
+      FontOptimizer.#ksX1001Text = FontOptimizer.#rangeTextStatic(44032, 55203);
     }
-  };
-}
-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;
+    return FontOptimizer.#ksX1001Text;
   }
-  for (const ext of CANDIDATE_EXTS) {
-    const candidate = path10.join(basePath, `index${ext}`);
-    if (await Bun.file(candidate).exists())
-      return candidate;
+  static #rangeTextStatic(start, end) {
+    let text = "";
+    for (let code = start;code <= end; code++)
+      text += String.fromCodePoint(code);
+    return text;
   }
-  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) };
-      });
+  #buildOptimizedFontFaceRule(font, face) {
+    const declarations = [
+      ["font-family", this.#quote(font.name)],
+      ["src", `url(${this.#quote(face.optimizedSrc)}) format("woff2")`],
+      ["font-weight", String(face.weight)],
+      ["font-style", face.style],
+      ["font-display", font.display ?? "swap"],
+      ...this.#toDeclarationEntries(font.declarations),
+      ...this.#toDeclarationEntries(face.path.declarations)
+    ];
+    return `@font-face {
+${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
+`)}
+}`;
+  }
+  async#buildFontaineFallbackCss(font, face, outputPath) {
+    if (font.adjustFontFallback === false)
+      return "";
+    const { generateFontFace, getMetricsForFamily, readMetrics, resolveCategoryFallbacks } = await import("fontaine");
+    const metrics = await readMetrics(outputPath).catch(() => null);
+    if (!metrics)
+      return "";
+    const fallbacks = resolveCategoryFallbacks({
+      fontFamily: font.name,
+      fallbacks: font.fallbacks ?? {},
+      metrics: { ...metrics, category: font.category }
+    });
+    const css = [];
+    for (let i = fallbacks.length - 1;i >= 0; i--) {
+      const fallback = fallbacks[i];
+      const fallbackMetrics = await getMetricsForFamily(fallback);
+      if (!fallbackMetrics)
+        continue;
+      css.push(generateFontFace({ ...metrics, category: font.category }, {
+        name: this.#getFontFallbackName(font),
+        font: fallback,
+        metrics: fallbackMetrics,
+        "font-weight": String(face.weight),
+        "font-style": face.style
+      }));
     }
-  };
-}
-function loaderFor(absPath) {
-  if (absPath.endsWith(".tsx"))
-    return "tsx";
-  if (absPath.endsWith(".jsx"))
-    return "jsx";
-  if (absPath.endsWith(".ts"))
-    return "ts";
-  return "js";
+    return css.join("");
+  }
+  #buildRootVariableRule(font) {
+    return `:root { ${this.#getFontVariableName(font)}: ${this.#quote(font.name)}, ${this.#quote(this.#getFontFallbackName(font))}; }`;
+  }
+  #buildFontUtilityRules(fonts) {
+    const rules = [];
+    const seen = new Set;
+    for (const font of fonts) {
+      const className = font.className || `font-${font.name}`;
+      const selector = `.${this.#escapeCssClassName(className)}`;
+      const rule = `${selector} { font-family: var(${this.#getFontVariableName(font)}); }`;
+      if (seen.has(rule))
+        continue;
+      seen.add(rule);
+      rules.push(rule);
+    }
+    return rules.join(`
+`);
+  }
+  #escapeCssClassName(value) {
+    return value.replace(/^-?\d|[^a-zA-Z0-9_-]/g, (part) => [...part].map((char) => `\\${char.codePointAt(0)?.toString(16)} `).join(""));
+  }
+  #toDeclarationEntries(declarations = []) {
+    return declarations.map((declaration) => [declaration.prop, declaration.value]);
+  }
+  #quote(value) {
+    return JSON.stringify(value);
+  }
 }
 
-// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-var VIRTUAL_PAGES_ENTRY = "akan-pages-entry";
+// pkgs/@akanjs/devkit/frontendBuild/fontPruner.ts
+import { rm as rm2, rmdir, stat as stat3 } from "fs/promises";
+import path11 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}";
 
-class PagesBundleBuilder {
+class FontPruner {
   #app;
-  #command;
-  #pageEntries;
-  #started = Date.now();
-  constructor(app, command = "start", pageEntries) {
+  #keepGlobs;
+  #publicRoot;
+  #artifactRoot;
+  constructor(app, { keepFonts = [] } = {}) {
     this.#app = app;
-    this.#command = command;
-    this.#pageEntries = pageEntries;
+    this.#keepGlobs = keepFonts;
+    this.#publicRoot = path11.join(app.dist.cwdPath, "public");
+    this.#artifactRoot = path11.join(app.dist.cwdPath, ".akan/artifact");
   }
-  async build() {
-    const akanConfig = await this.#app.getConfig();
-    const resolvedEntries = this.#pageEntries ?? await resolveSsrPageEntriesForApp(this.#app, await this.#app.getPageKeys());
-    const entrySource = PagesEntrySourceGenerator.generate(resolvedEntries);
-    const workspaceRoot = this.#app.workspace.workspaceRoot;
-    const result = await Bun.build({
-      entrypoints: [VIRTUAL_PAGES_ENTRY],
-      outdir: `${this.#artifactDir}/server`,
-      target: "bun",
-      format: "esm",
-      splitting: this.#splitting,
-      minify: this.#command === "build",
-      naming: {
-        entry: "pages-[hash].[ext]",
-        chunk: "chunks/[name]-[hash].[ext]",
-        asset: "assets/[name]-[hash].[ext]"
-      },
-      define: this.#define(),
-      plugins: [
-        PagesBundleBuilder.createPagesEntryPlugin(entrySource),
-        PagesBundleBuilder.createServerCssStubPlugin(),
-        PagesBundleBuilder.createServerUseClientFetchPlugin(),
-        await createExternalizeFrameworkPlugin({ app: this.#app, extra: akanConfig.externalLibs }),
-        akanConfig.barrelImports.length > 0 ? await createBarrelImportsPlugin(this.#app, {
-          pipeAfter: (source, args) => transformUseClient(source, {
-            path: args.path,
-            workspaceRoot
-          })
-        }) : createUseClientBundlePlugin({ workspaceRoot })
-      ]
-    });
-    if (!result.success)
-      throw new AggregateError(result.logs, "[PagesBundleBuilder] Bun.build failed");
-    const entryArtifact = result.outputs.find((a) => a.kind === "entry-point");
-    if (!entryArtifact)
-      throw new Error("[PagesBundleBuilder] Bun.build emitted no entry-point artifact");
-    const bundlePath = path11.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] ${path11.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
-    };
+  async prune() {
+    const empty = { removed: [], kept: [], freedBytes: 0 };
+    if (!await this.#isDirectory(this.#publicRoot))
+      return empty;
+    const candidates = await this.#collectCandidates();
+    if (!candidates.length)
+      return empty;
+    const fonts = await new FontOptimizer(this.#app, "build").discoverFonts();
+    const unoptimizedSrcs = new Set;
+    const optimizedSrcs = new Set;
+    for (const font of fonts) {
+      const target = isFontOptimizationEnabled(font) ? optimizedSrcs : unoptimizedSrcs;
+      for (const fontPath of font.paths)
+        target.add(path11.posix.basename(fontPath.src));
+    }
+    const result = { removed: [], kept: [], freedBytes: 0 };
+    const undecided = [];
+    for (const candidate of candidates) {
+      const reason = this.#staticKeepReason(candidate, unoptimizedSrcs);
+      if (reason)
+        result.kept.push({ file: candidate.rel, bytes: candidate.bytes, reason });
+      else
+        undecided.push(candidate);
+    }
+    if (undecided.length) {
+      const referrers = await this.#findReferrers(undecided, optimizedSrcs);
+      for (const candidate of undecided) {
+        const referrer = referrers.get(candidate.rel);
+        if (referrer)
+          result.kept.push({ file: candidate.rel, bytes: candidate.bytes, reason: { kind: "referenced", referrer } });
+        else
+          result.removed.push({ file: candidate.rel, bytes: candidate.bytes });
+      }
+    }
+    await this.#remove(result.removed.map(({ file }) => file));
+    result.freedBytes = result.removed.reduce((total, { bytes }) => total + bytes, 0);
+    this.#report(result);
+    return result;
   }
-  get #artifactDir() {
-    return `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
+  #staticKeepReason(candidate, unoptimizedSrcs) {
+    if (unoptimizedSrcs.has(candidate.basename))
+      return { kind: "unoptimized" };
+    for (const glob of this.#keepGlobs) {
+      if (new Bun.Glob(glob).match(candidate.rel))
+        return { kind: "declared", glob };
+    }
+    return null;
   }
-  get #splitting() {
-    return process.env.AKAN_SERVER_PAGES_SPLITTING === "1";
+  async#collectCandidates() {
+    const candidates = [];
+    for await (const rel of new Bun.Glob(FONT_GLOB).scan({ cwd: this.#publicRoot, dot: false })) {
+      const entry = await stat3(path11.join(this.#publicRoot, rel)).catch(() => null);
+      if (!entry?.isFile())
+        continue;
+      candidates.push({ rel: rel.split(path11.sep).join("/"), basename: path11.basename(rel), bytes: entry.size });
+    }
+    return candidates;
   }
-  #define() {
-    const nodeEnv = this.#command === "build" ? "production" : "development";
-    return {
-      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
-      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("ssr"),
-      ...Object.fromEntries(Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
-    };
+  async#findReferrers(candidates, optimizedSrcs) {
+    const referrers = new Map;
+    const authoritative = candidates;
+    const bundled = candidates.filter((candidate) => !optimizedSrcs.has(candidate.basename));
+    const roots = [
+      { dir: this.#publicRoot, label: "public", needles: authoritative },
+      { dir: path11.join(this.#artifactRoot, "styles"), label: ".akan/artifact/styles", needles: authoritative },
+      { dir: path11.join(this.#artifactRoot, "client"), label: ".akan/artifact/client", needles: bundled },
+      { dir: path11.join(this.#artifactRoot, "client-ssr"), label: ".akan/artifact/client-ssr", needles: bundled },
+      { dir: path11.join(this.#artifactRoot, "server"), label: ".akan/artifact/server", needles: bundled },
+      { dir: path11.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));
+      if (!pending.length || !await this.#isDirectory(root.dir))
+        continue;
+      await this.#scanRoot(root, pending, referrers);
+    }
+    return referrers;
   }
-  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"
-        }));
+  async#scanRoot(root, pending, referrers) {
+    const needles = pending.map((candidate) => ({
+      rel: candidate.rel,
+      forms: [...new Set([candidate.basename, encodeURIComponent(candidate.basename)])]
+    }));
+    for await (const rel of new Bun.Glob(REFERRER_GLOB).scan({ cwd: root.dir, dot: false })) {
+      const remaining = needles.filter((needle) => !referrers.has(needle.rel));
+      if (!remaining.length)
+        return;
+      const text = await Bun.file(path11.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(path11.sep).join("/")}`);
       }
-    };
+    }
   }
-  static createServerCssStubPlugin() {
-    return {
-      name: "akan-server-css-stub",
-      setup(build) {
-        build.onLoad({ filter: /\.css$/ }, () => ({
-          contents: "",
-          loader: "js"
-        }));
-      }
-    };
+  async#remove(files) {
+    await Promise.all(files.map((file) => rm2(path11.join(this.#publicRoot, file), { force: true })));
+    const dirs = [...new Set(files.map((file) => path11.posix.dirname(file)))].filter((dir) => dir !== "." && dir !== "/").sort((a, b) => b.length - a.length);
+    for (const dir of dirs)
+      await rmdir(path11.join(this.#publicRoot, dir)).catch(() => {
+        return;
+      });
   }
-  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: loaderFor2(args.path) };
-        });
-      }
-    };
+  #report(result) {
+    if (!result.removed.length && !result.kept.length)
+      return;
+    for (const { file, bytes } of result.removed)
+      this.#app.verbose(`[font-prune] dropped public/${file} (${FontPruner.formatBytes(bytes)})`);
+    for (const { file, reason } of result.kept)
+      this.#app.verbose(`[font-prune] kept public/${file} \u2014 ${FontPruner.describe(reason)}`);
+    const byReferrer = new Map;
+    for (const { bytes, reason } of result.kept) {
+      if (reason.kind !== "referenced")
+        continue;
+      const entry = byReferrer.get(reason.referrer) ?? { files: 0, bytes: 0 };
+      entry.files += 1;
+      entry.bytes += bytes;
+      byReferrer.set(reason.referrer, entry);
+    }
+    if (!byReferrer.size)
+      return;
+    const ranked = [...byReferrer.entries()].sort(([, a], [, b]) => b.bytes - a.bytes);
+    const named = ranked.slice(0, 3).map(([referrer, { files, bytes }]) => `${referrer} (${files}, ${FontPruner.formatBytes(bytes)})`);
+    const rest = ranked.length - named.length;
+    this.#app.logger.info(`[font-prune] kept ${FontPruner.formatBytes(ranked.reduce((total, [, entry]) => total + entry.bytes, 0))} of fonts in public/ because these reference them: ${named.join(", ")}${rest > 0 ? ` and ${rest} more` : ""}`);
   }
-  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 });");
+  static describe(reason) {
+    if (reason.kind === "unoptimized")
+      return "declared with optimize: false, so the runtime CSS serves it";
+    if (reason.kind === "declared")
+      return `kept by assets.keepFonts "${reason.glob}"`;
+    return `referenced by ${reason.referrer}`;
+  }
+  static formatBytes(bytes) {
+    if (bytes < 1024)
+      return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+      return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+  }
+  async#isDirectory(dir) {
+    return await stat3(dir).then((entry) => entry.isDirectory(), () => false);
   }
-}
-function loaderFor2(absPath) {
-  if (absPath.endsWith(".tsx"))
-    return "tsx";
-  if (absPath.endsWith(".jsx"))
-    return "jsx";
-  if (absPath.endsWith(".ts"))
-    return "ts";
-  return "js";
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/precompressArtifacts.ts
-import fs2 from "fs";
+import fs from "fs";
 import path12 from "path";
 import zlib from "zlib";
 var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
@@ -2052,7 +2003,7 @@ async function precompressArtifacts(app) {
   return result;
 }
 async function precompressRoot(root, result) {
-  if (!fs2.existsSync(root) || !fs2.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 })) {
@@ -2253,4 +2204,4 @@ ${preparedCssText}`).toString(36);
     }
   }
 }
-export { AllRoutesBuilder, CsrArtifactBuilder, CssCompiler, FontOptimizer, FontPruner, PagesBundleBuilder, precompressArtifacts, SsrBaseArtifactBuilder };
+export { AllRoutesBuilder, CssCompiler, PagesBundleBuilder, CsrArtifactBuilder, FontOptimizer, FontPruner, precompressArtifacts, SsrBaseArtifactBuilder };