@akanjs/cli 2.4.1-rc.7 → 2.4.1

package/index-m0vg9n8z.js

@@ -0,0 +1,2219 @@
+// @bun
+import {
+  BarrelAnalyzer,
+  ClientEntriesBundler,
+  GraphClientEntryDiscovery,
+  RouteClientBuilder,
+  VENDOR_SPECIFIERS,
+  createBarrelImportsPlugin,
+  createTsconfigPackageResolver,
+  rewriteBarrelImports,
+  transformUseClient
+} from "./index-rh16j3c7.js";
+import {
+  __require
+} from "./index-r24hmh0q.js";
+
+// pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
+import path4 from "path";
+
+// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
+import { mkdir } from "fs/promises";
+import path from "path";
+var LAYOUT_KEY_RE = /^\.\/(.+\/)?_layout\.(tsx|ts|jsx|js)$/;
+async function appHasStModule(appCwdPath) {
+  return Bun.file(path.join(appCwdPath, "lib", "st.ts")).exists();
+}
+var IMPLICIT_LAYOUT_DIR = path.join(".akan", "generated", "root-layouts");
+var IMPLICIT_DICT_DIR = path.join(".akan", "generated", "dict");
+var IMPLICIT_OVERRIDES_DIR = path.join(".akan", "generated", "overrides");
+var OVERRIDES_KEY_RE = /^\.\/(.+\/)?_overrides\.(tsx|ts|jsx|js)$/;
+async function writeGeneratedOverridesLayoutFile(opts) {
+  const filename = `${opts.key.replace(/^\.\//, "").replace(/[^a-zA-Z0-9]+/g, "_")}.tsx`;
+  const absPath = path.join(path.resolve(opts.appCwdPath), IMPLICIT_OVERRIDES_DIR, filename);
+  const userRel = path.relative(path.dirname(absPath), opts.userAbsPath).split(path.sep).join("/");
+  const userSpecifier = userRel.startsWith(".") ? userRel : `./${userRel}`;
+  const source = `"use client";
+import { UiOverrideProvider } from "akanjs/ui";
+import { createElement, type ReactNode } from "react";
+import value from ${JSON.stringify(userSpecifier)};
+
+export default function AkanUiOverridesLayout({ children }: { children?: ReactNode }) {
+  return createElement(UiOverrideProvider, { value }, children);
+}
+`;
+  await Bun.write(absPath, source);
+  return absPath;
+}
+function getRootBoundarySegments(key) {
+  const match = LAYOUT_KEY_RE.exec(key);
+  if (!match)
+    return null;
+  const prefix = match[1]?.replace(/\/$/, "");
+  if (!prefix)
+    return [];
+  return prefix.split("/").filter(Boolean);
+}
+function implicitRootLayoutKey(segments) {
+  return `./${[...segments, "__root_layout"].join("/")}.tsx`;
+}
+function implicitRootLayoutAbsPath(appCwdPath, segments) {
+  const filename = segments.length ? `${segments.join("__")}__root_layout.tsx` : "__root_layout.tsx";
+  return path.join(path.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
+}
+function implicitDictionaryMacroAbsPath(appCwdPath) {
+  return path.join(path.resolve(appCwdPath), IMPLICIT_DICT_DIR, "useDict.ts");
+}
+function isRootBoundarySegments(segments, basePaths) {
+  const firstVisibleIndex = segments.findIndex((segment) => !/^\(.+\)$/.test(segment));
+  if (firstVisibleIndex === -1)
+    return segments.length <= 1;
+  if (segments.slice(firstVisibleIndex + 1).some((segment) => /^\(.+\)$/.test(segment)))
+    return false;
+  const visible = segments.slice(firstVisibleIndex);
+  const allowedBasePaths = new Set([...basePaths].map((basePath) => basePath.trim()).filter(Boolean));
+  return visible.length === 1 && (firstVisibleIndex > 0 || allowedBasePaths.has(visible[0] ?? ""));
+}
+function findRootBoundaries(pageKeys, appCwdPath, basePaths) {
+  const boundaries = new Map;
+  for (const key of pageKeys) {
+    const segments = getRootBoundarySegments(key);
+    if (!segments)
+      continue;
+    if (!isRootBoundarySegments(segments, basePaths))
+      continue;
+    const id = segments.join("/");
+    boundaries.set(id, {
+      sourceKey: key,
+      sourceAbsPath: path.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
+      segments
+    });
+  }
+  const hasExplicitRootBoundary = [...boundaries.values()].some((boundary) => boundary.segments.length === 0);
+  if (!hasExplicitRootBoundary && boundaries.size === 0) {
+    boundaries.set("", { sourceKey: null, sourceAbsPath: null, segments: [] });
+  }
+  return [...boundaries.values()].sort((a, b) => a.segments.join("/").localeCompare(b.segments.join("/")));
+}
+function hasAncestorRootBoundary(boundary, boundaries) {
+  return boundaries.some((candidate) => candidate !== boundary && candidate.segments.length < boundary.segments.length && candidate.segments.every((segment, index) => boundary.segments[index] === segment));
+}
+function findExplicitRootLayoutAbsPath(pageKeys, appCwdPath) {
+  const rootLayoutKey = pageKeys.find((key) => {
+    const segments = getRootBoundarySegments(key);
+    return segments !== null && segments.length === 0;
+  });
+  return rootLayoutKey ? path.resolve(appCwdPath, "page", rootLayoutKey.replace(/^\.\//, "")) : null;
+}
+function routePrefixForSegments(segments) {
+  const visible = segments.filter((segment) => !/^\(.+\)$/.test(segment));
+  return visible[0] ?? null;
+}
+async function assertEnvClientConvention(appCwdPath, appName) {
+  const envPath = path.join(appCwdPath, "env", "env.client.ts");
+  if (!await Bun.file(envPath).exists()) {
+    throw new Error(`[route-convention] app "${appName}" must provide env/env.client.ts exporting "env" for generated System.Provider`);
+  }
+}
+async function writeGeneratedDictionaryMacroFile(appCwdPath, appName) {
+  const absPath = implicitDictionaryMacroAbsPath(appCwdPath);
+  await mkdir(path.dirname(absPath), { recursive: true });
+  await Bun.write(absPath, `import { getAllDictionary } from "@apps/${appName}/lib/dict" with { type: "macro" };
+
+export const allDictionary = getAllDictionary();
+`);
+  return absPath;
+}
+async function writeGeneratedRootLayoutFile(opts) {
+  await assertEnvClientConvention(opts.appCwdPath, opts.appName);
+  const dictMacroAbsPath = opts.includeSystemProvider ? await writeGeneratedDictionaryMacroFile(opts.appCwdPath, opts.appName) : null;
+  const absPath = implicitRootLayoutAbsPath(opts.appCwdPath, opts.boundary.segments);
+  await mkdir(path.dirname(absPath), { recursive: true });
+  const dictMacroRel = dictMacroAbsPath ? path.relative(path.dirname(absPath), dictMacroAbsPath).split(path.sep).join("/") : null;
+  const dictMacroSpecifier = dictMacroRel ? dictMacroRel.startsWith(".") ? dictMacroRel : `./${dictMacroRel}` : null;
+  const sourceRel = opts.boundary.sourceAbsPath ? path.relative(path.dirname(absPath), opts.boundary.sourceAbsPath).split(path.sep).join("/") : null;
+  const sourceSpecifier = sourceRel ? sourceRel.startsWith(".") ? sourceRel : `./${sourceRel}` : null;
+  const inheritedSourceAbsPath = opts.rootSourceAbsPath && opts.rootSourceAbsPath !== opts.boundary.sourceAbsPath ? opts.rootSourceAbsPath : null;
+  const inheritedSourceRel = inheritedSourceAbsPath ? path.relative(path.dirname(absPath), inheritedSourceAbsPath).split(path.sep).join("/") : null;
+  const inheritedSourceSpecifier = inheritedSourceRel ? inheritedSourceRel.startsWith(".") ? inheritedSourceRel : `./${inheritedSourceRel}` : null;
+  const clientImport = opts.includeStInit ? `import { st } from "@apps/${opts.appName}/client";
+void st;
+` : `import "@apps/${opts.appName}/client";
+`;
+  const inheritedImport = inheritedSourceSpecifier ? `import * as inheritedLayout from ${JSON.stringify(inheritedSourceSpecifier)};
+` : `const inheritedLayout = {};
+`;
+  const prefix = routePrefixForSegments(opts.boundary.segments);
+  const userImport = sourceSpecifier ? `import UserLayout, * as userLayout from ${JSON.stringify(sourceSpecifier)};
+` : `const UserLayout = ({ children }) => children;
+const userLayout = {};
+`;
+  const source = opts.includeSystemProvider ? `import type { LayoutProps, PageProps } from "akanjs/client";
+import { loadFonts } from "akanjs/client";
+import { System } from "akanjs/ui";
+import { env } from "@apps/${opts.appName}/env/env.client";
+import { allDictionary } from ${JSON.stringify(dictMacroSpecifier)};
+${clientImport}${inheritedImport}${userImport}
+const userFonts = userLayout.fonts ?? inheritedLayout.fonts ?? [];
+const defaultFonts = userFonts.filter((font) => font.default);
+if (defaultFonts.length > 1) throw new Error("[route-convention] only one default font is allowed per root layout");
+const defaultFont = defaultFonts[0];
+const defaultFontClassName = defaultFont ? (defaultFont.className ?? \`font-\${defaultFont.name}\`) : undefined;
+
+export async function generateHead(props: PageProps) {
+  if (userLayout.generateHead) return userLayout.generateHead(props);
+  if (userLayout.head !== undefined) return userLayout.head;
+  if (inheritedLayout.generateHead) return inheritedLayout.generateHead(props);
+  return inheritedLayout.head;
+}
+
+export async function generateMetadata(props: PageProps) {
+  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
+  if (userLayout.metadata !== undefined) return userLayout.metadata;
+  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
+  return inheritedLayout.metadata;
+}
+
+export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
+export const Error = userLayout.Error ?? inheritedLayout.Error;
+export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
+
+export default function GeneratedLayout({ children, params, searchParams }: LayoutProps) {
+  return (
+    <System.Provider
+      of={GeneratedLayout as never}
+      appName=${JSON.stringify(opts.appName)}
+      ${prefix ? `prefix=${JSON.stringify(prefix)}
+      ` : ""}params={params}
+      manifest={userLayout.manifest ?? inheritedLayout.manifest}
+      env={env}
+      theme={userLayout.theme ?? inheritedLayout.theme}
+      fonts={loadFonts(userFonts)}
+      className={defaultFontClassName}
+      gaTrackingId={userLayout.gaTrackingId ?? inheritedLayout.gaTrackingId}
+      layoutStyle={userLayout.layoutStyle ?? inheritedLayout.layoutStyle}
+      reconnect={userLayout.reconnect ?? inheritedLayout.reconnect ?? false}
+      wsConnect={userLayout.wsConnect ?? inheritedLayout.wsConnect ?? true}
+      allDictionary={process.env.AKAN_PUBLIC_RENDER_ENV === "ssr" ? allDictionary : undefined}
+    >
+      <UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>
+    </System.Provider>
+  );
+}
+` : `import type { LayoutProps, PageProps } from "akanjs/client";
+${inheritedImport}${userImport}
+export async function generateHead(props: PageProps) {
+  if (userLayout.generateHead) return userLayout.generateHead(props);
+  if (userLayout.head !== undefined) return userLayout.head;
+  if (inheritedLayout.generateHead) return inheritedLayout.generateHead(props);
+  return inheritedLayout.head;
+}
+
+export async function generateMetadata(props: PageProps) {
+  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
+  if (userLayout.metadata !== undefined) return userLayout.metadata;
+  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
+  return inheritedLayout.metadata;
+}
+
+export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
+export const Error = userLayout.Error ?? inheritedLayout.Error;
+export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
+
+export default function GeneratedLayout({ children, params, searchParams }: LayoutProps) {
+  return <UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>;
+}
+`;
+  await Bun.write(absPath, source);
+  return absPath;
+}
+async function resolveSsrPageEntries(opts) {
+  const absPageDir = path.resolve(opts.appCwdPath, "page");
+  const hasSt = await appHasStModule(opts.appCwdPath);
+  const basePaths = opts.basePaths ?? [];
+  const rootSourceAbsPath = findExplicitRootLayoutAbsPath(opts.pageKeys, opts.appCwdPath);
+  const rootBoundaries = findRootBoundaries(opts.pageKeys, opts.appCwdPath, basePaths);
+  const rootLayoutKeys = new Set(opts.pageKeys.filter((key) => {
+    const segments = getRootBoundarySegments(key);
+    return segments !== null && isRootBoundarySegments(segments, basePaths);
+  }));
+  const base = await Promise.all(opts.pageKeys.filter((key) => !rootLayoutKeys.has(key)).map(async (key) => {
+    const userAbsPath = path.resolve(absPageDir, key);
+    if (OVERRIDES_KEY_RE.test(key)) {
+      const moduleAbsPath = await writeGeneratedOverridesLayoutFile({
+        appCwdPath: opts.appCwdPath,
+        key,
+        userAbsPath
+      });
+      return { key, moduleAbsPath, seedAbsPaths: [userAbsPath] };
+    }
+    return { key, moduleAbsPath: userAbsPath };
+  }));
+  const generated = await Promise.all(rootBoundaries.map(async (boundary) => ({
+    key: implicitRootLayoutKey(boundary.segments),
+    moduleAbsPath: await writeGeneratedRootLayoutFile({
+      appCwdPath: opts.appCwdPath,
+      appName: opts.appName,
+      boundary,
+      rootSourceAbsPath,
+      includeStInit: hasSt && boundary.segments.length === 0,
+      includeSystemProvider: !hasAncestorRootBoundary(boundary, rootBoundaries)
+    }),
+    seedAbsPaths: [...new Set([boundary.sourceAbsPath, rootSourceAbsPath].filter((absPath) => absPath !== null))]
+  })));
+  const entries = [...base, ...generated];
+  entries.sort((a, b) => a.key.localeCompare(b.key));
+  return entries;
+}
+async function resolveSsrPageEntriesForApp(app, pageKeys) {
+  const config = await app.getConfig();
+  return resolveSsrPageEntries({ appCwdPath: app.cwdPath, appName: app.name, pageKeys, basePaths: config.basePaths });
+}
+
+// pkgs/@akanjs/devkit/artifact/routeSeedIndex.ts
+import path2 from "path";
+import { assertUniqueRoutePatterns, compareRouteSpecificity, parseRouteModuleKey } from "akanjs/common";
+function computeRouteSeedIndex(pageEntries) {
+  const layoutsByPrefix = new Map;
+  const pagesBySegments = [];
+  for (const { key, moduleAbsPath, seedAbsPaths } of pageEntries) {
+    const parsed = parseRouteModuleKey(key);
+    const files = [path2.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path2.resolve(seed))];
+    if (parsed.kind === "layout" || parsed.kind === "overrides") {
+      const prefix = parsed.routeSegments.join("/");
+      const prev = layoutsByPrefix.get(prefix) ?? [];
+      layoutsByPrefix.set(prefix, [...prev, ...files]);
+    } else if (parsed.kind === "page") {
+      pagesBySegments.push({
+        key,
+        pattern: parsed.pattern,
+        segments: parsed.routeSegments,
+        files,
+        includeOwnLayout: parsed.leaf === "_index"
+      });
+    }
+  }
+  assertUniqueRoutePatterns(pagesBySegments);
+  const rootLayouts = layoutsByPrefix.get("") ?? [];
+  const globalLayoutFiles = rootLayouts;
+  const seedEntries = [];
+  for (const { pattern, segments, files, includeOwnLayout } of pagesBySegments) {
+    const layouts = [];
+    const maxPrefixLength = includeOwnLayout ? segments.length : Math.max(segments.length - 1, 0);
+    for (let i = 0;i <= maxPrefixLength; i++) {
+      const prefix = segments.slice(0, i).join("/");
+      const layoutFiles = layoutsByPrefix.get(prefix);
+      if (layoutFiles)
+        layouts.push(...layoutFiles);
+    }
+    const seeds = Array.from(new Set([...layouts, ...files]));
+    const routeId = pattern || "/";
+    seedEntries.push({ routeId, pattern: routeId, seeds });
+  }
+  seedEntries.sort((a, b) => compareRouteSpecificity(a.pattern, b.pattern));
+  return { entries: seedEntries, globalLayoutFiles };
+}
+var ROUTE_SEED_INDEX_JSON = "route-seed-index.json";
+function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
+  const normalizedArtifactDir = path2.resolve(artifactDir);
+  if (options.production) {
+    return {
+      entries: index.entries.map((entry) => ({ routeId: entry.routeId }))
+    };
+  }
+  return {
+    entries: index.entries.map((entry) => ({
+      ...entry,
+      seeds: entry.seeds.map((seed) => serializeArtifactPath(seed, normalizedArtifactDir))
+    })),
+    globalLayoutFiles: index.globalLayoutFiles.map((file) => serializeArtifactPath(file, normalizedArtifactDir))
+  };
+}
+async function saveRouteSeedIndex(artifactDir, index, options = {}) {
+  const absPath = path2.join(path2.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
+  await Bun.write(absPath, `${JSON.stringify(serializeRouteSeedIndexForArtifact(index, artifactDir, options), null, 2)}
+`);
+  return absPath;
+}
+function serializeArtifactPath(artifactPath, artifactDir) {
+  if (!path2.isAbsolute(artifactPath))
+    return artifactPath;
+  return path2.relative(artifactDir, artifactPath).split(path2.sep).join("/");
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/routesManifestArtifactSerializer.ts
+import path3 from "path";
+
+class RoutesManifestArtifactSerializer {
+  #manifest;
+  #artifactDir;
+  #production;
+  constructor(manifest, artifactDir, options = {}) {
+    this.#manifest = manifest;
+    this.#artifactDir = path3.resolve(artifactDir);
+    this.#production = options.production ?? false;
+  }
+  static serialize(manifest, artifactDir, options = {}) {
+    return new RoutesManifestArtifactSerializer(manifest, artifactDir, options).serialize();
+  }
+  serialize() {
+    const serialized = {
+      ...this.#manifest,
+      knownEntries: this.#manifest.knownEntries.map((entry) => this.#serializeArtifactPath(entry))
+    };
+    if (this.#production)
+      delete serialized.knownEntries;
+    return {
+      ...serialized,
+      clientManifest: Object.fromEntries(Object.entries(this.#manifest.clientManifest).map(([key, row]) => [this.#serializeArtifactPath(key), row])),
+      ssrManifest: {
+        ...this.#manifest.ssrManifest,
+        moduleMap: Object.fromEntries(Object.entries(this.#manifest.ssrManifest.moduleMap).map(([entryUrl, byName]) => [
+          entryUrl,
+          Object.fromEntries(Object.entries(byName).map(([name, entry]) => [
+            name,
+            {
+              ...entry,
+              id: this.#serializeArtifactPath(entry.id),
+              chunks: entry.chunks.map((chunk) => this.#serializeArtifactPath(chunk))
+            }
+          ]))
+        ]))
+      }
+    };
+  }
+  #serializeArtifactPath(artifactPath) {
+    if (!path3.isAbsolute(artifactPath))
+      return artifactPath;
+    return path3.relative(this.#artifactDir, artifactPath).split(path3.sep).join("/");
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
+class AllRoutesBuilder {
+  #app;
+  #artifact;
+  #command;
+  #artifactDir;
+  #merged = {
+    clientManifest: {},
+    ssrManifest: { moduleLoading: null, moduleMap: {} },
+    knownEntries: []
+  };
+  #knownSet = new Set;
+  #routeIds = [];
+  #discovery = null;
+  constructor(app, artifact, command = "start") {
+    this.#app = app;
+    this.#artifact = artifact;
+    this.#command = command;
+    this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
+  }
+  async build() {
+    const pageKeys = await this.#app.getPageKeys();
+    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
+    const seedIndex = computeRouteSeedIndex(pageEntries);
+    this.#app.verbose(`[build-all] discovered ${seedIndex.entries.length} routes`);
+    this.#discovery = await GraphClientEntryDiscovery.create(this.#app);
+    for (const entry of seedIndex.entries) {
+      const seeds = Array.from(new Set([...seedIndex.globalLayoutFiles, ...entry.seeds]));
+      const delta = await this.#buildRoute(entry.routeId, seeds);
+      this.#mergeRoute(entry.routeId, delta);
+    }
+    this.#merged.knownEntries = Array.from(this.#knownSet);
+    const manifest = {
+      routeIds: this.#routeIds,
+      ...this.#merged
+    };
+    const manifestPath = path4.join(path4.resolve(this.#artifactDir), "routes-manifest.json");
+    await Bun.write(manifestPath, `${JSON.stringify(RoutesManifestArtifactSerializer.serialize(manifest, this.#artifactDir, {
+      production: this.#command === "build"
+    }), null, 2)}
+`);
+    this.#app.verbose(`[build-all] wrote ${manifestPath} routes=${this.#routeIds.length} entries=${this.#merged.knownEntries.length}`);
+    return { manifest, manifestPath, seedIndex };
+  }
+  async#buildRoute(routeId, seeds) {
+    if (!this.#discovery)
+      throw new Error("[build-all] client entry discovery is not initialized");
+    const started = Date.now();
+    const delta = await new RouteClientBuilder({
+      app: this.#app,
+      routeId,
+      seeds,
+      artifact: this.#artifact,
+      knownEntries: this.#knownSet,
+      discovery: this.#discovery,
+      command: this.#command
+    }).build();
+    this.#app.verbose(`[build-all] ${routeId} +${delta.newEntries.length} entries (${Date.now() - started}ms)`);
+    return delta;
+  }
+  #mergeRoute(routeId, delta) {
+    for (const [key, row] of Object.entries(delta.manifestDelta))
+      this.#merged.clientManifest[key] = row;
+    for (const [url, byName] of Object.entries(delta.ssrManifestDelta.moduleMap)) {
+      this.#merged.ssrManifest.moduleMap[url] = byName;
+    }
+    for (const abs of delta.newEntries)
+      this.#knownSet.add(abs);
+    this.#routeIds.push(routeId);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
+import { mkdir as mkdir2, rm, unlink } from "fs/promises";
+import path6 from "path";
+
+// pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
+import fs from "fs";
+import path5 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 path5.resolve(moduleAbsPath).split(path5.sep).join("/");
+  }
+  static #hasAsyncDefaultExport(moduleAbsPath) {
+    try {
+      const source = fs.readFileSync(path5.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 mkdir2(path6.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 path6.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 = path6.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
+    const artifactFile = Bun.file(path6.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 = path6.basename(htmlPath, ".html") === "index" ? "" : path6.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 = path6.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 path6.resolve(path6.dirname(htmlPath), normalized);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
+import path8 from "path";
+import { Logger } from "akanjs/common";
+import { compile } from "tailwindcss";
+
+// pkgs/@akanjs/devkit/frontendBuild/cssCandidateCache.ts
+import { stat } from "fs/promises";
+var CANDIDATE_RE = /-?[\w@][\w:/.-]*(?:\[[^\]]+\][\w:/.-]*)*/g;
+
+class CssCandidateCache {
+  static #version = 1;
+  #path;
+  #entries = new Map;
+  #dirty = false;
+  #reused = 0;
+  #rescanned = 0;
+  constructor(cachePath) {
+    this.#path = cachePath;
+  }
+  get reused() {
+    return this.#reused;
+  }
+  get rescanned() {
+    return this.#rescanned;
+  }
+  async load() {
+    const raw = await Bun.file(this.#path).json().catch(() => null);
+    if (!raw || raw.version !== CssCandidateCache.#version || typeof raw.files !== "object")
+      return this;
+    for (const [file, entry] of Object.entries(raw.files)) {
+      if (typeof entry?.mtimeMs !== "number" || !Array.isArray(entry.candidates))
+        continue;
+      this.#entries.set(file, entry);
+    }
+    return this;
+  }
+  async candidatesFor(file) {
+    const stats = await stat(file).catch(() => null);
+    const cached = this.#entries.get(file);
+    if (stats && cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+      this.#reused += 1;
+      return cached.candidates;
+    }
+    const content = await Bun.file(file).text();
+    const candidates = [...new Set(Array.from(content.matchAll(CANDIDATE_RE), (m) => m[0]))];
+    this.#rescanned += 1;
+    if (stats) {
+      this.#entries.set(file, { mtimeMs: stats.mtimeMs, size: stats.size, candidates });
+      this.#dirty = true;
+    }
+    return candidates;
+  }
+  async save(present) {
+    for (const file of [...this.#entries.keys()]) {
+      if (present.has(file))
+        continue;
+      this.#entries.delete(file);
+      this.#dirty = true;
+    }
+    if (!this.#dirty)
+      return;
+    this.#dirty = false;
+    const files = {};
+    for (const [file, entry] of this.#entries)
+      files[file] = entry;
+    await Bun.write(this.#path, JSON.stringify({ version: CssCandidateCache.#version, files })).catch(() => {
+      return;
+    });
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/cssImportResolver.ts
+import path7 from "path";
+var CSS_IMPORT_EXTS = ["", ".css", "/styles.css", "/index.css"];
+
+class CssImportResolver {
+  #workspaceRoot;
+  #paths;
+  #wildcardEntries;
+  constructor(workspaceRoot, paths = {}) {
+    this.#workspaceRoot = workspaceRoot;
+    this.#paths = paths;
+    this.#wildcardEntries = Object.entries(paths).filter(([key]) => key.endsWith("/*")).map(([key, replacements]) => ({ prefix: key.slice(0, -1), replacements })).sort((a, b) => b.prefix.length - a.prefix.length);
+  }
+  static async create(app) {
+    const tsconfig = await app.getTsConfig();
+    return new CssImportResolver(app.workspace.workspaceRoot, tsconfig.compilerOptions.paths ?? {});
+  }
+  async resolve(id, fromBase) {
+    for (const resolve of [
+      () => this.#resolveWithTsconfig(id),
+      () => this.#resolveWithBun(id, fromBase),
+      () => this.#resolveWithRequire(id, fromBase),
+      () => this.#resolvePackageStyle(id, fromBase)
+    ]) {
+      const resolved = await resolve();
+      if (resolved)
+        return resolved;
+    }
+    return null;
+  }
+  #resolveWithBun(id, fromBase) {
+    for (const base of this.#resolutionBases(fromBase)) {
+      try {
+        const resolved = Bun.resolveSync(id, base);
+        if (CssImportResolver.isCssFile(resolved))
+          return resolved;
+      } catch {}
+    }
+    return null;
+  }
+  #resolveWithRequire(id, fromBase) {
+    for (const base of this.#resolutionBases(fromBase)) {
+      try {
+        const resolved = __require.resolve(id, { paths: [base] });
+        if (CssImportResolver.isCssFile(resolved))
+          return resolved;
+      } catch {}
+    }
+    return null;
+  }
+  async#resolveWithTsconfig(id) {
+    const exact = this.#paths[id];
+    if (exact) {
+      for (const repl of exact) {
+        const resolved = await this.#firstExisting(path7.resolve(this.#workspaceRoot, repl));
+        if (resolved)
+          return resolved;
+      }
+    }
+    for (const { prefix, replacements } of this.#wildcardEntries) {
+      if (!id.startsWith(prefix))
+        continue;
+      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(path7.resolve(this.#workspaceRoot, replPath + suffix));
+        if (resolved)
+          return resolved;
+      }
+    }
+    return null;
+  }
+  async#resolvePackageStyle(id, fromBase) {
+    const pkgName = CssImportResolver.getPackageName(id);
+    if (!pkgName)
+      return null;
+    for (const base of this.#resolutionBases(fromBase)) {
+      try {
+        const pkgPath = __require.resolve(`${pkgName}/package.json`, { paths: [base] });
+        const resolved = await this.#resolvePackageStyleFromPackageJson(id, pkgName, pkgPath);
+        if (resolved)
+          return resolved;
+      } catch {}
+    }
+    for (const pkgPath of this.#packageJsonCandidates(pkgName)) {
+      const resolved = await this.#resolvePackageStyleFromPackageJson(id, pkgName, pkgPath);
+      if (resolved)
+        return resolved;
+    }
+    return null;
+  }
+  async#resolvePackageStyleFromPackageJson(id, pkgName, pkgPath) {
+    try {
+      if (!await Bun.file(pkgPath).exists())
+        return null;
+      const pkgDir = path7.dirname(pkgPath);
+      const pkg = await Bun.file(pkgPath).json();
+      const subpath = id === pkgName ? "." : `.${id.slice(pkgName.length)}`;
+      const exportValue = pkg.exports?.[subpath];
+      const styleEntry = (typeof exportValue === "string" ? exportValue : exportValue?.style || exportValue?.import || exportValue?.default) || pkg.exports?.["."]?.style || pkg.style || "index.css";
+      return await this.#firstExisting(path7.resolve(pkgDir, styleEntry));
+    } catch {
+      return null;
+    }
+  }
+  #resolutionBases(fromBase) {
+    return [fromBase, this.#workspaceRoot, path7.dirname(Bun.main), path7.resolve(path7.dirname(Bun.main), "../..")];
+  }
+  #packageJsonCandidates(pkgName) {
+    return [
+      path7.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
+      path7.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
+      path7.join(path7.dirname(Bun.main), "node_modules", pkgName, "package.json"),
+      path7.join(path7.dirname(Bun.main), "../../", pkgName, "package.json")
+    ];
+  }
+  async#firstExisting(basePath) {
+    for (const suffix of CSS_IMPORT_EXTS) {
+      const candidate = `${basePath}${suffix}`;
+      if (await Bun.file(candidate).exists())
+        return candidate;
+    }
+    return null;
+  }
+  static getPackageName(id) {
+    const parts = id.split("/");
+    if (id.startsWith("@"))
+      return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+    return parts[0] ?? null;
+  }
+  static isCssFile(filePath) {
+    return path7.extname(filePath) === ".css";
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
+var SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var NON_SOURCE_EXT_RE = /\.(json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav)$/i;
+var NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
+var AKANJS_NODE_MODULE_RE = /[\\/]node_modules[\\/]akanjs[\\/]/;
+
+class CssCompiler {
+  #logger = new Logger("CssCompiler");
+  #transpiler = new Bun.Transpiler({ loader: "tsx" });
+  #app;
+  #cssImportResolver = null;
+  constructor(app) {
+    this.#app = app;
+  }
+  get #candidateCachePath() {
+    return path8.join(this.#app.cwdPath, ".akan/cache/cssCandidates.json");
+  }
+  #cssText = null;
+  #cssTextByBasePath = null;
+  #fileExistsCache = new Map;
+  #resolvedFileCache = new Map;
+  #resolvedSpecifierCache = new Map;
+  #fileExists(absPath) {
+    let cached = this.#fileExistsCache.get(absPath);
+    if (!cached) {
+      cached = Bun.file(absPath).exists();
+      this.#fileExistsCache.set(absPath, cached);
+    }
+    return cached;
+  }
+  #resolveSourceFileCandidate(absPathNoExt) {
+    let cached = this.#resolvedFileCache.get(absPathNoExt);
+    if (cached)
+      return cached;
+    cached = (async () => {
+      if (await this.#fileExists(absPathNoExt))
+        return isSourceFile(absPathNoExt) ? absPathNoExt : null;
+      for (const ext of SOURCE_EXTS) {
+        const filePath = `${absPathNoExt}${ext}`;
+        if (await this.#fileExists(filePath))
+          return filePath;
+      }
+      for (const ext of SOURCE_EXTS) {
+        const filePath = path8.join(absPathNoExt, `index${ext}`);
+        if (await this.#fileExists(filePath))
+          return filePath;
+      }
+      return null;
+    })();
+    this.#resolvedFileCache.set(absPathNoExt, cached);
+    return cached;
+  }
+  async getCss({ refresh } = {}) {
+    if (this.#cssText !== null && !refresh)
+      return this.#cssText;
+    const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh });
+    this.#cssText = await this.compileCss(cssPaths, sourcePaths);
+    return this.#cssText;
+  }
+  async getCssByBasePath({ refresh } = {}) {
+    if (this.#cssTextByBasePath !== null && !refresh)
+      return this.#cssTextByBasePath;
+    const akanConfig = await this.#app.getConfig({ refresh });
+    const pageKeys = await this.#app.getPageKeys({ refresh });
+    const basePaths = [...akanConfig.basePaths];
+    const rootPageKeys = pageKeys.filter((pageKey) => getPageKeyBasePath(pageKey, basePaths) === null);
+    const cssEntries = await Promise.all([
+      (async () => {
+        if (rootPageKeys.length === 0)
+          return ["", ""];
+        const started = Date.now();
+        const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh, pageKeys: rootPageKeys });
+        const css = await this.compileCss(cssPaths, sourcePaths);
+        this.#logger.verbose(`css base=root paths=${cssPaths.length} sources=${sourcePaths.length} in ${Date.now() - started}ms`);
+        return ["", css];
+      })(),
+      ...basePaths.map(async (basePath) => {
+        const basePathPageKeys = pageKeys.filter((pageKey) => getPageKeyBasePath(pageKey, basePaths) === basePath);
+        if (basePathPageKeys.length === 0)
+          return [basePath, ""];
+        const started = Date.now();
+        const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh, pageKeys: basePathPageKeys });
+        const css = await this.compileCss(cssPaths, sourcePaths);
+        this.#logger.verbose(`css base=${basePath} paths=${cssPaths.length} sources=${sourcePaths.length} in ${Date.now() - started}ms`);
+        return [basePath, css];
+      })
+    ]);
+    this.#cssTextByBasePath = Object.fromEntries(cssEntries);
+    return this.#cssTextByBasePath;
+  }
+  async discoverCss({ refresh } = {}) {
+    const { cssPaths } = await this.discoverCssAndSources({ refresh });
+    return cssPaths;
+  }
+  async discoverCssAndSources({
+    refresh,
+    pageKeys
+  } = {}) {
+    pageKeys ??= await this.#app.getPageKeys({ refresh });
+    const seeds = pageKeys.map((key) => path8.resolve(this.#app.cwdPath, "page", key));
+    const cssFiles = new Set;
+    const sourceFiles = new Set;
+    const queue = [...seeds];
+    const resolvePackage = await createTsconfigPackageResolver(this.#app);
+    const analyzer = new BarrelAnalyzer({ resolvePackage });
+    const akanConfig = await this.#app.getConfig({ refresh });
+    while (queue.length > 0) {
+      const filePath = queue.shift();
+      if (!filePath || sourceFiles.has(filePath) || isIgnoredNodeModuleSource(filePath))
+        continue;
+      sourceFiles.add(filePath);
+      let content;
+      try {
+        content = await Bun.file(filePath).text();
+      } catch {
+        continue;
+      }
+      let source = content;
+      if (akanConfig.barrelImports.length > 0) {
+        try {
+          const rewritten = await rewriteBarrelImports(content, akanConfig.barrelImports, analyzer);
+          if (rewritten !== null)
+            source = rewritten;
+        } catch {}
+      }
+      let imports;
+      try {
+        imports = this.#transpiler.scanImports(source);
+      } catch {
+        continue;
+      }
+      const importerDir = path8.dirname(filePath);
+      for (const imp of imports) {
+        const spec = imp.path;
+        if (!spec)
+          continue;
+        if (spec.endsWith(".css")) {
+          const cssPath = await this.#resolveCssImport(spec, importerDir);
+          cssFiles.add(cssPath);
+          continue;
+        }
+        if (NON_SOURCE_EXT_RE.test(spec))
+          continue;
+        const resolved = await this.#resolveSourceImport(spec, importerDir, resolvePackage);
+        if (!resolved || sourceFiles.has(resolved) || isIgnoredNodeModuleSource(resolved))
+          continue;
+        queue.push(resolved);
+      }
+    }
+    return { cssPaths: [...cssFiles], sourcePaths: [...sourceFiles] };
+  }
+  async compileCss(cssPaths, sourcePaths) {
+    if (cssPaths.length === 0)
+      return "";
+    const compileStarted = Date.now();
+    const compilers = await Promise.all(cssPaths.map(async (cssPath) => {
+      const css = await Bun.file(cssPath).text();
+      const base = path8.dirname(cssPath);
+      const compiler = await compile(css, {
+        base,
+        loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase),
+        loadModule: (id, fromBase) => this.#loadModule(id, fromBase)
+      });
+      return { cssPath, compiler };
+    }));
+    const sourceDirs = new Set;
+    for (const entry of compilers) {
+      if (!entry)
+        continue;
+      for (const s of entry.compiler.sources)
+        sourceDirs.add(s.base);
+    }
+    const scanStarted = Date.now();
+    const candidates = await this.#scanCandidates(sourcePaths, [...sourceDirs]);
+    this.#logger.verbose(`css candidates scanned count=${candidates.length} sources=${sourcePaths.length} dirs=${sourceDirs.size} in ${Date.now() - scanStarted}ms`);
+    const parts = [];
+    for (const entry of compilers) {
+      if (!entry)
+        continue;
+      parts.push(entry.compiler.build(candidates));
+    }
+    this.#logger.verbose(`css compiled paths=${cssPaths.length} candidates=${candidates.length} in ${Date.now() - compileStarted}ms`);
+    return parts.join(`
+`);
+  }
+  async#loadStylesheet(id, fromBase) {
+    const p = await this.#resolveCssImport(id, fromBase);
+    const content = await Bun.file(p).text();
+    return { path: p, base: path8.dirname(p), content };
+  }
+  async#resolveCssImport(id, fromBase) {
+    if (id.startsWith(".") || id.startsWith("/"))
+      return path8.resolve(fromBase, id);
+    const resolver = await this.#getCssImportResolver();
+    const resolved = await resolver.resolve(id, fromBase);
+    if (resolved)
+      return resolved;
+    throw new Error(`[css] failed to resolve stylesheet import "${id}" from ${fromBase}`);
+  }
+  async#getCssImportResolver() {
+    if (this.#cssImportResolver)
+      return this.#cssImportResolver;
+    this.#cssImportResolver = await CssImportResolver.create(this.#app);
+    return this.#cssImportResolver;
+  }
+  async#loadModule(id, fromBase) {
+    const p = __require.resolve(id, { paths: [fromBase] });
+    const mod = await import(p);
+    return { path: p, base: path8.dirname(p), module: mod.default ?? mod };
+  }
+  #resolveSourceImport(id, fromBase, resolvePackage) {
+    const cacheKey = `${fromBase}\x00${id}`;
+    let cached = this.#resolvedSpecifierCache.get(cacheKey);
+    if (cached)
+      return cached;
+    cached = this.#resolveSourceImportUncached(id, fromBase, resolvePackage);
+    this.#resolvedSpecifierCache.set(cacheKey, cached);
+    return cached;
+  }
+  async#resolveSourceImportUncached(id, fromBase, resolvePackage) {
+    if (id.startsWith(".") || id.startsWith("/")) {
+      const abs = id.startsWith("/") ? id : path8.resolve(fromBase, id);
+      return this.#resolveSourceFileCandidate(abs);
+    }
+    const pkg = await resolvePackage(id);
+    if (pkg)
+      return pkg.entryFile;
+    for (const resolve of [() => resolveSourceWithBun(id, fromBase), () => resolveSourceWithRequire(id, fromBase)]) {
+      const resolved = await resolve();
+      if (resolved)
+        return resolved;
+    }
+    return null;
+  }
+  async#scanCandidates(sourcePaths, dirs) {
+    const candidates = new Set;
+    const glob = new Bun.Glob("**/*.{tsx,ts,jsx,js,html}");
+    const files = new Set(sourcePaths);
+    await Promise.all(dirs.map(async (dir) => {
+      for await (const file of glob.scan({ cwd: dir, absolute: true })) {
+        if (isIgnoredNodeModuleSource(file))
+          continue;
+        files.add(file);
+      }
+    }));
+    const cache = await new CssCandidateCache(this.#candidateCachePath).load();
+    await Promise.all([...files].map(async (file) => {
+      for (const candidate of await cache.candidatesFor(file))
+        candidates.add(candidate);
+    }));
+    await cache.save(files);
+    this.#logger.verbose(`css candidate cache reused=${cache.reused} rescanned=${cache.rescanned}`);
+    return [...candidates];
+  }
+}
+function resolveSourceWithBun(id, fromBase) {
+  try {
+    const resolved = Bun.resolveSync(id, fromBase);
+    return isSourceFile(resolved) ? resolved : null;
+  } catch {
+    return null;
+  }
+}
+function resolveSourceWithRequire(id, fromBase) {
+  try {
+    const resolved = __require.resolve(id, { paths: [fromBase] });
+    return isSourceFile(resolved) ? resolved : null;
+  } catch {
+    return null;
+  }
+}
+function isSourceFile(filePath) {
+  return SOURCE_EXTS.includes(path8.extname(filePath));
+}
+function isIgnoredNodeModuleSource(filePath) {
+  return NODE_MODULES_RE.test(filePath) && !AKANJS_NODE_MODULE_RE.test(filePath);
+}
+function getPageKeyBasePath(pageKey, basePaths) {
+  const normalized = pageKey.split(path8.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 mkdir3, stat as stat2 } from "fs/promises";
+import path9 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 = 1;
+  constructor(app, command = "start") {
+    this.#app = app;
+    this.#command = command;
+    this.#artifactRoot = path9.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 };
+    }
+    for (const font of fonts) {
+      if (!this.#isFontOptimizationEnabled(font))
+        continue;
+      await this.#optimizeFont(font);
+    }
+    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 path9.join(this.#artifactRoot, "fontCache.json");
+  }
+  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 = path9.isAbsolute(filePath) ? filePath : path9.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.#hashFontConfig(await this.#collectAutoSubsetText()) });
+    }
+    return this.#hashFontConfig({ version: FontOptimizer.#cacheVersion, fonts, sources });
+  }
+  async#fileStamp(filePath) {
+    try {
+      const stats = await stat2(filePath);
+      return { mtimeMs: Math.round(stats.mtimeMs), size: stats.size };
+    } catch {
+      return null;
+    }
+  }
+  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) => path9.join(this.#artifactRoot, relativePath));
+    for (const filePath of files) {
+      if (!await Bun.file(filePath).exists())
+        return null;
+    }
+    return { css: cache.css, files };
+  }
+  async#writeCache(key, result) {
+    const cache = {
+      version: FontOptimizer.#cacheVersion,
+      key,
+      css: result.css,
+      files: result.files.map((filePath) => path9.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 = path9.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);
+  }
+  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 = path9.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
+      await mkdir3(path9.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));
+  }
+  #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)));
+        }
+      }
+    }
+    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);
+      }
+      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;
+  }
+  #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;
+    const rel = src.replace(/^\//, "");
+    const candidates = [
+      this.#command === "build" ? path9.join(this.#app.dist.cwdPath, "public", rel) : null,
+      path9.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" });
+  }
+  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 = path9.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 path9.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 = path9.isAbsolute(filePath) ? filePath : path9.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 roots = ["page", "ui"].map((dir) => path9.join(this.#app.cwdPath, dir));
+    const glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,html,md}");
+    const parts = [];
+    await Promise.all(roots.map(async (root) => {
+      if (!await Bun.file(root).exists())
+        return;
+      for await (const filePath of glob.scan({ cwd: root, absolute: true })) {
+        parts.push(await Bun.file(filePath).text());
+      }
+    }));
+    return parts.join("");
+  }
+  #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);
+        }
+      }
+      FontOptimizer.#ksX1001Text = [...chars].join("");
+    } catch {
+      FontOptimizer.#ksX1001Text = FontOptimizer.#rangeTextStatic(44032, 55203);
+    }
+    return FontOptimizer.#ksX1001Text;
+  }
+  static #rangeTextStatic(start, end) {
+    let text = "";
+    for (let code = start;code <= end; code++)
+      text += String.fromCodePoint(code);
+    return text;
+  }
+  #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
+      }));
+    }
+    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
+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",
+  "croner",
+  "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 = path10.resolve(workspaceRoot, replPath + suffix);
+        const hit = await firstExisting(candidate);
+        if (hit)
+          return hit;
+      }
+    }
+    for (const { pkg, entryFile } of rootEntries) {
+      if (spec !== pkg && !spec.startsWith(`${pkg}/`))
+        continue;
+      if (spec === pkg)
+        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;
+    }
+    return null;
+  }
+  return {
+    name: "akan-externalize-framework",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, async (args) => {
+        const spec = args.path;
+        if (spec === "." || spec === ".." || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/"))
+          return;
+        if (extraExact.has(spec) || DEFAULT_EXCLUDE_EXACT.has(spec))
+          return { path: spec, external: true };
+        for (const prefix of DEFAULT_EXCLUDE_PREFIX) {
+          if (spec.startsWith(prefix))
+            return { path: spec, external: true };
+        }
+        if (OPTIONAL_BACKEND_EXTERNAL_EXACT.has(spec))
+          return { path: spec, external: true };
+        if (RUNTIME_EXTERNAL_EXACT.has(spec))
+          return { path: spec, external: true };
+        for (const prefix of RUNTIME_EXTERNAL_PREFIX) {
+          if (spec.startsWith(prefix))
+            return { path: spec, external: true };
+        }
+        for (const prefix of includePrefixes) {
+          if (!spec.startsWith(prefix))
+            continue;
+          const resolved = await resolveWorkspaceSubpath(spec);
+          if (resolved)
+            return { path: resolved };
+          return;
+        }
+        return;
+      });
+    }
+  };
+}
+async function firstExisting(basePath) {
+  if (await Bun.file(basePath).exists())
+    return basePath;
+  for (const ext of CANDIDATE_EXTS) {
+    const candidate = `${basePath}${ext}`;
+    if (await Bun.file(candidate).exists())
+      return candidate;
+  }
+  for (const ext of CANDIDATE_EXTS) {
+    const candidate = path10.join(basePath, `index${ext}`);
+    if (await Bun.file(candidate).exists())
+      return candidate;
+  }
+  return null;
+}
+
+// pkgs/@akanjs/devkit/transforms/useClientBundlePlugin.ts
+function createUseClientBundlePlugin(options = {}) {
+  return {
+    name: "akan-use-client-bundle",
+    setup(build) {
+      build.onLoad({ filter: /\.(tsx|ts|jsx|js)$/ }, async (args) => {
+        if (args.path.includes("/node_modules/"))
+          return;
+        let source;
+        try {
+          source = await Bun.file(args.path).text();
+        } catch {
+          return;
+        }
+        const stubbed = transformUseClient(source, {
+          path: args.path,
+          workspaceRoot: options.workspaceRoot
+        });
+        if (stubbed === null)
+          return;
+        return { contents: stubbed, loader: loaderFor(args.path) };
+      });
+    }
+  };
+}
+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/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.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
+    };
+  }
+  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"
+        }));
+      }
+    };
+  }
+  static createServerCssStubPlugin() {
+    return {
+      name: "akan-server-css-stub",
+      setup(build) {
+        build.onLoad({ filter: /\.css$/ }, () => ({
+          contents: "",
+          loader: "js"
+        }));
+      }
+    };
+  }
+  static createServerUseClientFetchPlugin() {
+    return {
+      name: "akan-server-use-client-fetch",
+      setup(build) {
+        build.onLoad({ filter: /[/\\]lib[/\\]useClient\.(ts|tsx|js|jsx)$/ }, async (args) => {
+          const source = await Bun.file(args.path).text();
+          const transformed = PagesBundleBuilder.transformServerUseClientFetchSource(source);
+          if (transformed === source)
+            return;
+          return { contents: transformed, loader: loaderFor2(args.path) };
+        });
+      }
+    };
+  }
+  static transformServerUseClientFetchSource(source) {
+    if (!source.includes(`with { type: "macro" }`) || !source.includes("FetchClient.build"))
+      return source;
+    return source.replace(/import\s+\{\s*getSerializedSignal\s*\}\s+from\s+["']\.\/sig["']\s+with\s+\{\s*type\s*:\s*["']macro["']\s*\};/, `import { fetch as serverFetch } from "./sig";`).replace(/const\s+fetchProto\s*=\s*FetchClient\.build<[^;]+;/, "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });");
+  }
+}
+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 path12 from "path";
+var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
+var MIN_COMPRESS_BYTES = 1024;
+async function precompressArtifacts(app) {
+  const roots = [path12.join(app.dist.cwdPath, ".akan/artifact/client")];
+  const result = { files: 0, inputBytes: 0, outputBytes: 0 };
+  await Promise.all(roots.map((root) => precompressRoot(root, result)));
+  if (result.files > 0) {
+    app.verbose(`[precompress] wrote ${result.files} gzip sidecars (${formatBytes(result.inputBytes)} -> ${formatBytes(result.outputBytes)})`);
+  }
+  return result;
+}
+async function precompressRoot(root, result) {
+  if (!fs2.existsSync(root) || !fs2.statSync(root).isDirectory())
+    return;
+  const glob = new Bun.Glob("**/*");
+  for await (const filePath of glob.scan({ cwd: root, absolute: true })) {
+    if (!await shouldPrecompress(filePath))
+      continue;
+    const bytes = await Bun.file(filePath).bytes();
+    const gz = Bun.gzipSync(toArrayBuffer(bytes));
+    await Bun.write(`${filePath}.gz`, gz);
+    result.files += 1;
+    result.inputBytes += bytes.byteLength;
+    result.outputBytes += gz.byteLength;
+  }
+}
+async function shouldPrecompress(filePath) {
+  if (filePath.endsWith(".gz"))
+    return false;
+  if (!COMPRESSIBLE_EXTS.has(path12.extname(filePath).toLowerCase()))
+    return false;
+  const file = Bun.file(filePath);
+  if (!await file.exists())
+    return false;
+  return file.size >= MIN_COMPRESS_BYTES;
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function 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`;
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/ssrBaseArtifactBuilder.ts
+import path13 from "path";
+import { optimize } from "@tailwindcss/node";
+function prepareCssAsset(command, basePath, cssText) {
+  return optimize(cssText, { file: `${basePath || "root"}.css`, minify: command === "build" }).code;
+}
+
+class SsrBaseArtifactBuilder {
+  #app;
+  #command;
+  #artifactDir;
+  #absArtifactDir;
+  #started = Date.now();
+  constructor(app, command = "start") {
+    this.#app = app;
+    this.#command = command;
+    this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
+    this.#absArtifactDir = path13.resolve(this.#artifactDir);
+  }
+  async build() {
+    const akanConfig = await this.#app.getConfig();
+    const { rscClientUrl, rscRuntimeClientManifest, rscRuntimeSsrManifest, vendorMap } = await this.#buildRuntimeClientEntries();
+    const pageKeys = await this.#app.getPageKeys();
+    this.#app.verbose(`[base-artifact] discovered ${pageKeys.length} route files under ${this.#app.cwdPath}/page`);
+    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
+    const { cssCompiler, optimizedFonts, cssAssets } = await this.#buildStyleAssets();
+    const pagesBundle = await new PagesBundleBuilder(this.#app, this.#command, pageEntries).build();
+    this.#app.verbose(`[base-artifact] pages bundle -> ${pagesBundle.bundlePath} (buildId=${pagesBundle.buildId}, splitting=${pagesBundle.splitting}, entry=${pagesBundle.entryBytes} bytes, outputs=${pagesBundle.outputCount}, chunks=${pagesBundle.chunkCount}, total=${pagesBundle.outputBytes} bytes)`);
+    const seedIndex = computeRouteSeedIndex(pageEntries);
+    const seedIndexPath = await saveRouteSeedIndex(this.#absArtifactDir, seedIndex, {
+      production: this.#command === "build"
+    });
+    this.#app.verbose(`[base-artifact] route seed index -> ${seedIndexPath} entries=${seedIndex.entries.length} globalLayouts=${seedIndex.globalLayoutFiles.length}`);
+    const artifact = {
+      rscClientUrl,
+      rscRuntimeClientManifest,
+      rscRuntimeSsrManifest,
+      vendorMap,
+      cssAssets,
+      pagesBundlePath: this.#command === "build" ? path13.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
+      pagesBundleBuildId: pagesBundle.buildId,
+      domains: [...akanConfig.domains],
+      subRoutes: Object.fromEntries(Array.from(akanConfig.subRoutes.entries()).map(([basePath, domains]) => [basePath, [...domains]])),
+      basePaths: [...akanConfig.basePaths],
+      branches: [...akanConfig.branches],
+      i18n: akanConfig.i18n,
+      imageConfig: akanConfig.images,
+      deepLinkAssociations: Object.values(akanConfig.mobile.targets).filter((target) => (target.deepLinks?.domains?.length ?? 0) > 0).map((target) => ({
+        targetName: target.name,
+        appId: target.appId,
+        domains: target.deepLinks?.domains ?? [],
+        iosTeamId: target.deepLinks?.ios?.teamId,
+        androidSha256CertFingerprints: target.deepLinks?.android?.sha256CertFingerprints
+      }))
+    };
+    await Bun.write(path13.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
+`);
+    this.#app.verbose(`[base-artifact] complete in ${Date.now() - this.#started}ms`);
+    return { artifact, seedIndex, cssCompiler, optimizedFonts };
+  }
+  async#buildRuntimeClientEntries() {
+    const akanServerPath = await this.#resolveAkanServerPath();
+    const rscClientEntry = path13.resolve(akanServerPath, "rscClient.tsx");
+    const rscSegmentOutletEntry = path13.resolve(akanServerPath, "rscSegmentOutlet.tsx");
+    const vendorEntries = VENDOR_SPECIFIERS.map((specifier) => ({
+      specifier,
+      absPath: path13.resolve(akanServerPath, "vendor", `${specifier.replaceAll("/", "-").replaceAll(".", "-")}.ts`)
+    }));
+    const entries = [rscClientEntry, rscSegmentOutletEntry, ...vendorEntries.map((v) => v.absPath)];
+    const clientBundle = await new ClientEntriesBundler({ app: this.#app, entries, command: this.#command }).bundle();
+    const ssrBundle = await new ClientEntriesBundler({
+      app: this.#app,
+      entries: [rscSegmentOutletEntry],
+      ...RouteClientBuilder.resolveSsrClientExternalOptions(this.#command),
+      outputSubdir: "client-ssr",
+      command: this.#command
+    }).bundle();
+    const rscClientUrl = clientBundle.entryUrlsByAbsPath.get(rscClientEntry) ?? "";
+    const rscRuntimeSsrManifest = {
+      moduleLoading: null,
+      moduleMap: Object.fromEntries(Object.entries(clientBundle.manifest).map(([key, row]) => {
+        const ssrOutput = ssrBundle.entryOutputAbsByAbsPath.get(rscSegmentOutletEntry);
+        if (!ssrOutput || key !== `${clientBundle.clientReferenceIdByAbsPath.get(rscSegmentOutletEntry)}#${row.name}`) {
+          return null;
+        }
+        return [
+          row.id,
+          { [row.name]: { id: ssrOutput, chunks: [ssrOutput, ssrOutput], name: row.name, async: true } }
+        ];
+      }).filter((entry) => Boolean(entry)))
+    };
+    const vendorMap = Object.fromEntries(vendorEntries.map(({ specifier, absPath }) => [specifier, clientBundle.entryUrlsByAbsPath.get(absPath) ?? ""]));
+    this.#app.verbose(`[base-artifact] rscClientUrl=${rscClientUrl} vendors=${Object.keys(vendorMap).length}`);
+    return {
+      rscClientUrl,
+      rscRuntimeClientManifest: clientBundle.manifest,
+      rscRuntimeSsrManifest,
+      vendorMap
+    };
+  }
+  async#resolveAkanServerPath() {
+    const candidates = [];
+    try {
+      candidates.push(path13.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
+    } catch {}
+    candidates.push(path13.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path13.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
+    try {
+      candidates.push(path13.dirname(Bun.resolveSync("akanjs/server", path13.dirname(Bun.main))));
+    } catch {}
+    candidates.push(path13.join(path13.dirname(Bun.main), "node_modules/akanjs/server"), path13.join(path13.dirname(Bun.main), "../../akanjs/server"), path13.resolve(import.meta.dir, "../../server"), path13.resolve(import.meta.dir, "../server"));
+    for (const candidate of candidates) {
+      if (await Bun.file(path13.join(candidate, "rscClient.tsx")).exists())
+        return candidate;
+    }
+    throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
+  }
+  async#buildStyleAssets() {
+    const cssCompiler = new CssCompiler(this.#app);
+    const cssByBasePath = await cssCompiler.getCssByBasePath();
+    const optimizedFonts = await new FontOptimizer(this.#app, this.#command).optimize();
+    const cssAssets = Object.fromEntries(await Promise.all(Object.entries(cssByBasePath).flatMap(([basePath, baseCssText]) => {
+      const cssText = [baseCssText, optimizedFonts.css].filter(Boolean).join(`
+`);
+      if (!cssText)
+        return [];
+      return [this.#writeCssAsset(basePath, cssText)];
+    })));
+    if (optimizedFonts.files.length > 0)
+      this.#app.verbose(`[base-artifact] optimized ${optimizedFonts.files.length} font files`);
+    return { cssCompiler, optimizedFonts, cssAssets };
+  }
+  async#writeCssAsset(basePath, cssText) {
+    const cssAssetName = basePath || "root";
+    const preparedCssText = await prepareCssAsset(this.#command, basePath, cssText);
+    const cssHash = Bun.hash(`${basePath}
+${preparedCssText}`).toString(36);
+    const [cssRelPath, cssUrl] = [
+      `styles/${cssAssetName}-${cssHash}.css`,
+      `/_akan/styles/${cssAssetName}-${cssHash}.css`
+    ];
+    await Bun.write(path13.join(this.#absArtifactDir, cssRelPath), preparedCssText);
+    this.#app.verbose(`[base-artifact] wrote ${preparedCssText.length} bytes of CSS for ${basePath} -> ${cssRelPath}`);
+    return [basePath, { cssUrl, cssRelPath }];
+  }
+}
+export { AllRoutesBuilder, CsrArtifactBuilder, CssCompiler, FontOptimizer, PagesBundleBuilder, precompressArtifacts, SsrBaseArtifactBuilder };