@akanjs/cli 3.0.0-alpha.7 → 3.0.0-alpha.70

package/{index-qb61h0k7.js → index-abyjt72y.js}

@@ -9,276 +9,26 @@ import {
   createTsconfigPackageResolver,
   rewriteBarrelImports,
   transformUseClient
-} from "./index-j9cxndc0.js";
+} from "./index-qnv0aqmm.js";
+import {
+  resolveSsrPageEntriesForApp
+} from "./index-f39512t6.js";
 import {
   __require
-} from "./index-r24hmh0q.js";
+} from "./index-yb2wsc7f.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 });
-}
+import path3 from "path";
 
 // pkgs/@akanjs/devkit/artifact/routeSeedIndex.ts
-import path2 from "path";
+import path 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))];
+    const files = [path.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path.resolve(seed))];
     if (parsed.kind === "layout" || parsed.kind === "overrides") {
       const prefix = parsed.routeSegments.join("/");
       const prev = layoutsByPrefix.get(prefix) ?? [];
@@ -315,7 +65,7 @@ function computeRouteSeedIndex(pageEntries) {
 }
 var ROUTE_SEED_INDEX_JSON = "route-seed-index.json";
 function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
-  const normalizedArtifactDir = path2.resolve(artifactDir);
+  const normalizedArtifactDir = path.resolve(artifactDir);
   if (options.production) {
     return {
       entries: index.entries.map((entry) => ({ routeId: entry.routeId }))
@@ -330,19 +80,19 @@ function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
   };
 }
 async function saveRouteSeedIndex(artifactDir, index, options = {}) {
-  const absPath = path2.join(path2.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
+  const absPath = path.join(path.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
   await Bun.write(absPath, `${JSON.stringify(serializeRouteSeedIndexForArtifact(index, artifactDir, options), null, 2)}
 `);
   return absPath;
 }
 function serializeArtifactPath(artifactPath, artifactDir) {
-  if (!path2.isAbsolute(artifactPath))
+  if (!path.isAbsolute(artifactPath))
     return artifactPath;
-  return path2.relative(artifactDir, artifactPath).split(path2.sep).join("/");
+  return path.relative(artifactDir, artifactPath).split(path.sep).join("/");
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/routesManifestArtifactSerializer.ts
-import path3 from "path";
+import path2 from "path";
 
 class RoutesManifestArtifactSerializer {
   #manifest;
@@ -350,7 +100,7 @@ class RoutesManifestArtifactSerializer {
   #production;
   constructor(manifest, artifactDir, options = {}) {
     this.#manifest = manifest;
-    this.#artifactDir = path3.resolve(artifactDir);
+    this.#artifactDir = path2.resolve(artifactDir);
     this.#production = options.production ?? false;
   }
   static serialize(manifest, artifactDir, options = {}) {
@@ -383,9 +133,9 @@ class RoutesManifestArtifactSerializer {
     };
   }
   #serializeArtifactPath(artifactPath) {
-    if (!path3.isAbsolute(artifactPath))
+    if (!path2.isAbsolute(artifactPath))
       return artifactPath;
-    return path3.relative(this.#artifactDir, artifactPath).split(path3.sep).join("/");
+    return path2.relative(this.#artifactDir, artifactPath).split(path2.sep).join("/");
   }
 }
 
@@ -435,7 +185,7 @@ class AllRoutesBuilder {
       routeIds: this.#routeIds,
       ...this.#merged
     };
-    const manifestPath = path4.join(path4.resolve(this.#artifactDir), "routes-manifest.json");
+    const manifestPath = path3.join(path3.resolve(this.#artifactDir), "routes-manifest.json");
     await Bun.write(manifestPath, `${JSON.stringify(RoutesManifestArtifactSerializer.serialize(manifest, this.#artifactDir, {
       production: this.#command === "build"
     }), null, 2)}
@@ -478,12 +228,12 @@ class AllRoutesBuilder {
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
-import { mkdir as mkdir2, rm, unlink } from "fs/promises";
-import path6 from "path";
+import { mkdir, rm, unlink } from "fs/promises";
+import path5 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
 import fs from "fs";
-import path5 from "path";
+import path4 from "path";
 import ts from "typescript";
 
 class PagesEntrySourceGenerator {
@@ -526,11 +276,11 @@ ${entries.join(`
 `;
   }
   static #toImportSpecifier(moduleAbsPath) {
-    return path5.resolve(moduleAbsPath).split(path5.sep).join("/");
+    return path4.resolve(moduleAbsPath).split(path4.sep).join("/");
   }
   static #hasAsyncDefaultExport(moduleAbsPath) {
     try {
-      const source = fs.readFileSync(path5.resolve(moduleAbsPath), "utf8");
+      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 {
@@ -609,7 +359,7 @@ class CsrArtifactBuilder {
     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 });
+    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",
@@ -641,7 +391,7 @@ ${logs}` : ""}`);
     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");
+    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";
@@ -672,8 +422,8 @@ ${logs}` : ""}`);
     ];
   }
   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"));
+    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();
@@ -686,7 +436,7 @@ ${logs}` : ""}`);
       const htmlFile = Bun.file(htmlPath);
       if (!await htmlFile.exists())
         continue;
-      const basePath = path6.basename(htmlPath, ".html") === "index" ? "" : path6.basename(htmlPath, ".html");
+      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);
@@ -728,7 +478,7 @@ ${remainingAssets.join(`
         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 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))
@@ -799,12 +549,12 @@ ${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
       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);
+    return path5.resolve(path5.dirname(htmlPath), normalized);
   }
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
-import path8 from "path";
+import path7 from "path";
 import { Logger } from "akanjs/common";
 import { compile } from "tailwindcss";
 
@@ -875,7 +625,7 @@ class CssCandidateCache {
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/cssImportResolver.ts
-import path7 from "path";
+import path6 from "path";
 var CSS_IMPORT_EXTS = ["", ".css", "/styles.css", "/index.css"];
 
 class CssImportResolver {
@@ -928,7 +678,7 @@ class CssImportResolver {
     const exact = this.#paths[id];
     if (exact) {
       for (const repl of exact) {
-        const resolved = await this.#firstExisting(path7.resolve(this.#workspaceRoot, repl));
+        const resolved = await this.#firstExisting(path6.resolve(this.#workspaceRoot, repl));
         if (resolved)
           return resolved;
       }
@@ -939,7 +689,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(path7.resolve(this.#workspaceRoot, replPath + suffix));
+        const resolved = await this.#firstExisting(path6.resolve(this.#workspaceRoot, replPath + suffix));
         if (resolved)
           return resolved;
       }
@@ -969,25 +719,29 @@ class CssImportResolver {
     try {
       if (!await Bun.file(pkgPath).exists())
         return null;
-      const pkgDir = path7.dirname(pkgPath);
+      const pkgDir = path6.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));
+      const exportedEntry = typeof exportValue === "string" ? exportValue : exportValue?.style || exportValue?.import || exportValue?.default;
+      if (exportedEntry)
+        return await this.#firstExisting(path6.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"));
     } catch {
       return null;
     }
   }
   #resolutionBases(fromBase) {
-    return [fromBase, this.#workspaceRoot, path7.dirname(Bun.main), path7.resolve(path7.dirname(Bun.main), "../..")];
+    return [fromBase, this.#workspaceRoot, path6.dirname(Bun.main), path6.resolve(path6.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")
+      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")
     ];
   }
   async#firstExisting(basePath) {
@@ -1005,7 +759,7 @@ class CssImportResolver {
     return parts[0] ?? null;
   }
   static isCssFile(filePath) {
-    return path7.extname(filePath) === ".css";
+    return path6.extname(filePath) === ".css";
   }
 }
 
@@ -1024,13 +778,15 @@ class CssCompiler {
     this.#app = app;
   }
   get #candidateCachePath() {
-    return path8.join(this.#app.cwdPath, ".akan/cache/cssCandidates.json");
+    return path7.join(this.#app.cwdPath, ".akan/cache/cssCandidates.json");
   }
   #cssText = null;
   #cssTextByBasePath = null;
   #fileExistsCache = new Map;
   #resolvedFileCache = new Map;
   #resolvedSpecifierCache = new Map;
+  #discoveredCssPaths = new Set;
+  importedStylesheetsByBasePath = {};
   #fileExists(absPath) {
     let cached = this.#fileExistsCache.get(absPath);
     if (!cached) {
@@ -1052,7 +808,7 @@ class CssCompiler {
           return filePath;
       }
       for (const ext of SOURCE_EXTS) {
-        const filePath = path8.join(absPathNoExt, `index${ext}`);
+        const filePath = path7.join(absPathNoExt, `index${ext}`);
         if (await this.#fileExists(filePath))
           return filePath;
       }
@@ -1064,13 +820,20 @@ class CssCompiler {
   async getCss({ refresh } = {}) {
     if (this.#cssText !== null && !refresh)
       return this.#cssText;
+    this.#discoveredCssPaths.clear();
+    this.importedStylesheetsByBasePath = {};
     const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh });
-    this.#cssText = await this.compileCss(cssPaths, sourcePaths);
+    const { css, imported } = await this.#compileWithImports(cssPaths, sourcePaths);
+    this.#cssText = css;
+    this.importedStylesheetsByBasePath = { "": imported };
+    await this.#warnUnreachableStylesheets();
     return this.#cssText;
   }
   async getCssByBasePath({ refresh } = {}) {
     if (this.#cssTextByBasePath !== null && !refresh)
       return this.#cssTextByBasePath;
+    this.#discoveredCssPaths.clear();
+    this.importedStylesheetsByBasePath = {};
     const akanConfig = await this.#app.getConfig({ refresh });
     const pageKeys = await this.#app.getPageKeys({ refresh });
     const basePaths = [...akanConfig.basePaths];
@@ -1081,7 +844,8 @@ class CssCompiler {
           return ["", ""];
         const started = Date.now();
         const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh, pageKeys: rootPageKeys });
-        const css = await this.compileCss(cssPaths, sourcePaths);
+        const { css, imported } = await this.#compileWithImports(cssPaths, sourcePaths);
+        this.importedStylesheetsByBasePath[""] = imported;
         this.#logger.verbose(`css base=root paths=${cssPaths.length} sources=${sourcePaths.length} in ${Date.now() - started}ms`);
         return ["", css];
       })(),
@@ -1091,14 +855,27 @@ class CssCompiler {
           return [basePath, ""];
         const started = Date.now();
         const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh, pageKeys: basePathPageKeys });
-        const css = await this.compileCss(cssPaths, sourcePaths);
+        const { css, imported } = await this.#compileWithImports(cssPaths, sourcePaths);
+        this.importedStylesheetsByBasePath[basePath] = imported;
         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);
+    await this.#warnUnreachableStylesheets();
     return this.#cssTextByBasePath;
   }
+  async#warnUnreachableStylesheets() {
+    const pageDir = path7.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}`))
+        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`);
+    }
+  }
   async discoverCss({ refresh } = {}) {
     const { cssPaths } = await this.discoverCssAndSources({ refresh });
     return cssPaths;
@@ -1108,7 +885,7 @@ class CssCompiler {
     pageKeys
   } = {}) {
     pageKeys ??= await this.#app.getPageKeys({ refresh });
-    const seeds = pageKeys.map((key) => path8.resolve(this.#app.cwdPath, "page", key));
+    const seeds = pageKeys.map((key) => path7.resolve(this.#app.cwdPath, "page", key));
     const cssFiles = new Set;
     const sourceFiles = new Set;
     const queue = [...seeds];
@@ -1140,7 +917,7 @@ class CssCompiler {
       } catch {
         continue;
       }
-      const importerDir = path8.dirname(filePath);
+      const importerDir = path7.dirname(filePath);
       for (const imp of imports) {
         const spec = imp.path;
         if (!spec)
@@ -1158,21 +935,47 @@ class CssCompiler {
         queue.push(resolved);
       }
     }
-    return { cssPaths: [...cssFiles], sourcePaths: [...sourceFiles] };
+    const tokenPaths = await this.#libTokenStylesheets(sourceFiles);
+    const cssPaths = [...new Set([...tokenPaths, ...cssFiles])];
+    for (const cssPath of cssPaths)
+      this.#discoveredCssPaths.add(cssPath);
+    return { cssPaths, sourcePaths: [...sourceFiles] };
+  }
+  async#libTokenStylesheets(sourceFiles) {
+    const libsRoot = path7.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))
+        continue;
+      const [libName] = relPath.split(path7.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");
+      return await this.#fileExists(tokensPath) ? tokensPath : null;
+    }));
+    return tokenPaths.filter((tokensPath) => !!tokensPath);
   }
   async compileCss(cssPaths, sourcePaths) {
+    const { css } = await this.#compileWithImports(cssPaths, sourcePaths);
+    return css;
+  }
+  async#compileWithImports(cssPaths, sourcePaths) {
     if (cssPaths.length === 0)
-      return "";
+      return { css: "", imported: [] };
     const compileStarted = Date.now();
     const compilers = await Promise.all(cssPaths.map(async (cssPath) => {
       const css = await Bun.file(cssPath).text();
-      const base = path8.dirname(cssPath);
+      const base = path7.dirname(cssPath);
+      const imported2 = new Map;
       const compiler = await compile(css, {
         base,
-        loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase),
+        loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase, imported2),
         loadModule: (id, fromBase) => this.#loadModule(id, fromBase)
       });
-      return { cssPath, compiler };
+      return { cssPath, compiler, imported: imported2 };
     }));
     const sourceDirs = new Set;
     for (const entry of compilers) {
@@ -1185,23 +988,39 @@ class CssCompiler {
     const candidates = await this.#scanCandidates(sourcePaths, [...sourceDirs]);
     this.#logger.verbose(`css candidates scanned count=${candidates.length} sources=${sourcePaths.length} dirs=${sourceDirs.size} in ${Date.now() - scanStarted}ms`);
     const parts = [];
+    const imported = [];
     for (const entry of compilers) {
       if (!entry)
         continue;
-      parts.push(entry.compiler.build(candidates));
+      const part = entry.compiler.build(candidates);
+      parts.push(part);
+      for (const [cssPath, content] of entry.imported) {
+        const declaredNames = declaredCustomProperties(content);
+        imported.push({ cssPath, declaredNames });
+        if (declaredNames.length === 0 || declaredNames.some((name) => part.includes(`${name}:`)))
+          continue;
+        this.#logger.warn(`css @import ${cssPath} was loaded by ${entry.cssPath} but none of its ${declaredNames.length} declaration(s) reached the compiled CSS`);
+      }
     }
     this.#logger.verbose(`css compiled paths=${cssPaths.length} candidates=${candidates.length} in ${Date.now() - compileStarted}ms`);
-    return parts.join(`
-`);
+    return { css: parts.join(`
+`), imported };
   }
-  async#loadStylesheet(id, fromBase) {
+  async#loadStylesheet(id, fromBase, imported) {
     const p = await this.#resolveCssImport(id, fromBase);
+    this.#discoveredCssPaths.add(p);
     const content = await Bun.file(p).text();
-    return { path: p, base: path8.dirname(p), content };
+    imported?.set(p, content);
+    this.#logger.verbose(`css import "${id}" from ${fromBase} -> ${p} (${content.length} bytes)`);
+    return { path: p, base: path7.dirname(p), content };
   }
   async#resolveCssImport(id, fromBase) {
-    if (id.startsWith(".") || id.startsWith("/"))
-      return path8.resolve(fromBase, id);
+    if (id.startsWith(".") || id.startsWith("/")) {
+      const filePath = path7.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})`);
+    }
     const resolver = await this.#getCssImportResolver();
     const resolved = await resolver.resolve(id, fromBase);
     if (resolved)
@@ -1217,7 +1036,7 @@ class CssCompiler {
   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 };
+    return { path: p, base: path7.dirname(p), module: mod.default ?? mod };
   }
   #resolveSourceImport(id, fromBase, resolvePackage) {
     const cacheKey = `${fromBase}\x00${id}`;
@@ -1230,7 +1049,7 @@ class CssCompiler {
   }
   async#resolveSourceImportUncached(id, fromBase, resolvePackage) {
     if (id.startsWith(".") || id.startsWith("/")) {
-      const abs = id.startsWith("/") ? id : path8.resolve(fromBase, id);
+      const abs = id.startsWith("/") ? id : path7.resolve(fromBase, id);
       return this.#resolveSourceFileCandidate(abs);
     }
     const pkg = await resolvePackage(id);
@@ -1281,21 +1100,25 @@ function resolveSourceWithRequire(id, fromBase) {
   }
 }
 function isSourceFile(filePath) {
-  return SOURCE_EXTS.includes(path8.extname(filePath));
+  return SOURCE_EXTS.includes(path7.extname(filePath));
 }
 function isIgnoredNodeModuleSource(filePath) {
   return NODE_MODULES_RE.test(filePath) && !AKANJS_NODE_MODULE_RE.test(filePath);
 }
+function declaredCustomProperties(css) {
+  const withoutThemeBlocks = css.replace(/@theme[^{]*\{[^}]*\}/g, "");
+  return [...new Set([...withoutThemeBlocks.matchAll(/(?:^|[\s;{])(--[\w-]+)\s*:/g)].map(([, name]) => name))].filter((name) => !!name);
+}
 function getPageKeyBasePath(pageKey, basePaths) {
-  const normalized = pageKey.split(path8.sep).join("/").replace(/^\.\//, "");
+  const normalized = pageKey.split(path7.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 { mkdir as mkdir2, stat as stat2 } from "fs/promises";
+import path8 from "path";
 import ts2 from "typescript";
 var FONT_URL_PREFIX = "/_akan/fonts";
 var DEFAULT_FONT_SUBSETS = ["latin"];
@@ -1312,7 +1135,7 @@ class FontOptimizer {
   constructor(app, command = "start") {
     this.#app = app;
     this.#command = command;
-    this.#artifactRoot = path9.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
+    this.#artifactRoot = path8.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
   }
   async optimize() {
     const fonts = await this.discoverFonts();
@@ -1337,7 +1160,7 @@ class FontOptimizer {
     return result;
   }
   get #cachePath() {
-    return path9.join(this.#artifactRoot, "fontCache.json");
+    return path8.join(this.#artifactRoot, "fontCache.json");
   }
   async#buildCacheKey(fonts) {
     const sources = [];
@@ -1352,7 +1175,7 @@ class FontOptimizer {
         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 abs = path8.isAbsolute(filePath) ? filePath : path8.join(this.#app.cwdPath, filePath);
         const stamp = await this.#fileStamp(abs);
         if (!stamp)
           return null;
@@ -1375,7 +1198,7 @@ class FontOptimizer {
     const cache = await Bun.file(this.#cachePath).json().catch(() => null);
     if (cache?.version !== FontOptimizer.#cacheVersion || cache.key !== key)
       return null;
-    const files = cache.files.map((relativePath) => path9.join(this.#artifactRoot, relativePath));
+    const files = cache.files.map((relativePath) => path8.join(this.#artifactRoot, relativePath));
     for (const filePath of files) {
       if (!await Bun.file(filePath).exists())
         return null;
@@ -1387,7 +1210,7 @@ class FontOptimizer {
       version: FontOptimizer.#cacheVersion,
       key,
       css: result.css,
-      files: result.files.map((filePath) => path9.relative(this.#artifactRoot, filePath))
+      files: result.files.map((filePath) => path8.relative(this.#artifactRoot, filePath))
     };
     await Bun.write(this.#cachePath, JSON.stringify(cache));
   }
@@ -1395,7 +1218,7 @@ class FontOptimizer {
     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 filePath = path8.resolve(this.#app.cwdPath, "page", key);
       const file = Bun.file(filePath);
       if (!await file.exists())
         return;
@@ -1414,8 +1237,8 @@ class FontOptimizer {
         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 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);
@@ -1562,8 +1385,8 @@ class FontOptimizer {
       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.#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) {
@@ -1598,7 +1421,7 @@ class FontOptimizer {
       return "woff2";
     if (signature === "OTTO")
       return "otf";
-    const ext = path9.extname(sourcePath).slice(1).toLowerCase();
+    const ext = path8.extname(sourcePath).slice(1).toLowerCase();
     if (ext === "otf" || ext === "woff" || ext === "woff2")
       return ext;
     return "ttf";
@@ -1607,7 +1430,7 @@ class FontOptimizer {
     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);
+    return path8.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
   }
   async#getSubsetText(font) {
     const parts = new Set;
@@ -1617,7 +1440,7 @@ class FontOptimizer {
     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 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());
@@ -1637,7 +1460,7 @@ class FontOptimizer {
   }
   async#collectAutoSubsetText() {
     const libPageRoots = (await this.#app.getPageRoots()).filter((root) => root.keyPrefix).map((root) => root.dir);
-    const roots = [...["page", "ui"].map((dir) => path9.join(this.#app.cwdPath, dir)), ...libPageRoots];
+    const roots = [...["page", "ui"].map((dir) => path8.join(this.#app.cwdPath, dir)), ...libPageRoots];
     const glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,html,md}");
     const parts = [];
     await Promise.all(roots.map(async (root) => {
@@ -1752,6 +1575,170 @@ ${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
   }
 }
 
+// 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}";
+
+class FontPruner {
+  #app;
+  #keepGlobs;
+  #publicRoot;
+  #artifactRoot;
+  constructor(app, { keepFonts = [] } = {}) {
+    this.#app = app;
+    this.#keepGlobs = keepFonts;
+    this.#publicRoot = path9.join(app.dist.cwdPath, "public");
+    this.#artifactRoot = path9.join(app.dist.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);
+    }
+    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;
+  }
+  #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;
+  }
+  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())
+        continue;
+      candidates.push({ rel: rel.split(path9.sep).join("/"), basename: path9.basename(rel), bytes: entry.size });
+    }
+    return candidates;
+  }
+  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);
+    }
+    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#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(() => {
+        return;
+      });
+  }
+  #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 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);
+  }
+}
+
 // pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
 import path11 from "path";
 
@@ -1763,7 +1750,6 @@ var DEFAULT_EXCLUDE_PREFIX = ["@akanjs/cli/", "@akanjs/devkit/"];
 var OPTIONAL_BACKEND_EXTERNAL_EXACT = new Set([
   "@libsql/client",
   "bullmq",
-  "croner",
   "ioredis",
   "postgres",
   "protobufjs"
@@ -2154,6 +2140,7 @@ class SsrBaseArtifactBuilder {
       branches: [...akanConfig.branches],
       i18n: akanConfig.i18n,
       imageConfig: akanConfig.images,
+      web: akanConfig.web,
       deepLinkAssociations: Object.values(akanConfig.mobile.targets).filter((target) => (target.deepLinks?.domains?.length ?? 0) > 0).map((target) => ({
         targetName: target.name,
         appId: target.appId,
@@ -2180,7 +2167,7 @@ class SsrBaseArtifactBuilder {
     const ssrBundle = await new ClientEntriesBundler({
       app: this.#app,
       entries: [rscSegmentOutletEntry],
-      ...RouteClientBuilder.resolveSsrClientExternalOptions(this.#command),
+      ...RouteClientBuilder.resolveSsrClientBundleOptions(this.#command),
       outputSubdir: "client-ssr",
       command: this.#command
     }).bundle();
@@ -2232,13 +2219,13 @@ class SsrBaseArtifactBuilder {
 `);
       if (!cssText)
         return [];
-      return [this.#writeCssAsset(basePath, cssText)];
+      return [this.#writeCssAsset(basePath, cssText, cssCompiler.importedStylesheetsByBasePath[basePath] ?? [])];
     })));
     if (optimizedFonts.files.length > 0)
       this.#app.verbose(`[base-artifact] optimized ${optimizedFonts.files.length} font files`);
     return { cssCompiler, optimizedFonts, cssAssets };
   }
-  async#writeCssAsset(basePath, cssText) {
+  async#writeCssAsset(basePath, cssText, imported) {
     const cssAssetName = basePath || "root";
     const preparedCssText = await prepareCssAsset(this.#command, basePath, cssText);
     const cssHash = Bun.hash(`${basePath}
@@ -2248,9 +2235,17 @@ ${preparedCssText}`).toString(36);
       `/_akan/styles/${cssAssetName}-${cssHash}.css`
     ];
     await Bun.write(path13.join(this.#absArtifactDir, cssRelPath), preparedCssText);
+    SsrBaseArtifactBuilder.#warnDroppedImports(this.#app, cssRelPath, preparedCssText, imported);
     this.#app.verbose(`[base-artifact] wrote ${preparedCssText.length} bytes of CSS for ${basePath} -> ${cssRelPath}`);
     return [basePath, { cssUrl, cssRelPath }];
   }
+  static #warnDroppedImports(app, cssRelPath, css, imported) {
+    for (const { cssPath, declaredNames } of imported) {
+      if (declaredNames.length === 0 || declaredNames.some((name) => css.includes(`${name}:`)))
+        continue;
+      app.logger.warn(`[base-artifact] @import ${cssPath} declares ${declaredNames.length} custom propert${declaredNames.length === 1 ? "y" : "ies"} and none of them are in ${cssRelPath}`);
+    }
+  }
 }
 // pkgs/@akanjs/devkit/frontendBuild/styleGuard.ts
 var PREFIX = "(?:bg|text|border(?:-[tblrxy])?(?:-[se])?|ring(?:-offset)?|fill|stroke|shadow|from|to|via|divide|outline|decoration|placeholder|caret|accent)";
@@ -2258,210 +2253,8 @@ var PALETTE = "(?:slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|gre
 var LEAD = "(^|[\\s\"'`{(\\[:!])";
 var TAIL = "(?=[\\s\"'`})\\]:/!,]|$)";
 var RAW_PALETTE_RE = new RegExp(`${LEAD}((?:${PREFIX})-)${PALETTE}-\\d{2,3}${TAIL}`, "g");
-var ARBITRARY_COLOR_RE = /\[(#[0-9a-fA-F]{3,8}|(?:rgb|rgba|hsl|hsla|oklch|oklab|lab|lch|hwb|color)\([^\]]*\))\]/g;
 var INTERPOLATED_ARBITRARY_RE = new RegExp(`${LEAD}[a-z][a-z0-9-]*-\\[[^\\]\`]*\\$\\{`, "g");
-var STYLE_OBJECT_RE = /style=\{\{([\s\S]*?)\}\}/g;
-var STYLE_TAG_RE = /<style[^>]*>([\s\S]*?)<\/style>/g;
-var INLINE_COLOR_LITERAL_RE = /#[0-9a-fA-F]{3,8}\b|(?:rgb|rgba|hsl|hsla|oklch|oklab|lab|lch|hwb)\(/g;
 var DAISYUI_LEGACY_RE = new RegExp(`${LEAD}(?:` + "btn-(?:primary|secondary|accent|neutral|info|success|warning|error|ghost|link|outline|square|circle|wide|block|xs|sm|md|lg)|" + "badge-(?:primary|secondary|accent|neutral|info|success|warning|error|ghost|outline)|" + "alert-(?:info|success|warning|error)|" + "input-(?:bordered|primary|secondary|accent|ghost|error)|" + "select-(?:bordered|primary|ghost)|textarea-(?:bordered|primary|ghost)|" + "checkbox-(?:primary|secondary|accent)|toggle-(?:primary|secondary|accent)|" + "loading-(?:spinner|dots|ring|ball|bars|infinity)|" + "card-(?:body|title|actions)|modal-(?:box|action|backdrop)|" + "collapse-(?:title|content|arrow|plus)|dropdown-(?:content|end|start|hover)|" + "stat-(?:title|value|desc)|tabs-(?:boxed|lifted|bordered)|tab-active|" + "menu-(?:title|dropdown)|steps-(?:horizontal|vertical)|join-item|" + "mockup-(?:code|phone|browser|window)|drawer-(?:side|content|toggle)" + `)${TAIL}`, "g");
-var ALL_RULES = [
-  "raw-palette",
-  "arbitrary-color",
-  "inline-color",
-  "daisyui-legacy",
-  "interpolated-arbitrary"
-];
-
-class StyleGuard {
-  run(files) {
-    const out = [];
-    for (const file of files) {
-      const directives = this.#parseDirectives(file.content);
-      const scan = this.#stripComments(file.content);
-      const local = [];
-      this.#scanClassLiterals(file, scan, local);
-      this.#scanInlineColors(file, scan, local);
-      for (const v of local)
-        if (!this.#isSuppressed(v, directives))
-          out.push(v);
-    }
-    return out;
-  }
-  #stripComments(src) {
-    const out = src.split("");
-    const blank = (i2) => {
-      if (src[i2] !== `
-`)
-        out[i2] = " ";
-    };
-    let state = "code";
-    let i = 0;
-    while (i < src.length) {
-      const c = src[i];
-      const d = src[i + 1];
-      if (state === "code") {
-        if (c === "/" && d === "/") {
-          blank(i);
-          blank(i + 1);
-          state = "line";
-          i += 2;
-        } else if (c === "/" && d === "*") {
-          blank(i);
-          blank(i + 1);
-          state = "block";
-          i += 2;
-        } else {
-          if (c === "'")
-            state = "squote";
-          else if (c === '"')
-            state = "dquote";
-          else if (c === "`")
-            state = "template";
-          i++;
-        }
-      } else if (state === "line") {
-        if (c === `
-`)
-          state = "code";
-        else
-          blank(i);
-        i++;
-      } else if (state === "block") {
-        if (c === "*" && d === "/") {
-          blank(i);
-          blank(i + 1);
-          state = "code";
-          i += 2;
-        } else {
-          blank(i);
-          i++;
-        }
-      } else {
-        const close = state === "squote" ? "'" : state === "dquote" ? '"' : "`";
-        if (c === "\\")
-          i += 2;
-        else {
-          if (c === close)
-            state = "code";
-          i++;
-        }
-      }
-    }
-    return out.join("");
-  }
-  #parseDirectives(content) {
-    const directives = { file: null, nextLine: new Map };
-    const lines = content.split(`
-`);
-    for (let i = 0;i < lines.length; i++) {
-      const line = lines[i];
-      const nextLineMatch = line.match(/styleguard-disable-next-line\b(.*)$/);
-      if (nextLineMatch) {
-        directives.nextLine.set(i + 2, this.#extractRules(nextLineMatch[1]));
-        continue;
-      }
-      const fileMatch = line.match(/styleguard-disable\b(.*)$/);
-      if (fileMatch)
-        directives.file = this.#mergeFileScope(directives.file, this.#extractRules(fileMatch[1]));
-    }
-    return directives;
-  }
-  #extractRules(tail) {
-    const found = ALL_RULES.filter((rule) => tail.includes(rule));
-    return found.length === 0 ? "all" : new Set(found);
-  }
-  #mergeFileScope(prev, next) {
-    if (prev === "all" || next === "all")
-      return "all";
-    return new Set([...prev ?? [], ...next]);
-  }
-  #isSuppressed(v, directives) {
-    if (directives.file === "all" || directives.file?.has(v.rule))
-      return true;
-    const nextLine = directives.nextLine.get(v.line);
-    return nextLine === "all" || (nextLine?.has(v.rule) ?? false);
-  }
-  #scanClassLiterals(file, scan, out) {
-    for (const m of scan.matchAll(RAW_PALETTE_RE)) {
-      out.push(this.#violation(file, m.index ?? 0, {
-        rule: "raw-palette",
-        severity: "error",
-        suggestion: "\uC2DC\uB9E8\uD2F1 \uD1A0\uD070\uC73C\uB85C \uAD50\uCCB4\uD558\uC138\uC694 \u2014 \uC608: text-gray-500\u2192text-muted-foreground, bg-red-500\u2192bg-destructive, bg-blue-500\u2192bg-info. \uBE0C\uB79C\uB4DC \uC0C9\uC740 page/styles.css \uD1A0\uD070\uC5D0\uC11C \uC870\uC815\uD569\uB2C8\uB2E4."
-      }));
-    }
-    for (const m of scan.matchAll(ARBITRARY_COLOR_RE)) {
-      out.push(this.#violation(file, m.index ?? 0, {
-        rule: "arbitrary-color",
-        severity: "error",
-        suggestion: "\uC784\uC758 \uC0C9 \uB9AC\uD130\uB7F4 \uB300\uC2E0 \uD1A0\uD070\uC744 \uC4F0\uC138\uC694 \u2014 bg-[#3b82f6]\u2192bg-info, text-[rgb(...)]\u2192\uC2DC\uB9E8\uD2F1 \uD1A0\uD070. \uAF2D \uD544\uC694\uD558\uBA74 \uC2A4\uCF54\uD504 \uD1A0\uD070(.campaign-x { --primary: \u2026 })\uC744 \uC815\uC758\uD558\uC138\uC694."
-      }));
-    }
-    for (const m of scan.matchAll(DAISYUI_LEGACY_RE)) {
-      out.push(this.#violation(file, m.index ?? 0, {
-        rule: "daisyui-legacy",
-        severity: "error",
-        suggestion: "daisyUI \uD074\uB798\uC2A4\uB294 \uC81C\uAC70\uB410\uC2B5\uB2C8\uB2E4. akanjs/ui \uD504\uB9AC\uBBF8\uD2F0\uBE0C(Button/Badge \uB4F1)\uB098 buttonRecipe()/badgeRecipe() + \uC2DC\uB9E8\uD2F1 \uD1A0\uD070\uC73C\uB85C \uAD50\uCCB4\uD558\uC138\uC694."
-      }));
-    }
-    for (const m of scan.matchAll(INTERPOLATED_ARBITRARY_RE)) {
-      out.push(this.#violation(file, m.index ?? 0, {
-        rule: "interpolated-arbitrary",
-        severity: "error",
-        suggestion: "\uB7F0\uD0C0\uC784 \uAC12\uC73C\uB85C \uC784\uC758\uAC12 \uD074\uB798\uC2A4\uB97C \uC870\uB9BD\uD558\uBA74 CSS \uAC00 \uC0DD\uC131\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4(\uC2A4\uCE90\uB108\uB294 \uC18C\uC2A4 \uD14D\uC2A4\uD2B8\uB97C \uC77D\uC2B5\uB2C8\uB2E4). \uD06C\uAE30/\uC704\uCE58\uB294 style prop \uC73C\uB85C \uB118\uAE30\uC138\uC694 \u2014 style={{ minHeight }}. \uAC12\uC774 enum \uC774\uBA74 \uB9AC\uD130\uB7F4 \uD074\uB798\uC2A4 \uB9F5\uC73C\uB85C \uB450\uC138\uC694."
-      }));
-    }
-  }
-  #scanInlineColors(file, scan, out) {
-    const push = (index) => out.push(this.#violation(file, index, {
-      rule: "inline-color",
-      severity: "error",
-      suggestion: "\uC778\uB77C\uC778 \uC0C9 \uB9AC\uD130\uB7F4 \uB300\uC2E0 CSS \uBCC0\uC218/\uD1A0\uD070\uC744 \uCC38\uC870\uD558\uC138\uC694 \u2014 style={{ color: 'var(--primary)' }} \uB610\uB294 \uC2DC\uB9E8\uD2F1 \uD074\uB798\uC2A4(text-primary). \uD558\uB4DC\uCF54\uB529 hex/rgb \uB294 \uD14C\uB9C8 \uC804\uD658\uC744 \uAE68\uB728\uB9BD\uB2C8\uB2E4."
-    }));
-    for (const region of [STYLE_OBJECT_RE, STYLE_TAG_RE]) {
-      for (const m of scan.matchAll(region)) {
-        const inner = m[1] ?? "";
-        const innerStart = (m.index ?? 0) + m[0].indexOf(inner);
-        for (const lit of inner.matchAll(INLINE_COLOR_LITERAL_RE)) {
-          push(innerStart + (lit.index ?? 0));
-        }
-      }
-    }
-  }
-  #violation(file, index, base) {
-    const before = file.content.slice(0, index);
-    const line = before.length === 0 ? 1 : before.split(`
-`).length;
-    const lineStart = before.lastIndexOf(`
-`) + 1;
-    const lineEnd = file.content.indexOf(`
-`, index);
-    const snippet = file.content.slice(lineStart, lineEnd === -1 ? undefined : lineEnd).trim();
-    return { ...base, path: file.path, line, snippet };
-  }
-  static countNamedComponentClasses(css) {
-    const names = new Set;
-    const layerRe = /@layer\s+components\s*\{/g;
-    for (const layer of css.matchAll(layerRe)) {
-      const bodyStart = (layer.index ?? 0) + layer[0].length;
-      const body = StyleGuard.#extractBalanced(css, bodyStart);
-      for (const sel of body.matchAll(/(^|[\s}])\.(-?[a-zA-Z_][\w-]*)/g))
-        names.add(sel[2]);
-    }
-    return { count: names.size, names: [...names].sort() };
-  }
-  static #extractBalanced(css, start) {
-    let depth = 1;
-    for (let i = start;i < css.length; i++) {
-      const ch = css[i];
-      if (ch === "{")
-        depth++;
-      else if (ch === "}") {
-        depth--;
-        if (depth === 0)
-          return css.slice(start, i);
-      }
-    }
-    return css.slice(start);
-  }
-}
-export { AllRoutesBuilder, CsrArtifactBuilder, CssCompiler, FontOptimizer, PagesBundleBuilder, precompressArtifacts, SsrBaseArtifactBuilder };
+var DAISYUI_TOKEN = "(?:base-(?:100|200|300|content)|(?:primary|secondary|accent|neutral|info|success|warning|error)-content|error)";
+var DAISYUI_TOKEN_RE = new RegExp(`${LEAD}(?:${PREFIX})-${DAISYUI_TOKEN}${TAIL}`, "g");
+export { AllRoutesBuilder, CsrArtifactBuilder, CssCompiler, FontOptimizer, FontPruner, PagesBundleBuilder, precompressArtifacts, SsrBaseArtifactBuilder };