reroute-js 0.0.1

package/core/index.js

@@ -0,0 +1,1174 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// 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/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 };
+}
+export {
+  transpileFile,
+  toBytes,
+  stripStart,
+  stripEnd,
+  seedSSRModuleForPath,
+  renderSSRDocument,
+  rebuildContentArtifacts,
+  loadIndexHtml,
+  listContentFiles,
+  join,
+  isCompressible,
+  gzipIfAccepted,
+  getMimeType,
+  getContentMeta,
+  getBundleUrlsFor,
+  generateContentRegistry,
+  generateContentHash,
+  extname,
+  discoverCollections,
+  computeSSRDataForPath,
+  buildHeadFromMeta,
+  buildContentDTOs,
+  basename,
+  applyIndexTemplate,
+  acceptsGzip,
+  LRUCache
+};
+
+//# debugId=3C32F25BA85F27F764756E2164756E21