@akanjs/devkit 3.0.0-alpha.66 → 3.0.0-alpha.68

package/akanConfig/akanConfig.test.ts

@@ -173,7 +173,7 @@ describe("AkanAppConfig", () => {
   });
 
   test("keeps a declared Dockerfile string verbatim", () => {
-    const dockerfile = "FROM oven/bun:1-slim\nCOPY . .\nCMD [\"bun\",\"main.js\"]";
+    const dockerfile = 'FROM oven/bun:1-slim\nCOPY . .\nCMD ["bun","main.js"]';
     const config = new AkanAppConfig(app, [], packageJson, { docker: dockerfile }, baseDevEnv);
 
     expect(config.docker).toBe(dockerfile);
@@ -487,7 +487,6 @@ describe("AkanAppConfig lib externalLibs", () => {
   });
 });
 
-
 describe("AkanAppConfig lib docker runs", () => {
   const libDocker = (preRuns: string[], postRuns: string[] = []) => ({
     externalLibs: [],

package/akanConfig/akanConfig.ts

@@ -8,6 +8,7 @@ import type { App, Lib } from "../commandDecorators";
 import { LibExecutor, WorkspaceExecutor } from "../executors";
 import type { BaseDevEnv, PackageJson } from "../types";
 import {
+  type AkanAssetsConfig,
   type AkanMobileConfig,
   type AkanMobileTargetConfig,
   type AkanRouteConfig,
@@ -21,6 +22,7 @@ import {
   type DockerConfig,
   type DockerOption,
   type DockerRun,
+  type LibAssetsConfig,
   type LibConfigResult,
   type LibDockerConfig,
 } from "./types";
@@ -111,6 +113,7 @@ const DEFAULT_AKAN_IMAGE_CONFIG: AkanImageConfig = {
   maximumRedirects: 3,
   fetchTimeoutMs: 7000,
   maxRemoteBytes: 25 * 1024 * 1024,
+  maxConcurrency: 0,
 };
 
 const normalizeIndexPath = (indexPath: string | undefined): string | undefined => {
@@ -179,13 +182,20 @@ type AppConfigDeclaration = Omit<DeepPartial<AppConfigResult>, "docker" | "web">
 export interface LibContributions {
   externalLibs: string[];
   docker: LibDockerConfig;
+  /** Keep globs rewritten to the app's own `public/`, where `akan sync` mounts each lib's assets. */
+  keepFonts?: string[];
 }
 
 const emptyLibContributions = (): LibContributions => ({
   externalLibs: [],
   docker: { preRuns: [], postRuns: [] },
+  keepFonts: [],
 });
 
+const normalizeKeepFonts = (keepFonts: string[] | undefined) => [
+  ...new Set((keepFonts ?? []).map((glob) => glob.trim().replace(/^\/+/, "")).filter(Boolean)),
+];
+
 /** First occurrence wins, so a step a lib and its app both declare becomes one layer. */
 const dedupeDockerRuns = (runs: DockerRun[]): DockerRun[] => {
   const byKey = new Map<string, DockerRun>();
@@ -211,6 +221,7 @@ export class AkanAppConfig implements AppConfigResult {
   /** True only when the app's akan.config.ts explicitly declares a `mobile` section (vs. the synthesized default). */
   hasMobileConfig: boolean;
   secrets: string[];
+  assets: AkanAssetsConfig;
   /** Raw setting; resolved against the app's lib deps at sync time (see `AppExecutor.syncPages`). */
   syncPageLibs: string[] | boolean;
   baseDevEnv: BaseDevEnv;
@@ -251,6 +262,13 @@ export class AkanAppConfig implements AppConfigResult {
     process.env.AKAN_PUBLIC_LOCALES = this.i18n.locales.join(",");
     this.publicEnv = (config?.publicEnv as string[] | undefined) ?? ([] as string[]);
     this.secrets = (config?.secrets as string[] | undefined) ?? ([] as string[]);
+    this.assets = {
+      pruneFonts: config?.assets?.pruneFonts ?? true,
+      keepFonts: [
+        ...normalizeKeepFonts(config?.assets?.keepFonts as string[] | undefined),
+        ...(libContributions.keepFonts ?? []),
+      ],
+    };
     this.syncPageLibs = (config?.syncPageLibs as string[] | boolean | undefined) ?? false;
     this.hasMobileConfig = Boolean(config.mobile);
     this.mobile = this.#resolveMobileConfig(config.mobile);
@@ -460,11 +478,7 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
   }
   //* Every workspace lib is read, not just this app's lib deps: narrowing the set needs the dependency
   //* scan, and the incremental page rebundle re-reads this config on every file change.
-  static async #collectLibContributions(
-    app: App,
-    libs: string[],
-    bustImportCache: boolean,
-  ): Promise<LibContributions> {
+  static async #collectLibContributions(app: App, libs: string[], bustImportCache: boolean): Promise<LibContributions> {
     const libConfigs = await Promise.all(
       libs.map(async (libName) =>
         LibExecutor.from(app, libName)
@@ -481,6 +495,10 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
         preRuns: libConfigs.flatMap((libConfig) => libConfig?.docker.preRuns ?? []),
         postRuns: libConfigs.flatMap((libConfig) => libConfig?.docker.postRuns ?? []),
       },
+      //* A lib writes the glob against its own `public/`; `akan sync` mounts that at `public/libs/<lib>`.
+      keepFonts: libConfigs.flatMap((libConfig) =>
+        (libConfig?.assets.keepFonts ?? []).map((glob) => `libs/${libConfig?.lib.name}/${glob}`),
+      ),
     };
   }
   #resolveProductionDependencyVersion(lib: string) {
@@ -592,12 +610,14 @@ export class AkanLibConfig implements LibConfigResult {
   lib: Lib;
   externalLibs: string[];
   docker: LibDockerConfig;
+  assets: LibAssetsConfig;
   /** Live-only: plugins declared in this lib's `akan.config.ts` (never serialized). */
   plugins: AkanPlugin[];
   constructor(lib: Lib, config: DeepPartial<LibConfigResult>, plugins: AkanPlugin[] = []) {
     this.lib = lib;
     this.externalLibs = config?.externalLibs ?? [];
     this.docker = { preRuns: config?.docker?.preRuns ?? [], postRuns: config?.docker?.postRuns ?? [] };
+    this.assets = { keepFonts: normalizeKeepFonts(config?.assets?.keepFonts as string[] | undefined) };
     this.plugins = plugins;
   }
   static async from(lib: Lib, { bustImportCache = false }: { bustImportCache?: boolean } = {}) {

package/akanConfig/types.ts

@@ -1,4 +1,5 @@
 export type {
+  AkanAssetsConfig,
   AkanConfigFile,
   AkanExecutor,
   AkanMobileConfig,
@@ -23,6 +24,7 @@ export type {
   DockerOption,
   DockerRun,
   FileConventionScanResult,
+  LibAssetsConfig,
   LibConfig,
   LibConfigInput,
   LibConfigResult,

package/applicationBuildRunner.ts

@@ -7,7 +7,13 @@ import type {
   ApplicationBuildResult,
 } from "./applicationBuildReporter";
 import type { App } from "./commandDecorators";
-import { AllRoutesBuilder, CsrArtifactBuilder, precompressArtifacts, SsrBaseArtifactBuilder } from "./frontendBuild";
+import {
+  AllRoutesBuilder,
+  CsrArtifactBuilder,
+  FontPruner,
+  precompressArtifacts,
+  SsrBaseArtifactBuilder,
+} from "./frontendBuild";
 import { Spinner } from "./spinner";
 
 export interface TypecheckOptions {
@@ -15,7 +21,7 @@ export interface TypecheckOptions {
   incremental?: boolean;
 }
 
-export type BuildPhaseId = "prepare" | "typecheck" | "backend" | "ssr" | "csr" | "compress" | "metadata";
+export type BuildPhaseId = "prepare" | "typecheck" | "backend" | "ssr" | "csr" | "assets" | "compress" | "metadata";
 
 export type BuildPhaseResult = ApplicationBuildPhaseResult & { id: BuildPhaseId };
 export type BuildResult = ApplicationBuildResult;
@@ -37,6 +43,7 @@ const BUILD_PHASE_EMOJIS: Record<BuildPhaseId, string> = {
   backend: "📦",
   ssr: "🧭",
   csr: "🎨",
+  assets: "✂️",
   compress: "🗜️",
   metadata: "📝",
 };
@@ -77,7 +84,7 @@ export class ApplicationBuildRunner {
   async build({ spinner = false }: BuildOptions = {}): Promise<BuildResult> {
     // serial build is needed because of Bun.build is unstable for parallel build
     const phaseOptions = { spinner };
-    const { web } = await this.#app.getConfig();
+    const { web, assets } = await this.#app.getConfig();
     await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"), undefined, {
       spinner,
     });
@@ -108,6 +115,16 @@ export class ApplicationBuildRunner {
       (result) => result?.outputDir ?? (web.csr ? "skipped" : "disabled by akan.config.ts web.csr"),
       phaseOptions,
     );
+    await this.#runPhase(
+      "assets",
+      "Trimming unread static assets",
+      async () => (assets.pruneFonts ? await new FontPruner(this.#app, assets).prune() : null),
+      (result) =>
+        result
+          ? `${result.removed.length} font file(s) dropped, ${ApplicationBuildRunner.formatBytes(result.freedBytes)} freed; ${result.kept.length} kept`
+          : "disabled by akan.config.ts assets.pruneFonts",
+      phaseOptions,
+    );
     await this.#runPhase(
       "compress",
       "Compressing static assets",

package/executors.ts

@@ -1381,7 +1381,7 @@ export class AppExecutor extends SysExecutor {
       //? `web` is a build declaration: `akan start` keeps the full dev surface because the incremental
       //? builder is also the file watcher, so switching it off would take server-code HMR with it.
       if (!akanConfig.web.ssr || !akanConfig.web.csr)
-        this.logger.warn(
+        this.logger.verbose(
           `akan.config.ts disables web.${!akanConfig.web.ssr ? "ssr" : "csr"}; \`akan start\` still serves it, \`akan build\` will not`,
         );
     }

package/frontendBuild/fontPruner.test.ts

@@ -0,0 +1,220 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { App } from "../commandDecorators";
+import { FontPruner } from "./fontPruner";
+
+const tempRoots: string[] = [];
+
+interface Tree {
+  layout?: string;
+  publicFiles?: Record<string, string>;
+  artifactFiles?: Record<string, string>;
+  csrFiles?: Record<string, string>;
+}
+
+const write = async (root: string, files: Record<string, string>) => {
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = path.join(root, rel);
+    await mkdir(path.dirname(abs), { recursive: true });
+    await writeFile(abs, content);
+  }
+};
+
+const makeApp = async ({ layout = layoutWith(), publicFiles = {}, artifactFiles = {}, csrFiles = {} }: Tree = {}) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-devkit-font-prune-"));
+  tempRoots.push(root);
+  const cwdPath = path.join(root, "apps/demo");
+  const distPath = path.join(root, "dist/apps/demo");
+  await mkdir(path.join(cwdPath, "page"), { recursive: true });
+  await writeFile(path.join(cwdPath, "page/_layout.tsx"), layout);
+  await write(path.join(distPath, "public"), publicFiles);
+  await write(path.join(distPath, ".akan/artifact"), artifactFiles);
+  await write(path.join(distPath, "csr"), csrFiles);
+  const app = {
+    cwdPath,
+    dist: { cwdPath: distPath },
+    workspace: { workspaceRoot: root },
+    getPageKeys: async () => ["./_layout.tsx"],
+    getPageRoots: async () => [],
+    verbose: () => undefined,
+    logger: { info: () => undefined, warn: () => undefined },
+  } as unknown as App;
+  return { app, distPath };
+};
+
+const layoutWith = (extra = "") => `
+export const fonts = [
+  {
+    name: "pretendard",${extra}
+    paths: [{ src: "/libs/shared/fonts/Pretendard-Bold.woff2", weight: 700 }],
+  },
+];
+export default function Layout() {
+  return null;
+}
+`;
+
+const exists = (distPath: string, rel: string) => Bun.file(path.join(distPath, "public", rel)).exists();
+
+afterEach(async () => {
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("FontPruner", () => {
+  test("drops a subset font's source and reports the bytes freed", async () => {
+    const { app, distPath } = await makeApp({
+      publicFiles: { "libs/shared/fonts/Pretendard-Bold.woff2": "x".repeat(2048) },
+    });
+
+    const result = await new FontPruner(app).prune();
+
+    expect(result.removed.map(({ file }) => file)).toEqual(["libs/shared/fonts/Pretendard-Bold.woff2"]);
+    expect(result.freedBytes).toBe(2048);
+    expect(await exists(distPath, "libs/shared/fonts/Pretendard-Bold.woff2")).toBe(false);
+  });
+
+  test("drops a font no declaration and no surface mentions", async () => {
+    const { app, distPath } = await makeApp({
+      publicFiles: { "libs/shared/fonts/NotoSansKR.ttf": "x" },
+    });
+
+    const result = await new FontPruner(app).prune();
+
+    expect(result.removed.map(({ file }) => file)).toEqual(["libs/shared/fonts/NotoSansKR.ttf"]);
+    expect(await exists(distPath, "libs/shared/fonts/NotoSansKR.ttf")).toBe(false);
+  });
+
+  test("keeps a font a stylesheet in public loads by url", async () => {
+    const { app, distPath } = await makeApp({
+      publicFiles: {
+        "libs/shared/fonts/Assistant-Bold.woff2": "x",
+        "libs/shared/excalidraw.css": '@font-face{src:url("/libs/shared/fonts/Assistant-Bold.woff2")}',
+      },
+    });
+
+    const result = await new FontPruner(app).prune();
+
+    expect(result.removed).toEqual([]);
+    expect(result.kept).toEqual([
+      {
+        file: "libs/shared/fonts/Assistant-Bold.woff2",
+        bytes: 1,
+        reason: { kind: "referenced", referrer: "public/libs/shared/excalidraw.css" },
+      },
+    ]);
+    expect(await exists(distPath, "libs/shared/fonts/Assistant-Bold.woff2")).toBe(true);
+  });
+
+  test("keeps a font whose filename a referrer percent-encodes", async () => {
+    const { app } = await makeApp({
+      publicFiles: {
+        "fonts/Lemon Milk Pro Medium.otf": "x",
+        "brand.css": "@font-face{src:url(/fonts/Lemon%20Milk%20Pro%20Medium.otf)}",
+      },
+    });
+
+    const result = await new FontPruner(app).prune();
+
+    expect(result.removed).toEqual([]);
+    expect(result.kept[0]?.reason).toEqual({ kind: "referenced", referrer: "public/brand.css" });
+  });
+
+  test("keeps the source of a font declared with optimize: false", async () => {
+    const { app, distPath } = await makeApp({
+      layout: layoutWith("\n    optimize: false,"),
+      publicFiles: { "libs/shared/fonts/Pretendard-Bold.woff2": "x" },
+    });
+
+    const result = await new FontPruner(app).prune();
+
+    expect(result.removed).toEqual([]);
+    expect(result.kept[0]?.reason).toEqual({ kind: "unoptimized" });
+    expect(await exists(distPath, "libs/shared/fonts/Pretendard-Bold.woff2")).toBe(true);
+  });
+
+  test("keeps a font matched by an assets.keepFonts glob", async () => {
+    const { app, distPath } = await makeApp({
+      publicFiles: { "libs/shared/fonts/Assistant-Bold.woff2": "x" },
+    });
+
+    const result = await new FontPruner(app, { keepFonts: ["libs/shared/fonts/Assistant-*.woff2"] }).prune();
+
+    expect(result.removed).toEqual([]);
+    expect(result.kept[0]?.reason).toEqual({ kind: "declared", glob: "libs/shared/fonts/Assistant-*.woff2" });
+    expect(await exists(distPath, "libs/shared/fonts/Assistant-Bold.woff2")).toBe(true);
+  });
+
+  test("ignores the declaration the build inlines into its own bundles", async () => {
+    const { app } = await makeApp({
+      artifactFiles: {
+        "server/pages-abc.js": 'const fonts=[{paths:[{src:"/libs/shared/fonts/Pretendard-Bold.woff2"}]}]',
+      },
+      csrFiles: { "index.html": '<script>src:"/libs/shared/fonts/Pretendard-Bold.woff2"</script>' },
+      publicFiles: { "libs/shared/fonts/Pretendard-Bold.woff2": "x" },
+    });
+
+    const result = await new FontPruner(app).prune();
+
+    expect(result.removed.map(({ file }) => file)).toEqual(["libs/shared/fonts/Pretendard-Bold.woff2"]);
+  });
+
+  test("keeps a font a bundle loads that no declaration names", async () => {
+    const { app } = await makeApp({
+      artifactFiles: { "client/chunk-abc.js": 'new FontFace("x","url(/fonts/Runtime-Regular.woff2)")' },
+      publicFiles: { "fonts/Runtime-Regular.woff2": "x" },
+    });
+
+    const result = await new FontPruner(app).prune();
+
+    expect(result.removed).toEqual([]);
+    expect(result.kept[0]?.reason).toEqual({ kind: "referenced", referrer: ".akan/artifact/client/chunk-abc.js" });
+  });
+
+  test("keeps a font the compiled stylesheet still points at", async () => {
+    const { app } = await makeApp({
+      artifactFiles: { "styles/root-abc.css": "@font-face{src:url(/libs/shared/fonts/Pretendard-Bold.woff2)}" },
+      publicFiles: { "libs/shared/fonts/Pretendard-Bold.woff2": "x" },
+    });
+
+    const result = await new FontPruner(app).prune();
+
+    expect(result.removed).toEqual([]);
+    expect(result.kept[0]?.reason).toEqual({
+      kind: "referenced",
+      referrer: ".akan/artifact/styles/root-abc.css",
+    });
+  });
+
+  test("leaves non-font assets alone", async () => {
+    const { app, distPath } = await makeApp({
+      publicFiles: { "logo.png": "x", "video.mp4": "x", "libs/shared/fonts/NotoSansKR.ttf": "x" },
+    });
+
+    await new FontPruner(app).prune();
+
+    expect(await exists(distPath, "logo.png")).toBe(true);
+    expect(await exists(distPath, "video.mp4")).toBe(true);
+    expect(await exists(distPath, "libs/shared/fonts/NotoSansKR.ttf")).toBe(false);
+  });
+
+  test("does nothing when the build shipped no public directory", async () => {
+    const { app } = await makeApp();
+    await rm(path.join(app.dist.cwdPath, "public"), { recursive: true, force: true });
+
+    const result = await new FontPruner(app).prune();
+
+    expect(result).toEqual({ removed: [], kept: [], freedBytes: 0 });
+  });
+
+  test("removes a directory the prune emptied", async () => {
+    const { app, distPath } = await makeApp({
+      publicFiles: { "libs/shared/fonts/NotoSansKR.ttf": "x" },
+    });
+
+    await new FontPruner(app).prune();
+
+    expect(await Bun.file(path.join(distPath, "public/libs/shared/fonts")).exists()).toBe(false);
+  });
+});

package/frontendBuild/fontPruner.ts

@@ -0,0 +1,206 @@
+import { rm, rmdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { isFontOptimizationEnabled } from "akanjs/client";
+import type { App } from "../commandDecorators";
+import { FontOptimizer } from "./fontOptimizer";
+
+const FONT_GLOB = "**/*.{woff2,woff,ttf,otf,ttc,eot}";
+const REFERRER_GLOB = "**/*.{css,js,mjs,cjs,json,html,htm,svg,xml,webmanifest}";
+
+export type FontKeepReason =
+  | { kind: "unoptimized" }
+  | { kind: "declared"; glob: string }
+  | { kind: "referenced"; referrer: string };
+
+export interface FontPruneResult {
+  removed: { file: string; bytes: number }[];
+  kept: { file: string; bytes: number; reason: FontKeepReason }[];
+  freedBytes: number;
+}
+
+/**
+ * Drops the font sources in a build's `public/` that no built surface reads. A font with `optimize` on is
+ * served from `/_akan/fonts` after subsetting, so its source is a build input — the image ships it and the
+ * runtime never opens it. Only `dist` is touched: an app's and a lib's own `public/` keep every file, because
+ * one lib's fonts are picked over differently by every app that mounts it and by other repos.
+ */
+export class FontPruner {
+  #app: App;
+  #keepGlobs: string[];
+  #publicRoot: string;
+  #artifactRoot: string;
+
+  constructor(app: App, { keepFonts = [] }: { keepFonts?: string[] } = {}) {
+    this.#app = app;
+    this.#keepGlobs = keepFonts;
+    this.#publicRoot = path.join(app.dist.cwdPath, "public");
+    this.#artifactRoot = path.join(app.dist.cwdPath, ".akan/artifact");
+  }
+
+  async prune(): Promise<FontPruneResult> {
+    const empty: FontPruneResult = { 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<string>();
+    const optimizedSrcs = new Set<string>();
+    for (const font of fonts) {
+      const target = isFontOptimizationEnabled(font) ? optimizedSrcs : unoptimizedSrcs;
+      for (const fontPath of font.paths) target.add(path.posix.basename(fontPath.src));
+    }
+
+    const result: FontPruneResult = { removed: [], kept: [], freedBytes: 0 };
+    const undecided: typeof candidates = [];
+    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: { rel: string; basename: string }, unoptimizedSrcs: Set<string>): FontKeepReason | null {
+    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: { rel: string; basename: string; bytes: number }[] = [];
+    for await (const rel of new Bun.Glob(FONT_GLOB).scan({ cwd: this.#publicRoot, dot: false })) {
+      const entry = await stat(path.join(this.#publicRoot, rel)).catch(() => null);
+      if (!entry?.isFile()) continue;
+      candidates.push({ rel: rel.split(path.sep).join("/"), basename: path.basename(rel), bytes: entry.size });
+    }
+    return candidates;
+  }
+
+  /**
+   * Matched by basename rather than by URL, so a reference survives every spelling a referrer may use — an
+   * absolute or relative `url()`, and the percent-encoded form a font whose filename carries a space needs.
+   *
+   * The build's own bundles are read on weaker terms than `public/` and the compiled CSS: every route file's
+   * `fonts` declaration is inlined into the pages bundle, the client chunks and the CSR shell, so a declared
+   * source is in all three whether or not anything loads it. A hit there is therefore ignored for a font the
+   * optimizer already subset — that string is the declaration, not a fetch.
+   */
+  async #findReferrers(
+    candidates: { rel: string; basename: string }[],
+    optimizedSrcs: Set<string>,
+  ): Promise<Map<string, string>> {
+    const referrers = new Map<string, string>();
+    const authoritative = candidates;
+    const bundled = candidates.filter((candidate) => !optimizedSrcs.has(candidate.basename));
+    const roots: { dir: string; label: string; needles: typeof candidates }[] = [
+      { dir: this.#publicRoot, label: "public", needles: authoritative },
+      { dir: path.join(this.#artifactRoot, "styles"), label: ".akan/artifact/styles", needles: authoritative },
+      { dir: path.join(this.#artifactRoot, "client"), label: ".akan/artifact/client", needles: bundled },
+      { dir: path.join(this.#artifactRoot, "client-ssr"), label: ".akan/artifact/client-ssr", needles: bundled },
+      { dir: path.join(this.#artifactRoot, "server"), label: ".akan/artifact/server", needles: bundled },
+      { dir: path.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: { dir: string; label: string },
+    pending: { rel: string; basename: string }[],
+    referrers: Map<string, string>,
+  ) {
+    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(path.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(path.sep).join("/")}`);
+      }
+    }
+  }
+
+  async #remove(files: string[]) {
+    await Promise.all(files.map((file) => rm(path.join(this.#publicRoot, file), { force: true })));
+    const dirs = [...new Set(files.map((file) => path.posix.dirname(file)))]
+      .filter((dir) => dir !== "." && dir !== "/")
+      .sort((a, b) => b.length - a.length);
+    for (const dir of dirs) await rmdir(path.join(this.#publicRoot, dir)).catch(() => undefined);
+  }
+
+  /**
+   * The referrer roll-up is `info`, not `verbose`: a generated file that lists every asset in `public/` — a
+   * service-worker precache manifest is the usual one — is a real reference and keeps every font it names, so
+   * without this line a build that pruned nothing looks the same as a build with nothing to prune.
+   */
+  #report(result: FontPruneResult) {
+    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} — ${FontPruner.describe(reason)}`);
+    const byReferrer = new Map<string, { files: number; bytes: number }>();
+    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: FontKeepReason) {
+    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: number): string {
+    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: string) {
+    return await stat(dir).then(
+      (entry) => entry.isDirectory(),
+      () => false,
+    );
+  }
+}

package/frontendBuild/index.ts

@@ -9,6 +9,7 @@ export * from "./cssImportResolver";
 export * from "./devChangePlanner";
 export * from "./devGeneratedIndexSync";
 export * from "./fontOptimizer";
+export * from "./fontPruner";
 export * from "./hmrChangeClassifier";
 export * from "./hmrWatcher";
 export * from "./pagesBundleBuilder";

package/integration/devStabilityHarness.ts

@@ -118,11 +118,7 @@ export default config;
       ),
       this.writeFile(
         "env/env.client.ts",
-        `import { getEnv } from "akanjs/base";
-
-export const env = {
-  ...getEnv(),
-} as const;
+        `export const env = {} as const;
 `,
       ),
       this.writeFile(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.0.0-alpha.66",
+  "version": "3.0.0-alpha.68",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -45,7 +45,7 @@
     "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "3.0.0-alpha.66",
+    "akanjs": "3.0.0-alpha.68",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dayjs": "^1.11.20",