reroute-js 0.9.0 → 0.9.2

package/elysia/index.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.9.0
+ * reroute-js v0.9.2
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -7,338 +7,33 @@
  *
  * Built with Bun <3
  */
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+// packages/core/src/content/discovery.ts
+import { readdir, stat } from "node:fs/promises";
 
 // packages/core/src/utils/path.ts
-var exports_path = {};
-__export(exports_path, {
-  stripStart: () => stripStart,
-  stripEnd: () => stripEnd,
-  join: () => join2,
-  extname: () => extname,
-  basename: () => basename
-});
-function join2(...parts) {
+function join(...parts) {
   return parts.join("/").replace(/\/+/g, "/");
 }
-function extname(p) {
-  const i = p.lastIndexOf(".");
-  return i >= 0 ? p.slice(i) : "";
-}
-function basename(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/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/tailwind.ts
-import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-function isTailwindAvailable(cwd) {
-  const packageJsonPath = join(cwd, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return false;
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    const deps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    return "@tailwindcss/cli" in deps;
-  } catch {
-    return false;
-  }
-}
-function getTailwindPaths(cwd) {
-  const input = join(cwd, "src/client/theme.css");
-  const output = join(cwd, ".reroute/theme.css");
-  return { input, output };
-}
-function hasTailwindInput(cwd) {
-  const { input } = getTailwindPaths(cwd);
-  if (!existsSync(input)) {
-    return false;
-  }
-  try {
-    const content = readFileSync(input, "utf-8");
-    return content.includes("tailwindcss");
-  } catch {
-    return false;
-  }
-}
-function resolveTailwindBin(cwd) {
-  const pathsToTry = [
-    join(cwd, "../node_modules/.bin/tailwindcss"),
-    join(cwd, "../../node_modules/.bin/tailwindcss"),
-    join(cwd, "../../../node_modules/.bin/tailwindcss")
-  ];
-  for (const binPath of pathsToTry) {
-    if (existsSync(binPath)) {
-      return binPath;
-    }
-  }
-  return join(cwd, "node_modules/.bin/tailwindcss");
-}
-async function buildTailwind(cwd) {
-  const { input, output } = getTailwindPaths(cwd);
-  return new Promise((resolve, reject) => {
-    const tailwindBin = resolveTailwindBin(cwd);
-    const args = ["-i", input, "-o", output];
-    console.log(`[reroute/tailwind] build start: -i ${input} -o ${output}`);
-    const tailwind = spawn(tailwindBin, args, {
-      cwd,
-      stdio: "pipe"
-    });
-    tailwind.stdout?.on("data", (data) => {
-      const line = data.toString().trim();
-      if (line) {
-        console.log(`[reroute/tailwind] ${line}`);
-      }
-    });
-    tailwind.stderr?.on("data", (data) => {
-      const line = data.toString().trim();
-      if (line) {
-        console.log(`[reroute/tailwind] ${line}`);
-      }
-    });
-    tailwind.on("close", (code) => {
-      if (code === 0) {
-        console.log("[reroute/tailwind] build done");
-        resolve();
-      } else {
-        reject(new Error(`Tailwind CSS build failed with code ${code}`));
-      }
-    });
-    tailwind.on("error", (error) => {
-      reject(error);
-    });
-  });
-}
-async function buildTailwindIfConfigured(cwd) {
-  try {
-    if (isTailwindAvailable(cwd) && hasTailwindInput(cwd)) {
-      await buildTailwind(cwd);
-      return true;
-    }
-    return false;
-  } catch (e) {
-    console.warn("[reroute/tailwind] build failed:", e);
-    return true;
-  }
-}
-// packages/core/src/bundler/transpile.ts
-var entryUrlToStaticDeps = new Map;
-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: true,
-      sourcemap: sm,
-      jsx: {
-        runtime: "automatic",
-        importSource: "react",
-        development: !options.minify
-      },
-      define: {
-        "process.env.NODE_ENV": options.minify ? '"production"' : '"development"',
-        __DEV__: options.minify ? "false" : "true",
-        "import.meta.env.MODE": options.minify ? '"production"' : '"development"'
-      },
-      ...options.minify ? { drop: ["console", "debugger"] } : {}
-    });
-  }
-  let result;
+// packages/core/src/content/discovery.ts
+async function discoverCollections(clientDir) {
+  const root = join(clientDir, "routes");
+  const collections = new Set;
   try {
-    result = await doBuild(options.sourcemap ? "external" : "none");
-  } catch (error) {
-    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 outputs = await Promise.all(result.outputs.map(async (o) => ({
-    path: o.path,
-    text: await o.text()
-  })));
-  const entryBase = basename(originalPath, extname(originalPath));
-  let entry = outputs.find((o) => o.path.endsWith(`${entryBase}.js`));
-  if (!entry) {
-    entry = outputs.filter((o) => o.path.endsWith(".js")).sort((a, b) => b.text.length - a.text.length)[0];
-  }
-  if (!entry) {
-    throw new Error(`[reroute] No JS output generated for ${originalPath}`);
-  }
-  const code = entry.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 chunks = outputs.filter((o) => o !== entry && o.path.endsWith(".js")).map((o) => ({
-    fileName: basename(o.path),
-    code: o.text,
-    hash: "",
-    isEntry: false,
-    imports: []
-  }));
-  for (const c of chunks) {
-    c.hash = await generateContentHash(c.code);
-    try {
-      const bn = c.fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const re = new RegExp(`["'\`]((?:\\./)?${bn})["'\`]`, "g");
-      const matches = [...code.matchAll(re)];
-      if (matches.length) {
-        c.isEntry = false;
+    const entries = await readdir(root, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const contentDir = join(root, entry.name, "content");
+        try {
+          await stat(contentDir);
+          collections.add(entry.name);
+        } catch {}
       }
-    } catch {}
-  }
-  const staticDepNames = [];
-  try {
-    for (const c of chunks) {
-      const bn = c.fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const re = new RegExp(`["'\`]((?:\\./)?${bn})["'\`]`, "g");
-      if (re.test(code))
-        staticDepNames.push(c.fileName);
     }
   } catch {}
-  const bundleInfo = {
-    hash: contentHash,
-    code,
-    sourceMap,
-    chunks
-  };
-  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 getBundleUrlsFor(modules, clientDir, prefix, options, bundleCache) {
-  const mods = Array.isArray(modules) ? modules : [modules];
-  const urls = [];
-  const { join: join3 } = await Promise.resolve().then(() => exports_path);
-  for (const mod of mods) {
-    const rel = mod.replace(/^\.\//, "");
-    const fullPath = join3(clientDir, rel);
-    try {
-      const bundleInfo = await transpileFile(fullPath, rel, options, bundleCache);
-      const base = basename(rel, extname(rel));
-      const entryUrl = `${prefix}/${base}.${bundleInfo.hash}.js`;
-      urls.push(entryUrl);
-      try {
-        const depNames = Array.isArray(bundleInfo.chunks) ? bundleInfo.chunks.map((c) => c.fileName).filter((name) => new RegExp(`["'\`]((?:\\./)?${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})["'\`]`, "g").test(bundleInfo.code)) : [];
-        const depUrls = depNames.map((n) => `${prefix}/${n}`.replace(/\/+/g, "/"));
-        entryUrlToStaticDeps.set(entryUrl, depUrls);
-      } catch {}
-    } catch (error) {
-      console.error(`[reroute] Error getting bundle URL for ${rel}:`, error);
-      urls.push(`${prefix}/${rel}`);
-    }
-  }
-  return urls;
-}
-function getStaticDepsForUrl(entryUrl) {
-  return entryUrlToStaticDeps.get(entryUrl) || [];
+  return Array.from(collections);
 }
-// packages/core/src/content/discovery.ts
-import { readdir, stat as stat2 } from "node:fs/promises";
-
 // packages/core/src/content/metadata.ts
-import { stat } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
-async function getContentMeta(absPath, isWatchMode2) {
-  try {
-    const url = pathToFileURL(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 "";
@@ -356,84 +51,13 @@ ${parts.join(`
 function escapeHtml(input) {
   return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
-
-// packages/core/src/content/discovery.ts
-async function listContentFiles(dir, baseRel) {
-  const out = [];
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = join2(dir, entry.name);
-      const rel = join2(baseRel, entry.name);
-      if (entry.isDirectory()) {
-        const nested = await listContentFiles(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 = join2("routes", normalized, "content");
-  const contentAbsDir = join2(clientDir, contentRelDir);
-  const files = await listContentFiles(contentAbsDir, "");
-  const items = [];
-  for (const rel of files) {
-    const fullRelPath = join2(contentRelDir, rel);
-    const absPath = join2(clientDir, fullRelPath);
-    const noExt = rel.replace(/\.(tsx|ts)$/, "");
-    const name = basename(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 = join2(clientDir, "routes");
-  const collections = new Set;
-  try {
-    const entries = await readdir(root, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const contentDir = join2(root, entry.name, "content");
-        try {
-          await stat2(contentDir);
-          collections.add(entry.name);
-        } catch {}
-      }
-    }
-  } catch {}
-  return Array.from(collections);
-}
-// packages/core/src/content/registry.ts
-async function generateContentRegistry(cwd) {
-  try {
-    const p = join2(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 {}
-}
 // packages/core/src/ssr/data.ts
-import { pathToFileURL as pathToFileURL3 } from "node:url";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // packages/core/src/ssr/modules.ts
-import { readdir as readdir2, stat as stat3 } from "node:fs/promises";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
-async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2) {
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode) {
   try {
     const parts = pathname.split("/").filter(Boolean);
     if (parts.length < 2)
@@ -441,20 +65,20 @@ async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2
     const collection = parts[0];
     const name = parts[1];
     try {
-      const registryPath = join2(cwd, ".reroute", "content.ts");
-      const reg = await import(pathToFileURL2(registryPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+      const registryPath = join(cwd, ".reroute", "content.ts");
+      const reg = await import(pathToFileURL(registryPath).href + (isWatchMode ? `?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 = join2(cwd, moduleUrl.replace(/^\//, ""));
-        const href = pathToFileURL2(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : "");
+        const abs = join(cwd, moduleUrl.replace(/^\//, ""));
+        const href = pathToFileURL(abs).href + (isWatchMode ? `?t=${Date.now()}` : "");
         const mod = await import(href);
         return mod;
       }
     } catch {}
     try {
-      const chunkDir = join2(cwd, ".reroute", "chunks", collection);
+      const chunkDir = join(cwd, ".reroute", "chunks", collection);
       const files = await readdir2(chunkDir);
       const matches = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
       if (matches.length) {
@@ -462,30 +86,30 @@ async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2
         let latestM = 0;
         for (const f of matches) {
           try {
-            const s = await stat3(join2(chunkDir, f));
+            const s = await stat2(join(chunkDir, f));
             if (s.mtimeMs >= latestM) {
               latestM = s.mtimeMs;
               latest = f;
             }
           } catch {}
         }
-        const absChunk = join2(chunkDir, latest);
-        const href = pathToFileURL2(absChunk).href + (isWatchMode2 ? `?t=${Date.now()}` : "");
+        const absChunk = join(chunkDir, latest);
+        const href = pathToFileURL(absChunk).href + (isWatchMode ? `?t=${Date.now()}` : "");
         const mod = await import(href);
         return mod;
       }
     } catch {}
     try {
-      const srcTsx = join2(clientDir, "routes", collection, "content", `${name}.tsx`);
-      const srcTs = join2(clientDir, "routes", collection, "content", `${name}.ts`);
+      const srcTsx = join(clientDir, "routes", collection, "content", `${name}.tsx`);
+      const srcTs = join(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 = pathToFileURL2(absSrc).href;
-        const mod = await (isWatchMode2 ? import(`${href}?t=${Date.now()}`) : import(href));
+        const href = pathToFileURL(absSrc).href;
+        const mod = await (isWatchMode ? import(`${href}?t=${Date.now()}`) : import(href));
         return mod;
       }
     } catch {}
@@ -494,7 +118,7 @@ async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2
 }
 
 // packages/core/src/ssr/seed.ts
-async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2) {
+async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode) {
   try {
     const parts = pathname.split("/").filter(Boolean);
     if (parts.length < 2)
@@ -502,7 +126,7 @@ async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2) {
     const collection = parts[0];
     const name = parts[1];
     const key = `${collection}:${name}`;
-    const mod = await importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2);
+    const mod = await importContentModuleForPath(pathname, clientDir, cwd, isWatchMode);
     if (!mod)
       return;
     const C = mod.default || mod;
@@ -522,9 +146,9 @@ async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2) {
 
 // packages/core/src/ssr/data.ts
 async function computeSSRDataForPath(params) {
-  const { pathname, clientDir, cwd, isWatchMode: isWatchMode2 } = params;
+  const { pathname, clientDir, cwd, isWatchMode } = params;
   try {
-    await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2);
+    await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode);
   } catch {}
   try {
     const parts = pathname.split("/").filter(Boolean);
@@ -539,15 +163,15 @@ async function computeSSRDataForPath(params) {
     }
   } catch {}
   try {
-    const routesPath = join2(cwd, ".reroute", "routes.ts");
-    const m = await import(pathToFileURL3(routesPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+    const routesPath = join(cwd, ".reroute", "routes.ts");
+    const m = await import(pathToFileURL2(routesPath).href + (isWatchMode ? `?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 = join2(clientDir, "routes", String(r.path));
-        const mod = await import(pathToFileURL3(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+        const abs = join(clientDir, "routes", String(r.path));
+        const mod = await import(pathToFileURL2(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
         const ssr = mod?.ssr;
         const dataFn = ssr?.data;
         if (typeof dataFn === "function") {
@@ -559,10 +183,10 @@ async function computeSSRDataForPath(params) {
   return null;
 }
 // packages/core/src/ssr/render.ts
-import { readdir as readdir3, stat as stat4 } from "node:fs/promises";
-import { pathToFileURL as pathToFileURL4 } from "node:url";
+import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 
-// node_modules/dedent/dist/dedent.mjs
+// node_modules/.bun/dedent@1.7.0/node_modules/dedent/dist/dedent.mjs
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
   if (Object.getOwnPropertySymbols) {
@@ -684,7 +308,7 @@ import { renderToString } from "react-dom/server";
 
 // packages/core/src/template/html.ts
 async function loadIndexHtml(clientDir) {
-  const templatePath = join2(clientDir, "index.html");
+  const templatePath = join(clientDir, "index.html");
   try {
     const content = await Bun.file(templatePath).text();
     return content;
@@ -761,7 +385,7 @@ async function renderSSRDocument(options) {
     rootComponent,
     clientDir,
     cwd,
-    isWatchMode: isWatchMode2,
+    isWatchMode,
     bundleUrl,
     head = "",
     lang = "en",
@@ -777,15 +401,6 @@ async function renderSSRDocument(options) {
 <link rel="modulepreload" href="${bundleUrl}" />`;
     }
   } catch {}
-  try {
-    const staticDeps = getStaticDepsForUrl(bundleUrl);
-    if (Array.isArray(staticDeps) && staticDeps.length) {
-      for (const dep of staticDeps) {
-        extraHead += `
-<link rel="modulepreload" href="${dep}" />`;
-      }
-    }
-  } catch {}
   let statusOverride;
   try {
     globalThis.__REROUTE_SSR_ACCESSED__ = {};
@@ -798,8 +413,8 @@ async function renderSSRDocument(options) {
       let modulePath = "";
       let isContentCollection = false;
       try {
-        const maybeDir = join2(clientDir, "routes", collection, "content");
-        const s = await stat4(maybeDir);
+        const maybeDir = join(clientDir, "routes", collection, "content");
+        const s = await stat3(maybeDir);
         isContentCollection = typeof s?.isDirectory === "function" ? s.isDirectory() : true;
       } catch {
         isContentCollection = false;
@@ -808,8 +423,8 @@ async function renderSSRDocument(options) {
         throw new Error("skip-content-preload");
       }
       try {
-        const registryPath = join2(cwd, ".reroute", "content.ts");
-        const reg = await import(pathToFileURL4(registryPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+        const registryPath = join(cwd, ".reroute", "content.ts");
+        const reg = await import(pathToFileURL3(registryPath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
         const get = reg?.getContentEntry;
         const entry = typeof get === "function" ? get(collection, name) : undefined;
         const moduleUrl = entry?.module;
@@ -819,7 +434,7 @@ async function renderSSRDocument(options) {
       } catch {}
       if (!modulePath) {
         try {
-          const chunkDir = join2(cwd, ".reroute", "chunks", collection);
+          const chunkDir = join(cwd, ".reroute", "chunks", collection);
           const files = await readdir3(chunkDir);
           const candidates = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
           if (candidates.length) {
@@ -827,25 +442,25 @@ async function renderSSRDocument(options) {
             let latestM = 0;
             for (const candidateName of candidates) {
               try {
-                const s = await stat4(join2(chunkDir, candidateName));
+                const s = await stat3(join(chunkDir, candidateName));
                 if (s.mtimeMs >= latestM) {
                   latestM = s.mtimeMs;
                   latest = candidateName;
                 }
               } catch {}
             }
-            modulePath = `/${join2(".reroute", "chunks", collection, latest).replace(/\\+/g, "/")}`;
+            modulePath = `/${join(".reroute", "chunks", collection, latest).replace(/\\+/g, "/")}`;
           }
         } catch {}
       }
       if (!modulePath) {
-        const tsx = join2(clientDir, "routes", collection, "content", `${name}.tsx`);
-        const ts = join2(clientDir, "routes", collection, "content", `${name}.ts`);
+        const tsx = join(clientDir, "routes", collection, "content", `${name}.tsx`);
+        const ts = join(clientDir, "routes", collection, "content", `${name}.ts`);
         let srcUrl = "";
         if (await Bun.file(tsx).exists()) {
-          srcUrl = `/${join2("routes", collection, "content", `${name}.tsx`).replace(/\\+/g, "/")}`;
+          srcUrl = `/${join("routes", collection, "content", `${name}.tsx`).replace(/\\+/g, "/")}`;
         } else if (await Bun.file(ts).exists()) {
-          srcUrl = `/${join2("routes", collection, "content", `${name}.ts`).replace(/\\+/g, "/")}`;
+          srcUrl = `/${join("routes", collection, "content", `${name}.ts`).replace(/\\+/g, "/")}`;
         }
         if (srcUrl) {
           modulePath = srcUrl;
@@ -863,7 +478,7 @@ async function renderSSRDocument(options) {
       }
     }
   } catch {}
-  await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2);
+  await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode);
   const __SSR_DATA__ = {};
   try {
     try {
@@ -883,15 +498,15 @@ async function renderSSRDocument(options) {
       }
     } catch {}
     try {
-      const routesPath = join2(cwd, ".reroute", "routes.ts");
-      const m = await import(pathToFileURL4(routesPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+      const routesPath = join(cwd, ".reroute", "routes.ts");
+      const m = await import(pathToFileURL3(routesPath).href + (isWatchMode ? `?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 = join2(clientDir, "routes", String(r.path));
-          const mod = await import(pathToFileURL4(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+          const abs = join(clientDir, "routes", String(r.path));
+          const mod = await import(pathToFileURL3(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
           const ssr = mod?.ssr;
           const dataFn = ssr?.data;
           if (typeof dataFn === "function") {
@@ -907,8 +522,8 @@ async function renderSSRDocument(options) {
   } catch {}
   let __byCollectionForSSR = {};
   try {
-    const p = join2(cwd, ".reroute", "content.ts");
-    const mod = await import(pathToFileURL4(p).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+    const p = join(cwd, ".reroute", "content.ts");
+    const mod = await import(pathToFileURL3(p).href + (isWatchMode ? `?t=${Date.now()}` : ""));
     __byCollectionForSSR = mod?.byCollection || {};
     try {
       globalThis.__REROUTE_COLLECTIONS__ = __byCollectionForSSR;
@@ -922,10 +537,10 @@ async function renderSSRDocument(options) {
   let inlineStyleTag = "";
   try {
     const candidates = [
-      join2(clientDir, "..", ".reroute", "theme.css"),
-      join2(clientDir, "..", "..", ".reroute", "theme.css"),
-      join2(clientDir, "..", "..", "..", ".reroute", "theme.css"),
-      join2(clientDir, "..", "..", "..", "..", ".reroute", "theme.css")
+      join(clientDir, "..", ".reroute", "theme.css"),
+      join(clientDir, "..", "..", ".reroute", "theme.css"),
+      join(clientDir, "..", "..", "..", ".reroute", "theme.css"),
+      join(clientDir, "..", "..", "..", "..", ".reroute", "theme.css")
     ];
     let cssPath = "";
     for (const p of candidates) {
@@ -1008,7 +623,7 @@ async function renderSSRDocument(options) {
 </script>`;
   } catch {}
   hydrationScript += scripts.map((src) => `<script type="module" src="${src}"></script>`).join("");
-  if (isWatchMode2) {
+  if (isWatchMode) {
     hydrationScript += `<script type="module" src="/__reroute_watch.js"></script>`;
   }
   let perPageHead = "";
@@ -1033,8 +648,8 @@ ${ssrHead}`;
     }
   } catch {}
   try {
-    const routesPath = join2(cwd, ".reroute", "routes.ts");
-    const m = await import(pathToFileURL4(routesPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+    const routesPath = join(cwd, ".reroute", "routes.ts");
+    const m = await import(pathToFileURL3(routesPath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
     const match = typeof m.matchRoute === "function" ? m.matchRoute(pathname) : null;
     const r = match?.route;
     if (!r) {
@@ -1042,8 +657,8 @@ ${ssrHead}`;
     }
     if (r && typeof r.path === "string") {
       try {
-        const abs = join2(clientDir, "routes", String(r.path));
-        const mod = await import(pathToFileURL4(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+        const abs = join(clientDir, "routes", String(r.path));
+        const mod = await import(pathToFileURL3(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
         const meta = mod?.meta;
         const ssr = mod?.ssr;
         if (meta)
@@ -1077,8 +692,8 @@ ${ssrHead}`;
           }
           if (chosen && typeof chosen.path === "string") {
             try {
-              const abs = join2(clientDir, "routes", String(chosen.path));
-              const mod = await import(pathToFileURL4(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+              const abs = join(clientDir, "routes", String(chosen.path));
+              const mod = await import(pathToFileURL3(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
               const meta = mod?.meta;
               const ssr = mod?.ssr;
               if (meta)
@@ -1261,10 +876,8 @@ function jsonError(message, status = 500) {
 }
 
 // packages/elysia/src/libs/image.ts
-import { createHash } from "node:crypto";
-import { existsSync as existsSync2 } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { existsSync } from "node:fs";
+import { join as join2 } from "node:path";
 import sharp from "sharp";
 var imageCache = new Map;
 var MAX_CACHE_SIZE = 100;
@@ -1274,7 +887,9 @@ function initImageCache(cacheDir) {
 }
 function getCacheKey(imagePath, options) {
   const optionsString = JSON.stringify(options);
-  const hash2 = createHash("sha256").update(`${imagePath}:${optionsString}`).digest("hex");
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(`${imagePath}:${optionsString}`);
+  const hash2 = hasher.digest("hex");
   return hash2;
 }
 function getContentType(format) {
@@ -1305,13 +920,13 @@ async function loadFromDiskCache(cacheKey) {
   if (!diskCacheDir)
     return null;
   try {
-    const cachePath = join3(diskCacheDir, `${cacheKey}.json`);
-    const imagePath = join3(diskCacheDir, `${cacheKey}.img`);
-    if (!existsSync2(cachePath) || !existsSync2(imagePath)) {
+    const cachePath = join2(diskCacheDir, `${cacheKey}.json`);
+    const imagePath = join2(diskCacheDir, `${cacheKey}.img`);
+    if (!existsSync(cachePath) || !existsSync(imagePath)) {
       return null;
     }
-    const metadata2 = JSON.parse(await readFile(cachePath, "utf-8"));
-    const buffer = await readFile(imagePath);
+    const metadata2 = JSON.parse(await Bun.file(cachePath).text());
+    const buffer = Buffer.from(await Bun.file(imagePath).arrayBuffer());
     return {
       buffer,
       contentType: metadata2.contentType,
@@ -1328,17 +943,16 @@ async function saveToDiskCache(cacheKey, result) {
   if (!diskCacheDir)
     return;
   try {
-    await mkdir(diskCacheDir, { recursive: true });
-    const cachePath = join3(diskCacheDir, `${cacheKey}.json`);
-    const imagePath = join3(diskCacheDir, `${cacheKey}.img`);
-    await writeFile(cachePath, JSON.stringify({
+    const cachePath = join2(diskCacheDir, `${cacheKey}.json`);
+    const imagePath = join2(diskCacheDir, `${cacheKey}.img`);
+    await Bun.write(cachePath, JSON.stringify({
       contentType: result.contentType,
       format: result.format,
       width: result.width,
       height: result.height,
       size: result.size
     }));
-    await writeFile(imagePath, result.buffer);
+    await Bun.write(imagePath, result.buffer);
   } catch (error) {
     console.error("Failed to save image to disk cache:", error);
   }
@@ -1369,7 +983,7 @@ async function optimizeImage(imagePath, options, acceptHeader) {
     const arrayBuffer = await response.arrayBuffer();
     sourceBuffer = Buffer.from(arrayBuffer);
   } else {
-    sourceBuffer = await readFile(imagePath);
+    sourceBuffer = Buffer.from(await Bun.file(imagePath).arrayBuffer());
   }
   const format = options.format === "auto" || !options.format ? negotiateFormat(acceptHeader, undefined) : options.format;
   let transformer = sharp(sourceBuffer);
@@ -1439,31 +1053,72 @@ function isImageFile(path2) {
 
 // packages/elysia/src/routes/artifacts.ts
 import { NotFoundError } from "elysia";
-function registerArtifactsRoutes(app, cwd) {
-  app.get("/.reroute/*", async ({ params, headers }) => {
-    const sub = String(params["*"] || "").replace(/^\/+/, "");
-    if (!sub)
+
+// packages/elysia/src/libs/cache.ts
+function getEncoding(acceptEncoding) {
+  return /\bbr\b/i.test(acceptEncoding) ? "br" : /gzip/i.test(acceptEncoding) ? "gz" : "raw";
+}
+
+// packages/elysia/src/routes/artifacts.ts
+async function serveStaticFile(filePath, headers, fileCache, cacheControl) {
+  const acceptEncoding = headers["accept-encoding"] || "";
+  const encoding = getEncoding(acceptEncoding);
+  const cacheKey = `${filePath}:${encoding}`;
+  const cached = fileCache.get(cacheKey);
+  if (cached)
+    return cached.clone();
+  const exists = await Bun.file(filePath).exists();
+  if (!exists)
+    throw new NotFoundError;
+  const buf = await Bun.file(filePath).arrayBuffer();
+  const content2 = new Uint8Array(buf);
+  const contentType = getMimeType(filePath);
+  const { body, extraHeaders } = gzipIfAccepted(content2, contentType, headers["accept-encoding"]);
+  const response = new Response(body, {
+    headers: {
+      "Content-Type": contentType,
+      "Cache-Control": cacheControl,
+      ...extraHeaders
+    }
+  });
+  fileCache.set(cacheKey, response);
+  return response.clone();
+}
+function registerArtifactsRoutes(app, cwd, fileCache, options) {
+  const { bundleMaxAge, directive, isWatchMode = false } = options;
+  app.get("/bundles/*", async ({ params, headers }) => {
+    const fileName = String(params["*"] || "").replace(/^\/+/, "");
+    if (!fileName)
       throw new NotFoundError;
-    const abs = join2(cwd, ".reroute", sub);
+    const filePath = join(cwd, ".reroute", "bundles", fileName);
     try {
-      const exists = await Bun.file(abs).exists();
-      if (!exists)
-        throw new NotFoundError;
-      const buf = await Bun.file(abs).arrayBuffer();
-      const content2 = new Uint8Array(buf);
-      const contentType = getMimeType(abs);
-      const { body, extraHeaders } = gzipIfAccepted(content2, contentType, headers["accept-encoding"]);
-      return new Response(body, {
-        headers: {
-          "Content-Type": contentType,
-          "Cache-Control": "public, max-age=31536000, immutable",
-          ...extraHeaders
-        }
-      });
+      let cacheControl;
+      if (isWatchMode) {
+        cacheControl = "no-cache, no-store, must-revalidate";
+      } else {
+        const isContentHashed = /\.([a-z0-9]{8,})\.(js|css)$/i.test(fileName);
+        cacheControl = isContentHashed ? "public, max-age=31536000, immutable" : bundleMaxAge > 0 ? `${directive}, max-age=${bundleMaxAge}` : "no-cache";
+      }
+      return await serveStaticFile(filePath, headers, fileCache, cacheControl);
     } catch (e) {
       if (e instanceof NotFoundError)
         throw e;
-      console.error("[reroute] Failed to serve .reroute file:", abs, e);
+      console.error("[reroute] Failed to serve bundle:", filePath, e);
+      throw new NotFoundError;
+    }
+  });
+  app.get("/.reroute/collections/*", async ({ params, headers }) => {
+    const fileName = String(params["*"] || "").replace(/^\/+/, "");
+    if (!fileName)
+      throw new NotFoundError;
+    const filePath = join(cwd, ".reroute", "collections", fileName);
+    try {
+      const cacheControl = isWatchMode ? "no-cache, no-store, must-revalidate" : "public, max-age=31536000, immutable";
+      return await serveStaticFile(filePath, headers, fileCache, cacheControl);
+    } catch (e) {
+      if (e instanceof NotFoundError)
+        throw e;
+      console.error("[reroute] Failed to serve collection file:", filePath, e);
       throw new NotFoundError;
     }
   });
@@ -1472,23 +1127,46 @@ function registerArtifactsRoutes(app, cwd) {
 
 // packages/elysia/src/routes/content.ts
 import { NotFoundError as NotFoundError2 } from "elysia";
-function registerContentRoutes(app, clientDir, prefix, isWatchMode2) {
-  app.get("/__content/*", async ({ params, set }) => {
+function registerContentRoutes(app, cwd, collectionCache, directive, maxAge, isWatchMode) {
+  app.get("/__content/*", async ({ params }) => {
     const collectionPath = String(params["*"] || "").trim();
     if (!collectionPath)
       throw new NotFoundError2;
-    const items = await buildContentDTOs(collectionPath, clientDir, prefix, isWatchMode2);
-    const body = JSON.stringify({ collection: collectionPath, items });
-    set.status = 200;
-    set.headers["content-type"] = "application/json; charset=utf-8";
-    return new Response(body);
+    const cacheKey = `content:${collectionPath}`;
+    const cached = collectionCache.get(cacheKey);
+    if (cached)
+      return cached.clone();
+    try {
+      const collectionFile = join(cwd, ".reroute", "collections", `${collectionPath}.js`);
+      const exists = await Bun.file(collectionFile).exists();
+      if (!exists)
+        throw new NotFoundError2;
+      const url = `${Bun.pathToFileURL(collectionFile).href}${isWatchMode ? `?t=${Date.now()}` : ""}`;
+      const mod = await import(url);
+      const items = mod.items || [];
+      const body = JSON.stringify({ collection: collectionPath, items });
+      const response = new Response(body, {
+        status: 200,
+        headers: {
+          "content-type": "application/json; charset=utf-8",
+          "cache-control": `${directive}, max-age=${maxAge}`
+        }
+      });
+      collectionCache.set(cacheKey, response);
+      return response.clone();
+    } catch (e) {
+      if (e instanceof NotFoundError2)
+        throw e;
+      console.error(`[reroute] Failed to serve collection ${collectionPath}:`, e);
+      throw new NotFoundError2;
+    }
   });
   return app;
 }
 
 // packages/elysia/src/routes/dev.ts
 import { NotFoundError as NotFoundError3 } from "elysia";
-function registerDevRoutes(app, liveReloadClients, isWatchMode2, opts) {
+function registerDevRoutes(app, liveReloadClients, isWatchMode, opts) {
   app.get("/__reroute_preload", async ({ query }) => {
     const rawSrc = String(query.src || "").trim();
     const key = String(query.key || "").trim();
@@ -1507,10 +1185,11 @@ function registerDevRoutes(app, liveReloadClients, isWatchMode2, opts) {
 ` + `(globalThis.__REROUTE_MODULES__ ||= {});
 ` + `globalThis.__REROUTE_MODULES__['${key}'] = __C;
 ` + `export {};`;
+    const cacheControl = isWatchMode ? "no-cache, no-store, must-revalidate" : "public, max-age=31536000, immutable";
     return new Response(code, {
       headers: {
         "content-type": "application/javascript; charset=utf-8",
-        "cache-control": isWatchMode2 ? "no-cache" : "public, max-age=31536000, immutable"
+        "cache-control": cacheControl
       }
     });
   });
@@ -1524,13 +1203,13 @@ function registerDevRoutes(app, liveReloadClients, isWatchMode2, opts) {
       pathname = String(p);
     }
     try {
-      let data2 = isWatchMode2 ? undefined : opts?.dataCache?.get(pathname);
+      let data2 = opts?.dataCache?.get(pathname);
       if (data2 === undefined) {
         data2 = await computeSSRDataForPath({
           pathname,
           clientDir: opts?.clientDir || "",
           cwd: opts?.cwd || "",
-          isWatchMode: isWatchMode2
+          isWatchMode
         });
         opts?.dataCache?.set(pathname, data2);
       }
@@ -1539,7 +1218,7 @@ function registerDevRoutes(app, liveReloadClients, isWatchMode2, opts) {
       return jsonError("failed", 500);
     }
   });
-  if (!isWatchMode2)
+  if (!isWatchMode)
     return app;
   console.log("[reroute] Registering SSE endpoint at /__reroute_watch");
   app.get("/__reroute_watch", () => {
@@ -1583,7 +1262,7 @@ function registerDevRoutes(app, liveReloadClients, isWatchMode2, opts) {
 ` + `function waitServerThenReload(){
 ` + `  const ping = () => fetch(location.origin, { cache: 'no-store' })
 ` + `    .then(()=>location.reload())
-` + `    .catch(()=>setTimeout(ping, 300));
+` + `    .catch(()=>setTimeout(ping, 50));
 ` + `  ping();
 ` + `}
 ` + `function connect(){
@@ -1605,8 +1284,8 @@ export {};`;
 }
 
 // packages/elysia/src/routes/image.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join3 } from "node:path";
 function registerImageRoutes(app, options) {
   const {
     clientDir,
@@ -1654,13 +1333,13 @@ function registerImageRoutes(app, options) {
         imagePath = url;
       } else {
         const cleanUrl = url.startsWith("/") ? url.slice(1) : url;
-        imagePath = join4(clientDir, cleanUrl);
-        const normalizedPath = join4(clientDir, cleanUrl);
+        imagePath = join3(clientDir, cleanUrl);
+        const normalizedPath = join3(clientDir, cleanUrl);
         if (!normalizedPath.startsWith(clientDir)) {
           set.status = 403;
           return { error: "Access denied" };
         }
-        if (!existsSync3(imagePath)) {
+        if (!existsSync2(imagePath)) {
           set.status = 404;
           return { error: "Image not found" };
         }
@@ -1703,7 +1382,7 @@ function registerSSRRoutes(app, options) {
     rootComponent,
     clientDir,
     cwd,
-    isWatchMode: isWatchMode2,
+    isWatchMode,
     getBundleUrl,
     head = "",
     lang = "en",
@@ -1716,12 +1395,18 @@ function registerSSRRoutes(app, options) {
     dataCache,
     shouldIgnorePathname
   } = options;
-  const SSR_HTML_TTL_MS = isWatchMode2 ? 0 : 5 * 60 * 1000;
+  const SSR_HTML_TTL_MS = 5 * 60 * 1000;
   const htmlCache = new LRUCache(200);
   const makeKey = (pathname, acceptEncoding) => `${pathname}::${acceptEncoding || "identity"}`;
   for (const collection of collections) {
     app.get(`/${collection}/*`, async ({ request, headers }) => {
       const method = request.method || "GET";
+      if (method === "HEAD") {
+        return new Response(null, {
+          status: 200,
+          headers: { "content-type": "text/html; charset=utf-8" }
+        });
+      }
       if (method !== "GET")
         throw new NotFoundError4;
       const accept = request.headers.get?.("accept") || "";
@@ -1731,7 +1416,7 @@ function registerSSRRoutes(app, options) {
         const url = new URL(request.url);
         const pathname = url.pathname;
         const acceptEncoding = headers["accept-encoding"] || "";
-        if (SSR_HTML_TTL_MS > 0) {
+        if (!isWatchMode && SSR_HTML_TTL_MS > 0) {
           try {
             const ck = makeKey(pathname, acceptEncoding);
             const cached = htmlCache.get(ck);
@@ -1745,23 +1430,19 @@ function registerSSRRoutes(app, options) {
         }
         const bundleUrl = await getBundleUrl();
         try {
-          const deps = getStaticDepsForUrl(bundleUrl);
-          const all = [bundleUrl, ...deps];
-          if (all.length) {
-            const linkValue = all.map((u) => `<${u}>; rel=modulepreload; as=script`).join(", ");
-            try {
-              const hints = new Headers({ Link: linkValue });
-              request?.sendEarlyHints?.(hints);
-            } catch {}
-            headers.link = headers.link ? `${headers.link}, ${linkValue}` : linkValue;
-          }
+          const linkValue = `<${bundleUrl}>; rel=modulepreload; as=script`;
+          try {
+            const hints = new Headers({ Link: linkValue });
+            request?.sendEarlyHints?.(hints);
+          } catch {}
+          headers.link = headers.link ? `${headers.link}, ${linkValue}` : linkValue;
         } catch {}
         const result = await renderSSRDocument({
           pathname,
           rootComponent,
           clientDir,
           cwd,
-          isWatchMode: isWatchMode2,
+          isWatchMode,
           bundleUrl,
           head,
           lang,
@@ -1769,9 +1450,10 @@ function registerSSRRoutes(app, options) {
           minify
         });
         const { body, extraHeaders } = gzipIfAccepted(result.html, "text/html; charset=utf-8", acceptEncoding);
+        const cacheControlHeader = isWatchMode ? "no-cache, no-store, must-revalidate" : `${directive}, max-age=${maxAge}`;
         const resHeaders = {
           "content-type": "text/html; charset=utf-8",
-          "cache-control": isWatchMode2 ? "no-cache" : `${directive}, max-age=${maxAge}`,
+          "cache-control": cacheControlHeader,
           ...headers.link ? { link: headers.link } : {},
           ...extraHeaders
         };
@@ -1779,7 +1461,7 @@ function registerSSRRoutes(app, options) {
           status: result.status,
           headers: resHeaders
         });
-        if (SSR_HTML_TTL_MS > 0 && result.status === 200) {
+        if (!isWatchMode && SSR_HTML_TTL_MS > 0 && result.status === 200) {
           try {
             const ck = makeKey(pathname, acceptEncoding);
             htmlCache.set(ck, {
@@ -1813,13 +1495,13 @@ function registerSSRRoutes(app, options) {
       if (pathname === "/__reroute_data" && method === "GET") {
         try {
           const p = url.searchParams.get("path") || "/";
-          let data2 = isWatchMode2 ? undefined : dataCache?.get(p);
+          let data2 = dataCache?.get(p);
           if (data2 === undefined) {
             data2 = await computeSSRDataForPath({
               pathname: p,
               clientDir,
               cwd,
-              isWatchMode: isWatchMode2
+              isWatchMode
             });
             dataCache?.set(p, data2);
           }
@@ -1828,13 +1510,15 @@ function registerSSRRoutes(app, options) {
           return jsonError("failed", 500);
         }
       }
-      if (method === "GET" && !isInternal) {
+      if ((method === "GET" || method === "HEAD") && !isInternal) {
+        if (method === "HEAD") {
+          set.status = 200;
+          set.headers["content-type"] = "text/html; charset=utf-8";
+          return new Response(null);
+        }
         try {
-          if (isWatchMode2) {
-            await generateContentRegistry(cwd);
-          }
           const acceptEncoding = request.headers.get("accept-encoding") || "";
-          if (SSR_HTML_TTL_MS > 0) {
+          if (!isWatchMode && SSR_HTML_TTL_MS > 0) {
             try {
               const ck = makeKey(pathname, acceptEncoding);
               const cached = htmlCache.get(ck);
@@ -1847,23 +1531,19 @@ function registerSSRRoutes(app, options) {
           }
           const bundleUrl = await getBundleUrl();
           try {
-            const deps = getStaticDepsForUrl(bundleUrl);
-            const all = [bundleUrl, ...deps];
-            if (all.length) {
-              const linkValue = all.map((u) => `<${u}>; rel=modulepreload; as=script`).join(", ");
-              try {
-                const hints = new Headers({ Link: linkValue });
-                request?.sendEarlyHints?.(hints);
-              } catch {}
-              set.headers.link = set.headers.link ? `${set.headers.link}, ${linkValue}` : linkValue;
-            }
+            const linkValue = `<${bundleUrl}>; rel=modulepreload; as=script`;
+            try {
+              const hints = new Headers({ Link: linkValue });
+              request?.sendEarlyHints?.(hints);
+            } catch {}
+            set.headers.link = set.headers.link ? `${set.headers.link}, ${linkValue}` : linkValue;
           } catch {}
           const result = await renderSSRDocument({
             pathname,
             rootComponent,
             clientDir,
             cwd,
-            isWatchMode: isWatchMode2,
+            isWatchMode,
             bundleUrl,
             head,
             lang,
@@ -1873,7 +1553,7 @@ function registerSSRRoutes(app, options) {
           const { body, extraHeaders } = gzipIfAccepted(result.html, "text/html; charset=utf-8", acceptEncoding);
           set.status = result.status;
           set.headers["content-type"] = "text/html; charset=utf-8";
-          set.headers["cache-control"] = isWatchMode2 ? "no-cache" : `${directive}, max-age=${maxAge}`;
+          set.headers["cache-control"] = isWatchMode ? "no-cache, no-store, must-revalidate" : `${directive}, max-age=${maxAge}`;
           if (extraHeaders["Content-Encoding"]) {
             set.headers["content-encoding"] = extraHeaders["Content-Encoding"];
           }
@@ -1881,7 +1561,7 @@ function registerSSRRoutes(app, options) {
             set.headers.vary = extraHeaders.Vary;
           }
           const response = new Response(body);
-          if (SSR_HTML_TTL_MS > 0 && result.status === 200) {
+          if (!isWatchMode && SSR_HTML_TTL_MS > 0 && result.status === 200) {
             try {
               const ck = makeKey(pathname, acceptEncoding);
               htmlCache.set(ck, {
@@ -1910,220 +1590,52 @@ function registerStaticRoutes(app, options) {
     directive,
     indexHTML,
     staticHeaders,
-    minify,
-    sourcemap,
     shouldIgnore,
-    bundleCache,
     fileCache,
-    isWatchMode: isWatchMode2
+    isWatchMode = false
   } = options;
   app.get(`${prefix}/*`, async ({ params, headers }) => {
     const requestPath = params["*"];
-    const hashedJsMatch = requestPath.match(/^(.+)\.([a-f0-9]{8})\.js$/);
-    if (hashedJsMatch) {
+    const filePath = join(clientDir, requestPath);
+    try {
       const acceptEncoding = headers["accept-encoding"] || "";
-      const cacheKey = `${requestPath}:${acceptEncoding}`;
+      const encoding = getEncoding(acceptEncoding);
+      const cacheKey = `${filePath}:${encoding}`;
       const cached = fileCache.get(cacheKey);
-      if (cached) {
+      if (cached)
         return cached.clone();
-      }
-      const [, filename, hash2] = hashedJsMatch;
-      const tsxPath = join2(clientDir, `${filename}.tsx`);
-      const tsPath = join2(clientDir, `${filename}.ts`);
-      let filePath2 = null;
-      if (await Bun.file(tsxPath).exists()) {
-        filePath2 = tsxPath;
-      } else if (await Bun.file(tsPath).exists()) {
-        filePath2 = tsPath;
-      }
-      if (filePath2) {
-        try {
-          const bundleInfo = await transpileFile(filePath2, `${filename}.tsx`, { minify, sourcemap }, bundleCache);
-          if (bundleInfo.hash === hash2) {
-            const contentType = "application/javascript; charset=utf-8";
-            const { body, extraHeaders } = gzipIfAccepted(bundleInfo.code, contentType, acceptEncoding);
-            try {
-              if (Array.isArray(bundleInfo.chunks) && bundleInfo.chunks.length) {
-                for (const chunk of bundleInfo.chunks) {
-                  const chunkPath = `${prefix}/${chunk.fileName}`.replace(/\/+/g, "/");
-                  const identityResp = new Response(chunk.code, {
-                    headers: {
-                      "Content-Type": contentType,
-                      "Cache-Control": `${directive}, max-age=${365 * 24 * 60 * 60}, immutable`,
-                      ...staticHeaders
-                    }
-                  });
-                  fileCache.set(chunkPath, identityResp);
-                  const enc = headers["accept-encoding"] || "";
-                  const comp = gzipIfAccepted(chunk.code, contentType, enc);
-                  const compressedResp = new Response(comp.body, {
-                    headers: {
-                      "Content-Type": contentType,
-                      "Cache-Control": `${directive}, max-age=${365 * 24 * 60 * 60}, immutable`,
-                      ...comp.extraHeaders,
-                      ...staticHeaders
-                    }
-                  });
-                  fileCache.set(`${chunkPath}:${enc}`, compressedResp);
-                }
-              }
-            } catch {}
-            const response = new Response(body, {
-              headers: {
-                "Content-Type": contentType,
-                "Cache-Control": `${directive}, max-age=${365 * 24 * 60 * 60}, immutable`,
-                ...extraHeaders,
-                ...staticHeaders
-              }
-            });
-            fileCache.set(cacheKey, response.clone());
-            return response;
-          }
-        } catch (error) {
-          console.error(`[reroute] Error serving bundle:`, error);
-        }
-      }
-    }
-    const sourceMapMatch = requestPath.match(/^(.+)\.([a-f0-9]{8})\.js\.map$/);
-    if (sourceMapMatch) {
-      const [, filename, hash2] = sourceMapMatch;
-      const tsxPath = join2(clientDir, `${filename}.tsx`);
-      const tsPath = join2(clientDir, `${filename}.ts`);
-      let filePath2 = null;
-      if (await Bun.file(tsxPath).exists()) {
-        filePath2 = tsxPath;
-      } else if (await Bun.file(tsPath).exists()) {
-        filePath2 = tsPath;
-      }
-      if (filePath2) {
-        try {
-          const bundleInfo = await transpileFile(filePath2, `${filename}.tsx`, { minify, sourcemap }, bundleCache);
-          if (bundleInfo.hash === hash2 && bundleInfo.sourceMap) {
-            const contentType = "application/json; charset=utf-8";
-            const { body, extraHeaders } = gzipIfAccepted(bundleInfo.sourceMap, contentType, headers["accept-encoding"]);
-            return new Response(body, {
-              headers: {
-                "Content-Type": contentType,
-                "Cache-Control": `${directive}, max-age=${365 * 24 * 60 * 60}, immutable`,
-                ...extraHeaders,
-                ...staticHeaders
-              }
-            });
-          }
-        } catch (error) {
-          console.error(`[reroute] Error serving sourcemap:`, error);
-        }
-      }
-    }
-    if (requestPath.endsWith(".js")) {
-      const acceptEncoding = headers["accept-encoding"] || "";
-      const pathWithEnc = `${prefix}/${requestPath}`.replace(/\/+/g, "/");
-      const cachedVariant = fileCache.get(`${pathWithEnc}:${acceptEncoding}`) || fileCache.get(pathWithEnc);
-      if (cachedVariant) {
-        return cachedVariant.clone();
-      }
-    }
-    if (requestPath.endsWith(".tsx") || requestPath.endsWith(".ts")) {
-      try {
-        const m = requestPath.match(/^routes\/([^/]+)\/content\/([^/]+)\.(tsx|ts)$/);
-        if (m) {
-          const collection = m[1];
-          const name = m[2];
-          try {
-            const cwd = process.cwd();
-            const regPath = join2(cwd, ".reroute", "content.ts");
-            const reg = await import((await import("node:url")).pathToFileURL(regPath).href + `?t=${Date.now()}`);
-            const get = reg?.getContentEntry;
-            const entry = typeof get === "function" ? get(collection, name) : undefined;
-            const mod = entry?.module;
-            if (mod?.endsWith(".js")) {
-              return new Response(null, {
-                status: 302,
-                headers: { Location: mod }
-              });
-            }
-          } catch {}
-          try {
-            const chunkDir = join2(process.cwd(), ".reroute", "chunks", collection);
-            const files = await (await import("node:fs/promises")).readdir(chunkDir);
-            const candidates = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
-            if (candidates.length) {
-              let latest = candidates[0];
-              let latestM = 0;
-              const { stat: stat5 } = await import("node:fs/promises");
-              for (const f of candidates) {
-                try {
-                  const s = await stat5(join2(chunkDir, f));
-                  if (s.mtimeMs >= latestM) {
-                    latestM = s.mtimeMs;
-                    latest = f;
-                  }
-                } catch {}
-              }
-              const loc = `/${join2(".reroute", "chunks", collection, latest).replace(/\\+/g, "/")}`;
-              return new Response(null, {
-                status: 302,
-                headers: { Location: loc }
-              });
-            }
-          } catch {}
-        }
-      } catch {}
-      const filePath2 = join2(clientDir, requestPath);
-      if (shouldIgnore(filePath2))
-        throw new NotFoundError5;
-      try {
-        const exists = await Bun.file(filePath2).exists();
-        if (!exists)
-          throw new NotFoundError5;
-        const bundleInfo = await transpileFile(filePath2, requestPath, { minify, sourcemap }, bundleCache);
-        const contentType = "application/javascript; charset=utf-8";
-        const { body, extraHeaders } = gzipIfAccepted(bundleInfo.code, contentType, headers["accept-encoding"]);
-        return new Response(body, {
-          headers: {
-            "Content-Type": contentType,
-            "Cache-Control": isWatchMode2 ? "no-cache" : `${directive}, max-age=${maxAge}`,
-            ...extraHeaders,
-            ...staticHeaders
-          }
-        });
-      } catch (error) {
-        if (error instanceof NotFoundError5)
-          throw error;
-        console.error(`[reroute] Error:`, error);
-        throw new NotFoundError5;
-      }
-    }
-    const filePath = join2(clientDir, requestPath);
-    try {
       let actualFilePath = filePath;
       let exists = await Bun.file(actualFilePath).exists();
       if (!exists && indexHTML) {
-        actualFilePath = join2(filePath, "index.html");
+        actualFilePath = join(filePath, "index.html");
         exists = await Bun.file(actualFilePath).exists();
       }
       if (!exists)
         throw new NotFoundError5;
       if (shouldIgnore(actualFilePath))
         throw new NotFoundError5;
-      const cached = fileCache.get(filePath);
-      if (cached)
-        return cached.clone();
       const contentBuf = await Bun.file(actualFilePath).arrayBuffer();
       const content2 = new Uint8Array(contentBuf);
       const contentType = getMimeType(actualFilePath);
       const { body, extraHeaders } = gzipIfAccepted(content2, contentType, headers["accept-encoding"]);
-      const isLongLivedAsset = contentType.startsWith("image/") || contentType.startsWith("font/") || contentType.includes("woff") || contentType.includes("ttf") || contentType.includes("otf");
-      const cacheMaxAge = maxAge === 0 ? 0 : isLongLivedAsset ? 31536000 : maxAge;
+      let cacheControl;
+      if (isWatchMode) {
+        const isSourceFile = /\.(tsx?|jsx?|css)$/i.test(actualFilePath);
+        cacheControl = isSourceFile ? "no-cache, no-store, must-revalidate" : `${directive}, max-age=${maxAge}`;
+      } else {
+        const isLongLivedAsset = contentType.startsWith("image/") || contentType.startsWith("font/") || contentType.includes("woff") || contentType.includes("ttf") || contentType.includes("otf");
+        const cacheMaxAge = maxAge === 0 ? 0 : isLongLivedAsset ? 365 * 24 * 60 * 60 : maxAge;
+        cacheControl = cacheMaxAge > 0 ? `${directive}, max-age=${cacheMaxAge}${isLongLivedAsset ? ", immutable" : ""}` : "no-cache";
+      }
       const response = new Response(body, {
         headers: {
           "Content-Type": contentType,
-          "Cache-Control": cacheMaxAge > 0 ? `${directive}, max-age=${cacheMaxAge}${isLongLivedAsset ? ", immutable" : ""}` : "no-cache",
+          "Cache-Control": cacheControl,
           ...extraHeaders,
           ...staticHeaders
         }
       });
-      fileCache.set(filePath, response);
+      fileCache.set(cacheKey, response);
       return response.clone();
     } catch (error) {
       if (error instanceof NotFoundError5)
@@ -2140,7 +1652,6 @@ var reroute = (options = {}) => async (app) => {
   const ssrHead = options.head || "";
   const ssrLang = options.lang || "en";
   const ssrAppId = options.appId || "root";
-  const entrypoint = options.entrypoint || "index.tsx";
   const rootComponent = options.app;
   const assets = options.assets || "src/client";
   let prefix = options.prefix || "/";
@@ -2157,16 +1668,16 @@ var reroute = (options = {}) => async (app) => {
   const directive = options.directive || "public";
   const indexHTML = options.indexHTML ?? true;
   const minify = options.minify ?? true;
-  const sourcemap = options.sourcemap ?? true;
   const imageMaxAge = options.imageMaxAge ?? 31536000;
   const imageAllowedDomains = options.imageAllowedDomains || [];
   const imageMaxWidth = options.imageMaxWidth ?? 3840;
   const imageMaxHeight = options.imageMaxHeight ?? 2160;
+  const bundleMaxAge = options.bundleMaxAge ?? 3600;
   if (prefix === "/")
     prefix = "";
   const fileCache = new LRUCache(100);
   const dataCache = new LRUCache(100);
-  const bundleCache = new Map;
+  const collectionCache = new LRUCache(50);
   const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : "/";
   const liveReloadClients = new Set;
   const notifyReload = () => {
@@ -2184,20 +1695,41 @@ var reroute = (options = {}) => async (app) => {
   };
   const clientDir = assets.startsWith("/") ? assets : `${cwd.replace(/\/$/, "")}/${assets.replace(/^\.\//, "")}`;
   const shouldIgnore = !ignorePatterns.length ? () => false : (file) => ignorePatterns.find((pattern) => typeof pattern === "string" ? file.includes(pattern) : pattern.test(file));
-  const isWatchMode2 = Array.isArray(process.execArgv) && process.execArgv.includes("--watch") || Array.isArray(process.argv) && process.argv.includes("--watch");
+  const isWatchMode = Array.isArray(process.execArgv) && process.execArgv.includes("--watch") || Array.isArray(process.argv) && process.argv.includes("--watch");
   const dataCacheControl = `${directive}, max-age=${maxAge}`;
-  if (isWatchMode2)
+  if (isWatchMode)
     console.log(`[reroute] Live reload enabled`);
-  await generateContentRegistry(cwd);
-  let cachedBundleUrlPromise = null;
-  const ensureBundleUrl = () => {
-    if (!cachedBundleUrlPromise) {
-      cachedBundleUrlPromise = getBundleUrlsFor(entrypoint, clientDir, prefix, { minify, sourcemap }, bundleCache).then((u) => u[0]);
-    }
-    return cachedBundleUrlPromise;
+  const readBundleUrl = async () => {
+    const bundlesDir = `${cwd}/.reroute/bundles`;
+    try {
+      const glob = new Bun.Glob("index.*.js");
+      const files = await Array.fromAsync(glob.scan(bundlesDir));
+      const indexFile = files.find((f) => !f.includes(".stub.")) || files[0];
+      if (indexFile) {
+        return `/bundles/${indexFile}`;
+      } else {
+        throw new Error("Bundle not found. Run `reroute gen` first.");
+      }
+    } catch {}
+    throw new Error("Bundle not found. Run `reroute gen` first.");
   };
-  registerContentRoutes(app, clientDir, prefix, isWatchMode2);
-  registerDevRoutes(app, liveReloadClients, isWatchMode2, {
+  const initialBundleUrl = await readBundleUrl();
+  console.log(`[reroute] Using pre-built bundle: ${initialBundleUrl}`);
+  app.onError(({ request, set, error }) => {
+    if ("status" in error && error.status === 404) {
+      set.status = 404;
+      return;
+    }
+    if (request.method === "HEAD") {
+      console.log("[reroute] HEAD request received");
+      set.status = 200;
+      set.headers["Content-Type"] = "text/plain";
+      return "";
+    }
+    console.error("[reroute] \uD83D\uDEA8 Server error:", error);
+  });
+  registerContentRoutes(app, cwd, collectionCache, directive, maxAge, isWatchMode);
+  registerDevRoutes(app, liveReloadClients, isWatchMode, {
     clientDir,
     cwd,
     dataCacheControl,
@@ -2213,13 +1745,13 @@ var reroute = (options = {}) => async (app) => {
       pathname = String(p);
     }
     try {
-      let data2 = isWatchMode2 ? undefined : dataCache.get(pathname);
+      let data2 = dataCache.get(pathname);
       if (data2 === undefined) {
         data2 = await computeSSRDataForPath({
           pathname,
           clientDir,
           cwd,
-          isWatchMode: isWatchMode2
+          isWatchMode
         });
         dataCache.set(pathname, data2);
       }
@@ -2228,23 +1760,21 @@ var reroute = (options = {}) => async (app) => {
       return jsonError("failed", 500);
     }
   });
-  if (isWatchMode2) {
+  if (isWatchMode) {
     app.post("/__reroute_reload", () => {
-      try {
-        dataCache.clear();
-        notifyReload();
-        return new Response(JSON.stringify({ ok: true }), {
-          headers: { "content-type": "application/json" }
-        });
-      } catch {
-        return new Response(JSON.stringify({ ok: false }), {
-          status: 500,
-          headers: { "content-type": "application/json" }
-        });
-      }
+      fileCache.clear();
+      dataCache.clear();
+      notifyReload();
+      return new Response(JSON.stringify({ ok: true }), {
+        headers: { "content-type": "application/json" }
+      });
     });
   }
-  registerArtifactsRoutes(app, cwd);
+  registerArtifactsRoutes(app, cwd, fileCache, {
+    bundleMaxAge,
+    directive,
+    isWatchMode
+  });
   const imageCacheDir = `${cwd}/.reroute/image-cache`;
   initImageCache(imageCacheDir);
   registerImageRoutes(app, {
@@ -2264,8 +1794,8 @@ var reroute = (options = {}) => async (app) => {
         rootComponent,
         clientDir,
         cwd,
-        isWatchMode: isWatchMode2,
-        getBundleUrl: ensureBundleUrl,
+        isWatchMode,
+        getBundleUrl: readBundleUrl,
         head: ssrHead,
         lang: ssrLang,
         appId: ssrAppId,
@@ -2293,12 +1823,9 @@ var reroute = (options = {}) => async (app) => {
     directive,
     indexHTML,
     staticHeaders,
-    minify,
-    sourcemap,
     shouldIgnore,
-    bundleCache,
     fileCache,
-    isWatchMode: isWatchMode2
+    isWatchMode
   });
   return app;
 };
@@ -2306,4 +1833,4 @@ export {
   reroute
 };
 
-//# debugId=76563F260B520FB764756E2164756E21
+//# debugId=AD268A47B9D4009364756E2164756E21