reroute-js 0.7.2 → 0.8.0

package/cli/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 // @bun
 /**
- * reroute-js v0.7.2
+ * reroute-js v0.8.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -47,7 +47,7 @@ async function getVersionString() {
 }
 async function getVersion() {
   if (true) {
-    return "0.7.2";
+    return "0.8.0";
   }
   const possiblePaths = [
     path.join(import.meta.dir, "../../../../package.json"),
@@ -65,7 +65,7 @@ async function getVersion() {
 }
 async function getCommit() {
   if (true) {
-    return "993e6df";
+    return "b31f8e3";
   }
   return "dev";
 }
@@ -649,6 +649,11 @@ function isMarkdownFile(filePath) {
 }
 var init_markdown_processor = () => {};
 
+// packages/cli/src/libs/production.ts
+function isProductionMode(args = []) {
+  return true;
+}
+
 // packages/cli/src/libs/tailwind.ts
 import { spawn } from "node:child_process";
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
@@ -1030,15 +1035,16 @@ async function buildContentChunks(cwd) {
       let code = "";
       try {
         console.log(`[reroute/content] build ${buildSrc}`);
+        const isProd = isProductionMode();
         const result = await Bun.build({
           entrypoints: [buildSrc],
           target: "browser",
           format: "esm",
           splitting: false,
-          sourcemap: Bun.env.NODE_ENV === "production" ? "linked" : "none",
-          minify: Bun.env.NODE_ENV === "production",
+          sourcemap: isProd ? "linked" : "none",
+          minify: isProd,
           define: {
-            "process.env.NODE_ENV": Bun.env.NODE_ENV === "production" ? '"production"' : '"development"'
+            "process.env.NODE_ENV": isProd ? '"production"' : '"development"'
           }
         });
         if (!result.success)
@@ -1445,6 +1451,7 @@ var init_log = __esm(() => {
     "[reroute/dev]": "{green-fg}",
     "[reroute/start]": "{bright-cyan-fg}",
     "[reroute/build]": "{bright-magenta-fg}",
+    "[reroute/analyze]": "{bright-green-fg}",
     "[api]": "{blue-fg}",
     "[app]": "{bright-green-fg}"
   };
@@ -2037,7 +2044,7 @@ async function build(args) {
 `));
     process.stdout.write(`${colorizeLogPrefixAnsi(`[reroute/build] Building binary to ${outputPath}...`)}
 `);
-    const isProduction = true;
+    const isProduction = isProductionMode(args) || args.includes("--minify");
     const buildArgs = ["build", "src/index.ts", "--target", "bun", "--compile"];
     if (isProduction) {
       buildArgs.push("--minify");
@@ -2048,7 +2055,7 @@ async function build(args) {
           return false;
         }
       }
-      return arg !== "--outfile" && arg !== "-o" && arg !== "--minify" && arg !== "--no-minify";
+      return arg !== "--outfile" && arg !== "-o" && arg !== "--minify" && arg !== "--no-minify" && arg !== "--prod";
     });
     buildArgs.push(...filteredArgs, "--outfile", outputPath);
     await new Promise((resolve, reject) => {
@@ -2078,86 +2085,3448 @@ var init_build = __esm(() => {
   init_log();
 });
 
-// packages/cli/src/cli.ts
-import path2 from "node:path";
-var commands = {
-  init: () => Promise.resolve().then(() => (init_init(), exports_init)),
-  gen: () => Promise.resolve().then(() => (init_gen(), exports_gen)),
-  boot: () => Promise.resolve().then(() => (init_boot(), exports_boot)),
-  dev: () => Promise.resolve().then(() => (init_dev(), exports_dev)),
-  start: () => Promise.resolve().then(() => (init_start(), exports_start)),
-  build: () => Promise.resolve().then(() => (init_build(), exports_build))
-};
-async function main() {
-  const args = process.argv.slice(2);
-  if (args[0] === "--version" || args[0] === "-v") {
-    const version = await getVersionString2();
-    console.log(version);
-    process.exit(0);
+// packages/core/src/bundler/hash.ts
+async function generateContentHash(content) {
+  const data = new TextEncoder().encode(content);
+  const buf = await crypto.subtle.digest("SHA-256", data);
+  let hex = "";
+  for (const b of new Uint8Array(buf))
+    hex += b.toString(16).padStart(2, "0");
+  return hex.slice(0, 8);
+}
+
+// packages/cli/src/libs/command.ts
+var exports_command = {};
+__export(exports_command, {
+  getRerouteCommand: () => getRerouteCommand4
+});
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join10 } from "node:path";
+function getRerouteCommand4() {
+  const binPath = join10(import.meta.dir, "..", "..", "bin.ts");
+  const isBunDev = existsSync8(binPath);
+  if (isBunDev) {
+    return `bun ${binPath}`;
   }
-  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
-    await printHelp2();
-    process.exit(0);
+  const cwd = process.cwd();
+  const nodeModulesPaths = [
+    join10(cwd, "node_modules", ".bin", "reroute"),
+    join10(cwd, "..", "node_modules", ".bin", "reroute"),
+    join10(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join10(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+  ];
+  for (const binPath2 of nodeModulesPaths) {
+    if (existsSync8(binPath2)) {
+      return binPath2;
+    }
   }
-  const command = args[0];
-  if (!commands[command]) {
-    console.error(`Unknown command: ${command}`);
-    console.error("");
-    await printHelp2();
-    process.exit(1);
+  return "reroute";
+}
+var init_command = () => {};
+
+// packages/cli/src/libs/index.ts
+var init_libs = __esm(() => {
+  init_command();
+  init_log();
+  init_markdown();
+  init_markdown_processor();
+  init_tailwind();
+});
+
+// packages/cli/index.ts
+var init_cli = __esm(() => {
+  init_libs();
+});
+
+// packages/core/src/utils/path.ts
+var exports_path = {};
+__export(exports_path, {
+  stripStart: () => stripStart,
+  stripEnd: () => stripEnd,
+  join: () => join11,
+  extname: () => extname2,
+  basename: () => basename2
+});
+function join11(...parts) {
+  return parts.join("/").replace(/\/+/g, "/");
+}
+function extname2(p) {
+  const i = p.lastIndexOf(".");
+  return i >= 0 ? p.slice(i) : "";
+}
+function basename2(p, ext) {
+  const name = p.replace(/\\/g, "/").split("/").pop() || p;
+  return ext && name.endsWith(ext) ? name.slice(0, -ext.length) : name;
+}
+function stripStart(p, ch) {
+  return p.startsWith(ch) ? p.slice(ch.length) : p;
+}
+function stripEnd(p, ch) {
+  return p.endsWith(ch) ? p.slice(0, -ch.length) : p;
+}
+
+// packages/core/src/bundler/transpile.ts
+function isWatchMode() {
+  try {
+    return Array.isArray(process.execArgv) && process.execArgv.includes("--watch") || Array.isArray(process.argv) && process.argv.includes("--watch");
+  } catch {
+    return false;
+  }
+}
+async function transpileFile(filePath, originalPath, options, bundleCache) {
+  const src = await Bun.file(filePath).text();
+  const cacheKey = `${filePath}-${await generateContentHash(src)}`;
+  if (bundleCache.has(cacheKey)) {
+    return bundleCache.get(cacheKey);
+  }
+  console.log(`[reroute] Building ${originalPath}${options.minify ? " (minified)" : ""}...`);
+  try {
+    if (isWatchMode()) {
+      const cwd = typeof process !== "undefined" && process.cwd ? process.cwd() : "";
+      if (cwd) {
+        await buildTailwindIfConfigured(cwd);
+      }
+    }
+  } catch (e) {
+    console.warn("[reroute/tailwind] rebuild failed:", e);
+  }
+  async function doBuild(sm) {
+    return await Bun.build({
+      entrypoints: [filePath],
+      target: "browser",
+      format: "esm",
+      minify: options.minify,
+      splitting: false,
+      sourcemap: sm,
+      define: {
+        "process.env.NODE_ENV": options.minify ? '"production"' : '"development"'
+      }
+    });
   }
+  let result;
   try {
-    const module = await commands[command]();
-    await module.default(args.slice(1));
+    result = await doBuild(options.sourcemap ? "external" : "none");
   } catch (error) {
-    console.error("Error executing command:", error);
-    process.exit(1);
+    console.warn(`[reroute] Build errored for ${originalPath} (sourcemap external). Retrying without sourcemap...`, error);
+    result = await doBuild("none");
   }
+  if (!result.success) {
+    console.error(`[reroute] Failed to build ${filePath}`);
+    for (const log2 of result.logs)
+      console.error(log2);
+    throw new Error(`Failed to transpile ${filePath}`);
+  }
+  const output = result.outputs[0];
+  const code = await output.text();
+  let sourceMap;
+  if (options.sourcemap && result.outputs.length > 1) {
+    const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
+    if (mapOutput) {
+      sourceMap = await mapOutput.text();
+    }
+  }
+  const contentHash = await generateContentHash(code);
+  const bundleInfo = {
+    hash: contentHash,
+    code,
+    sourceMap
+  };
+  bundleCache.set(cacheKey, bundleInfo);
+  const sizeKB = (code.length / 1024).toFixed(2);
+  const gzippedSize = Bun.gzipSync(new TextEncoder().encode(code)).length;
+  const gzippedKB = (gzippedSize / 1024).toFixed(2);
+  console.log(`[reroute] Built ${originalPath} -> ${sizeKB} KB (${gzippedKB} KB gzipped)`);
+  return bundleInfo;
 }
-async function printHelp2() {
-  console.log("");
-  console.log(await getVersionString2());
-  console.log("");
-  console.log("");
-  console.log("Usage:");
-  console.log("");
-  console.log("  reroute <command> [options]");
-  console.log("");
-  console.log("");
-  console.log("Commands:");
-  console.log("");
-  console.log("  init        Scaffold a new Reroute project");
-  console.log("  boot        Initialize .reroute directory with stub files");
-  console.log("  gen         Generate content registry and static assets");
-  console.log("  dev         Start development environment");
-  console.log("  start       Run production-like server locally");
-  console.log("  build       Build production binary");
-  console.log("");
-  console.log("");
-  console.log("Options:");
-  console.log("");
-  console.log("  -h, --help     Show help");
-  console.log("  -v, --version  Show version");
-  console.log("");
-  console.log("");
-  console.log("Examples:");
-  console.log("");
-  console.log("  reroute init my-app");
-  console.log("  reroute boot");
-  console.log("");
-  console.log("  reroute gen");
-  console.log("  reroute gen -w");
-  console.log("  reroute gen --watch");
-  console.log("");
-  console.log("  reroute dev");
-  console.log("  reroute dev -s");
-  console.log("  reroute dev --single");
-  console.log("");
-  console.log("  reroute start");
-  console.log("");
-  console.log("  reroute build");
-  console.log("  reroute build -o ./dist/myapp");
-  console.log("  reroute build --outfile ./dist/myapp");
+async function getBundleUrlsFor(modules, clientDir, prefix, options, bundleCache) {
+  const mods = Array.isArray(modules) ? modules : [modules];
+  const urls = [];
+  const { join: join12 } = await Promise.resolve().then(() => exports_path);
+  for (const mod of mods) {
+    const rel = mod.replace(/^\.\//, "");
+    const fullPath = join12(clientDir, rel);
+    try {
+      const bundleInfo = await transpileFile(fullPath, rel, options, bundleCache);
+      const base = basename2(rel, extname2(rel));
+      urls.push(`${prefix}/${base}.${bundleInfo.hash}.js`);
+    } catch (error) {
+      console.error(`[reroute] Error getting bundle URL for ${rel}:`, error);
+      urls.push(`${prefix}/${rel}`);
+    }
+  }
+  return urls;
+}
+var init_transpile = __esm(() => {
+  init_cli();
+});
+
+// packages/core/src/bundler/index.ts
+var init_bundler = __esm(() => {
+  init_transpile();
+});
+
+// packages/core/src/content/metadata.ts
+import { stat } from "node:fs/promises";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+async function getContentMeta(absPath, isWatchMode2) {
+  try {
+    const url = pathToFileURL2(absPath).href;
+    const mod = await import(`${url}${isWatchMode2 ? `?t=${Date.now()}` : ""}`);
+    const meta = mod.meta || mod.frontmatter || {};
+    if (meta && typeof meta === "object")
+      return meta;
+    return {};
+  } catch {
+    try {
+      const s = await stat(absPath);
+      return { date: new Date(s.mtimeMs).toISOString() };
+    } catch {
+      return {};
+    }
+  }
+}
+function buildHeadFromMeta(meta) {
+  if (!meta || typeof meta !== "object")
+    return "";
+  const parts = [];
+  const title = typeof meta.title === "string" ? meta.title : undefined;
+  const description = typeof meta.description === "string" ? meta.description : typeof meta.excerpt === "string" ? meta.excerpt : undefined;
+  if (title)
+    parts.push(`<title>${escapeHtml(title)}</title>`);
+  if (description)
+    parts.push(`<meta name="description" content="${escapeHtml(description)}" />`);
+  return parts.length ? `
+${parts.join(`
+`)}` : "";
+}
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var init_metadata = () => {};
+
+// packages/core/src/content/discovery.ts
+import { readdir as readdir3, stat as stat2 } from "node:fs/promises";
+async function listContentFiles2(dir, baseRel) {
+  const out = [];
+  try {
+    const entries = await readdir3(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join11(dir, entry.name);
+      const rel = join11(baseRel, entry.name);
+      if (entry.isDirectory()) {
+        const nested = await listContentFiles2(full, rel);
+        out.push(...nested);
+      } else if (entry.isFile()) {
+        if (/\.(tsx|ts)$/.test(entry.name) && !entry.name.startsWith("_")) {
+          out.push(rel);
+        }
+      }
+    }
+  } catch {}
+  return out;
+}
+async function buildContentDTOs(collectionPath, clientDir, prefix, isWatchMode2) {
+  const normalized = stripStart(stripEnd(collectionPath, "/"), "/");
+  const contentRelDir = join11("routes", normalized, "content");
+  const contentAbsDir = join11(clientDir, contentRelDir);
+  const files = await listContentFiles2(contentAbsDir, "");
+  const items = [];
+  for (const rel of files) {
+    const fullRelPath = join11(contentRelDir, rel);
+    const absPath = join11(clientDir, fullRelPath);
+    const noExt = rel.replace(/\.(tsx|ts)$/, "");
+    const name = basename2(noExt);
+    const moduleUrl = `${prefix}/${fullRelPath}`.replace(/\/+/g, "/");
+    const meta = await getContentMeta(absPath, isWatchMode2);
+    const href = `/${normalized}/${name}`.replace(/\\+/g, "/");
+    items.push({
+      slug: noExt,
+      name,
+      path: fullRelPath,
+      module: moduleUrl,
+      meta,
+      href
+    });
+  }
+  return items;
+}
+async function discoverCollections(clientDir) {
+  const root = join11(clientDir, "routes");
+  const collections = new Set;
+  try {
+    const entries = await readdir3(root, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const contentDir = join11(root, entry.name, "content");
+        try {
+          await stat2(contentDir);
+          collections.add(entry.name);
+        } catch {}
+      }
+    }
+  } catch {}
+  return Array.from(collections);
+}
+var init_discovery = __esm(() => {
+  init_metadata();
+});
+
+// packages/core/src/content/registry.ts
+async function generateContentRegistry(cwd) {
+  try {
+    const p = join11(cwd, ".reroute", "content.ts");
+    const exists = await Bun.file(p).exists();
+    console.log(exists ? "[reroute] Content registry up-to-date" : "[reroute] Warning: .reroute/content.ts not found");
+  } catch {}
+}
+var init_registry = () => {};
+
+// packages/core/src/content/index.ts
+var init_content = __esm(() => {
+  init_discovery();
+  init_metadata();
+  init_registry();
+});
+
+// packages/core/src/ssr/modules.ts
+import { readdir as readdir4, stat as stat3 } from "node:fs/promises";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2) {
+  try {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts.length < 2)
+      return null;
+    const collection = parts[0];
+    const name = parts[1];
+    try {
+      const registryPath = join11(cwd, ".reroute", "content.ts");
+      const reg = await import(pathToFileURL3(registryPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+      const get = reg?.getContentEntry;
+      const entry = typeof get === "function" ? get(collection, name) : undefined;
+      const moduleUrl = entry?.module;
+      if (moduleUrl?.endsWith(".js")) {
+        const abs = join11(cwd, moduleUrl.replace(/^\//, ""));
+        const href = pathToFileURL3(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : "");
+        const mod = await import(href);
+        return mod;
+      }
+    } catch {}
+    try {
+      const chunkDir = join11(cwd, ".reroute", "chunks", collection);
+      const files = await readdir4(chunkDir);
+      const matches = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
+      if (matches.length) {
+        let latest = matches[0];
+        let latestM = 0;
+        for (const f of matches) {
+          try {
+            const s = await stat3(join11(chunkDir, f));
+            if (s.mtimeMs >= latestM) {
+              latestM = s.mtimeMs;
+              latest = f;
+            }
+          } catch {}
+        }
+        const absChunk = join11(chunkDir, latest);
+        const href = pathToFileURL3(absChunk).href + (isWatchMode2 ? `?t=${Date.now()}` : "");
+        const mod = await import(href);
+        return mod;
+      }
+    } catch {}
+    try {
+      const srcTsx = join11(clientDir, "routes", collection, "content", `${name}.tsx`);
+      const srcTs = join11(clientDir, "routes", collection, "content", `${name}.ts`);
+      let absSrc = null;
+      if (await Bun.file(srcTsx).exists())
+        absSrc = srcTsx;
+      else if (await Bun.file(srcTs).exists())
+        absSrc = srcTs;
+      if (absSrc) {
+        const href = pathToFileURL3(absSrc).href;
+        const mod = await (isWatchMode2 ? import(`${href}?t=${Date.now()}`) : import(href));
+        return mod;
+      }
+    } catch {}
+  } catch {}
+  return null;
+}
+var init_modules = () => {};
+
+// packages/core/src/ssr/seed.ts
+async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2) {
+  try {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts.length < 2)
+      return;
+    const collection = parts[0];
+    const name = parts[1];
+    const key = `${collection}:${name}`;
+    const mod = await importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2);
+    if (!mod)
+      return;
+    const C = mod.default || mod;
+    globalThis.__REROUTE_SSR_MODULES__ = globalThis.__REROUTE_SSR_MODULES__ || {};
+    globalThis.__REROUTE_SSR_MODULES__[key] = C;
+    try {
+      const pageMeta = mod.meta || mod.frontmatter || {};
+      const pageSSR = mod.ssr || {};
+      globalThis.__REROUTE_SSR_EXPORTS__ = globalThis.__REROUTE_SSR_EXPORTS__ || {};
+      globalThis.__REROUTE_SSR_EXPORTS__[key] = {
+        meta: pageMeta,
+        ssr: pageSSR
+      };
+    } catch {}
+  } catch {}
+}
+var init_seed = __esm(() => {
+  init_modules();
+});
+
+// packages/core/src/ssr/data.ts
+import { pathToFileURL as pathToFileURL4 } from "node:url";
+async function computeSSRDataForPath(params) {
+  const { pathname, clientDir, cwd, isWatchMode: isWatchMode2 } = params;
+  try {
+    await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2);
+  } catch {}
+  try {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts.length >= 2) {
+      const key = `${parts[0]}:${parts[1]}`;
+      const g = globalThis;
+      const exp = g.__REROUTE_SSR_EXPORTS__?.[key];
+      const dataFn = exp?.ssr?.data;
+      if (typeof dataFn === "function") {
+        return await dataFn({ pathname, params: { name: parts[1] } });
+      }
+    }
+  } catch {}
+  try {
+    const routesPath = join11(cwd, ".reroute", "routes.ts");
+    const m = await import(pathToFileURL4(routesPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+    const match = typeof m.matchRoute === "function" ? m.matchRoute(pathname) : null;
+    const r = match?.route;
+    const paramsValue = match?.params || {};
+    if (r && typeof r.path === "string") {
+      try {
+        const abs = join11(clientDir, "routes", String(r.path));
+        const mod = await import(pathToFileURL4(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+        const ssr = mod?.ssr;
+        const dataFn = ssr?.data;
+        if (typeof dataFn === "function") {
+          return await dataFn({ pathname, params: paramsValue });
+        }
+      } catch {}
+    }
+  } catch {}
+  return null;
+}
+var init_data = __esm(() => {
+  init_seed();
+});
+
+// node_modules/dedent/dist/dedent.mjs
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1;i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null)
+    return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object")
+      return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function createDedent(options) {
+  dedent2.withOptions = (newOptions) => createDedent(_objectSpread(_objectSpread({}, options), newOptions));
+  return dedent2;
+  function dedent2(strings, ...values) {
+    const raw = typeof strings === "string" ? [strings] : strings.raw;
+    const {
+      alignValues = false,
+      escapeSpecialCharacters = Array.isArray(strings),
+      trimWhitespace = true
+    } = options;
+    let result = "";
+    for (let i = 0;i < raw.length; i++) {
+      let next = raw[i];
+      if (escapeSpecialCharacters) {
+        next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
+      }
+      result += next;
+      if (i < values.length) {
+        const value = alignValues ? alignValue(values[i], result) : values[i];
+        result += value;
+      }
+    }
+    const lines = result.split(`
+`);
+    let mindent = null;
+    for (const l of lines) {
+      const m = l.match(/^(\s+)\S+/);
+      if (m) {
+        const indent = m[1].length;
+        if (!mindent) {
+          mindent = indent;
+        } else {
+          mindent = Math.min(mindent, indent);
+        }
+      }
+    }
+    if (mindent !== null) {
+      const m = mindent;
+      result = lines.map((l) => l[0] === " " || l[0] === "\t" ? l.slice(m) : l).join(`
+`);
+    }
+    if (trimWhitespace) {
+      result = result.trim();
+    }
+    if (escapeSpecialCharacters) {
+      result = result.replace(/\\n/g, `
+`);
+    }
+    return result;
+  }
+}
+function alignValue(value, precedingText) {
+  if (typeof value !== "string" || !value.includes(`
+`)) {
+    return value;
+  }
+  const currentLine = precedingText.slice(precedingText.lastIndexOf(`
+`) + 1);
+  const indentMatch = currentLine.match(/^(\s+)/);
+  if (indentMatch) {
+    const indent = indentMatch[1];
+    return value.replace(/\n/g, `
+${indent}`);
+  }
+  return value;
+}
+var dedent, dedent_default;
+var init_dedent = __esm(() => {
+  dedent = createDedent({});
+  dedent_default = dedent;
+});
+
+// packages/core/src/template/html.ts
+async function loadIndexHtml(clientDir) {
+  const templatePath = join11(clientDir, "index.html");
+  try {
+    const content = await Bun.file(templatePath).text();
+    return content;
+  } catch (error) {
+    console.error(`[reroute] Failed to load template from ${templatePath}:`, error);
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Reroute</title>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>`;
+  }
+}
+function applyIndexTemplate(templateHtml, appHtml, {
+  head = "",
+  hydrationScript = "",
+  lang = "en",
+  appId = "root"
+}) {
+  let html = templateHtml;
+  html = html.replace(/<html([^>]*)>/i, (_m, attrs) => {
+    const hasLang = /(^|\s)lang\s*=/.test(attrs);
+    const newAttrs = hasLang ? attrs.replace(/lang\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/i, `lang="${lang}"`) : `${attrs} lang="${lang}"`;
+    return `<html${newAttrs}>`;
+  });
+  let headToInject = head || "";
+  try {
+    const titleMatch = headToInject.match(/<title[\s\S]*?<\/title>/i);
+    if (titleMatch) {
+      const titleTag = titleMatch[0];
+      if (/<title[\s\S]*?<\/title>/i.test(html)) {
+        html = html.replace(/<title[\s\S]*?<\/title>/i, titleTag);
+      } else {}
+      headToInject = headToInject.replace(titleTag, "");
+    }
+    const descRe = /<meta\s+name\s*=\s*['"]description['"][^>]*>/i;
+    const descMatch = headToInject.match(descRe);
+    if (descMatch) {
+      const descTag = descMatch[0];
+      if (descRe.test(html)) {
+        html = html.replace(descRe, descTag);
+      }
+      headToInject = headToInject.replace(descTag, "");
+    }
+  } catch {}
+  if (headToInject) {
+    html = html.replace(/<\/head>/i, `${headToInject}
+	</head>`);
+  }
+  html = html.replace(/<script\b[^>]*src\s*=\s*["'][^"']+\.(ts|tsx)(?:[?#][^"']*)?["'][^>]*>\s*<\/script>/gi, "");
+  const appIdEscaped = appId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const rootDivRegex = new RegExp(`(<div[^>]*\\bid=(\\"|')${appIdEscaped}\\2[^>]*>)([\\s\\S]*?)(<\\/div>)`, "i");
+  if (rootDivRegex.test(html)) {
+    html = html.replace(rootDivRegex, `$1${appHtml}$4`);
+  } else {
+    html = html.replace(/<\/body>/i, `		<div id="${appId}">${appHtml}</div>
+	</body>`);
+  }
+  if (hydrationScript) {
+    html = html.replace(/<\/body>/i, `		${hydrationScript}
+	</body>`);
+  }
+  return html;
+}
+var init_html = () => {};
+
+// packages/core/src/template/index.ts
+var init_template = __esm(() => {
+  init_html();
+});
+
+// packages/core/src/ssr/render.ts
+import { readdir as readdir5, stat as stat4 } from "node:fs/promises";
+import { pathToFileURL as pathToFileURL5 } from "node:url";
+import { cloneElement } from "react";
+import { renderToString } from "react-dom/server";
+async function renderSSRDocument(options) {
+  const {
+    pathname,
+    rootComponent,
+    clientDir,
+    cwd,
+    isWatchMode: isWatchMode2,
+    bundleUrl,
+    head = "",
+    lang = "en",
+    appId = "root",
+    minify = false
+  } = options;
+  const scripts = [bundleUrl];
+  let hydrationScript = "";
+  let extraHead = "";
+  let statusOverride;
+  try {
+    globalThis.__REROUTE_SSR_ACCESSED__ = {};
+  } catch {}
+  try {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts.length >= 2) {
+      const collection = parts[0];
+      const name = parts[1];
+      let modulePath = "";
+      let isContentCollection = false;
+      try {
+        const maybeDir = join11(clientDir, "routes", collection, "content");
+        const s = await stat4(maybeDir);
+        isContentCollection = typeof s?.isDirectory === "function" ? s.isDirectory() : true;
+      } catch {
+        isContentCollection = false;
+      }
+      if (!isContentCollection) {
+        throw new Error("skip-content-preload");
+      }
+      try {
+        const registryPath = join11(cwd, ".reroute", "content.ts");
+        const reg = await import(pathToFileURL5(registryPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+        const get = reg?.getContentEntry;
+        const entry = typeof get === "function" ? get(collection, name) : undefined;
+        const moduleUrl = entry?.module;
+        if (moduleUrl?.endsWith(".js")) {
+          modulePath = moduleUrl;
+        }
+      } catch {}
+      if (!modulePath) {
+        try {
+          const chunkDir = join11(cwd, ".reroute", "chunks", collection);
+          const files = await readdir5(chunkDir);
+          const candidates = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
+          if (candidates.length) {
+            let latest = candidates[0];
+            let latestM = 0;
+            for (const candidateName of candidates) {
+              try {
+                const s = await stat4(join11(chunkDir, candidateName));
+                if (s.mtimeMs >= latestM) {
+                  latestM = s.mtimeMs;
+                  latest = candidateName;
+                }
+              } catch {}
+            }
+            modulePath = `/${join11(".reroute", "chunks", collection, latest).replace(/\\+/g, "/")}`;
+          }
+        } catch {}
+      }
+      if (!modulePath) {
+        const tsx = join11(clientDir, "routes", collection, "content", `${name}.tsx`);
+        const ts = join11(clientDir, "routes", collection, "content", `${name}.ts`);
+        let srcUrl = "";
+        if (await Bun.file(tsx).exists()) {
+          srcUrl = `/${join11("routes", collection, "content", `${name}.tsx`).replace(/\\+/g, "/")}`;
+        } else if (await Bun.file(ts).exists()) {
+          srcUrl = `/${join11("routes", collection, "content", `${name}.ts`).replace(/\\+/g, "/")}`;
+        }
+        if (srcUrl) {
+          modulePath = srcUrl;
+        }
+      }
+      if (!modulePath) {
+        statusOverride = 404;
+      }
+      if (modulePath) {
+        const key = `${collection}:${name}`;
+        extraHead += `
+<link rel="modulepreload" href="${modulePath}" />`;
+        const qs = `src=${encodeURIComponent(modulePath)}&key=${encodeURIComponent(key)}`;
+        hydrationScript += `<script type="module" src="/__reroute_preload?${qs}"></script>`;
+      }
+    }
+  } catch {}
+  await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2);
+  const __SSR_DATA__ = {};
+  try {
+    try {
+      const parts = pathname.split("/").filter(Boolean);
+      if (parts.length >= 2) {
+        const g = globalThis;
+        const key = `${parts[0]}:${parts[1]}`;
+        const exp = g.__REROUTE_SSR_EXPORTS__?.[key];
+        const dataFn = exp?.ssr?.data;
+        if (typeof dataFn === "function") {
+          const out = await dataFn({
+            pathname,
+            params: { name: parts[1] }
+          });
+          __SSR_DATA__[pathname] = out;
+        }
+      }
+    } catch {}
+    try {
+      const routesPath = join11(cwd, ".reroute", "routes.ts");
+      const m = await import(pathToFileURL5(routesPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+      const match = typeof m.matchRoute === "function" ? m.matchRoute(pathname) : null;
+      const r = match?.route;
+      const params = match?.params || {};
+      if (r && typeof r.path === "string") {
+        try {
+          const abs = join11(clientDir, "routes", String(r.path));
+          const mod = await import(pathToFileURL5(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+          const ssr = mod?.ssr;
+          const dataFn = ssr?.data;
+          if (typeof dataFn === "function") {
+            const out = await dataFn({ pathname, params });
+            __SSR_DATA__[pathname] = out;
+          }
+        } catch {}
+      }
+    } catch {}
+  } catch {}
+  try {
+    globalThis.__REROUTE_DATA__ = __SSR_DATA__;
+  } catch {}
+  let __byCollectionForSSR = {};
+  try {
+    const p = join11(cwd, ".reroute", "content.ts");
+    const mod = await import(pathToFileURL5(p).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+    __byCollectionForSSR = mod?.byCollection || {};
+    try {
+      globalThis.__REROUTE_COLLECTIONS__ = __byCollectionForSSR;
+    } catch {}
+  } catch {}
+  const componentWithPathname = cloneElement(rootComponent, {
+    pathname
+  });
+  const appHtml = renderToString(componentWithPathname);
+  const baseTemplate = await loadIndexHtml(clientDir);
+  let inlineStyleTag = "";
+  try {
+    const candidates = [
+      join11(clientDir, "..", ".reroute", "theme.css"),
+      join11(clientDir, "..", "..", ".reroute", "theme.css"),
+      join11(clientDir, "..", "..", "..", ".reroute", "theme.css"),
+      join11(clientDir, "..", "..", "..", "..", ".reroute", "theme.css")
+    ];
+    let cssPath = "";
+    for (const p of candidates) {
+      if (await Bun.file(p).exists()) {
+        cssPath = p;
+        break;
+      }
+    }
+    if (cssPath) {
+      let css = await Bun.file(cssPath).text();
+      if (minify) {
+        css = css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{}:;,>+~])\s*/g, "$1").replace(/;}/g, "}").trim();
+      }
+      inlineStyleTag = `<style data-reroute="tailwind">${css}</style>`;
+    }
+  } catch {}
+  try {
+    const g = globalThis;
+    const acc = g.__REROUTE_SSR_ACCESSED__;
+    const sortByDate = (order) => (a, b) => {
+      const da = a?.meta?.date ? Date.parse(String(a.meta.date)) : 0;
+      const db = b?.meta?.date ? Date.parse(String(b.meta.date)) : 0;
+      return order === "asc" ? da - db : db - da;
+    };
+    const usage = {};
+    if (acc && typeof acc.forEach === "function") {
+      acc.forEach((c) => {
+        if (typeof c === "string")
+          usage[c] = { limit: Number.POSITIVE_INFINITY, sort: "custom" };
+      });
+    } else if (acc && typeof acc === "object") {
+      for (const [k, v] of Object.entries(acc)) {
+        const lim = typeof v?.limit === "number" ? v.limit : Number.POSITIVE_INFINITY;
+        const s = typeof v?.sort === "string" ? v.sort : "custom";
+        usage[k] = { limit: lim, sort: s };
+      }
+    }
+    const collections = Object.keys(usage);
+    if (collections.length) {
+      const subset = {};
+      const partial = {};
+      for (const c of collections) {
+        const conf = usage[c];
+        const full = __byCollectionForSSR?.[c] || [];
+        let arr = full;
+        if (Number.isFinite(conf.limit) && conf.limit > 0 && conf.sort !== "custom") {
+          if (conf.sort === "date-desc") {
+            arr = [...full].sort(sortByDate("desc")).slice(0, conf.limit);
+          } else if (conf.sort === "date-asc") {
+            arr = [...full].sort(sortByDate("asc")).slice(0, conf.limit);
+          } else if (conf.sort === "none") {
+            arr = full.slice(0, conf.limit);
+          }
+        }
+        subset[c] = arr;
+        partial[c] = Array.isArray(arr) && Array.isArray(full) ? arr.length < full.length : false;
+      }
+      const subsetJson = JSON.stringify(subset);
+      const partialJson = JSON.stringify(partial);
+      hydrationScript += `
+<script>
+  (function(){ try {
+    var w = (typeof window!== 'undefined'? window : globalThis);
+    w.__REROUTE_COLLECTIONS__ = w.__REROUTE_COLLECTIONS__ || {};
+    Object.assign(w.__REROUTE_COLLECTIONS__, ${subsetJson});
+    w.__REROUTE_COLLECTIONS_PARTIAL__ = w.__REROUTE_COLLECTIONS_PARTIAL__ || {};
+    Object.assign(w.__REROUTE_COLLECTIONS_PARTIAL__, ${partialJson});
+  } catch(e){} })();
+</script>`;
+    }
+  } catch {}
+  try {
+    const seededJson = JSON.stringify(__SSR_DATA__);
+    hydrationScript += `
+<script>
+  (function(){ try {
+    var w = (typeof window!== 'undefined'? window : globalThis);
+    w.__REROUTE_DATA__ = Object.assign({}, w.__REROUTE_DATA__ || {}, ${seededJson});
+  } catch(e){} })();
+</script>`;
+  } catch {}
+  hydrationScript += scripts.map((src) => `<script type="module" src="${src}"></script>`).join("");
+  if (isWatchMode2) {
+    hydrationScript += `<script type="module" src="/__reroute_watch.js"></script>`;
+  }
+  let perPageHead = "";
+  let pageLang;
+  try {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts.length >= 2) {
+      const key = `${parts[0]}:${parts[1]}`;
+      const g = globalThis;
+      const exp = g.__REROUTE_SSR_EXPORTS__?.[key];
+      const meta = exp?.meta;
+      const ssr = exp?.ssr;
+      perPageHead += buildHeadFromMeta(meta);
+      const ssrHead = typeof ssr?.head === "string" ? ssr.head : Array.isArray(ssr?.head) ? String(ssr.head.join(`
+`)) : "";
+      if (ssrHead)
+        perPageHead += `
+${ssrHead}`;
+      if (typeof ssr?.lang === "string" && ssr.lang.trim()) {
+        pageLang = ssr.lang.trim();
+      }
+    }
+  } catch {}
+  try {
+    const routesPath = join11(cwd, ".reroute", "routes.ts");
+    const m = await import(pathToFileURL5(routesPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+    const match = typeof m.matchRoute === "function" ? m.matchRoute(pathname) : null;
+    const r = match?.route;
+    if (!r) {
+      statusOverride = statusOverride || 404;
+    }
+    if (r && typeof r.path === "string") {
+      try {
+        const abs = join11(clientDir, "routes", String(r.path));
+        const mod = await import(pathToFileURL5(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+        const meta = mod?.meta;
+        const ssr = mod?.ssr;
+        if (meta)
+          perPageHead += buildHeadFromMeta(meta);
+        if (ssr) {
+          const ssrHead = typeof ssr.head === "string" ? ssr.head : Array.isArray(ssr.head) ? String(ssr.head.join(`
+`)) : "";
+          if (ssrHead)
+            perPageHead += `
+${ssrHead}`;
+          if (typeof ssr.lang === "string" && ssr.lang.trim()) {
+            pageLang = ssr.lang.trim();
+          }
+        }
+      } catch {}
+    } else {
+      try {
+        const list = m?.notFoundRoutes;
+        if (Array.isArray(list)) {
+          let chosen;
+          let bestLen = -1;
+          for (const nf of list) {
+            const pat = String(nf?.pattern || "/");
+            if (!pathname.startsWith(pat))
+              continue;
+            const len = pat.split("/").filter(Boolean).length;
+            if (len >= bestLen) {
+              bestLen = len;
+              chosen = nf;
+            }
+          }
+          if (chosen && typeof chosen.path === "string") {
+            try {
+              const abs = join11(clientDir, "routes", String(chosen.path));
+              const mod = await import(pathToFileURL5(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+              const meta = mod?.meta;
+              const ssr = mod?.ssr;
+              if (meta)
+                perPageHead += buildHeadFromMeta(meta);
+              const ssrHead = typeof ssr?.head === "string" ? ssr.head : Array.isArray(ssr?.head) ? String(ssr.head.join(`
+`)) : "";
+              if (ssrHead)
+                perPageHead += `
+${ssrHead}`;
+              if (typeof ssr?.lang === "string" && ssr.lang?.trim()) {
+                pageLang = String(ssr.lang).trim();
+              }
+            } catch {}
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+  const combinedHead = dedent_default([dedent_default(head) || "", dedent_default(extraHead), dedent_default(perPageHead)].filter(Boolean).join(`
+`));
+  const html2 = applyIndexTemplate(baseTemplate, appHtml, {
+    head: [inlineStyleTag, combinedHead].filter(Boolean).join(`
+`),
+    hydrationScript,
+    lang: pageLang || lang,
+    appId
+  });
+  return {
+    html: html2,
+    status: statusOverride || 200
+  };
+}
+var init_render = __esm(() => {
+  init_dedent();
+  init_metadata();
+  init_template();
+  init_seed();
+});
+
+// packages/core/src/ssr/index.ts
+var init_ssr = __esm(() => {
+  init_data();
+  init_render();
+  init_seed();
+});
+// packages/core/src/utils/cache.ts
+class LRUCache {
+  cache;
+  maxSize;
+  constructor(maxSize = 100) {
+    this.cache = new Map;
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return;
+    }
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    this.cache.set(key, value);
+    if (this.cache.size > this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+}
+var init_cache = () => {};
+
+// packages/core/src/utils/mime.ts
+function getMimeType(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  const mimeTypes = {
+    html: "text/html",
+    css: "text/css",
+    js: "application/javascript",
+    ts: "application/javascript",
+    json: "application/json",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf"
+  };
+  return mimeTypes[ext || ""] || "application/octet-stream";
+}
+function isCompressible(contentType) {
+  if (!contentType)
+    return false;
+  const ct = contentType.split(";")[0].trim();
+  return ct.startsWith("text/") || ct === "application/javascript" || ct === "application/json" || ct === "application/xml" || ct === "image/svg+xml";
+}
+
+// packages/core/src/utils/compression.ts
+function acceptsGzip(acceptEncoding) {
+  return Boolean(acceptEncoding && /gzip/i.test(acceptEncoding));
+}
+function toBytes(input) {
+  return typeof input === "string" ? new TextEncoder().encode(input) : input;
+}
+function gzipIfAccepted(body, contentType, acceptEncoding) {
+  const extraHeaders = {};
+  if (acceptsGzip(acceptEncoding) && isCompressible(contentType)) {
+    try {
+      const compressed = Bun.gzipSync(toBytes(body));
+      extraHeaders["Content-Encoding"] = "gzip";
+      extraHeaders.Vary = "Accept-Encoding";
+      return { body: compressed, extraHeaders };
+    } catch {}
+  }
+  return { body, extraHeaders };
+}
+var init_compression = () => {};
+
+// packages/core/src/utils/index.ts
+var init_utils = __esm(() => {
+  init_cache();
+  init_compression();
+});
+
+// packages/core/src/index.ts
+var init_src = __esm(() => {
+  init_bundler();
+  init_content();
+  init_ssr();
+  init_template();
+  init_utils();
+});
+
+// packages/core/index.ts
+var exports_core = {};
+__export(exports_core, {
+  transpileFile: () => transpileFile,
+  toBytes: () => toBytes,
+  stripStart: () => stripStart,
+  stripEnd: () => stripEnd,
+  seedSSRModuleForPath: () => seedSSRModuleForPath,
+  renderSSRDocument: () => renderSSRDocument,
+  loadIndexHtml: () => loadIndexHtml,
+  listContentFiles: () => listContentFiles2,
+  join: () => join11,
+  isCompressible: () => isCompressible,
+  gzipIfAccepted: () => gzipIfAccepted,
+  getMimeType: () => getMimeType,
+  getContentMeta: () => getContentMeta,
+  getBundleUrlsFor: () => getBundleUrlsFor,
+  generateContentRegistry: () => generateContentRegistry,
+  generateContentHash: () => generateContentHash,
+  extname: () => extname2,
+  discoverCollections: () => discoverCollections,
+  computeSSRDataForPath: () => computeSSRDataForPath,
+  buildHeadFromMeta: () => buildHeadFromMeta,
+  buildContentDTOs: () => buildContentDTOs,
+  basename: () => basename2,
+  applyIndexTemplate: () => applyIndexTemplate,
+  acceptsGzip: () => acceptsGzip,
+  LRUCache: () => LRUCache
+});
+var init_core = __esm(() => {
+  init_src();
+});
+
+// packages/cli/src/commands/analyze.ts
+var exports_analyze = {};
+__export(exports_analyze, {
+  default: () => analyze
+});
+import { existsSync as existsSync9, statSync } from "node:fs";
+import { readdir as readdir6, readFile as readFile2, stat as stat5, writeFile as writeFile4 } from "node:fs/promises";
+import { basename as basename3, join as join12, relative } from "node:path";
+import Table from "cli-table3";
+async function findBundles(cwd) {
+  const bundles = [];
+  const chunksDir = join12(cwd, ".reroute", "chunks");
+  if (existsSync9(chunksDir)) {
+    const collections = await readdir6(chunksDir, { withFileTypes: true });
+    for (const collection of collections) {
+      if (!collection.isDirectory())
+        continue;
+      const collectionDir = join12(chunksDir, collection.name);
+      const files = await readdir6(collectionDir);
+      for (const file of files) {
+        if (!file.endsWith(".js"))
+          continue;
+        const filePath = join12(collectionDir, file);
+        const stats = await stat5(filePath);
+        const content2 = await readFile2(filePath);
+        const gzippedSize = Bun.gzipSync(content2).length;
+        bundles.push({
+          path: filePath,
+          name: file,
+          size: stats.size,
+          gzippedSize,
+          relativePath: relative(cwd, filePath),
+          type: "chunk"
+        });
+      }
+    }
+  }
+  const distDir = join12(cwd, "dist");
+  if (existsSync9(distDir)) {
+    const files = await readdir6(distDir);
+    for (const file of files) {
+      const filePath = join12(distDir, file);
+      const stats = statSync(filePath);
+      if (stats.isFile() && !file.endsWith(".map") && !file.endsWith(".d.ts")) {
+        const content2 = await readFile2(filePath);
+        const gzippedSize = Bun.gzipSync(content2).length;
+        bundles.push({
+          path: filePath,
+          name: file,
+          size: stats.size,
+          gzippedSize,
+          relativePath: relative(cwd, filePath),
+          type: "binary"
+        });
+      }
+    }
+  }
+  return bundles;
+}
+async function findBrowserEntry(cwd) {
+  try {
+    const clientDir = join12(cwd, "src", "client");
+    const tsxEntry = join12(clientDir, "index.tsx");
+    const tsEntry = join12(clientDir, "index.ts");
+    let sourceEntry = null;
+    if (existsSync9(tsxEntry)) {
+      sourceEntry = tsxEntry;
+    } else if (existsSync9(tsEntry)) {
+      sourceEntry = tsEntry;
+    }
+    if (!sourceEntry)
+      return null;
+    const { generateContentHash: generateContentHash2 } = await Promise.resolve().then(() => (init_core(), exports_core));
+    const isProd = isProductionMode();
+    const result = await Bun.build({
+      entrypoints: [sourceEntry],
+      target: "browser",
+      format: "esm",
+      minify: isProd,
+      sourcemap: "linked",
+      external: [],
+      define: {
+        "process.env.NODE_ENV": isProd ? '"production"' : '"development"'
+      }
+    });
+    if (!result.success) {
+      if (result.logs && result.logs.length > 0) {
+        console.warn("[reroute/analyze] Browser build errors:", result.logs.map((log2) => log2.message).join(`
+`));
+      }
+      return null;
+    }
+    if (result.outputs.length === 0) {
+      console.warn("[reroute/analyze] Browser build produced no outputs");
+      return null;
+    }
+    const tempDir = join12(cwd, ".reroute", "browser");
+    await import("node:fs/promises").then((fs) => fs.mkdir(tempDir, { recursive: true }));
+    const output = result.outputs[0];
+    const code = await output.text();
+    const actualHash = await generateContentHash2(code);
+    const bundlePath = join12(tempDir, `index.${actualHash}.js`);
+    await writeFile4(bundlePath, code, "utf-8");
+    const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
+    if (mapOutput) {
+      const mapContent = await mapOutput.text();
+      await writeFile4(`${bundlePath}.map`, mapContent, "utf-8");
+    }
+    return bundlePath;
+  } catch (error) {
+    console.warn("[reroute/analyze] Could not build browser entry:", error);
+    return null;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / k ** i).toFixed(2)} ${sizes[i]}`;
+}
+function calculateStats(bundles) {
+  const byCollection = {};
+  let totalSize = 0;
+  let totalGzippedSize = 0;
+  for (const bundle of bundles) {
+    totalSize += bundle.size;
+    totalGzippedSize += bundle.gzippedSize;
+    if (bundle.type === "chunk") {
+      const match = bundle.relativePath.match(/\.reroute\/chunks\/([^/]+)/);
+      const collection = match ? match[1] : "unknown";
+      if (!byCollection[collection]) {
+        byCollection[collection] = [];
+      }
+      byCollection[collection].push(bundle);
+    } else {
+      if (!byCollection.binaries) {
+        byCollection.binaries = [];
+      }
+      byCollection.binaries.push(bundle);
+    }
+  }
+  return {
+    totalBundles: bundles.length,
+    totalSize,
+    totalGzippedSize,
+    bundles,
+    byCollection
+  };
+}
+async function getInstalledPackageSizes(cwd) {
+  const packageSizes = new Map;
+  const nodeModulesDir = join12(cwd, "node_modules");
+  if (!existsSync9(nodeModulesDir))
+    return packageSizes;
+  try {
+    const { execSync } = await import("node:child_process");
+    const output = execSync(`du -sk ${nodeModulesDir}/* 2>/dev/null || true`, {
+      encoding: "utf8",
+      maxBuffer: 10485760
+    });
+    const lines = output.trim().split(`
+`);
+    for (const line of lines) {
+      const [sizeKB, path3] = line.split("\t");
+      if (!path3)
+        continue;
+      const pkgName = basename3(path3);
+      if (pkgName.startsWith("@")) {
+        const scopeDir = path3;
+        const scopedOutput = execSync(`du -sk ${scopeDir}/* 2>/dev/null || true`, {
+          encoding: "utf8"
+        });
+        const scopedLines = scopedOutput.trim().split(`
+`);
+        for (const scopedLine of scopedLines) {
+          const [scopedSizeKB, scopedPath] = scopedLine.split("\t");
+          if (!scopedPath)
+            continue;
+          const fullPkgName = `${pkgName}/${basename3(scopedPath)}`;
+          packageSizes.set(fullPkgName, Number.parseInt(scopedSizeKB, 10) * 1024);
+        }
+      } else {
+        packageSizes.set(pkgName, Number.parseInt(sizeKB, 10) * 1024);
+      }
+    }
+  } catch (_error) {}
+  return packageSizes;
+}
+async function buildDependencyTree(entryPath, cwd) {
+  try {
+    if (!existsSync9(entryPath))
+      return null;
+    const root = {
+      name: basename3(entryPath),
+      path: entryPath,
+      size: 0,
+      children: []
+    };
+    const fromMap = await buildTreeFromSourceMap(entryPath, cwd);
+    if (fromMap)
+      return fromMap;
+    try {
+      let place = function(filePath, size) {
+        if (filePath.includes("node_modules")) {
+          let pkgName = filePath.slice(filePath.indexOf("node_modules") + "node_modules".length + 1);
+          pkgName = pkgName.startsWith("@") ? pkgName.split("/").slice(0, 2).join("/") : pkgName.split("/")[0];
+          let pkgNode = nodeModulesNode.children?.find((c) => c.name === pkgName);
+          if (!pkgNode) {
+            pkgNode = {
+              name: pkgName || "unknown",
+              path: join12(cwd, "node_modules", pkgName || ""),
+              size: 0,
+              children: []
+            };
+            nodeModulesNode.children?.push(pkgNode);
+          }
+          pkgNode.children?.push({
+            name: basename3(filePath),
+            path: filePath,
+            size
+          });
+        } else {
+          const rel = relative(cwd, filePath);
+          const parts = rel.split("/").filter(Boolean);
+          let current = srcNode;
+          for (let i = 0;i < parts.length - 1; i++) {
+            const part = parts[i];
+            let child = current.children?.find((c) => c.name === part);
+            if (!child) {
+              child = {
+                name: part,
+                path: join12(cwd, ...parts.slice(0, i + 1)),
+                size: 0,
+                children: []
+              };
+              current.children?.push(child);
+            }
+            current = child;
+          }
+          current.children?.push({
+            name: parts[parts.length - 1] || basename3(filePath),
+            path: filePath,
+            size
+          });
+        }
+      }, compute = function(node) {
+        if (node.children && node.children.length > 0) {
+          node.size = node.children.reduce((s, c) => s + compute(c), 0);
+        }
+        return node.size;
+      };
+      const content2 = await readFile2(entryPath, "utf-8");
+      const modulePattern = /\/\/\s*(.+?\.(?:ts|tsx|js|jsx|mjs|cjs))\s*$/gm;
+      const nodeModulesNode = {
+        name: "node_modules",
+        path: join12(cwd, "node_modules"),
+        size: 0,
+        children: []
+      };
+      const srcNode = {
+        name: "src",
+        path: cwd,
+        size: 0,
+        children: []
+      };
+      root.children?.push(nodeModulesNode, srcNode);
+      let match;
+      let lastPath = "";
+      let lastPos = 0;
+      match = modulePattern.exec(content2);
+      while (match !== null) {
+        if (lastPath) {
+          const size = match.index - lastPos;
+          if (size > 0)
+            place(lastPath, size);
+        }
+        lastPath = match[1];
+        lastPos = match.index + match[0].length;
+        match = modulePattern.exec(content2);
+      }
+      if (lastPath) {
+        const size = content2.length - lastPos;
+        if (size > 0)
+          place(lastPath, size);
+      }
+      compute(root);
+      return {
+        entry: entryPath,
+        totalSize: root.size,
+        root
+      };
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function buildTreeFromSourceMap(bundlePath, cwd) {
+  try {
+    let decodeVLQ = function(str, indexRef) {
+      let result = 0;
+      let shift = 0;
+      let continuation;
+      do {
+        const ch = str[indexRef.i++];
+        if (ch == null)
+          return 0;
+        const val = charToInt.get(ch) ?? 0;
+        continuation = (val & 32) !== 0;
+        const digit = val & 31;
+        result += digit << shift;
+        shift += 5;
+      } while (continuation);
+      const negate = result & 1;
+      result >>= 1;
+      return negate ? -result : result;
+    }, absFor = function(sourcePath) {
+      if (sourcePath.startsWith("/") || sourcePath.match(/^[A-Za-z]:\\/))
+        return sourcePath;
+      const bundleDir = bundlePath.substring(0, bundlePath.lastIndexOf("/"));
+      return join12(bundleDir, sourceRoot || "", sourcePath);
+    }, computeSizes = function(node) {
+      if (node.children && node.children.length > 0) {
+        node.size = node.children.reduce((s, c) => s + computeSizes(c), 0);
+      }
+      return node.size;
+    };
+    const mapPath = `${bundlePath}.map`;
+    if (!existsSync9(mapPath))
+      return null;
+    const [bundle, mapJson] = await Promise.all([
+      readFile2(bundlePath, "utf-8"),
+      readFile2(mapPath, "utf-8")
+    ]);
+    const map = JSON.parse(mapJson);
+    const sourceRoot = map.sourceRoot || "";
+    const genLines = bundle.split(`
+`).map((l) => l.length);
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    const charToInt = new Map;
+    for (let i = 0;i < chars.length; i++)
+      charToInt.set(chars[i], i);
+    const perSource = new Array(map.sources.length).fill(0);
+    const lines = map.mappings.split(";");
+    for (let line = 0;line < lines.length; line++) {
+      const segs = lines[line];
+      if (!segs)
+        continue;
+      let genCol = 0;
+      let src2 = 0;
+      let _srcLine = 0;
+      let _srcCol = 0;
+      const decoded = [];
+      const idx = { i: 0 };
+      while (idx.i < segs.length) {
+        const start2 = idx.i;
+        genCol += decodeVLQ(segs, idx);
+        let srcIndex = null;
+        if (idx.i < segs.length && segs[idx.i] !== ",") {
+          src2 += decodeVLQ(segs, idx);
+          _srcLine += decodeVLQ(segs, idx);
+          _srcCol += decodeVLQ(segs, idx);
+          if (idx.i < segs.length && segs[idx.i] !== ",") {
+            decodeVLQ(segs, idx);
+          }
+          srcIndex = src2;
+        }
+        decoded.push({ gen: genCol, src: srcIndex });
+        if (segs[idx.i] === ",")
+          idx.i++;
+        if (idx.i === start2)
+          idx.i++;
+      }
+      if (decoded.length === 0)
+        continue;
+      for (let i = 0;i < decoded.length; i++) {
+        const curr = decoded[i];
+        const nextGen = i + 1 < decoded.length ? decoded[i + 1].gen : genLines[line] ?? 0;
+        const span = Math.max(0, nextGen - curr.gen);
+        if (span > 0 && curr.src != null && perSource[curr.src] != null) {
+          perSource[curr.src] += span;
+        }
+      }
+    }
+    const root = {
+      name: basename3(bundlePath),
+      path: bundlePath,
+      size: 0,
+      children: []
+    };
+    const nodeModulesNode = {
+      name: "node_modules",
+      path: join12(cwd, "node_modules"),
+      size: 0,
+      children: []
+    };
+    const srcNode = {
+      name: "src",
+      path: cwd,
+      size: 0,
+      children: []
+    };
+    root.children?.push(nodeModulesNode, srcNode);
+    for (let i = 0;i < map.sources.length; i++) {
+      const size = perSource[i];
+      if (size <= 0)
+        continue;
+      const srcPath = absFor(map.sources[i]);
+      if (srcPath.includes("node_modules")) {
+        let pkgName;
+        if (srcPath.includes(".bun/")) {
+          const bunMatch = srcPath.match(/\.bun\/([^/]+)@[^/]+\/node_modules\/([^/]+)\//);
+          if (bunMatch) {
+            const innerPkg = bunMatch[2];
+            if (innerPkg === "@borewit" || innerPkg.startsWith("@")) {
+              const scopeMatch = srcPath.match(/\.bun\/[^/]+@[^/]+\/node_modules\/((@[^/]+\/[^/]+))/);
+              pkgName = scopeMatch ? scopeMatch[1] : innerPkg;
+            } else {
+              pkgName = innerPkg;
+            }
+          } else {
+            const fallbackMatch = srcPath.match(/\.bun\/([^@/]+)/);
+            pkgName = fallbackMatch ? fallbackMatch[1] : "unknown";
+          }
+        } else {
+          const afterNm = srcPath.slice(srcPath.lastIndexOf("node_modules") + "node_modules".length + 1);
+          pkgName = afterNm.startsWith("@") ? afterNm.split("/").slice(0, 2).join("/") : afterNm.split("/")[0];
+        }
+        let pkgNode = nodeModulesNode.children?.find((c) => c.name === pkgName);
+        if (!pkgNode) {
+          pkgNode = {
+            name: pkgName || "unknown",
+            path: join12(cwd, "node_modules", pkgName || ""),
+            size: 0,
+            children: []
+          };
+          nodeModulesNode.children?.push(pkgNode);
+        }
+        pkgNode.children?.push({
+          name: basename3(srcPath),
+          path: srcPath,
+          size
+        });
+      } else {
+        const rel = relative(cwd, srcPath);
+        const parts = rel.split("/").filter(Boolean);
+        let current = srcNode;
+        for (let i2 = 0;i2 < parts.length - 1; i2++) {
+          const part = parts[i2];
+          let child = current.children?.find((c) => c.name === part);
+          if (!child) {
+            child = {
+              name: part,
+              path: join12(cwd, ...parts.slice(0, i2 + 1)),
+              size: 0,
+              children: []
+            };
+            current.children?.push(child);
+          }
+          current = child;
+        }
+        current.children?.push({
+          name: parts[parts.length - 1] || basename3(srcPath),
+          path: srcPath,
+          size
+        });
+      }
+    }
+    computeSizes(root);
+    return {
+      entry: bundlePath,
+      totalSize: root.size,
+      root
+    };
+  } catch {
+    return null;
+  }
+}
+async function generateHTMLReport(stats, depTree, mainInfo, browserDepTree, browserInfo, initialSearch) {
+  const bundles = stats.bundles.sort((a, b) => b.size - a.size);
+  let actualServerBinarySize = null;
+  let actualServerBinaryGzipped = null;
+  try {
+    const distDir = join12(process.cwd(), "dist");
+    if (existsSync9(distDir)) {
+      const files = await readdir6(distDir);
+      for (const file of files) {
+        const filePath = join12(distDir, file);
+        const stats2 = statSync(filePath);
+        if (stats2.isFile() && !file.includes(".")) {
+          actualServerBinarySize = stats2.size;
+          const content2 = await readFile2(filePath);
+          actualServerBinaryGzipped = Bun.gzipSync(content2).length;
+          break;
+        }
+      }
+    }
+  } catch {}
+  const icon = (name, color = "#0f0", size = 16) => {
+    const icons = {
+      chart: '<path d="M3 3v18h18"/><path d="M7 12l4-4 4 4 6-6"/>',
+      world: '<path d="M21 12a9 9 0 1 1-6.219-8.56"/><path d="M3 9v6a6 6 0 0 0 6 6h6"/><path d="M21 9v6a6 6 0 0 1-6 6H9"/>',
+      search: '<circle cx="10" cy="10" r="7"/><path d="m21 21-6-6"/>',
+      treemap: '<path d="M3 3v18h18"/><path d="M3 9h8v12H3z"/><path d="M13 9h8v6h-8z"/><path d="M13 17h8v4h-8z"/>',
+      package: '<path d="M12 3v20"/><path d="M2 7h20v14H2z"/><path d="M2 7l10-4 10 4"/>',
+      server: '<path d="M4 5h16"/><path d="M4 9h16"/><path d="M4 13h16"/><path d="M4 17h16"/><path d="M6 3v18"/><path d="M18 3v18"/>'
+    };
+    const path3 = icons[name] || icons.chart;
+    return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" stroke="${color}" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="display: inline-block; vertical-align: middle; margin-right: 0.4rem;">${path3}</svg>`;
+  };
+  const html2 = `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Reroute Bundle Analysis</title>
+	<script src="https://d3js.org/d3.v7.min.js"></script>
+	<style>
+		* {
+			margin: 0;
+			padding: 0;
+			box-sizing: border-box;
+		}
+		body {
+			font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Fira Code', 'Droid Sans Mono', 'Source Code Pro', monospace;
+			background: #000;
+			color: #0f0;
+			padding: 1.5rem;
+			line-height: 1.5;
+			font-size: 13px;
+		}
+		.container {
+			max-width: 1600px;
+			margin: 0 auto;
+		}
+		h1 {
+			color: #0f0;
+			margin-bottom: 0.5rem;
+			font-size: 1.25rem;
+			font-weight: 600;
+			letter-spacing: 0.5px;
+		}
+		h1::before {
+			content: '$ ';
+			color: #666;
+		}
+		.sticky-search {
+			position: sticky;
+			top: 0;
+			background: #000;
+			z-index: 100;
+			padding: 1rem 0;
+			margin: 0;
+		}
+		.search-row {
+			display: grid;
+			grid-template-columns: 1fr auto;
+			gap: 0.75rem;
+			align-items: start;
+			height: 33px;
+		}
+		.search-container {
+			position: relative;
+			display: flex;
+			flex-direction: column;
+			gap: 0.5rem;
+		}
+		.search-input-wrapper {
+			position: relative;
+		}
+		.search-clear {
+			position: absolute;
+			right: 0.5rem;
+			top: 50%;
+			transform: translateY(-50%);
+			background: none;
+			border: none;
+			color: #666;
+			cursor: pointer;
+			padding: 0.25rem;
+			display: none;
+			align-items: center;
+			justify-content: center;
+			font-size: 17px;
+			line-height: 1;
+		}
+		.search-clear:hover {
+			color: #0f0;
+		}
+		.search-clear.visible {
+			display: flex;
+		}
+		.search-input {
+			width: 100%;
+			padding: 0.5rem 2rem 0.5rem 0.75rem;
+			background: #111;
+			border: 1px solid #333;
+			color: #0f0;
+			font-size: 13px;
+			font-family: inherit;
+		}
+		.note {
+			color: #666;
+			font-size: 12px;
+			padding: 0.75rem;
+			background: #111;
+			border-left: 2px solid #333;
+		}
+		.note strong {
+			color: #0f0;
+		}
+		@media (max-width: 640px) {
+			.search-row {
+				grid-template-columns: 1fr;
+				gap: 0.5rem;
+			}
+		}
+		.search-input:focus {
+			outline: none;
+			border-color: #0f0;
+		}
+		.search-input::placeholder {
+			color: #666;
+		}
+		.search-stats {
+			margin-bottom: 1rem;
+			font-size: 12px;
+			color: #666;
+		}
+		.search-actions {
+			display: flex;
+			gap: 0.5rem;
+			align-items: stretch;
+		}
+		@media (max-width: 640px) {
+			.search-actions {
+				width: 100%;
+			}
+		}
+		.checkbox-label {
+			padding: 0.5rem 0.75rem;
+			background: #111;
+			border: 1px solid #333;
+			color: #0f0;
+			font-size: 13px;
+			font-family: inherit;
+			cursor: pointer;
+			white-space: nowrap;
+			display: flex;
+			align-items: center;
+			gap: 0.5rem;
+			user-select: none;
+		}
+		.checkbox-label:hover {
+			background: #1a1a1a;
+			border-color: #0f0;
+		}
+		.checkbox-label input[type="checkbox"] {
+			cursor: pointer;
+			width: 14px;
+			height: 14px;
+			accent-color: #0f0;
+		}
+		@media (max-width: 640px) {
+			.checkbox-label {
+				flex: 1;
+			}
+		}
+		.btn-toggle {
+			padding: 0.5rem 0.75rem;
+			background: #111;
+			border: 1px solid #333;
+			color: #0f0;
+			font-size: 13px;
+			font-family: inherit;
+			cursor: pointer;
+			white-space: nowrap;
+			display: flex;
+			align-items: center;
+			box-sizing: border-box;
+		}
+		.btn-toggle:hover {
+			background: #1a1a1a;
+			border-color: #0f0;
+		}
+		@media (max-width: 640px) {
+			.btn-toggle {
+				flex: 1;
+			}
+		}
+		.hidden {
+			display: none !important;
+		}
+		.section {
+			margin-bottom: 1.5rem;
+			border: 1px solid #333;
+			background: #0a0a0a;
+		}
+		.section-header {
+			padding: 0.75rem 1rem;
+			background: #111;
+			border-bottom: 1px solid #333;
+			cursor: pointer;
+			user-select: none;
+			display: flex;
+			justify-content: space-between;
+			align-items: center;
+		}
+		.section-header:hover {
+			background: #151515;
+		}
+		.section-title {
+			font-size: 14px;
+			font-weight: 600;
+			color: #0f0;
+		}
+		.section-title.server {
+			color: #666;
+		}
+		.section-meta {
+			color: #666;
+			font-size: 12px;
+		}
+		.section-toggle {
+			color: #666;
+			font-size: 12px;
+		}
+		.section-content {
+			padding: 1rem;
+		}
+		.section.collapsed .section-content {
+			display: none;
+		}
+		.section.collapsed .section-toggle::before {
+			content: '▶ ';
+		}
+		.section-toggle::before {
+			content: '▼ ';
+		}
+		.stats-grid {
+			display: grid;
+			grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+			gap: 0.5rem;
+			margin-bottom: 1rem;
+		}
+		.stat {
+			background: #111;
+			padding: 0.5rem 0.75rem;
+			border: 1px solid #222;
+		}
+		.stat-label {
+			font-size: 11px;
+			color: #666;
+			margin-bottom: 0.25rem;
+		}
+		.stat-value {
+			font-size: 16px;
+			font-weight: 600;
+			color: #0f0;
+		}
+		.stat-value.server {
+			color: #666;
+		}
+		.dep-list {
+			list-style: none;
+			margin: 0;
+			padding: 0;
+		}
+		.dep-item {
+			padding: 0.4rem 0;
+			border-bottom: 1px solid #1a1a1a;
+			display: flex;
+			justify-content: space-between;
+			align-items: center;
+			font-size: 12px;
+		}
+		.dep-item:last-child {
+			border-bottom: none;
+		}
+		.dep-name {
+			color: #0f0;
+			font-weight: 500;
+		}
+		.dep-name.server {
+			color: #666;
+		}
+		.dep-size {
+			color: #666;
+			font-size: 11px;
+		}
+		.dep-children {
+			margin-left: 1.5rem;
+			margin-top: 0.25rem;
+		}
+		.dep-child {
+			color: #666;
+			font-size: 11px;
+			padding: 0.2rem 0;
+		}
+		.load-more {
+			margin-top: 0.75rem;
+			padding: 0.4rem 0.75rem;
+			background: #111;
+			border: 1px solid #333;
+			color: #0f0;
+			cursor: pointer;
+			font-family: inherit;
+			font-size: 12px;
+			width: 100%;
+		}
+		.load-more:hover {
+			background: #1a1a1a;
+			border-color: #0f0;
+		}
+		.treemap-container {
+			width: 100%;
+			overflow: visible;
+		}
+		.empty {
+			text-align: center;
+			padding: 2rem;
+			color: #666;
+			font-size: 12px;
+		}
+		.treemap-cell {
+			stroke: #111;
+			stroke-width: 1px;
+			cursor: pointer;
+			transition: all 0.2s;
+		}
+		.treemap-cell:hover {
+			stroke: #0f0;
+			stroke-width: 2px;
+		}
+		.treemap-label {
+			fill: #0f0;
+			font-size: 10px;
+			pointer-events: none;
+			text-anchor: middle;
+			font-weight: 500;
+		}
+		.treemap-tooltip {
+			position: absolute;
+			background: #000;
+			border: 1px solid #0f0;
+			padding: 0.5rem 0.75rem;
+			pointer-events: none;
+			opacity: 0;
+			transition: opacity 0.15s;
+			z-index: 1000;
+			font-size: 11px;
+		}
+		.treemap-tooltip.visible {
+			opacity: 1;
+		}
+		.tooltip-name {
+			font-weight: 600;
+			color: #0f0;
+			margin-bottom: 0.25rem;
+		}
+		.tooltip-path {
+			color: #666;
+			font-size: 10px;
+			margin-bottom: 0.25rem;
+			word-break: break-all;
+		}
+		.tooltip-size {
+			color: #0f0;
+			font-size: 11px;
+		}
+	</style>
+</head>
+<body>
+	<div class="container">
+		<h1>reroute analyze</h1>
+
+		<div class="sticky-search">
+			<div class="search-row">
+				<div class="search-container">
+					<div class="search-input-wrapper">
+						<input
+							type="text"
+							id="search-input"
+							class="search-input"
+							placeholder="search dependencies (e.g., 'react', 'scheduler', 'sharp')..."
+						/>
+						<button class="search-clear" id="search-clear" type="button" aria-label="Clear search">×</button>
+					</div>
+				</div>
+				<div class="search-actions">
+					<button class="btn-toggle" id="expand-all">expand</button>
+					<button class="btn-toggle" id="collapse-all">collapse</button>
+				</div>
+			</div>
+		</div>
+
+		<div class="section">
+			<div class="section-header">
+				<div>
+					<div class="section-title">${icon("chart")}Summary</div>
+				</div>
+			</div>
+			<div class="section-content">
+				<div class="stats-grid">
+					<div class="stat">
+						<div class="stat-label">browser dependencies</div>
+						<div class="stat-value">${(() => {
+    const nodeModules = browserDepTree?.root.children?.find((c) => c.name === "node_modules");
+    return nodeModules?.children?.length || 0;
+  })()}</div>
+					</div>
+					<div class="stat">
+						<div class="stat-label">browser bundle</div>
+						<div class="stat-value">${browserInfo ? formatBytes(browserInfo.size) : "N/A"}</div>
+					</div>
+					<div class="stat">
+						<div class="stat-label">server dependencies</div>
+						<div class="stat-value">${(() => {
+    const nodeModules = depTree?.root.children?.find((c) => c.name === "node_modules");
+    return nodeModules?.children?.length || 0;
+  })()}</div>
+					</div>
+					<div class="stat">
+						<div class="stat-label">final server binary</div>
+						<div class="stat-value">${actualServerBinarySize ? formatBytes(actualServerBinarySize) : "N/A"}</div>
+					</div>
+				</div>
+			</div>
+		</div>
+
+		<!-- ═══════════════════════════════════════════════════════════ -->
+		<!-- BROWSER SECTION (what users download) -->
+		<!-- ═══════════════════════════════════════════════════════════ -->
+
+		${browserInfo ? `
+		<div class="section">
+			<div class="section-header" onclick="this.parentElement.classList.toggle('collapsed')">
+				<div>
+					<div class="section-title">${icon("world")}browser bundle</div>
+					<div class="section-meta">${browserInfo.name} &middot; ${formatBytes(browserInfo.size)} raw &middot; ${formatBytes(browserInfo.gzippedSize)} gzipped</div>
+				</div>
+				<div class="section-toggle"></div>
+			</div>
+			<div class="section-content">
+				<div class="stats-grid">
+					<div class="stat">
+						<div class="stat-label">raw size</div>
+						<div class="stat-value">${formatBytes(browserInfo.size)}</div>
+					</div>
+					<div class="stat">
+						<div class="stat-label">gzipped</div>
+						<div class="stat-value">${formatBytes(browserInfo.gzippedSize)}</div>
+					</div>
+					<div class="stat">
+						<div class="stat-label">compression</div>
+						<div class="stat-value">${((1 - browserInfo.gzippedSize / browserInfo.size) * 100).toFixed(1)}%</div>
+					</div>
+					<div class="stat">
+						<div class="stat-label">3G transfer</div>
+						<div class="stat-value">${(() => {
+    const t = browserInfo.gzippedSize / 1024 / 204.8;
+    return t >= 1 ? `${t.toFixed(1)}s` : `${(t * 1000).toFixed(0)}ms`;
+  })()}</div>
+					</div>
+					<div class="stat">
+						<div class="stat-label">4G transfer</div>
+						<div class="stat-value">${(() => {
+    const t = browserInfo.gzippedSize / 1024 / 1152;
+    return t >= 1 ? `${t.toFixed(1)}s` : `${(t * 1000).toFixed(0)}ms`;
+  })()}</div>
+					</div>
+					<div class="stat">
+						<div class="stat-label">5G transfer</div>
+						<div class="stat-value">${(() => {
+    const t = browserInfo.gzippedSize / 1024 / 6400;
+    return t >= 1 ? `${t.toFixed(1)}s` : `${(t * 1000).toFixed(0)}ms`;
+  })()}</div>
+					</div>
+				</div>
+			</div>
+		</div>
+		` : ""}
+		${browserDepTree ? `
+		<div class="section collapsed">
+			<div class="section-header" onclick="this.parentElement.classList.toggle('collapsed')">
+				<div>
+					<div class="section-title">${icon("search")}browser dependencies</div>
+					<div class="section-meta">dependency breakdown</div>
+				</div>
+				<div class="section-toggle"></div>
+			</div>
+			<div class="section-content">
+				<div id="browser-deps-list"></div>
+			</div>
+		</div>
+
+		<div class="section collapsed">
+			<div class="section-header" onclick="this.parentElement.classList.toggle('collapsed')">
+				<div>
+					<div class="section-title">${icon("treemap")}browser treemap</div>
+					<div class="section-meta">visual dependency breakdown</div>
+				</div>
+				<div class="section-toggle"></div>
+			</div>
+			<div class="section-content">
+				<div class="treemap-container" id="browser-treemap"></div>
+			</div>
+		</div>
+		` : ""}
+
+		${Object.entries(stats.byCollection).filter(([collection]) => collection !== "binaries").map(([collection, collectionBundles]) => {
+    const collectionTotal = collectionBundles.reduce((sum, b) => sum + b.size, 0);
+    const collectionGzipped = collectionBundles.reduce((sum, b) => sum + b.gzippedSize, 0);
+    return `
+		<div class="section collapsed">
+			<div class="section-header" onclick="this.parentElement.classList.toggle('collapsed')">
+				<div>
+					<div class="section-title">${icon("package")}${collection} chunks</div>
+					<div class="section-meta">${collectionBundles.length} files &middot; ${formatBytes(collectionTotal)} raw &middot; ${formatBytes(collectionGzipped)} gzipped</div>
+				</div>
+				<div class="section-toggle"></div>
+			</div>
+			<div class="section-content">
+				<ul class="dep-list" id="${collection}-chunks-list">
+					${collectionBundles.sort((a, b) => b.size - a.size).slice(0, 10).map((bundle) => `
+					<li class="dep-item">
+						<span class="dep-name">${bundle.name}</span>
+						<span class="dep-size">${formatBytes(bundle.size)} &middot; ${formatBytes(bundle.gzippedSize)} gz</span>
+					</li>
+					`).join("")}
+				</ul>
+				${collectionBundles.length > 10 ? `
+				<button class="load-more" onclick="loadMore${collection}()">load ${collectionBundles.length - 10} more...</button>
+				<script>
+					let ${collection}Loaded = false;
+					function loadMore${collection}() {
+						if (${collection}Loaded) return;
+						${collection}Loaded = true;
+						const list = document.getElementById('${collection}-chunks-list');
+						const remaining = ${JSON.stringify(collectionBundles.slice(10).map((b) => ({ name: b.name, size: b.size, gzippedSize: b.gzippedSize })))};
+						for (const bundle of remaining) {
+							const li = document.createElement('li');
+							li.className = 'dep-item';
+							li.innerHTML = '<span class="dep-name">' + bundle.name + '</span><span class="dep-size">' + formatBytes(bundle.size) + ' &middot; ' + formatBytes(bundle.gzippedSize) + ' gz</span>';
+							list.appendChild(li);
+						}
+						event.target.remove();
+					}
+				</script>
+				` : ""}
+			</div>
+		</div>
+		`;
+  }).join("")}
+
+		<!-- ═══════════════════════════════════════════════════════════ -->
+		<!-- SERVER SECTION (not shipped to browser) -->
+		<!-- ═══════════════════════════════════════════════════════════ -->
+
+		${actualServerBinarySize ? `
+		<div class="section collapsed">
+			<div class="section-header" onclick="this.parentElement.classList.toggle('collapsed')">
+				<div>
+					<div class="section-title server">${icon("server", "#666")}final server binary</div>
+					<div class="section-meta">standalone executable &middot; ${formatBytes(actualServerBinarySize)} &middot; not shipped to browser</div>
+				</div>
+				<div class="section-toggle"></div>
+			</div>
+			<div class="section-content">
+				<div class="stats-grid">
+					<div class="stat">
+						<div class="stat-label">binary size</div>
+						<div class="stat-value server">${formatBytes(actualServerBinarySize)}</div>
+					</div>
+					${actualServerBinaryGzipped ? `
+					<div class="stat">
+						<div class="stat-label">gzipped</div>
+						<div class="stat-value server">${formatBytes(actualServerBinaryGzipped)}</div>
+					</div>
+					<div class="stat">
+						<div class="stat-label">compression</div>
+						<div class="stat-value server">${((1 - actualServerBinaryGzipped / actualServerBinarySize) * 100).toFixed(1)}%</div>
+					</div>
+					` : ""}
+				</div>
+			</div>
+		</div>
+		` : ""}
+		${depTree ? `
+		<div class="section collapsed">
+			<div class="section-header" onclick="this.parentElement.classList.toggle('collapsed')">
+				<div>
+					<div class="section-title server">${icon("search", "#666")}server dependencies</div>
+					<div class="section-meta">server-side only &middot; not shipped to browser</div>
+				</div>
+				<div class="section-toggle"></div>
+			</div>
+			<div class="section-content">
+				<div id="server-deps-list"></div>
+			</div>
+		</div>
+
+		<div class="section collapsed">
+			<div class="section-header" onclick="this.parentElement.classList.toggle('collapsed')">
+				<div>
+					<div class="section-title server">${icon("treemap", "#666")}server treemap</div>
+					<div class="section-meta">visual dependency breakdown</div>
+				</div>
+				<div class="section-toggle"></div>
+			</div>
+			<div class="section-content">
+				<div class="treemap-container" id="server-treemap"></div>
+			</div>
+		</div>
+		` : ""}
+
+		${bundles.length === 0 ? '<div class="empty">no bundles found. run <code>reroute gen</code> or <code>reroute build</code> first.</div>' : ""}
+	</div>
+	<div class="treemap-tooltip" id="tooltip">
+		<div class="tooltip-name" id="tooltip-name"></div>
+		<div class="tooltip-path" id="tooltip-path"></div>
+		<div class="tooltip-size" id="tooltip-size"></div>
+	</div>
+	${browserDepTree || depTree ? `
+	<script>
+		const browserDepTree = ${browserDepTree ? JSON.stringify(browserDepTree) : "null"};
+		const serverDepTree = ${depTree ? JSON.stringify(depTree) : "null"};
+		const formatBytes = ${formatBytes.toString()};
+
+		function cleanPath(path) {
+			if (!path) return '';
+			const nodeModulesIdx = path.indexOf('node_modules');
+			if (nodeModulesIdx === -1) return path;
+			return path.substring(nodeModulesIdx);
+		}
+
+		function convertNode(node) {
+			return {
+				name: node.name,
+				path: node.path,
+				size: node.size,
+				children: node.children && node.children.length > 0 ? node.children.map(convertNode) : null
+			};
+		}
+
+		function renderDepTreemap(tree, containerId) {
+			const container = d3.select(containerId);
+			container.selectAll("*").remove();
+			const width = container.node()?.clientWidth || 1200;
+
+			const tooltip = d3.select("#tooltip");
+
+			const root = d3.hierarchy(convertNode(tree.root))
+				.sum(d => d.size || 0)
+				.sort((a, b) => (b.value || 0) - (a.value || 0));
+
+			// Calculate height based on data - use aspect ratio that works well for treemaps
+			// More items = taller treemap, but cap at reasonable max
+			const leafCount = root.leaves().length;
+			const baseHeight = Math.max(400, Math.min(1200, width * 0.6));
+			const height = Math.min(baseHeight + (leafCount * 2), width * 1.2);
+
+			const svg = container.append("svg")
+				.attr("width", width)
+				.attr("height", height);
+
+			const treemap = d3.treemap()
+				.size([width, height])
+				.padding(2)
+				.round(true);
+
+			treemap(root);
+
+			function hashString(str) {
+				let h = 0;
+				for (let i = 0; i < str.length; i++) {
+					h = ((h << 5) - h + str.charCodeAt(i)) | 0;
+				}
+				return Math.abs(h);
+			}
+			function getPackageName(d) {
+				const p = d.data.path || '';
+				if (!p.includes('node_modules')) return null;
+				const idx = p.lastIndexOf('node_modules/');
+				if (idx === -1) return null;
+				const after = p.slice(idx + 'node_modules/'.length);
+				// Handle @scope/package or package
+				if (after.startsWith('@')) {
+					const parts = after.split('/');
+					return parts.length >= 2 ? parts[0] + '/' + parts[1] : after;
+				}
+				return after.split('/')[0];
+			}
+
+			// Terminal-style colors
+			const colorCache = {};
+			function colorFor(d) {
+				const p = d.data.path || '';
+				if (p.includes('node_modules')) {
+					const pkg = getPackageName(d) || 'unknown';
+
+					if (!colorCache[pkg]) {
+						const hash = hashString(pkg);
+						// Shades of green for terminal aesthetic
+						const brightness = 40 + (hash % 40);
+						colorCache[pkg] = 'rgb(0, ' + brightness + ', 0)';
+					}
+
+					return colorCache[pkg];
+				}
+				// Brighter green for local src files
+				const depth = Math.min(d.depth, 4);
+				const brightness = 80 + depth * 30;
+				return 'rgb(0, ' + Math.min(255, brightness) + ', 0)';
+			}
+
+			const cell = svg.selectAll("g")
+				.data(root.leaves())
+				.enter()
+				.append("g")
+				.attr("transform", d => \`translate(\${d.x0},\${d.y0})\`);
+
+			cell.append("rect")
+				.attr("class", "treemap-cell")
+				.attr("width", d => d.x1 - d.x0)
+				.attr("height", d => d.y1 - d.y0)
+				.attr("fill", colorFor)
+				.on("mouseover", function(event, d) {
+					d3.select(this).attr("stroke", "#0f0").attr("stroke-width", 2);
+					tooltip.select("#tooltip-name").text(d.data.name);
+					tooltip.select("#tooltip-path").text(cleanPath(d.data.path || ''));
+					tooltip.select("#tooltip-size").text(formatBytes(d.value));
+					tooltip.classed("visible", true);
+				})
+				.on("mousemove", function(event) {
+					tooltip.style("left", (event.pageX + 10) + "px")
+					       .style("top", (event.pageY - 10) + "px");
+				})
+				.on("mouseout", function() {
+					d3.select(this).attr("stroke", "#111").attr("stroke-width", 1);
+					tooltip.classed("visible", false);
+				});
+
+			// Labels on cells - show first letter for small cells, truncated text for larger ones
+			const labels = cell.filter(d => {
+				const w = d.x1 - d.x0;
+				const h = d.y1 - d.y0;
+				// Show label if cell is at least 10px wide and 10px tall (enough for first letter)
+				return w > 10 && h > 10;
+			})
+				.append("text")
+				.attr("class", "treemap-label")
+				.attr("x", d => (d.x1 - d.x0) / 2)
+				.attr("y", d => (d.y1 - d.y0) / 2)
+				.style("text-anchor", "middle")
+				.style("dominant-baseline", "middle");
+
+			labels.each(function(d) {
+				const name = d.data.name;
+				const width = d.x1 - d.x0;
+				const height = d.y1 - d.y0;
+				const text = d3.select(this);
+
+				// Estimate character width: ~6px per character for 10px monospace font
+				const charWidth = 6;
+				const maxChars = Math.floor((width - 8) / charWidth); // 8px padding
+				const minSize = Math.min(width, height);
+
+				let labelText = '';
+				let fontSize = 10;
+
+				if (width < 20 || height < 14 || maxChars < 1) {
+					// Very small cell - show first letter only, ensure it's readable
+					labelText = name.charAt(0).toUpperCase();
+					// Scale font to fit but ensure minimum 8px for readability
+					fontSize = Math.max(8, Math.min(12, minSize * 0.65));
+				} else if (width < 30 || maxChars < 2) {
+					// Small cell - show first letter (or 2 chars if fits)
+					labelText = name.substring(0, Math.min(1, name.length)).toUpperCase();
+					fontSize = Math.max(8, Math.min(10, minSize * 0.5));
+				} else if (width < 40 || maxChars < 3) {
+					// Small-medium cell - show first 2-3 characters
+					labelText = name.substring(0, Math.min(2, name.length));
+					fontSize = 9;
+				} else if (maxChars >= name.length) {
+					// Large enough - show full name
+					labelText = name;
+					fontSize = 10;
+				} else {
+					// Medium cell - truncate based on available width
+					const truncateLength = Math.max(3, maxChars - 3); // Leave room for "..."
+					labelText = name.substring(0, truncateLength) + '...';
+					fontSize = 10;
+				}
+
+				text.style("font-size", fontSize + "px")
+					.text(labelText);
+
+				// Show size for larger cells
+				if (width > 90 && height > 32) {
+					text.append("tspan")
+						.attr("x", width / 2)
+						.attr("dy", "14")
+						.text(formatBytes(d.value));
+				}
+			});
+		}
+
+		let currentSearchTerm = '';
+
+		function updateSearchStats(visibleCount, totalCount) {
+			const stats = document.getElementById('search-stats');
+			if (stats) {
+				if (currentSearchTerm) {
+					stats.textContent = 'Showing ' + visibleCount + ' of ' + totalCount + ' items matching "' + currentSearchTerm + '"';
+				} else {
+					stats.textContent = '';
+				}
+			}
+		}
+
+		function filterTreemap(searchTerm) {
+			currentSearchTerm = searchTerm.toLowerCase();
+			if (!searchTerm) {
+				if (browserDepTree) renderDepTreemap(browserDepTree, "#browser-treemap");
+				if (serverDepTree) renderDepTreemap(serverDepTree, "#server-treemap");
+				updateSearchStats(0, 0);
+
+				// Show all elements
+				document.querySelectorAll('.section').forEach(el => el.classList.remove('hidden'));
+				document.querySelectorAll('tbody tr').forEach(el => el.classList.remove('hidden'));
+				document.querySelectorAll('.dep-item').forEach(el => el.classList.remove('hidden'));
+				document.querySelectorAll('.stat').forEach(el => el.classList.remove('hidden'));
+				return;
+			}
+
+			let totalMatches = 0;
+			let totalItems = 0;
+
+		// Filter treemap data
+		function filterNode(node) {
+			// Only match against the package/file name, not the full path
+			// to avoid matching build directories like .reroute/
+			const matches = node.name.toLowerCase().includes(searchTerm);
+
+			if (!node.children || node.children.length === 0) {
+				return matches ? { ...node } : null;
+			}
+
+			const filteredChildren = node.children
+				.map(child => filterNode(child))
+				.filter(child => child !== null);
+
+			if (filteredChildren.length > 0 || matches) {
+				return {
+					...node,
+					children: filteredChildren.length > 0 ? filteredChildren : undefined
+				};
+			}
+
+			return null;
+		}
+
+			function countLeaves(node) {
+				if (!node.children || node.children.length === 0) return 1;
+				return node.children.reduce((sum, child) => sum + countLeaves(child), 0);
+			}
+
+			// Filter browser treemap
+			if (browserDepTree) {
+				const filtered = filterNode(browserDepTree.root);
+				if (filtered) {
+					const totalLeaves = countLeaves(browserDepTree.root);
+					const visibleLeaves = countLeaves(filtered);
+					totalItems += totalLeaves;
+					totalMatches += visibleLeaves;
+					renderDepTreemap({ ...browserDepTree, root: filtered }, "#browser-treemap");
+				} else {
+					const elem = document.getElementById('browser-treemap');
+					if (elem) elem.innerHTML = '<div class="empty">No matches found</div>';
+				}
+			}
+
+			// Filter server treemap
+			if (serverDepTree) {
+				const filtered = filterNode(serverDepTree.root);
+				if (filtered) {
+					renderDepTreemap({ ...serverDepTree, root: filtered }, "#server-treemap");
+				} else {
+					const elem = document.getElementById('server-treemap');
+					if (elem) elem.innerHTML = '<div class="empty">No matches found</div>';
+				}
+			}
+
+			// Render matching items that aren't loaded yet
+			if (searchTerm) {
+				renderMatchingDeps('browser-deps-list', searchTerm);
+				renderMatchingDeps('server-deps-list', searchTerm);
+			}
+
+			// Filter dependency lists
+			document.querySelectorAll('.dep-item').forEach(item => {
+				const packageName = item.getAttribute('data-package-name') || '';
+				if (packageName.includes(searchTerm)) {
+					item.classList.remove('hidden');
+					totalMatches++;
+				} else {
+					item.classList.add('hidden');
+				}
+				totalItems++;
+			});
+
+			// Filter bundle/chunk tables
+			document.querySelectorAll('tbody tr').forEach(row => {
+				const text = row.textContent.toLowerCase();
+				if (text.includes(searchTerm)) {
+					row.classList.remove('hidden');
+					totalMatches++;
+				} else {
+					row.classList.add('hidden');
+				}
+				totalItems++;
+			});
+
+			// Filter section headers and content
+			document.querySelectorAll('.section').forEach(section => {
+				// Check if section has visible content
+				const tbody = section.querySelector('tbody');
+				const depList = section.querySelector('.dep-list');
+				const treemapContainer = section.querySelector('.treemap-container');
+				const stats = section.querySelectorAll('.stat');
+				const sectionTitle = section.querySelector('.section-title');
+
+				let hasVisibleContent = false;
+
+				if (tbody) {
+					const visibleRows = tbody.querySelectorAll('tr:not(.hidden)');
+					hasVisibleContent = visibleRows.length > 0;
+				} else if (depList) {
+					const visibleItems = depList.querySelectorAll('.dep-item:not(.hidden)');
+					hasVisibleContent = visibleItems.length > 0;
+				} else if (treemapContainer) {
+					hasVisibleContent = !treemapContainer.querySelector('.empty');
+				} else if (stats.length > 0) {
+					// Stat sections: show if any stat matches
+					const statMatches = Array.from(stats).some(stat =>
+						stat.textContent.toLowerCase().includes(searchTerm)
+					);
+					hasVisibleContent = statMatches;
+				} else if (sectionTitle && sectionTitle.textContent.toLowerCase().includes(searchTerm)) {
+					// Section title matches
+					hasVisibleContent = true;
+				}
+
+				if (hasVisibleContent) {
+					section.classList.remove('hidden');
+				} else {
+					section.classList.add('hidden');
+				}
+			});
+
+			updateSearchStats(totalMatches, totalItems);
+		}
+
+		// Setup search
+		const searchInput = document.getElementById('search-input');
+		const searchClear = document.getElementById('search-clear');
+
+		function updateClearButton() {
+			if (searchClear && searchInput) {
+				if (searchInput.value.trim().length > 0) {
+					searchClear.classList.add('visible');
+				} else {
+					searchClear.classList.remove('visible');
+				}
+			}
+		}
+
+		if (searchInput) {
+			searchInput.addEventListener('input', (e) => {
+				filterTreemap(e.target.value);
+				updateClearButton();
+			});
+			// Check initial state
+			updateClearButton();
+		}
+
+		if (searchClear) {
+			searchClear.addEventListener('click', () => {
+				if (searchInput) {
+					searchInput.value = '';
+					searchInput.focus();
+					filterTreemap('');
+					updateClearButton();
+				}
+			});
+		}
+
+		// Expand/collapse all handlers
+		const expandAllBtn = document.getElementById('expand-all');
+		const collapseAllBtn = document.getElementById('collapse-all');
+
+		if (expandAllBtn) {
+			expandAllBtn.addEventListener('click', () => {
+				document.querySelectorAll('.section.collapsed').forEach(section => {
+					section.classList.remove('collapsed');
+				});
+			});
+		}
+
+		if (collapseAllBtn) {
+			collapseAllBtn.addEventListener('click', () => {
+				document.querySelectorAll('.section:not(.collapsed)').forEach(section => {
+					// Don't collapse the Summary section
+					const title = section.querySelector('.section-title');
+					if (title && !title.textContent.includes('Summary')) {
+						section.classList.add('collapsed');
+					}
+				});
+			});
+		}
+
+		// Store full packages data for search
+		const depListData = new Map();
+
+		// Helper to create a dep item element
+		function createDepItem(pkg, isServer, totalSize, bundleInfo) {
+			const li = document.createElement('li');
+			li.className = 'dep-item';
+			li.setAttribute('data-package-name', pkg.name.toLowerCase());
+
+			const nameSpan = document.createElement('span');
+			nameSpan.className = isServer ? 'dep-name server' : 'dep-name';
+			nameSpan.textContent = pkg.name;
+
+			const sizeSpan = document.createElement('span');
+			sizeSpan.className = 'dep-size';
+
+			// Estimate gzipped size using compression ratio
+			let sizeText = formatBytes(pkg.size);
+			if (bundleInfo && bundleInfo.size > 0) {
+				const compressionRatio = bundleInfo.gzippedSize / bundleInfo.size;
+				const estimatedGz = Math.round(pkg.size * compressionRatio);
+				sizeText += ' (' + formatBytes(estimatedGz) + ' gz)';
+			}
+			sizeText += ' · ' + ((pkg.size / totalSize) * 100).toFixed(1) + '%';
+			sizeSpan.textContent = sizeText;
+
+			li.appendChild(nameSpan);
+			li.appendChild(sizeSpan);
+			return li;
+		}
+
+		// Populate dependency lists
+		function populateDepList(tree, containerId, isServer, bundleInfo) {
+			const container = document.getElementById(containerId);
+			if (!container || !tree) return;
+
+			const nodeModules = tree.root.children?.find(c => c.name === 'node_modules');
+			if (!nodeModules || !nodeModules.children) return;
+
+			const packages = nodeModules.children
+				.filter(pkg => pkg.size > 0)
+				.sort((a, b) => b.size - a.size);
+
+			// Store full packages data for this container
+			depListData.set(containerId, {
+				packages: packages,
+				isServer: isServer,
+				totalSize: tree.totalSize,
+				bundleInfo: bundleInfo,
+				loadedCount: 0
+			});
+
+			const ul = document.createElement('ul');
+			ul.className = 'dep-list';
+
+			const initialCount = 10;
+			for (let i = 0; i < Math.min(initialCount, packages.length); i++) {
+				const li = createDepItem(packages[i], isServer, tree.totalSize, bundleInfo);
+				ul.appendChild(li);
+			}
+
+			depListData.get(containerId).loadedCount = Math.min(initialCount, packages.length);
+
+			container.appendChild(ul);
+
+			if (packages.length > initialCount) {
+				const btn = document.createElement('button');
+				btn.className = 'load-more';
+				btn.textContent = 'load ' + (packages.length - initialCount) + ' more...';
+				btn.onclick = function() {
+					const data = depListData.get(containerId);
+					const existingItems = new Set();
+					ul.querySelectorAll('.dep-item').forEach(item => {
+						existingItems.add(item.getAttribute('data-package-name'));
+					});
+
+					let loaded = 0;
+					for (let i = 0; i < packages.length; i++) {
+						const pkg = packages[i];
+						const nameLower = pkg.name.toLowerCase();
+						if (!existingItems.has(nameLower)) {
+							const li = createDepItem(pkg, isServer, tree.totalSize, bundleInfo);
+							ul.appendChild(li);
+							loaded++;
+						}
+					}
+					data.loadedCount = packages.length;
+					btn.remove();
+				};
+				container.appendChild(btn);
+			}
+		}
+
+		// Render matching items that aren't loaded yet
+		function renderMatchingDeps(containerId, searchTerm) {
+			const data = depListData.get(containerId);
+			if (!data || !searchTerm) return;
+
+			const container = document.getElementById(containerId);
+			if (!container) return;
+
+			const ul = container.querySelector('.dep-list');
+			if (!ul) return;
+
+			const searchLower = searchTerm.toLowerCase();
+			const existingItems = new Set();
+			ul.querySelectorAll('.dep-item').forEach(item => {
+				existingItems.add(item.getAttribute('data-package-name'));
+			});
+
+			// Find matching packages that aren't rendered yet
+			const matchingPackages = data.packages.filter((pkg) => {
+				const nameLower = pkg.name.toLowerCase();
+				const matches = nameLower.includes(searchLower);
+				const notRendered = !existingItems.has(nameLower);
+				return matches && notRendered;
+			});
+
+			// Render matching items
+			matchingPackages.forEach(pkg => {
+				const li = createDepItem(pkg, data.isServer, data.totalSize, data.bundleInfo);
+				ul.appendChild(li);
+			});
+		}
+
+		// Initial render
+		const browserInfo = ${JSON.stringify(browserInfo)};
+		const serverInfo = ${JSON.stringify(mainInfo)};
+
+		if (browserDepTree) {
+			populateDepList(browserDepTree, 'browser-deps-list', false, browserInfo);
+			renderDepTreemap(browserDepTree, "#browser-treemap");
+		}
+		if (serverDepTree) {
+			populateDepList(serverDepTree, 'server-deps-list', true, serverInfo);
+			renderDepTreemap(serverDepTree, "#server-treemap");
+		}
+
+		window.addEventListener("resize", () => {
+			if (currentSearchTerm) {
+				filterTreemap(currentSearchTerm);
+			} else {
+				if (browserDepTree) renderDepTreemap(browserDepTree, "#browser-treemap");
+				if (serverDepTree) renderDepTreemap(serverDepTree, "#server-treemap");
+			}
+		});
+
+		// Apply initial search if provided
+		const initialSearchTerm = ${JSON.stringify(initialSearch || "")};
+		if (initialSearchTerm && searchInput) {
+			searchInput.value = initialSearchTerm;
+			filterTreemap(initialSearchTerm);
+			updateClearButton();
+		}
+	</script>
+	` : ""}
+
+		<div class="footer">
+			<div class="search-stats" id="search-stats"></div>
+			<div class="note">
+				<strong>Browser</strong> bundles are shipped to users. <strong>Server</strong> binaries run on your server only.
+			</div>
+			${mainInfo ? `
+			<div class="note" style="margin-top: 0.5rem;">
+				<strong>Final Server Binary</strong> is a standalone executable that includes the Bun runtime, your application code, and all dependencies. This allows it to run without requiring Node.js or Bun to be installed on the deployment server.
+			</div>
+			` : ""}
+		</div>
+	</div>
+</body>
+</html>`;
+  return html2;
+}
+async function printConsoleReport(stats, depTree, mainInfo, browserDepTree, browserInfo, fullOutput = false) {
+  console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Bundle Analysis Report
+`));
+  if (mainInfo || browserInfo) {
+    console.log(`\x1B[90mNote: Browser bundles are shipped to users. Server binaries run on your server only.\x1B[0m
+`);
+  }
+  if (browserInfo) {
+    console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m`);
+    console.log(`\x1B[1m\x1B[36mBrowser Bundle: ${browserInfo.name}\x1B[0m \x1B[32m(shipped to browser)\x1B[0m`);
+    console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m
+`);
+    const browserTable = new Table({
+      head: ["Metric", "Value"],
+      colWidths: [25, 35],
+      style: {
+        head: ["cyan", "bold"],
+        border: ["gray"]
+      },
+      chars: ASCII_TABLE_CHARS
+    });
+    browserTable.push(["Raw Size", formatBytes(browserInfo.size)], ["Gzipped", formatBytes(browserInfo.gzippedSize)], [
+      "Compression Ratio",
+      `${((1 - browserInfo.gzippedSize / browserInfo.size) * 100).toFixed(1)}%`
+    ]);
+    console.log(browserTable.toString());
+    console.log("");
+    const gzipKB = browserInfo.gzippedSize / 1024;
+    const time3G = gzipKB / 204.8;
+    const time4G = gzipKB / 1152;
+    const time5G = gzipKB / 6400;
+    const timeWiFi = gzipKB / 12800;
+    const transferTable = new Table({
+      head: ["Network", "Throughput", "Transfer Time"],
+      colWidths: [15, 15, 20],
+      style: {
+        head: ["cyan", "bold"],
+        border: ["gray"]
+      },
+      chars: ASCII_TABLE_CHARS
+    });
+    transferTable.push([
+      "3G Fast",
+      "1.6 Mbps",
+      time3G >= 1 ? `~${time3G.toFixed(2)}s` : `~${(time3G * 1000).toFixed(0)}ms`
+    ], [
+      "4G",
+      "9 Mbps",
+      time4G >= 1 ? `~${time4G.toFixed(2)}s` : `~${(time4G * 1000).toFixed(0)}ms`
+    ], [
+      "5G",
+      "50 Mbps",
+      time5G >= 1 ? `~${time5G.toFixed(2)}s` : `~${(time5G * 1000).toFixed(0)}ms`
+    ], [
+      "Wi-Fi 100",
+      "100 Mbps",
+      timeWiFi >= 1 ? `~${timeWiFi.toFixed(2)}s` : `~${(timeWiFi * 1000).toFixed(0)}ms`
+    ]);
+    console.log(transferTable.toString());
+    console.log(`\x1B[90m  Note: Estimates use gzipped size, ignore latency/HTTP overhead\x1B[0m
+`);
+  }
+  if (browserDepTree) {
+    const nodeModules = browserDepTree.root.children?.find((c) => c.name === "node_modules");
+    const src2 = browserDepTree.root.children?.find((c) => c.name === "src");
+    if (nodeModules || src2) {
+      console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m`);
+      console.log("\x1B[1m\x1B[36mBrowser Dependency Breakdown\x1B[0m \x1B[32m(shipped to browser)\x1B[0m");
+      console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m
+`);
+      if (nodeModules && nodeModules.size > 0) {
+        const nmPercent = (nodeModules.size / browserDepTree.totalSize * 100).toFixed(1);
+        console.log(`\x1B[1mnode_modules: ${formatBytes(nodeModules.size)} (${nmPercent}%)\x1B[0m
+`);
+        const packages = (nodeModules.children || []).filter((pkg) => pkg.size > 0).sort((a, b) => b.size - a.size);
+        if (packages.length > 0) {
+          const pkgTable = new Table({
+            head: ["Package / File", "Raw Size", "Gzipped", "% of Total"],
+            colWidths: [40, 15, 15, 12],
+            style: {
+              head: ["green", "bold"],
+              border: ["gray"]
+            },
+            chars: ASCII_TABLE_CHARS
+          });
+          const packagesToShow = fullOutput ? packages : packages.filter((pkg) => pkg.size / browserDepTree.totalSize >= 0.01);
+          for (const pkg of packagesToShow) {
+            const percentage = (pkg.size / browserDepTree.totalSize * 100).toFixed(1);
+            const pkgEstimatedGz = Math.round(pkg.size * (browserInfo?.gzippedSize || 0) / (browserInfo?.size || 1));
+            pkgTable.push([
+              `\x1B[1m${pkg.name}\x1B[0m`,
+              formatBytes(pkg.size),
+              formatBytes(pkgEstimatedGz),
+              `${percentage}%`
+            ]);
+            const files = (pkg.children || []).filter((f) => f.size > 0).sort((a, b) => b.size - a.size);
+            const filesToShow = fullOutput ? files : files.slice(0, 10);
+            for (const file of filesToShow) {
+              const filePercent = (file.size / browserDepTree.totalSize * 100).toFixed(1);
+              const estimatedGz = Math.round(file.size * (browserInfo?.gzippedSize || 0) / (browserInfo?.size || 1));
+              pkgTable.push([
+                `  ${String.fromCharCode(8627)} ${file.name}`,
+                formatBytes(file.size),
+                formatBytes(estimatedGz),
+                `${filePercent}%`
+              ]);
+            }
+            if (!fullOutput && files.length > 10) {
+              pkgTable.push([
+                `  ... ${files.length - 10} more files`,
+                "",
+                "",
+                ""
+              ]);
+            }
+          }
+          console.log(pkgTable.toString());
+          console.log("");
+        }
+      }
+      if (src2 && src2.size > 0) {
+        const srcPercent = (src2.size / browserDepTree.totalSize * 100).toFixed(1);
+        console.log(`\x1B[1msrc: ${formatBytes(src2.size)} (${srcPercent}%)\x1B[0m
+`);
+      }
+    }
+  }
+  const browserChunks = Object.entries(stats.byCollection).filter(([collection]) => collection !== "binaries");
+  if (browserChunks.length > 0) {
+    for (const [collection, bundles] of browserChunks) {
+      const collectionTotal = bundles.reduce((sum, b) => sum + b.size, 0);
+      const collectionGzipped = bundles.reduce((sum, b) => sum + b.gzippedSize, 0);
+      console.log(`\x1B[1mBrowser Chunks: ${collection}\x1B[0m \x1B[32m(shipped to browser)\x1B[0m`);
+      console.log(`  Total: ${formatBytes(collectionTotal)} (${formatBytes(collectionGzipped)} gzipped)
+`);
+      const sorted = bundles.sort((a, b) => b.size - a.size);
+      const bundleTable = new Table({
+        head: ["Bundle", "Size", "Gzipped", "% of Total"],
+        colWidths: [40, 12, 12, 12],
+        style: {
+          head: ["green", "bold"],
+          border: ["gray"]
+        },
+        chars: ASCII_TABLE_CHARS
+      });
+      for (const bundle of sorted) {
+        const percentage = (bundle.size / stats.totalSize * 100).toFixed(1);
+        bundleTable.push([
+          bundle.name,
+          formatBytes(bundle.size),
+          formatBytes(bundle.gzippedSize),
+          `${percentage}%`
+        ]);
+      }
+      console.log(bundleTable.toString());
+      console.log("");
+    }
+  }
+  if (mainInfo) {
+    console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m`);
+    console.log(`\x1B[1m\x1B[36mServer Binary: ${mainInfo.name}\x1B[0m \x1B[90m(not shipped to browser)\x1B[0m`);
+    console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m
+`);
+    const mainTable = new Table({
+      head: ["Metric", "Value"],
+      colWidths: [25, 35],
+      style: {
+        head: ["cyan", "bold"],
+        border: ["gray"]
+      },
+      chars: ASCII_TABLE_CHARS
+    });
+    mainTable.push(["Binary Size", formatBytes(mainInfo.size)]);
+    console.log(mainTable.toString());
+    console.log("");
+  }
+  if (depTree) {
+    const nodeModules = depTree.root.children?.find((c) => c.name === "node_modules");
+    const src2 = depTree.root.children?.find((c) => c.name === "src");
+    if (nodeModules || src2) {
+      console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m`);
+      console.log("\x1B[1m\x1B[36mServer Dependency Breakdown\x1B[0m \x1B[90m(server-side only)\x1B[0m");
+      console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m
+`);
+      if (nodeModules && nodeModules.size > 0) {
+        const nmPercent = (nodeModules.size / depTree.totalSize * 100).toFixed(1);
+        console.log(`\x1B[1mnode_modules: ${formatBytes(nodeModules.size)} (${nmPercent}%)\x1B[0m
+`);
+        const packages = (nodeModules.children || []).filter((pkg) => pkg.size > 0).sort((a, b) => b.size - a.size);
+        if (packages.length > 0) {
+          const pkgTable = new Table({
+            head: ["Package / File", "Size", "% of Total"],
+            colWidths: [50, 20, 12],
+            style: {
+              head: ["red", "bold"],
+              border: ["gray"]
+            },
+            chars: ASCII_TABLE_CHARS
+          });
+          const packagesToShow = fullOutput ? packages : packages.filter((pkg) => pkg.size / depTree.totalSize >= 0.01);
+          for (const pkg of packagesToShow) {
+            const percentage = (pkg.size / depTree.totalSize * 100).toFixed(1);
+            pkgTable.push([
+              `\x1B[1m${pkg.name}\x1B[0m`,
+              formatBytes(pkg.size),
+              `${percentage}%`
+            ]);
+            const files = (pkg.children || []).filter((f) => f.size > 0).sort((a, b) => b.size - a.size);
+            const filesToShow = fullOutput ? files : files.slice(0, 10);
+            for (const file of filesToShow) {
+              const filePercent = (file.size / depTree.totalSize * 100).toFixed(1);
+              pkgTable.push([
+                `  ${String.fromCharCode(8627)} ${file.name}`,
+                formatBytes(file.size),
+                `${filePercent}%`
+              ]);
+            }
+            if (!fullOutput && files.length > 10) {
+              pkgTable.push([`  ... ${files.length - 10} more files`, "", ""]);
+            }
+          }
+          console.log(pkgTable.toString());
+          console.log("");
+        }
+      }
+      if (src2 && src2.size > 0) {
+        const srcPercent = (src2.size / depTree.totalSize * 100).toFixed(1);
+        console.log(`\x1B[1msrc: ${formatBytes(src2.size)} (${srcPercent}%)\x1B[0m
+`);
+        const srcItems = (src2.children || []).filter((item) => item.size > 0).sort((a, b) => b.size - a.size);
+        if (srcItems.length > 0) {
+          const srcTable = new Table({
+            head: ["Source", "Size", "% of Total"],
+            colWidths: [45, 12, 12],
+            style: {
+              head: ["green", "bold"],
+              border: ["gray"]
+            },
+            chars: ASCII_TABLE_CHARS
+          });
+          for (const item of srcItems) {
+            const percentage = (item.size / depTree.totalSize * 100).toFixed(1);
+            srcTable.push([
+              item.name,
+              formatBytes(item.size),
+              `${percentage}%`
+            ]);
+          }
+          console.log(srcTable.toString());
+          console.log("");
+        }
+      }
+    }
+  }
+  console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m`);
+  console.log("\x1B[1m\x1B[36mSummary\x1B[0m");
+  console.log(`\x1B[1m\x1B[36m${String.fromCharCode(9473).repeat(1)}\x1B[0m
+`);
+  const summaryTable = new Table({
+    head: ["Metric", "Value"],
+    colWidths: [25, 35],
+    style: {
+      head: ["cyan", "bold"],
+      border: ["gray"]
+    },
+    chars: ASCII_TABLE_CHARS
+  });
+  const browserNodeModules = browserDepTree?.root.children?.find((c) => c.name === "node_modules");
+  const browserDepCount = browserNodeModules?.children?.length || 0;
+  const serverNodeModules = depTree?.root.children?.find((c) => c.name === "node_modules");
+  const serverDepCount = serverNodeModules?.children?.length || 0;
+  let actualServerBinarySize = null;
+  let actualServerBinaryGzipped = null;
+  try {
+    const distDir = join12(process.cwd(), "dist");
+    if (existsSync9(distDir)) {
+      const files = await readdir6(distDir);
+      for (const file of files) {
+        const filePath = join12(distDir, file);
+        const stats2 = statSync(filePath);
+        if (stats2.isFile() && !file.includes(".")) {
+          actualServerBinarySize = stats2.size;
+          const content2 = await readFile2(filePath);
+          actualServerBinaryGzipped = Bun.gzipSync(content2).length;
+          break;
+        }
+      }
+    }
+  } catch {}
+  const browserBundleDisplay = browserInfo ? `${formatBytes(browserInfo.size)} (${formatBytes(browserInfo.gzippedSize)} gz)` : "N/A";
+  const serverBinaryDisplay = actualServerBinarySize ? `${formatBytes(actualServerBinarySize)}${actualServerBinaryGzipped ? ` (${formatBytes(actualServerBinaryGzipped)} gz)` : ""}` : mainInfo ? formatBytes(mainInfo.size) : "N/A";
+  summaryTable.push(["Browser Dependencies", browserDepCount.toString()], ["Browser Bundle", browserBundleDisplay], ["Server Dependencies", serverDepCount.toString()], ["Final Server Binary", serverBinaryDisplay]);
+  console.log(summaryTable.toString());
+  console.log("");
+  if (actualServerBinarySize) {
+    console.log("\x1B[90mNote: Final Server Binary is a standalone executable that includes the Bun runtime,\x1B[0m");
+    console.log("\x1B[90m      your application code, and all dependencies. This allows it to run without\x1B[0m");
+    console.log("\x1B[90m      requiring Node.js or Bun to be installed on the deployment server.\x1B[0m");
+    console.log("");
+  }
+  if (stats.bundles.length === 0) {
+    console.log(colorizeLogPrefixAnsi("[reroute/analyze] No bundles found. Run `reroute build` first. For production builds, use NODE_ENV=production or --prod flag.\n"));
+  }
+}
+async function analyze(args) {
+  try {
+    const cwd = process.cwd();
+    const outputHtml = args.includes("--html");
+    const openBrowser = args.includes("--open") || args.includes("-o");
+    const isProd = isProductionMode(args);
+    const searchIndex = args.indexOf("--search");
+    const initialSearch = searchIndex !== -1 && args[searchIndex + 1] ? args[searchIndex + 1] : "";
+    const rerouteIndexPath = join12(cwd, ".reroute", "index.ts");
+    if (!existsSync9(rerouteIndexPath)) {
+      console.log(colorizeLogPrefixAnsi(`[reroute/analyze] .reroute artifacts not found, running build...
+`));
+      const { spawn: spawn5 } = await import("node:child_process");
+      const { getRerouteCommand: getRerouteCommand5 } = await Promise.resolve().then(() => (init_command(), exports_command));
+      const rerouteCmd = getRerouteCommand5();
+      const useShell = rerouteCmd.includes(" ");
+      const buildCommand = useShell ? `${rerouteCmd} build` : rerouteCmd;
+      const buildArgs = useShell ? [] : ["build"];
+      await new Promise((resolve, reject) => {
+        const buildProcess = spawn5(buildCommand, buildArgs, {
+          stdio: "inherit",
+          shell: useShell
+        });
+        buildProcess.on("exit", (code) => {
+          if (code !== null && code !== 0) {
+            reject(new Error(`Build exited with code ${code}`));
+          } else {
+            resolve();
+          }
+        });
+        buildProcess.on("error", (error) => {
+          reject(error);
+        });
+      });
+      console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Build complete
+`));
+    }
+    console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Scanning for bundles...
+`));
+    const bundles = await findBundles(cwd);
+    const stats = calculateStats(bundles);
+    console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Building browser entrypoint for analysis...
+`));
+    const browserEntry = await findBrowserEntry(cwd);
+    let browserDepTree = null;
+    let browserInfo = null;
+    if (browserEntry) {
+      console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Analyzing browser bundle: ${relative(cwd, browserEntry)}
+`));
+      browserDepTree = await buildDependencyTree(browserEntry, cwd);
+      if (!browserDepTree) {
+        console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Could not build dependency tree from browser bundle. Sourcemap may be missing or invalid.
+`));
+      }
+      try {
+        const browserStat = await stat5(browserEntry);
+        const browserContent = await readFile2(browserEntry);
+        const browserGzipped = Bun.gzipSync(browserContent).length;
+        browserInfo = {
+          name: basename3(browserEntry),
+          size: browserStat.size,
+          gzippedSize: browserGzipped
+        };
+      } catch {}
+    } else {
+      console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Could not build browser entrypoint for analysis. Browser dependency breakdown will not be available.
+`));
+    }
+    let entry = null;
+    let depTree = null;
+    let mainInfo = null;
+    const srcEntry = join12(cwd, "src", "index.ts");
+    if (existsSync9(srcEntry)) {
+      console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Building server binary for analysis...
+`));
+      const { mkdir: mkdir4 } = await import("node:fs/promises");
+      const serverAnalysisDir = join12(cwd, ".reroute", "server");
+      await mkdir4(serverAnalysisDir, { recursive: true });
+      const result = await Bun.build({
+        entrypoints: [srcEntry],
+        target: "bun",
+        minify: isProd,
+        sourcemap: "linked",
+        external: [],
+        splitting: false
+      });
+      if (result.success && result.outputs.length > 0) {
+        const output = result.outputs[0];
+        const code = await output.text();
+        const analysisEntry = join12(serverAnalysisDir, "index.js");
+        await writeFile4(analysisEntry, code, "utf-8");
+        const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
+        if (mapOutput) {
+          const mapContent = await mapOutput.text();
+          await writeFile4(`${analysisEntry}.map`, mapContent, "utf-8");
+        }
+        entry = analysisEntry;
+      }
+    }
+    if (entry) {
+      console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Building dependency graph for ${relative(cwd, entry)}
+`));
+      depTree = await buildDependencyTree(entry, cwd);
+      console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Checking installed package sizes...
+`));
+      const installedSizes = await getInstalledPackageSizes(cwd);
+      if (depTree) {
+        const packageJsonPath = join12(cwd, "package.json");
+        if (existsSync9(packageJsonPath)) {
+          try {
+            const packageJson = JSON.parse(await readFile2(packageJsonPath, "utf-8"));
+            const runtimeDeps = packageJson.dependencies || {};
+            const nodeModulesNode = depTree.root.children?.find((c) => c.name === "node_modules");
+            if (nodeModulesNode) {
+              const trackedPkgs = new Set(nodeModulesNode.children?.map((c) => c.name) || []);
+              for (const pkgName of Object.keys(runtimeDeps)) {
+                if (!trackedPkgs.has(pkgName) && installedSizes.has(pkgName)) {
+                  nodeModulesNode.children?.push({
+                    name: pkgName,
+                    path: join12(cwd, "node_modules", pkgName),
+                    size: installedSizes.get(pkgName) || 0
+                  });
+                }
+              }
+              nodeModulesNode.size = nodeModulesNode.children?.reduce((sum, c) => {
+                if (c.children && c.children.length > 0) {
+                  c.size = c.children.reduce((s, child) => s + child.size, 0);
+                }
+                return sum + c.size;
+              }, 0) || 0;
+              depTree.root.size = depTree.root.children?.reduce((sum, c) => sum + c.size, 0) || 0;
+              depTree.totalSize = depTree.root.size;
+            }
+          } catch (_e) {}
+        }
+      }
+      try {
+        const entryStat = await stat5(entry);
+        const entryContent = await readFile2(entry);
+        const entryGzipped = Bun.gzipSync(entryContent).length;
+        mainInfo = {
+          name: basename3(entry),
+          size: entryStat.size,
+          gzippedSize: entryGzipped
+        };
+      } catch {}
+    }
+    const fullOutput = args.includes("--full");
+    await printConsoleReport(stats, depTree, mainInfo, browserDepTree, browserInfo, fullOutput);
+    if (outputHtml || openBrowser) {
+      const htmlPath = join12(cwd, ".reroute", "analysis.html");
+      const html2 = await generateHTMLReport(stats, depTree, mainInfo, browserDepTree, browserInfo, initialSearch);
+      const { mkdir: mkdir4 } = await import("node:fs/promises");
+      await mkdir4(join12(cwd, ".reroute"), { recursive: true });
+      await writeFile4(htmlPath, html2, "utf-8");
+      console.log(colorizeLogPrefixAnsi(`[reroute/analyze] HTML report generated: ${relative(cwd, htmlPath)}
+`));
+      if (openBrowser) {
+        try {
+          const { spawn: spawn5 } = await import("node:child_process");
+          const platform = process.platform;
+          let command2;
+          let commandArgs;
+          if (platform === "darwin") {
+            command2 = "open";
+            commandArgs = [htmlPath];
+          } else if (platform === "win32") {
+            command2 = "cmd";
+            commandArgs = ["/c", "start", "", htmlPath];
+          } else {
+            command2 = "xdg-open";
+            commandArgs = [htmlPath];
+          }
+          spawn5(command2, commandArgs, { detached: true, stdio: "ignore" });
+          console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Opened report in browser
+`));
+        } catch {
+          console.warn(colorizeLogPrefixAnsi(`[reroute/analyze] Could not open browser automatically. Please open ${htmlPath} manually.
+`));
+        }
+      }
+    }
+  } catch (error) {
+    console.error(colorizeLogPrefixAnsi(`[reroute/analyze] Error: ${String(error)}
+`));
+    throw error;
+  }
+}
+var ASCII_TABLE_CHARS;
+var init_analyze = __esm(() => {
+  init_log();
+  ASCII_TABLE_CHARS = {
+    top: "-",
+    "top-mid": "+",
+    "top-left": "+",
+    "top-right": "+",
+    bottom: "-",
+    "bottom-mid": "+",
+    "bottom-left": "+",
+    "bottom-right": "+",
+    left: "|",
+    "left-mid": "+",
+    mid: "-",
+    "mid-mid": "+",
+    right: "|",
+    "right-mid": "+",
+    middle: "|"
+  };
+});
+
+// packages/cli/src/cli.ts
+import path3 from "node:path";
+var commands = {
+  init: () => Promise.resolve().then(() => (init_init(), exports_init)),
+  gen: () => Promise.resolve().then(() => (init_gen(), exports_gen)),
+  boot: () => Promise.resolve().then(() => (init_boot(), exports_boot)),
+  dev: () => Promise.resolve().then(() => (init_dev(), exports_dev)),
+  start: () => Promise.resolve().then(() => (init_start(), exports_start)),
+  build: () => Promise.resolve().then(() => (init_build(), exports_build)),
+  analyze: () => Promise.resolve().then(() => (init_analyze(), exports_analyze))
+};
+async function main() {
+  const args = process.argv.slice(2);
+  if (args[0] === "--version" || args[0] === "-v") {
+    const version = await getVersionString2();
+    console.log(version);
+    process.exit(0);
+  }
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    await printHelp2();
+    process.exit(0);
+  }
+  const command2 = args[0];
+  if (!commands[command2]) {
+    console.error(`Unknown command: ${command2}`);
+    console.error("");
+    await printHelp2();
+    process.exit(1);
+  }
+  try {
+    const commandArgs = args.slice(1);
+    if (commandArgs.includes("--prod")) {
+      process.env.NODE_ENV = "production";
+      if (typeof Bun !== "undefined") {
+        Bun.env.NODE_ENV = "production";
+      }
+    }
+    const module = await commands[command2]();
+    await module.default(commandArgs);
+  } catch (error) {
+    console.error("Error executing command:", error);
+    process.exit(1);
+  }
+}
+async function printHelp2() {
+  console.log("");
+  console.log(await getVersionString2());
+  console.log("");
+  console.log("");
+  console.log("Usage:");
+  console.log("");
+  console.log("  reroute <command> [options]");
+  console.log("");
+  console.log("");
+  console.log("Commands:");
+  console.log("");
+  console.log("  init        Scaffold a new Reroute project");
+  console.log("  boot        Initialize .reroute directory with stub files");
+  console.log("  gen         Generate content registry and static assets");
+  console.log("  dev         Start development environment");
+  console.log("  start       Run production-like server locally");
+  console.log("  build       Build production binary");
+  console.log("  analyze     Analyze bundle sizes and generate report");
+  console.log("");
+  console.log("");
+  console.log("Options:");
+  console.log("");
+  console.log("  -h, --help     Show help");
+  console.log("  -v, --version  Show version");
+  console.log("  --prod         Enable production mode (same as NODE_ENV=production)");
+  console.log("");
+  console.log("");
+  console.log("Examples:");
+  console.log("");
+  console.log("  reroute init my-app");
+  console.log("  reroute boot");
+  console.log("");
+  console.log("  reroute gen");
+  console.log("  reroute gen -w");
+  console.log("  reroute gen --watch");
+  console.log("");
+  console.log("  reroute dev");
+  console.log("  reroute dev -s");
+  console.log("  reroute dev --single");
+  console.log("");
+  console.log("  reroute start");
+  console.log("");
+  console.log("  reroute build");
+  console.log("  reroute build --prod");
+  console.log("  reroute build -o ./dist/myapp");
+  console.log("  reroute build --outfile ./dist/myapp");
+  console.log("");
+  console.log("  reroute analyze");
+  console.log("  reroute analyze --prod");
+  console.log("  reroute analyze --full");
+  console.log("  reroute analyze --html");
+  console.log("  reroute analyze --open");
 }
 async function getVersionString2() {
   const version = await getVersion2();
@@ -2166,12 +5535,12 @@ async function getVersionString2() {
 }
 async function getVersion2() {
   if (true) {
-    return "0.7.2";
+    return "0.8.0";
   }
   const possiblePaths = [
-    path2.join(import.meta.dir, "../../../package.json"),
-    path2.join(import.meta.dir, "../../package.json"),
-    path2.join(import.meta.dir, "../package.json")
+    path3.join(import.meta.dir, "../../../package.json"),
+    path3.join(import.meta.dir, "../../package.json"),
+    path3.join(import.meta.dir, "../package.json")
   ];
   for (const pkgPath of possiblePaths) {
     try {
@@ -2183,10 +5552,10 @@ async function getVersion2() {
 }
 async function getCommit2() {
   if (true) {
-    return "993e6df";
+    return "b31f8e3";
   }
   return "dev";
 }
 main();
 
-//# debugId=27B92FF191E5405264756E2164756E21
+//# debugId=8F50A077EDCF534864756E2164756E21