gemi 0.108.0 → 0.110.0

package/dist/bin/gemi.js

@@ -35956,7 +35956,7 @@ function camelCase(text) {
 
 // bin/ai-client/extract.ts
 import { createRequire } from "module";
-import path7 from "path";
+import path8 from "path";
 function parseAgentReference(reference) {
   const hash = reference.lastIndexOf("#");
   if (hash === -1)
@@ -35970,7 +35970,7 @@ function parseAgentReference(reference) {
 }
 async function loadTypeScript(cwd) {
   try {
-    return createRequire(path7.join(cwd, "package.json"))("typescript");
+    return createRequire(path8.join(cwd, "package.json"))("typescript");
   } catch {
     try {
       return (await import("typescript")).default;
@@ -35980,7 +35980,7 @@ async function loadTypeScript(cwd) {
   }
 }
 function extractAgent(ts, reference, { cwd = process.cwd(), name } = {}) {
-  const file = path7.resolve(cwd, reference.file);
+  const file = path8.resolve(cwd, reference.file);
   if (!ts.sys.fileExists(file)) {
     throw new GenerateClientError(`${reference.file} does not exist.`);
   }
@@ -35992,7 +35992,7 @@ function extractAgent(ts, reference, { cwd = process.cwd(), name } = {}) {
   if (agentType.getSymbol()?.getName() !== "Agent" || !agentFile) {
     throw new GenerateClientError(`${reference.file}#${reference.exportName} is not an Agent \u2014 it is ` + `\`${checker.typeToString(agentType)}\`. Point at the value \`Agent.create(...)\` returned.`);
   }
-  const probe = path7.join(path7.dirname(file), `__gemi_generate_client_${process.pid}.ts`);
+  const probe = path8.join(path8.dirname(file), `__gemi_generate_client_${process.pid}.ts`);
   const source = [
     `import type { OutputOf, ToolShapesOf } from ${JSON.stringify(specifier(probe, agentFile))};`,
     `import type * as agentModule from ${JSON.stringify(specifier(probe, file))};`,
@@ -36013,7 +36013,7 @@ function extractAgent(ts, reference, { cwd = process.cwd(), name } = {}) {
     return second.getTypeChecker().getTypeAtLocation(declaration.name);
   };
   const mapper = new TypeMapper(ts, second.getTypeChecker());
-  const agentName = name ?? pascalCase(exported === "default" ? path7.parse(file).name : exported);
+  const agentName = name ?? pascalCase(exported === "default" ? path8.parse(file).name : exported);
   const toolsType = alias("Tools");
   const tools = mapper.checker.getPropertiesOfType(toolsType).map((tool) => {
     const shape = mapper.checker.getTypeOfSymbol(tool);
@@ -36029,7 +36029,7 @@ function extractAgent(ts, reference, { cwd = process.cwd(), name } = {}) {
   const output = mapper.map(alias("Output"), "StructuredOutput", "the agent's output");
   return {
     name: agentName,
-    source: `${path7.relative(cwd, file).split(path7.sep).join("/")}#${reference.exportName}`,
+    source: `${path8.relative(cwd, file).split(path8.sep).join("/")}#${reference.exportName}`,
     tools,
     output,
     types: mapper.types,
@@ -36037,7 +36037,7 @@ function extractAgent(ts, reference, { cwd = process.cwd(), name } = {}) {
   };
 }
 function compilerOptions(ts, file) {
-  const configPath = ts.findConfigFile(path7.dirname(file), ts.sys.fileExists);
+  const configPath = ts.findConfigFile(path8.dirname(file), ts.sys.fileExists);
   let options = {
     target: ts.ScriptTarget.ESNext,
     module: ts.ModuleKind.ESNext,
@@ -36045,7 +36045,7 @@ function compilerOptions(ts, file) {
   };
   if (configPath) {
     const config = ts.readConfigFile(configPath, ts.sys.readFile);
-    options = ts.parseJsonConfigFileContent(config.config, ts.sys, path7.dirname(configPath)).options;
+    options = ts.parseJsonConfigFileContent(config.config, ts.sys, path8.dirname(configPath)).options;
   }
   return {
     ...options,
@@ -36067,8 +36067,8 @@ function exportedType(ts, checker, sourceFile, reference) {
   return { type: checker.getTypeOfSymbolAtLocation(symbol, sourceFile), name: symbol.getName() };
 }
 function specifier(from, to) {
-  const relative4 = path7.relative(path7.dirname(from), to).split(path7.sep).join("/").replace(/(\.d)?\.(ts|tsx|mts|cts)$/, "");
-  return relative4.startsWith(".") ? relative4 : `./${relative4}`;
+  const relative5 = path8.relative(path8.dirname(from), to).split(path8.sep).join("/").replace(/(\.d)?\.(ts|tsx|mts|cts)$/, "");
+  return relative5.startsWith(".") ? relative5 : `./${relative5}`;
 }
 function isFrameworkJsonValue(type) {
   const alias = type.aliasSymbol;
@@ -36687,8 +36687,8 @@ __export(exports_generate, {
   PLATFORMS: () => PLATFORMS,
   GenerateClientError: () => GenerateClientError
 });
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import path8 from "path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import path9 from "path";
 async function generateClient(options) {
   const cwd = options.cwd ?? process.cwd();
   const platform = parsePlatform(options.platform);
@@ -36701,10 +36701,10 @@ async function generateClient(options) {
   }
   const ts = await loadTypeScript(cwd);
   const model = extractAgent(ts, parseAgentReference(options.agent), { cwd, name: options.name });
-  const directory = path8.resolve(cwd, options.out);
-  const file = path8.join(directory, `${model.name}.${platform === "swift" ? "swift" : "kt"}`);
+  const directory = path9.resolve(cwd, options.out);
+  const file = path9.join(directory, `${model.name}.${platform === "swift" ? "swift" : "kt"}`);
   mkdirSync3(directory, { recursive: true });
-  writeFileSync3(file, platform === "swift" ? renderSwift(model) : renderKotlin(model, options.package));
+  writeFileSync4(file, platform === "swift" ? renderSwift(model) : renderKotlin(model, options.package));
   const warnings = [...model.warnings];
   if (platform === "swift" && options.package) {
     warnings.push("--package is for Kotlin; a Swift file has no package, so it was ignored.");
@@ -36726,10 +36726,10 @@ var init_generate = __esm(() => {
 });
 
 // bin/gemi.ts
-import path9 from "path";
-import { existsSync as existsSync8 } from "fs";
+import path10 from "path";
+import { existsSync as existsSync10 } from "fs";
 import { mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
+import { tmpdir as tmpdir2 } from "os";
 
 // bin/createRollupInput.ts
 var {Glob } = globalThis.Bun;
@@ -40088,6 +40088,128 @@ function documentBase(base) {
   return base.startsWith("/") || /^[a-z][a-z\d+.-]*:\/\//i.test(base) ? normalizeAssetBase(base) : DEFAULT_ASSET_BASE;
 }
 
+// vite/islandPlugin.ts
+import { realpathSync } from "fs";
+import { relative, sep } from "path";
+
+// internal/islandRuntime.ts
+var ISLAND_RUNTIME_ID = "virtual:gemi-island-runtime";
+var RESOLVED_ISLAND_RUNTIME_ID = `\x00${ISLAND_RUNTIME_ID}`;
+var ISLAND_ENTRY_QUERY = "?gemi-island";
+function islandEntrySource(file) {
+  return `import * as m from ${JSON.stringify(file)};
+export { m };
+export { h } from ${JSON.stringify(ISLAND_RUNTIME_ID)};
+`;
+}
+var ISLAND_HYDRATE_SOURCE = `function h(marker, Component) {
+  if (typeof Component !== "function" && (typeof Component !== "object" || Component === null)) {
+    throw new Error("gemi: island module has no component export for " + marker.outerHTML.slice(0, 80));
+  }
+  const json = marker.getAttribute("data-props");
+  const props = json ? JSON.parse(json) : {};
+  let slot = null;
+  for (const candidate of marker.querySelectorAll("gemi-slot")) {
+    if (candidate.closest("gemi-island") === marker) {
+      slot = candidate;
+      break;
+    }
+  }
+  const children = slot
+    ? [createElement("gemi-slot", {
+        style: { display: "contents" },
+        suppressHydrationWarning: true,
+        dangerouslySetInnerHTML: { __html: slot.innerHTML },
+      })]
+    : [];
+  return hydrateRoot(marker, createElement(Component, props, ...children), {
+    identifierPrefix: marker.getAttribute("data-uid") || undefined,
+  });
+}`;
+var ISLAND_RUNTIME_SOURCE = `import { createElement } from "react";
+import { hydrateRoot } from "react-dom/client";
+export ${ISLAND_HYDRATE_SOURCE}
+`;
+
+// vite/islandPlugin.ts
+var ISLAND_CALL = /\bisland\s*\(\s*(\(\s*\)\s*=>\s*import\(\s*(["'])([^"'\n]+)\2\s*\))/g;
+function realPath(path3) {
+  try {
+    return realpathSync(path3);
+  } catch {
+    return path3;
+  }
+}
+function gemiIslandPlugin() {
+  let root = process.cwd();
+  let clientBuild = false;
+  const emitted = new Set;
+  return {
+    name: "gemi-plugin-islands",
+    enforce: "pre",
+    configResolved(config) {
+      root = realPath(config.root);
+      clientBuild = config.command === "build" && !config.build.ssr;
+    },
+    buildStart() {
+      emitted.clear();
+    },
+    resolveId(id) {
+      return id === ISLAND_RUNTIME_ID ? RESOLVED_ISLAND_RUNTIME_ID : null;
+    },
+    load(id) {
+      if (id === RESOLVED_ISLAND_RUNTIME_ID)
+        return ISLAND_RUNTIME_SOURCE;
+      if (id.endsWith(ISLAND_ENTRY_QUERY)) {
+        return islandEntrySource(id.slice(0, -ISLAND_ENTRY_QUERY.length));
+      }
+      return null;
+    },
+    async transform(code, id) {
+      if (id.includes("/node_modules/") || id.startsWith("\x00") || id.endsWith(ISLAND_ENTRY_QUERY)) {
+        return null;
+      }
+      if (!/\.[cm]?[jt]sx?$/.test(id.split("?")[0]))
+        return null;
+      if (!code.includes("island"))
+        return null;
+      const environmentConsumer = this.environment?.config?.consumer;
+      const emitEntries = clientBuild && (environmentConsumer === undefined || environmentConsumer === "client");
+      const s = new MagicString(code);
+      const imports = [];
+      for (const match of code.matchAll(ISLAND_CALL)) {
+        const [, loader, quote, specifier] = match;
+        const resolved = await this.resolve(specifier, id);
+        if (!resolved || resolved.external)
+          continue;
+        const file = realPath(resolved.id.split("?")[0]);
+        const key = relative(root, file).split(sep).join("/");
+        if (key.startsWith(".."))
+          continue;
+        const name = `__gemi_island_${imports.length}`;
+        imports.push(`import * as ${name} from ${quote}${specifier}${quote};`);
+        const start = match.index + match[0].length - loader.length;
+        s.overwrite(start, start + loader.length, `Object.assign(() => Promise.resolve(${name}), { gemiIsland: ${JSON.stringify(key)}, gemiModule: ${name} })`);
+        const moduleId = resolved.id.split("?")[0];
+        if (emitEntries && !emitted.has(moduleId)) {
+          emitted.add(moduleId);
+          this.emitFile({
+            type: "chunk",
+            id: `${moduleId}${ISLAND_ENTRY_QUERY}`,
+            preserveSignature: "strict"
+          });
+        }
+      }
+      if (imports.length === 0)
+        return null;
+      s.prepend(`${imports.join(`
+`)}
+`);
+      return { code: s.toString(), map: s.generateMap({ hires: true }) };
+    }
+  };
+}
+
 // vite/index.ts
 var gemi = async () => {
   const userConfig = await loadGemiConfig(process.cwd());
@@ -40124,6 +40246,7 @@ var gemi = async () => {
       config: () => userViteConfig
     },
     gemiAssetBasePlugin(assetBase),
+    gemiIslandPlugin(),
     {
       name: "gemi-plugin-hot-reload",
       handleHotUpdate({ server, modules }) {
@@ -40140,7 +40263,7 @@ var vite_default = gemi;
 
 // vite/previousAssets.ts
 import { copyFile, lstat, mkdir as mkdir2, readdir, readFile, stat, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, isAbsolute, join as join4, relative, resolve, sep } from "path";
+import { dirname as dirname2, isAbsolute, join as join4, relative as relative2, resolve, sep as sep2 } from "path";
 var PREVIOUS_ASSETS_RECORD = ".vite/previous-assets.json";
 var DEFAULT_RETAINED_RELEASES = 2;
 var DEFAULT_RETAINED_MAX_AGE_SECONDS = 7 * 24 * 60 * 60;
@@ -40274,8 +40397,8 @@ function isCarriable(file) {
 }
 function inside(root, file) {
   const path3 = resolve(root, file);
-  const rel2 = relative(root, path3);
-  return rel2 && !rel2.startsWith("..") && !isAbsolute(rel2) && rel2.split(sep)[0] === ASSETS_DIR ? path3 : null;
+  const rel2 = relative2(root, path3);
+  return rel2 && !rel2.startsWith("..") && !isAbsolute(rel2) && rel2.split(sep2)[0] === ASSETS_DIR ? path3 : null;
 }
 async function isDirectory(path3) {
   try {
@@ -40427,15 +40550,15 @@ var {
 
 // bin/check-models.ts
 import { statSync as statSync2 } from "fs";
-import { relative as relative3, resolve as resolve2 } from "path";
+import { relative as relative4, resolve as resolve2 } from "path";
 
 // support/discover.ts
 import { existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
-import { join as join6, relative as relative2 } from "path";
+import { join as join6, relative as relative3 } from "path";
 function sourceFiles(dir, ignore = []) {
   const out = [];
   const ignored = (path3) => {
-    const rel2 = relative2(dir, path3).split("\\").join("/");
+    const rel2 = relative3(dir, path3).split("\\").join("/");
     return ignore.some((pattern) => rel2 === pattern || rel2.startsWith(`${pattern}/`));
   };
   const walk3 = (current) => {
@@ -40539,7 +40662,7 @@ async function declaredModules(rootDir) {
   try {
     ({ default: Kernel } = await import(path3));
   } catch (error) {
-    throw new CheckModelsError(`Could not load ${relative3(rootDir, path3)}:
+    throw new CheckModelsError(`Could not load ${relative4(rootDir, path3)}:
     ${error.message}`);
   }
   return new Kernel().models ?? [];
@@ -40592,8 +40715,8 @@ ${error.message}`);
   const paths = modelFiles(modelsDir, ignore);
   const files = [];
   for (const path3 of paths) {
-    const label = relative3(rootDir, path3);
-    const specifier = `./${relative3(modelsDir, path3).split("\\").join("/").replace(/\.tsx?$/, "")}`;
+    const label = relative4(rootDir, path3);
+    const specifier = `./${relative4(modelsDir, path3).split("\\").join("/").replace(/\.tsx?$/, "")}`;
     try {
       files.push({
         label,
@@ -41126,11 +41249,11 @@ function hashDirectory(dir) {
     const entries = readdirSync3(current, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
     for (const entry of entries) {
       const full = path5.join(current, entry.name);
-      const relative4 = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const relative5 = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
-        walk3(full, relative4);
+        walk3(full, relative5);
       } else if (entry.isFile()) {
-        hash.update(relative4);
+        hash.update(relative5);
         hash.update("\x00");
         hash.update(readFileSync3(full));
         hash.update("\x00");
@@ -41427,15 +41550,350 @@ function exitCodeOf(proc) {
   return signal ? 128 + signal : 1;
 }
 
+// stats/run.ts
+import path7 from "path";
+import { existsSync as existsSync9, mkdtempSync, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir } from "os";
+
+// stats/bundleStats.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { join as join8 } from "path";
+import { brotliCompressSync, constants as constants3, gzipSync } from "zlib";
+
+// server/modulePreloads.ts
+var CLIENT_ENTRY_KEY = "app/client.tsx";
+
+// stats/bundleStats.ts
+var VIEW_PREFIX = "app/views/";
+var VIEW_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var ROOT_LAYOUT = "RootLayout";
+var ZERO = { raw: 0, gzip: 0, brotli: 0 };
+var add = (a, b) => ({
+  raw: a.raw + b.raw,
+  gzip: a.gzip + b.gzip,
+  brotli: a.brotli + b.brotli
+});
+function chunkName(file) {
+  return file.replace(/^.*\//, "").replace(/-[\w-]{8}(?=\.\w+$)/, "");
+}
+function routeKey(entry) {
+  return entry.group ? `${entry.group}:${entry.path}` : entry.path;
+}
+function bundleStats(options) {
+  const { clientDir } = options;
+  const manifest = options.manifest ?? JSON.parse(readFileSync5(join8(clientDir, ".vite/manifest.json"), "utf8"));
+  const sizes = new Map;
+  const size = (file) => {
+    let known = sizes.get(file);
+    if (!known)
+      sizes.set(file, known = measure(clientDir, file));
+    return known;
+  };
+  const sum = (files) => [...files].map(size).reduce(add, ZERO);
+  const closure = (key, seen = new Set) => {
+    if (seen.has(key) || !manifest[key])
+      return seen;
+    seen.add(key);
+    for (const imported of manifest[key].imports ?? [])
+      closure(imported, seen);
+    return seen;
+  };
+  const jsFiles = (keys) => [...new Set([...keys].map((key) => manifest[key].file))].filter(isJs).sort();
+  const islandEntries = Object.keys(manifest).filter(isIslandEntry).sort();
+  const shared = closure(CLIENT_ENTRY_KEY);
+  for (const [key, chunk] of Object.entries(manifest)) {
+    if (key.includes(ISLAND_RUNTIME_NAME) || chunk.name?.includes(ISLAND_RUNTIME_NAME))
+      closure(key, shared);
+  }
+  const islandModules = new Map(islandEntries.map((entry) => [
+    entry,
+    (manifest[entry].imports ?? []).filter((imported) => !shared.has(imported))
+  ]));
+  const islandsBelow = (keys) => {
+    const seen = new Set;
+    const walk3 = (at) => {
+      if (seen.has(at) || !manifest[at] || isIslandEntry(at))
+        return;
+      seen.add(at);
+      for (const next of [...manifest[at].imports ?? [], ...manifest[at].dynamicImports ?? []])
+        walk3(next);
+    };
+    for (const key of keys)
+      walk3(key);
+    return islandEntries.filter((entry) => islandModules.get(entry).some((module) => seen.has(module)));
+  };
+  const viewKey = (view) => VIEW_EXTENSIONS.map((ext) => `${VIEW_PREFIX}${view}${ext}`).find((key) => manifest[key]);
+  const hydrated = (views) => {
+    const keys = closure(CLIENT_ENTRY_KEY);
+    for (const view of views) {
+      const key = viewKey(view);
+      if (key)
+        closure(key, keys);
+    }
+    const files = jsFiles(keys);
+    return { ...sum(files), views, chunks: files.map(chunkName) };
+  };
+  const staticRoute = (views, layout) => {
+    const roots = [layout ?? ROOT_LAYOUT, ...views].map(viewKey).filter((key) => Boolean(key));
+    const islands2 = islandsBelow(roots);
+    const keys = new Set;
+    for (const island of islands2)
+      closure(island, keys);
+    const files = jsFiles(keys);
+    return { ...sum(files), views, static: true, islands: islands2, chunks: files.map(chunkName) };
+  };
+  const routes = {};
+  if (options.routes) {
+    for (const entry of options.routes) {
+      routes[routeKey(entry)] = entry.static ? staticRoute(entry.views, entry.static.layout) : hydrated(entry.views);
+    }
+  } else {
+    for (const [key, chunk] of Object.entries(manifest)) {
+      if (!chunk.isEntry || !key.startsWith(VIEW_PREFIX) || isIslandEntry(key))
+        continue;
+      const view = key.slice(VIEW_PREFIX.length).replace(/\.[jt]sx?$/, "");
+      routes[view] = hydrated([view]);
+    }
+  }
+  const islands = {};
+  for (const key of islandEntries) {
+    const files = jsFiles(closure(key));
+    islands[key] = { ...sum(files), chunks: files.map(chunkName) };
+  }
+  const chunks = {};
+  const allFiles = [...new Set(Object.values(manifest).map((chunk) => chunk.file))];
+  for (const file of allFiles.filter(isJs).sort()) {
+    const name = chunkName(file);
+    let unique = name;
+    for (let n2 = 2;chunks[unique]; n2++)
+      unique = `${name}~${n2}`;
+    chunks[unique] = size(file);
+  }
+  const css = new Set(Object.values(manifest).flatMap((chunk) => chunk.css ?? []));
+  return {
+    version: 1,
+    by: options.routes ? "routes" : "views",
+    routes,
+    islands,
+    chunks,
+    css: sum(css)
+  };
+}
+var ISLAND_RUNTIME_NAME = "gemi-island-runtime";
+function isIslandEntry(key) {
+  return key.endsWith(ISLAND_ENTRY_QUERY);
+}
+function isJs(file) {
+  return /\.m?js$/.test(file);
+}
+function measure(clientDir, file) {
+  const path7 = join8(clientDir, file);
+  const sibling = (ext) => existsSync8(path7 + ext) ? statSync3(path7 + ext).size : null;
+  let buffer;
+  const read = () => buffer ??= readFileSync5(path7);
+  return {
+    raw: statSync3(path7).size,
+    gzip: sibling(".gz") ?? gzipSync(read(), { level: 9 }).length,
+    brotli: sibling(".br") ?? brotliCompressSync(read(), {
+      params: { [constants3.BROTLI_PARAM_QUALITY]: 11 }
+    }).length
+  };
+}
+var kb = (bytes) => bytes / 1024;
+var format = (bytes) => kb(bytes).toFixed(1);
+var signed = (bytes) => `${bytes > 0 ? "+" : ""}${format(bytes)}`;
+function budgetFor(key, route, budgets) {
+  if (!budgets)
+    return;
+  const page = route.views.at(-1);
+  return budgets.routes?.[key] ?? (page ? budgets.routes?.[page] : undefined) ?? budgets.default;
+}
+function overBudget(stats, budgets) {
+  if (!budgets)
+    return [];
+  const unit = budgets.unit ?? "gzip";
+  return Object.entries(stats.routes).flatMap(([key, route]) => {
+    const budget = budgetFor(key, route, budgets);
+    return budget !== undefined && kb(route[unit]) > budget ? [`${key}: ${format(route[unit])} KB ${unit} is over its budget of ${budget} KB`] : [];
+  });
+}
+function unusedBudgets(stats, budgets) {
+  const keys = Object.keys(budgets?.routes ?? {});
+  const known = new Set(Object.keys(stats.routes));
+  for (const route of Object.values(stats.routes)) {
+    const page = route.views.at(-1);
+    if (page)
+      known.add(page);
+  }
+  return keys.filter((key) => !known.has(key));
+}
+var NOISE_KB = 2;
+var byGzip = (stats) => Object.keys(stats.routes).sort((a, b) => stats.routes[b].gzip - stats.routes[a].gzip);
+function markdownReport(stats, base, budgets) {
+  const unit = budgets?.unit ?? "gzip";
+  const lines = [
+    `| Route | ${unit} KB | \u0394 gzip | \u0394 raw | \u0394 brotli | budget |`,
+    "|---|---:|---:|---:|---:|---:|"
+  ];
+  for (const key of byGzip(stats)) {
+    const now = stats.routes[key];
+    const before = base?.routes[key];
+    const delta = (size) => before ? signed(now[size] - before[size]) : base ? "new" : "\u2013";
+    const budget = budgetFor(key, now, budgets);
+    const flag = budget !== undefined && kb(now[unit]) > budget ? " \u274C" : before && kb(now.gzip - before.gzip) > NOISE_KB ? " \u26A0\uFE0F" : "";
+    const kind = now.static ? " (static)" : "";
+    lines.push(`| \`${key}\`${kind}${flag} | ${format(now[unit])} | ${delta("gzip")} | ${delta("raw")} | ${delta("brotli")} | ${budget ?? ""} |`);
+  }
+  if (base) {
+    const removedRoutes = Object.keys(base.routes).filter((key) => !stats.routes[key]);
+    if (removedRoutes.length) {
+      lines.push("", `**Removed routes:** ${removedRoutes.map((key) => `\`${key}\``).join(", ")}`);
+    }
+    const added = Object.keys(stats.chunks).filter((name) => !base.chunks[name]);
+    const removed = Object.keys(base.chunks).filter((name) => !stats.chunks[name]);
+    const changed = Object.keys(stats.chunks).filter((name) => base.chunks[name] && kb(Math.abs(stats.chunks[name].gzip - base.chunks[name].gzip)) > 0.5);
+    const list = (names, describe) => names.length ? names.map((name) => `\`${name}\` ${describe(name)}`).join(", ") : "none";
+    lines.push("", `**New chunks:** ${list(added, (name) => `(${format(stats.chunks[name].gzip)} KB gzip)`)}`, `**Removed chunks:** ${list(removed, (name) => `(${format(base.chunks[name].gzip)} KB gzip)`)}`, `**Changed chunks (> 0.5 KB gzip):** ${list(changed, (name) => `(${signed(stats.chunks[name].gzip - base.chunks[name].gzip)} KB gzip)`)}`, `**CSS:** ${format(stats.css.gzip)} KB gzip (${signed(stats.css.gzip - base.css.gzip)})`);
+  }
+  return lines.join(`
+`);
+}
+function textReport(stats, budgets) {
+  const unit = budgets?.unit ?? "gzip";
+  const rows = byGzip(stats).map((key) => {
+    const route = stats.routes[key];
+    const budget = budgetFor(key, route, budgets);
+    const over = budget !== undefined && kb(route[unit]) > budget;
+    return [
+      key,
+      route.static ? "static" : "hydrated",
+      format(route.raw),
+      format(route.gzip),
+      format(route.brotli),
+      String(route.chunks.length),
+      budget === undefined ? "" : `${budget}${over ? " OVER" : ""}`
+    ];
+  });
+  const header = [
+    stats.by === "routes" ? "Route" : "View",
+    "Kind",
+    "raw KB",
+    "gzip KB",
+    "br KB",
+    "files",
+    `budget (${unit})`
+  ];
+  const table = [header, ...rows];
+  const widths = header.map((_, i) => Math.max(...table.map((row) => row[i].length)));
+  const line = (row) => row.map((cell, i) => i < 2 ? cell.padEnd(widths[i]) : cell.padStart(widths[i])).join("  ").trimEnd();
+  const islands = Object.entries(stats.islands);
+  return [
+    "Initial JavaScript per " + (stats.by === "routes" ? "route" : "view") + ":",
+    "",
+    ...table.map(line),
+    ...islands.length ? [
+      "",
+      "Islands (each with its imports):",
+      ...islands.map(([key, island]) => `  ${key}  ${format(island.gzip)} KB gzip, ${island.chunks.length} file(s)`)
+    ] : [],
+    "",
+    `CSS: ${format(stats.css.raw)} KB raw, ${format(stats.css.gzip)} KB gzip`
+  ].join(`
+`);
+}
+
+// stats/run.ts
+async function runStats(options) {
+  const log = options.log ?? console.log;
+  const error = options.error ?? console.error;
+  const clientDir = path7.join(options.rootDir, "dist", "client");
+  if (!existsSync9(path7.join(clientDir, ".vite/manifest.json"))) {
+    error(`No client build in ${clientDir}. Run \`gemi build\` first.`);
+    return 1;
+  }
+  let routes = null;
+  if (options.routes !== false) {
+    const table = await loadRouteTable(options.rootDir, options.preloadArgs ?? []);
+    if ("routes" in table)
+      routes = table.routes;
+    else
+      error(`Could not read the route table, so this reports per view and can't tell static ` + `views apart (pass --no-routes to skip it):
+${table.message}`);
+  }
+  const stats = bundleStats({ clientDir, routes });
+  const budgets = options.config?.budgets;
+  log(textReport(stats, budgets));
+  if (options.json) {
+    writeFileSync3(options.json, `${JSON.stringify(stats, null, 2)}
+`);
+  }
+  if (options.markdown) {
+    const base = options.base && existsSync9(options.base) ? JSON.parse(readFileSync6(options.base, "utf8")) : null;
+    writeFileSync3(options.markdown, `${markdownReport(stats, base, budgets)}
+`);
+  }
+  for (const key of unusedBudgets(stats, budgets)) {
+    error(`warning: the budget for "${key}" matches no route or view.`);
+  }
+  const problems = overBudget(stats, budgets);
+  if (problems.length) {
+    error(`
+Over budget (stats.budgets in gemi.config.ts):
+${problems.join(`
+`)}`);
+    return 1;
+  }
+  return 0;
+}
+async function loadRouteTable(rootDir, preloadArgs, options = {}) {
+  let entry;
+  try {
+    entry = Bun.resolveSync("gemi/stats/route-table", rootDir);
+  } catch {
+    return { ok: false, message: `gemi/stats/route-table does not resolve from ${rootDir}.` };
+  }
+  const dir = mkdtempSync(path7.join(tmpdir(), "gemi-stats-"));
+  const out = path7.join(dir, "routes.json");
+  try {
+    const child = Bun.spawn({
+      cmd: ["bun", "--preload", "gemi/bun/preload", ...preloadArgs, entry, out],
+      cwd: rootDir,
+      env: { ...process.env, GEMI_NO_SCHEDULE: "1" },
+      stdout: "ignore",
+      stderr: "pipe"
+    });
+    const timeoutMs = options.timeoutMs ?? 60000;
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, timeoutMs);
+    const [code, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+    clearTimeout(timer);
+    if (timedOut) {
+      return { ok: false, message: `reading the route table took over ${timeoutMs / 1000}s.` };
+    }
+    if (code !== 0 || !existsSync9(out)) {
+      return {
+        ok: false,
+        message: stderr.trim() || `the route table process exited with ${code}.`
+      };
+    }
+    return { ok: true, routes: JSON.parse(readFileSync6(out, "utf8")) };
+  } finally {
+    rmSync3(dir, { recursive: true, force: true });
+  }
+}
+
 // bin/gemi.ts
 function appPreloadArgs(appDir) {
-  const preloadPath = path9.join(appDir, "preload.ts");
-  return existsSync8(preloadPath) ? ["--preload", preloadPath] : [];
+  const preloadPath = path10.join(appDir, "preload.ts");
+  return existsSync10(preloadPath) ? ["--preload", preloadPath] : [];
 }
 program.command("dev").action(async () => {
   console.log("Starting dev server...");
-  const rootDir = path9.resolve(process.cwd());
-  const appDir = path9.join(rootDir, "app");
+  const rootDir = path10.resolve(process.cwd());
+  const appDir = path10.join(rootDir, "app");
   process.env.NODE_ENV = "development";
   const exited = spawnForwardingSignals({
     cmd: [
@@ -41445,16 +41903,34 @@ program.command("dev").action(async () => {
       "--preload",
       "gemi/bun/preload",
       ...appPreloadArgs(appDir),
-      `${path9.join(appDir, "server.ts")}`
+      `${path10.join(appDir, "server.ts")}`
     ]
   });
   reportUpdate({ rootDir });
   process.exit(await exited);
 });
-program.command("build").action(async () => {
+function withStatsOptions(command) {
+  return command.option("--json <file>", "Also write the stats as JSON (for CI diffs)").option("--base <file>", "Another build's JSON to compare with in --markdown (e.g. main's)").option("--markdown <file>", "Write the stats as a Markdown table, compared with --base").option("--no-routes", "Don't read the route table; report per view");
+}
+async function printStats(rootDir, options) {
+  const config = await loadGemiConfig(rootDir);
+  return runStats({
+    rootDir,
+    config: config.stats,
+    json: options.json && path10.resolve(options.json),
+    base: options.base && path10.resolve(options.base),
+    markdown: options.markdown && path10.resolve(options.markdown),
+    routes: options.routes,
+    preloadArgs: appPreloadArgs(path10.join(rootDir, "app"))
+  });
+}
+withStatsOptions(program.command("stats").description("Print the initial JavaScript each route loads (raw, gzip, brotli) from the " + "last `gemi build`, and fail when a route is over its budget " + "(`stats.budgets` in gemi.config.ts)")).action(async (options) => {
+  process.exit(await printStats(path10.resolve(process.cwd()), options));
+});
+withStatsOptions(program.command("build").option("--stats", "After building, print the initial JS per route and check the budgets")).action(async (options) => {
   if (process.env.GEMI_BUILD_PROD !== "1") {
     const proc = Bun.spawn({
-      cmd: ["bun", process.argv[1], "build"],
+      cmd: ["bun", process.argv[1], ...process.argv.slice(2)],
       env: { ...process.env, NODE_ENV: "production", GEMI_BUILD_PROD: "1" },
       stdout: "inherit",
       stderr: "inherit"
@@ -41463,14 +41939,14 @@ program.command("build").action(async () => {
     process.exit(proc.exitCode ?? 0);
   }
   process.env.NODE_ENV = "production";
-  const rootDir = path9.resolve(process.cwd());
-  const appDir = path9.join(rootDir, "app");
+  const rootDir = path10.resolve(process.cwd());
+  const appDir = path10.join(rootDir, "app");
   const config = await loadGemiConfig(rootDir);
   const input = await createRollupInput_default(appDir);
   process.env.GEMI_INPUT = JSON.stringify(input);
   const previousAssets = resolvePreviousAssets(config.previousAssets, rootDir);
-  const stagingDir = previousAssets ? await mkdtemp(path9.join(tmpdir(), "gemi-previous-assets-")) : undefined;
-  const clientDir = path9.join(rootDir, "dist", "client");
+  const stagingDir = previousAssets ? await mkdtemp(path10.join(tmpdir2(), "gemi-previous-assets-")) : undefined;
+  const clientDir = path10.join(rootDir, "dist", "client");
   const emitted = [];
   let carriedPaths = [];
   try {
@@ -41509,8 +41985,8 @@ program.command("build").action(async () => {
   await writeStaticAssetsRecord(clientDir, {
     files: { ...carried.record.files, ...fresh.record.files }
   });
-  const kb = (bytes) => `${(bytes / 1024).toFixed(1)} kB`;
-  console.log(`Precompressed ${fresh.stats.files} asset(s): ${kb(fresh.stats.identityBytes)} \u2192 ` + `${kb(fresh.stats.brBytes)} br / ${kb(fresh.stats.gzipBytes)} gzip ` + `(${Math.round(performance.now() - startedAt)} ms).`);
+  const kb2 = (bytes) => `${(bytes / 1024).toFixed(1)} kB`;
+  console.log(`Precompressed ${fresh.stats.files} asset(s): ${kb2(fresh.stats.identityBytes)} \u2192 ` + `${kb2(fresh.stats.brBytes)} br / ${kb2(fresh.stats.gzipBytes)} gzip ` + `(${Math.round(performance.now() - startedAt)} ms).`);
   console.log("Building server...");
   await build({
     configFile: false,
@@ -41533,12 +42009,16 @@ program.command("build").action(async () => {
       console.error(message);
     process.exit(1);
   }
+  if (options.stats || options.json || options.markdown) {
+    console.log("");
+    process.exit(await printStats(rootDir, options));
+  }
   process.exit();
 });
 program.command("start").action(async () => {
   console.log("Starting server...");
-  const rootDir = path9.resolve(process.cwd());
-  const appDir = path9.join(rootDir, "app");
+  const rootDir = path10.resolve(process.cwd());
+  const appDir = path10.join(rootDir, "app");
   const code = await spawnForwardingSignals({
     cmd: [
       "bun",
@@ -41552,8 +42032,8 @@ program.command("start").action(async () => {
   process.exit(code);
 });
 program.command("queue:work").description("Boot the app and run queued jobs, without serving HTTP, so job capacity " + "scales apart from web traffic. Needs a queue driver every process can " + 'reach, such as "database". Drains on SIGTERM/SIGINT like `gemi start`').action(async () => {
-  const rootDir = path9.resolve(process.cwd());
-  const appDir = path9.join(rootDir, "app");
+  const rootDir = path10.resolve(process.cwd());
+  const appDir = path10.join(rootDir, "app");
   let entry;
   try {
     entry = Bun.resolveSync("gemi/queue/work", rootDir);
@@ -41569,8 +42049,8 @@ program.command("queue:work").description("Boot the app and run queued jobs, wit
 });
 program.enablePositionalOptions();
 program.command("run").description("Run a Command from app/commands. Everything after the name is the " + "command's own, including its flags. Omit the name to list them").argument("[name]", "The command's name").argument("[args...]", "Passed through to the command untouched").passThroughOptions().action(async (name, args) => {
-  const rootDir = path9.resolve(process.cwd());
-  const appDir = path9.join(rootDir, "app");
+  const rootDir = path10.resolve(process.cwd());
+  const appDir = path10.join(rootDir, "app");
   let entry;
   try {
     entry = Bun.resolveSync("gemi/console/run", rootDir);
@@ -41594,13 +42074,13 @@ program.command("run").description("Run a Command from app/commands. Everything
   process.exit(code);
 });
 program.command("migrate").description("Migrate an app from the 0.42 service-provider layout to the config + " + "container layout, flagging APIs retired since").option("--dry-run", "Print the plan without writing anything").action(async (options) => {
-  const rootDir = path9.resolve(process.cwd());
+  const rootDir = path10.resolve(process.cwd());
   console.log(options.dryRun ? `Planning migration of ${rootDir}...` : `Migrating ${rootDir}...`);
   await runMigrate({ rootDir, dryRun: options.dryRun });
 });
 program.command("upgrade").description("Upgrade the `gemi` package. With no argument it moves to the newest " + "release on the channel you are already on \u2014 `rc` for a release " + "candidate, `latest` otherwise \u2014 so an rc is never 'upgraded' backwards " + "onto the older stable release").argument("[target]", "A version (`0.59.0`) to pin or roll back to, or a dist-tag (`rc`, " + "`latest`). Defaults to the current channel's tag").option("--dry-run", "Resolve the version and print the install command, run nothing").action(async (target, options) => {
   const code = await runUpgrade({
-    rootDir: path9.resolve(process.cwd()),
+    rootDir: path10.resolve(process.cwd()),
     target,
     dryRun: options.dryRun
   });
@@ -41608,7 +42088,7 @@ program.command("upgrade").description("Upgrade the `gemi` package. With no argu
 });
 program.command("install-skill").description(`Install the \`${SKILL_NAME}\` agent skill that ships with your gemi into ` + `.agents/skills/. \`gemi upgrade\` re-runs this afterwards, so the rules an ` + `agent reads stay pinned to the gemi the app actually runs`).option("--force", "Replace an installed copy that has local edits, or one this command did not write").action(async (options) => {
   process.exit(installSkill({
-    rootDir: path9.resolve(process.cwd()),
+    rootDir: path10.resolve(process.cwd()),
     force: options.force
   }));
 });
@@ -41622,7 +42102,7 @@ check.command("models").description("Report policied model classes that the modu
 ], []).action(async (options) => {
   try {
     const report2 = await checkModels({
-      rootDir: path9.resolve(process.cwd()),
+      rootDir: path10.resolve(process.cwd()),
       modelsDir: options.dir,
       ignore: options.ignore,
       models: options.models
@@ -41641,7 +42121,7 @@ program.command("ai:generate-client").description("Generate an agent's tool and
     const { file, warnings } = await generateClient2({ agent, ...options });
     for (const warning of warnings)
       console.warn(`warning: ${warning}`);
-    console.log(`Wrote ${path9.relative(process.cwd(), file)}`);
+    console.log(`Wrote ${path10.relative(process.cwd(), file)}`);
     process.exit(0);
   } catch (error) {
     if (!(error instanceof GenerateClientError2))
@@ -41666,5 +42146,5 @@ program.command("app:route-manifest").action(async () => {
 });
 program.parse();
 
-//# debugId=45F966AEDDDBFC5864756E2164756E21
+//# debugId=0E49B3FD0C1F8A9E64756E2164756E21
 //# sourceMappingURL=gemi.js.map