reroute-js 0.0.1

package/elysia/index.js

@@ -0,0 +1,1829 @@
+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/utils/path.ts
+var exports_path = {};
+__export(exports_path, {
+  stripStart: () => stripStart,
+  stripEnd: () => stripEnd,
+  join: () => join,
+  extname: () => extname,
+  basename: () => basename
+});
+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/elysia/src/plugin.ts
+import { watch as fsWatch } from "node:fs";
+
+// 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/core/src/bundler/transpile.ts
+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)" : ""}...`);
+  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 {
+    result = await doBuild(options.sourcemap ? "external" : "none");
+    if (!result.success) {
+      console.warn(`[reroute] Build failed for ${originalPath}, retrying without sourcemap...`);
+      result = await doBuild("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 log of result.logs)
+      console.error(log);
+    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 getBundleUrlsFor(modules, clientDir, prefix, options, bundleCache) {
+  const mods = Array.isArray(modules) ? modules : [modules];
+  const urls = [];
+  const { join: join2 } = await Promise.resolve().then(() => exports_path);
+  for (const mod of mods) {
+    const rel = mod.replace(/^\.\//, "");
+    const fullPath = join2(clientDir, rel);
+    try {
+      const bundleInfo = await transpileFile(fullPath, rel, options, bundleCache);
+      const base = basename(rel, extname(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;
+}
+// packages/core/src/content/builder.ts
+import { mkdir, readdir } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+async function sha8(text) {
+  const data = new TextEncoder().encode(text);
+  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);
+}
+async function buildChunkFor(absSrc, cwd, collection, name) {
+  try {
+    const result = await Bun.build({
+      entrypoints: [absSrc],
+      target: "browser",
+      format: "esm",
+      splitting: false,
+      sourcemap: "none",
+      minify: false,
+      define: { "process.env.NODE_ENV": '"production"' }
+    });
+    if (!result.success)
+      return null;
+    const code = await result.outputs[0]?.text();
+    const hash2 = await sha8(code);
+    const relDir = join(".reroute", "chunks", collection);
+    const absDir = join(cwd, relDir);
+    const outFile = `${name}.${hash2}.js`;
+    const outPath = join(absDir, outFile);
+    await mkdir(absDir, { recursive: true });
+    const exists = await Bun.file(outPath).exists();
+    if (!exists)
+      await Bun.write(outPath, code);
+    const url = `/${join(relDir, outFile).replace(/\\+/g, "/")}`;
+    return { outPath, url, code };
+  } catch (e) {
+    console.error("[reroute] Failed to build content chunk:", absSrc, e);
+    return null;
+  }
+}
+async function getMetaFor(absSrc, isWatchMode) {
+  try {
+    const url = pathToFileURL(absSrc).href + (isWatchMode ? `?t=${Date.now()}` : "");
+    const m = await import(url);
+    return m.meta || m.frontmatter || {};
+  } catch {
+    return {};
+  }
+}
+async function rebuildContentArtifacts(cwd, clientDir, isWatchMode = true) {
+  const routesRoot = join(clientDir, "routes");
+  const items = [];
+  try {
+    const entries = await readdir(routesRoot, { withFileTypes: true });
+    for (const dir of entries) {
+      if (!dir.isDirectory())
+        continue;
+      const collection = dir.name;
+      const contentDir = join(routesRoot, collection, "content");
+      let contentFiles = [];
+      try {
+        const list = await readdir(contentDir, { withFileTypes: true });
+        contentFiles = list.filter((e) => e.isFile() && /\.(tsx|ts)$/.test(e.name) && !e.name.startsWith("_")).map((e) => e.name);
+      } catch {
+        continue;
+      }
+      for (const file of contentFiles) {
+        const name = file.replace(/\.(tsx|ts)$/, "");
+        const absSrc = join(contentDir, file);
+        const chunk = await buildChunkFor(absSrc, cwd, collection, name);
+        if (!chunk)
+          continue;
+        const meta = await getMetaFor(absSrc, isWatchMode);
+        items.push({
+          collection,
+          name,
+          slug: name,
+          href: `/${collection}/${name}`,
+          moduleUrl: chunk.url,
+          meta
+        });
+      }
+    }
+  } catch (e) {
+    console.error("[reroute] Failed to scan content routes:", e);
+    return;
+  }
+  try {
+    const lines = [];
+    lines.push("// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8");
+    lines.push("/* eslint-disable */");
+    lines.push("// @ts-nocheck");
+    lines.push("");
+    lines.push("export const contents = [");
+    for (const e of items) {
+      lines.push("  { collection: '" + e.collection + "', slug: '" + e.slug + "', name: '" + e.name + "', href: '" + e.href + "', module: '" + e.moduleUrl + "', meta: " + JSON.stringify(e.meta || {}) + " },");
+    }
+    lines.push("] as const;");
+    lines.push("");
+    lines.push("export const byCollection: Record<string, any[]> = {};");
+    lines.push("for (const c of contents) { (byCollection[c.collection] ||= []).push(c as any); }");
+    lines.push("");
+    lines.push("export const byCollectionAndName: Record<string, Record<string, any>> = {};");
+    lines.push("for (const c of contents) { ((byCollectionAndName[c.collection] ||= {})[c.name] = c as any); }");
+    lines.push("");
+    lines.push("export type Collections = keyof typeof byCollection;");
+    lines.push("export type Names<C extends Collections> = keyof (typeof byCollectionAndName)[C];");
+    lines.push("export type ContentEntry = (typeof contents)[number];");
+    lines.push("");
+    lines.push("export function getContentEntry<C extends string, N extends string>(collection: C, name: N) {");
+    lines.push("  const m = (byCollectionAndName as any)[collection];");
+    lines.push("  return m ? (m as Record<string, any>)[name] : undefined;");
+    lines.push("}");
+    lines.push("");
+    await mkdir(join(cwd, ".reroute"), { recursive: true });
+    await Bun.write(join(cwd, ".reroute", "content.ts"), lines.join(`
+`));
+  } catch (e) {
+    console.error("[reroute] Failed to write .reroute/content.ts:", e);
+  }
+  try {
+    const byCol = new Map;
+    for (const it of items) {
+      const arr = byCol.get(it.collection) || [];
+      arr.push(it);
+      byCol.set(it.collection, arr);
+    }
+    await mkdir(join(cwd, ".reroute", "collections"), { recursive: true });
+    for (const [collection, list] of byCol) {
+      const js = [];
+      js.push("// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8");
+      js.push("");
+      js.push("export const items = [");
+      for (const e of list) {
+        js.push(`  { collection: '${e.collection}', slug: '${e.slug}', name: '${e.name}', href: '${e.href}', module: '${e.moduleUrl}', meta: ${JSON.stringify(e.meta || {})} },`);
+      }
+      js.push("];");
+      js.push("");
+      js.push("export const byName = {};");
+      js.push("for (const it of items) { byName[it.name] = it; }");
+      js.push("");
+      js.push("export function get(collectionName, name) {");
+      js.push(`  if (collectionName !== '${collection}') return undefined;`);
+      js.push("  return byName[name];");
+      js.push("}");
+      js.push("");
+      await Bun.write(join(cwd, ".reroute", "collections", `${collection}.js`), js.join(`
+`));
+    }
+  } catch (e) {
+    console.error("[reroute] Failed to write .reroute/collections/*:", e);
+  }
+  console.log("[reroute] Content artifacts up-to-date");
+}
+// packages/core/src/content/discovery.ts
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
+
+// packages/core/src/content/metadata.ts
+import { stat } from "node:fs/promises";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+async function getContentMeta(absPath, isWatchMode) {
+  try {
+    const url = pathToFileURL2(absPath).href;
+    const mod = await import(`${url}${isWatchMode ? `?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;");
+}
+
+// packages/core/src/content/discovery.ts
+async function listContentFiles(dir, baseRel) {
+  const out = [];
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      const rel = join(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, isWatchMode) {
+  const normalized = stripStart(stripEnd(collectionPath, "/"), "/");
+  const contentRelDir = join("routes", normalized, "content");
+  const contentAbsDir = join(clientDir, contentRelDir);
+  const files = await listContentFiles(contentAbsDir, "");
+  const items = [];
+  for (const rel of files) {
+    const fullRelPath = join(contentRelDir, rel);
+    const absPath = join(clientDir, fullRelPath);
+    const noExt = rel.replace(/\.(tsx|ts)$/, "");
+    const name = basename(noExt);
+    const moduleUrl = `${prefix}/${fullRelPath}`.replace(/\/+/g, "/");
+    const meta = await getContentMeta(absPath, isWatchMode);
+    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 = join(clientDir, "routes");
+  const collections = new Set;
+  try {
+    const entries = await readdir2(root, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const contentDir = join(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 = join(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 pathToFileURL4 } from "node:url";
+
+// packages/core/src/ssr/modules.ts
+import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode) {
+  try {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts.length < 2)
+      return null;
+    const collection = parts[0];
+    const name = parts[1];
+    try {
+      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;
+      if (moduleUrl?.endsWith(".js")) {
+        const abs = join(cwd, moduleUrl.replace(/^\//, ""));
+        const href = pathToFileURL3(abs).href + (isWatchMode ? `?t=${Date.now()}` : "");
+        const mod = await import(href);
+        return mod;
+      }
+    } catch {}
+    try {
+      const chunkDir = join(cwd, ".reroute", "chunks", collection);
+      const files = await readdir3(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(join(chunkDir, f));
+            if (s.mtimeMs >= latestM) {
+              latestM = s.mtimeMs;
+              latest = f;
+            }
+          } catch {}
+        }
+        const absChunk = join(chunkDir, latest);
+        const href = pathToFileURL3(absChunk).href + (isWatchMode ? `?t=${Date.now()}` : "");
+        const mod = await import(href);
+        return mod;
+      }
+    } catch {}
+    try {
+      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 = pathToFileURL3(absSrc).href;
+        const mod = await (isWatchMode ? import(`${href}?t=${Date.now()}`) : import(href));
+        return mod;
+      }
+    } catch {}
+  } catch {}
+  return null;
+}
+
+// packages/core/src/ssr/seed.ts
+async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode) {
+  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, isWatchMode);
+    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 {}
+}
+
+// packages/core/src/ssr/data.ts
+async function computeSSRDataForPath(params) {
+  const { pathname, clientDir, cwd, isWatchMode } = params;
+  try {
+    await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode);
+  } 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 = join(cwd, ".reroute", "routes.ts");
+    const m = await import(pathToFileURL4(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 = join(clientDir, "routes", String(r.path));
+        const mod = await import(pathToFileURL4(abs).href + (isWatchMode ? `?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;
+}
+// packages/core/src/ssr/render.ts
+import { readdir as readdir4, stat as stat4 } from "node:fs/promises";
+import { pathToFileURL as pathToFileURL5 } from "node:url";
+
+// 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);
+}
+var dedent = createDedent({});
+var dedent_default = dedent;
+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;
+}
+
+// packages/core/src/ssr/render.ts
+import { cloneElement } from "react";
+import { renderToString } from "react-dom/server";
+
+// packages/core/src/template/html.ts
+async function loadIndexHtml(clientDir) {
+  const templatePath = join(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;
+}
+// packages/core/src/ssr/render.ts
+async function renderSSRDocument(options) {
+  const {
+    pathname,
+    rootComponent,
+    clientDir,
+    cwd,
+    isWatchMode,
+    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 = join(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 = join(cwd, ".reroute", "content.ts");
+        const reg = await import(pathToFileURL5(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")) {
+          modulePath = moduleUrl;
+        }
+      } catch {}
+      if (!modulePath) {
+        try {
+          const chunkDir = join(cwd, ".reroute", "chunks", collection);
+          const files = await readdir4(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(join(chunkDir, candidateName));
+                if (s.mtimeMs >= latestM) {
+                  latestM = s.mtimeMs;
+                  latest = candidateName;
+                }
+              } catch {}
+            }
+            modulePath = `/${join(".reroute", "chunks", collection, latest).replace(/\\+/g, "/")}`;
+          }
+        } catch {}
+      }
+      if (!modulePath) {
+        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 = `/${join("routes", collection, "content", `${name}.tsx`).replace(/\\+/g, "/")}`;
+        } else if (await Bun.file(ts).exists()) {
+          srcUrl = `/${join("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, isWatchMode);
+  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 = join(cwd, ".reroute", "routes.ts");
+      const m = await import(pathToFileURL5(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 = join(clientDir, "routes", String(r.path));
+          const mod = await import(pathToFileURL5(abs).href + (isWatchMode ? `?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 = join(cwd, ".reroute", "content.ts");
+    const mod = await import(pathToFileURL5(p).href + (isWatchMode ? `?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 = [
+      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) {
+      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 (isWatchMode) {
+    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 = join(cwd, ".reroute", "routes.ts");
+    const m = await import(pathToFileURL5(routesPath).href + (isWatchMode ? `?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 = join(clientDir, "routes", String(r.path));
+        const mod = await import(pathToFileURL5(abs).href + (isWatchMode ? `?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 = join(clientDir, "routes", String(chosen.path));
+              const mod = await import(pathToFileURL5(abs).href + (isWatchMode ? `?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
+  };
+}
+// 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;
+  }
+}
+// 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 };
+}
+// 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)
+      throw new NotFoundError;
+    const abs = join(cwd, ".reroute", sub);
+    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
+        }
+      });
+    } catch (e) {
+      if (e instanceof NotFoundError)
+        throw e;
+      console.error("[reroute] Failed to serve .reroute file:", abs, e);
+      throw new NotFoundError;
+    }
+  });
+  return app;
+}
+
+// packages/elysia/src/routes/content.ts
+import { NotFoundError as NotFoundError2 } from "elysia";
+function registerContentRoutes(app, clientDir, prefix, isWatchMode) {
+  app.get("/__content/*", async ({ params, set }) => {
+    const collectionPath = String(params["*"] || "").trim();
+    if (!collectionPath)
+      throw new NotFoundError2;
+    const items = await buildContentDTOs(collectionPath, clientDir, prefix, isWatchMode);
+    const body = JSON.stringify({ collection: collectionPath, items });
+    set.status = 200;
+    set.headers["content-type"] = "application/json; charset=utf-8";
+    return new Response(body);
+  });
+  return app;
+}
+
+// packages/elysia/src/routes/dev.ts
+import { NotFoundError as NotFoundError3 } from "elysia";
+
+// packages/elysia/src/utils/http.ts
+var makeETag = (s) => {
+  try {
+    const h = globalThis?.Bun?.hash?.(s) ?? 0;
+    return `W/"${s.length.toString(16)}-${Number(h).toString(36)}"`;
+  } catch {
+    return `W/"${s.length.toString(16)}-0"`;
+  }
+};
+var getIfNoneMatch = (headers) => {
+  try {
+    if (!headers)
+      return;
+    const h = headers;
+    if (typeof h?.get === "function")
+      return String(h.get("if-none-match") || "");
+    return String(h["if-none-match"] || h["If-None-Match"] || "");
+  } catch {
+    return;
+  }
+};
+function jsonWithCache(payload, cacheControl, reqHeaders) {
+  const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const etag = makeETag(body);
+  const inm = getIfNoneMatch(reqHeaders) || "";
+  if (etag && inm && inm === etag) {
+    return new Response(null, {
+      status: 304,
+      headers: {
+        ETag: etag,
+        "Cache-Control": cacheControl
+      }
+    });
+  }
+  return new Response(body, {
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+      "Cache-Control": cacheControl,
+      ETag: etag
+    }
+  });
+}
+function jsonError(message, status = 500) {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: { "Content-Type": "application/json; charset=utf-8" }
+  });
+}
+
+// packages/elysia/src/routes/dev.ts
+function registerDevRoutes(app, liveReloadClients, isWatchMode, opts) {
+  app.get("/__reroute_preload", async ({ query }) => {
+    const rawSrc = String(query.src || "").trim();
+    const key = String(query.key || "").trim();
+    let src2 = rawSrc;
+    try {
+      src2 = decodeURIComponent(rawSrc);
+    } catch {}
+    const safeChunk = src2.startsWith("/.reroute/chunks/") && /^[A-Za-z0-9_./-]+\.js$/.test(src2);
+    const safeSource = src2.startsWith("/routes/") && /^[A-Za-z0-9_./\-[\]]+\.(tsx?|js)$/.test(src2);
+    const safe = (safeChunk || safeSource) && !src2.includes("..");
+    if (!safe || !key)
+      throw new NotFoundError3;
+    const code = `// preload for ${key}
+` + `import * as __m from '${src2}';
+` + `const __C = __m.default || __m;
+` + `(globalThis.__REROUTE_MODULES__ ||= {});
+` + `globalThis.__REROUTE_MODULES__['${key}'] = __C;
+` + `export {};`;
+    return new Response(code, {
+      headers: {
+        "content-type": "application/javascript; charset=utf-8",
+        "cache-control": isWatchMode ? "no-cache" : "public, max-age=31536000, immutable"
+      }
+    });
+  });
+  app.get("/__reroute_data", async ({ query, headers }) => {
+    const p = String(query.path || query.p || "/");
+    let pathname = "/";
+    try {
+      const u = new URL(p, "http://localhost");
+      pathname = u.pathname + u.search;
+    } catch {
+      pathname = String(p);
+    }
+    try {
+      const data2 = await computeSSRDataForPath({
+        pathname,
+        clientDir: opts?.clientDir || "",
+        cwd: opts?.cwd || "",
+        isWatchMode
+      });
+      return jsonWithCache({ data: data2 }, opts?.dataCacheControl || "no-cache", headers);
+    } catch (_e) {
+      return jsonError("failed", 500);
+    }
+  });
+  if (!isWatchMode)
+    return app;
+  console.log("[reroute] Registering SSE endpoint at /__reroute_watch");
+  app.get("/__reroute_watch", () => {
+    const encoder = new TextEncoder;
+    let interval;
+    const stream = new ReadableStream({
+      start(controller) {
+        liveReloadClients.add(controller);
+        console.log("[reroute] Browser connected for live reload");
+        controller.enqueue(encoder.encode(`retry: 1000
+`));
+        controller.enqueue(encoder.encode(`data: connected
+
+`));
+        interval = setInterval(() => {
+          try {
+            controller.enqueue(encoder.encode(`: ping
+
+`));
+          } catch {}
+        }, 25000);
+      },
+      cancel() {
+        if (interval)
+          clearInterval(interval);
+        console.log("[reroute] Browser disconnected from live reload");
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  });
+  app.get("/__reroute_watch.js", () => {
+    const code = `// live-reload client
+` + `const url='/__reroute_watch';
+` + `let es; let reloading=false;
+` + `function waitServerThenReload(){
+` + `  const ping = () => fetch(location.origin, { cache: 'no-store' })
+` + `    .then(()=>location.reload())
+` + `    .catch(()=>setTimeout(ping, 300));
+` + `  ping();
+` + `}
+` + `function connect(){
+` + `  es=new EventSource(url);
+` + `  es.onopen=()=>console.log('[reroute] watching changes');
+` + `  es.onmessage=(e)=>{ if(e.data==='reload'){ reloading=true; try{ es.close(); }catch{} waitServerThenReload(); } };
+` + `  es.onerror=()=>{ if(!reloading){ reloading=true; try{ es.close(); }catch{} waitServerThenReload(); } };
+` + `}
+` + `connect();
+export {};`;
+    return new Response(code, {
+      headers: {
+        "content-type": "application/javascript; charset=utf-8",
+        "cache-control": "no-cache"
+      }
+    });
+  });
+  return app;
+}
+
+// packages/elysia/src/routes/ssr.ts
+import { NotFoundError as NotFoundError4 } from "elysia";
+function registerSSRRoutes(app, options) {
+  const {
+    rootComponent,
+    clientDir,
+    cwd,
+    isWatchMode,
+    getBundleUrl,
+    head = "",
+    lang = "en",
+    appId = "root",
+    collections,
+    minify = false,
+    dataCacheControl
+  } = options;
+  for (const collection of collections) {
+    app.get(`/${collection}/*`, async ({ request }) => {
+      const method = request.method || "GET";
+      if (method !== "GET")
+        throw new NotFoundError4;
+      const accept = request.headers.get?.("accept") || "";
+      if (!/text\/html/i.test(String(accept)))
+        throw new NotFoundError4;
+      try {
+        const pathname = new URL(request.url).pathname;
+        const bundleUrl = await getBundleUrl();
+        const result = await renderSSRDocument({
+          pathname,
+          rootComponent,
+          clientDir,
+          cwd,
+          isWatchMode,
+          bundleUrl,
+          head,
+          lang,
+          appId,
+          minify
+        });
+        return new Response(result.html, {
+          status: result.status,
+          headers: {
+            "content-type": "text/html; charset=utf-8",
+            Vary: "Accept"
+          }
+        });
+      } catch (e) {
+        console.error(`[reroute] SSR ${collection} render error:`, e);
+        throw new NotFoundError4;
+      }
+    });
+  }
+  app.onError(async ({ code, request, set }) => {
+    if (code === "NOT_FOUND") {
+      const url = new URL(request.url);
+      const pathname = url.pathname;
+      const method = request.method || "GET";
+      const isInternal = pathname.startsWith("/__reroute_watch") || pathname.startsWith("/__content/") || pathname.startsWith("/__reroute_preload") || pathname.startsWith("/__reroute_data") || pathname.startsWith("/__reroute_watch.js");
+      if (pathname === "/__reroute_data" && method === "GET") {
+        try {
+          const p = url.searchParams.get("path") || "/";
+          const data2 = await computeSSRDataForPath({
+            pathname: p,
+            clientDir,
+            cwd,
+            isWatchMode
+          });
+          return jsonWithCache({ data: data2 }, dataCacheControl || "no-cache", request.headers);
+        } catch (_e) {
+          return jsonError("failed", 500);
+        }
+      }
+      if (method === "GET" && !isInternal) {
+        try {
+          if (isWatchMode) {
+            await generateContentRegistry(cwd);
+          }
+          const bundleUrl = await getBundleUrl();
+          const result = await renderSSRDocument({
+            pathname,
+            rootComponent,
+            clientDir,
+            cwd,
+            isWatchMode,
+            bundleUrl,
+            head,
+            lang,
+            appId,
+            minify
+          });
+          set.status = result.status;
+          set.headers["content-type"] = "text/html; charset=utf-8";
+          return new Response(result.html);
+        } catch {}
+      }
+    }
+  });
+  return app;
+}
+
+// packages/elysia/src/routes/static.ts
+import { NotFoundError as NotFoundError5 } from "elysia";
+function registerStaticRoutes(app, options) {
+  const {
+    clientDir,
+    prefix,
+    maxAge,
+    directive,
+    indexHTML,
+    staticHeaders,
+    minify,
+    sourcemap,
+    shouldIgnore,
+    bundleCache,
+    fileCache,
+    isWatchMode
+  } = options;
+  app.get(`${prefix}/*`, async ({ params, headers }) => {
+    const requestPath = params["*"];
+    const hashedJsMatch = requestPath.match(/^(.+)\.([a-f0-9]{8})\.js$/);
+    if (hashedJsMatch) {
+      const [, filename, hash2] = hashedJsMatch;
+      const tsxPath = join(clientDir, `${filename}.tsx`);
+      const tsPath = join(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, 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 bundle:`, error);
+        }
+      }
+    }
+    const sourceMapMatch = requestPath.match(/^(.+)\.([a-f0-9]{8})\.js\.map$/);
+    if (sourceMapMatch) {
+      const [, filename, hash2] = sourceMapMatch;
+      const tsxPath = join(clientDir, `${filename}.tsx`);
+      const tsPath = join(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(".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 = join(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 = join(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(join(chunkDir, f));
+                  if (s.mtimeMs >= latestM) {
+                    latestM = s.mtimeMs;
+                    latest = f;
+                  }
+                } catch {}
+              }
+              const loc = `/${join(".reroute", "chunks", collection, latest).replace(/\\+/g, "/")}`;
+              return new Response(null, {
+                status: 302,
+                headers: { Location: loc }
+              });
+            }
+          } catch {}
+        }
+      } catch {}
+      const filePath2 = join(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": isWatchMode ? "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 = join(clientDir, requestPath);
+    try {
+      let actualFilePath = filePath;
+      let exists = await Bun.file(actualFilePath).exists();
+      if (!exists && indexHTML) {
+        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 response = new Response(body, {
+        headers: {
+          "Content-Type": contentType,
+          "Cache-Control": maxAge ? `${directive}, max-age=${maxAge}` : directive,
+          ...extraHeaders,
+          ...staticHeaders
+        }
+      });
+      fileCache.set(filePath, response);
+      return response.clone();
+    } catch (error) {
+      if (error instanceof NotFoundError5)
+        throw error;
+      console.error(`[reroute] Error serving ${filePath}:`, error);
+      throw new NotFoundError5;
+    }
+  });
+  return app;
+}
+
+// packages/elysia/src/plugin.ts
+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 || "/";
+  const ignorePatterns = options.ignorePatterns || [
+    ".DS_Store",
+    ".git",
+    ".env",
+    "index.html",
+    /favicon\.ico/,
+    /\.well-known/
+  ];
+  const staticHeaders = options.staticHeaders;
+  const maxAge = options.maxAge ?? 3600;
+  const directive = options.directive || "public";
+  const indexHTML = options.indexHTML ?? true;
+  const minify = options.minify ?? false;
+  const sourcemap = options.sourcemap ?? true;
+  if (prefix === "/")
+    prefix = "";
+  const fileCache = new LRUCache(100);
+  const bundleCache = new Map;
+  const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : "/";
+  const liveReloadClients = new Set;
+  const notifyReload = () => {
+    const encoder = new TextEncoder;
+    const message = encoder.encode(`data: reload
+
+`);
+    for (const controller of liveReloadClients) {
+      try {
+        controller.enqueue(message);
+      } catch {
+        liveReloadClients.delete(controller);
+      }
+    }
+  };
+  const clientDir = assets.startsWith("/") ? assets : `${cwd.replace(/\/$/, "")}/${assets.replace(/^\.\//, "")}`;
+  const join2 = (...parts) => parts.join("/").replace(/\/+/g, "/");
+  const shouldIgnore = !ignorePatterns.length ? () => false : (file) => ignorePatterns.find((pattern) => typeof pattern === "string" ? file.includes(pattern) : pattern.test(file));
+  const isWatchMode = process.execArgv[0] === "--watch";
+  const dataCacheControl = `${directive}, max-age=${maxAge}`;
+  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;
+  };
+  registerContentRoutes(app, clientDir, prefix, isWatchMode);
+  registerDevRoutes(app, liveReloadClients, isWatchMode, {
+    clientDir,
+    cwd,
+    dataCacheControl
+  });
+  app.get("/__reroute_data", async ({ query, headers }) => {
+    const p = String(query.path || query.p || "/");
+    let pathname = "/";
+    try {
+      const u = new URL(p, "http://localhost");
+      pathname = u.pathname + u.search;
+    } catch {
+      pathname = String(p);
+    }
+    try {
+      const data2 = await computeSSRDataForPath({
+        pathname,
+        clientDir,
+        cwd,
+        isWatchMode
+      });
+      return jsonWithCache({ data: data2 }, dataCacheControl, headers);
+    } catch (_e) {
+      return jsonError("failed", 500);
+    }
+  });
+  if (isWatchMode) {
+    try {
+      let debounce;
+      const schedule = () => {
+        clearTimeout(debounce);
+        debounce = setTimeout(async () => {
+          try {
+            bundleCache.clear();
+            cachedBundleUrlPromise = null;
+            await rebuildContentArtifacts(cwd, clientDir, true);
+            notifyReload();
+            console.log("[reroute] Rebuilt on change and notified clients");
+          } catch (e) {
+            console.error("[reroute] Dev rebuild failed:", e);
+          }
+        }, 120);
+      };
+      fsWatch(clientDir, { recursive: true }, (_event, filename) => {
+        try {
+          const name = String(filename || "");
+          if (!name)
+            return;
+          if (!/\.(ts|tsx|js|jsx|html|css|json)$/i.test(name))
+            return;
+          if (shouldIgnore(join2(clientDir, name)))
+            return;
+          schedule();
+        } catch {}
+      });
+      console.log(`[reroute] Watching ${clientDir} for changes`);
+    } catch (e) {
+      console.warn("[reroute] Failed to start dev file watcher:", e);
+    }
+  }
+  registerArtifactsRoutes(app, cwd);
+  if (rootComponent) {
+    const collections = await discoverCollections(clientDir);
+    if (collections.length > 0) {
+      console.log(`[reroute] Discovered collections: ${collections.join(", ")}`);
+    }
+    registerSSRRoutes(app, {
+      rootComponent,
+      clientDir,
+      cwd,
+      isWatchMode,
+      getBundleUrl: ensureBundleUrl,
+      head: ssrHead,
+      lang: ssrLang,
+      appId: ssrAppId,
+      collections,
+      minify,
+      dataCacheControl
+    });
+  }
+  registerStaticRoutes(app, {
+    clientDir,
+    prefix,
+    maxAge,
+    directive,
+    indexHTML,
+    staticHeaders,
+    minify,
+    sourcemap,
+    shouldIgnore,
+    bundleCache,
+    fileCache,
+    isWatchMode
+  });
+  return app;
+};
+export {
+  reroute
+};
+
+//# debugId=E29EB407CD742AE464756E2164756E21