reroute-js 0.45.11 → 0.46.0

package/cli/bin.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env bun
 // @bun
 /**
- * reroute-js v0.45.11
+ * reroute-js v0.46.0
  *
  * @license MIT
  * @copyright 2026 stewones <hi@stewan.io>
- * @see https://github.com/stewones/reroute
+ * @see https://github.com/Intenseloop/reroute
  *
  * Built with Bun <3
  */
@@ -15,25 +15,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   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],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -48,7 +66,7 @@ async function getVersionString() {
 }
 async function getVersion() {
   if (true) {
-    return "0.45.11";
+    return "0.46.0";
   }
   const possiblePaths = [
     path.join(import.meta.dir, "../../../../package.json"),
@@ -66,7 +84,7 @@ async function getVersion() {
 }
 async function getCommit() {
   if (true) {
-    return "c2463d3";
+    return "9116acf";
   }
   return "dev";
 }
@@ -518,6 +536,364 @@ var init_content = __esm(() => {
   init_metadata();
 });
 
+// packages/core/src/i18n/catalog.ts
+function getMessage(catalog, key) {
+  if (!(catalog && key))
+    return;
+  const parts = key.split(".");
+  let current = catalog;
+  for (const part of parts) {
+    if (current == null || typeof current === "string")
+      return;
+    current = current[part];
+  }
+  return typeof current === "string" ? current : undefined;
+}
+function lookupMessage(catalogs, locale, defaultLocale, key) {
+  return getMessage(catalogs[locale], key) ?? (locale !== defaultLocale ? getMessage(catalogs[defaultLocale], key) : undefined);
+}
+var init_catalog = () => {};
+
+// packages/core/src/i18n/discover.ts
+import { readdir as readdir3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+async function loadCatalog(filePath) {
+  try {
+    const text = await Bun.file(filePath).text();
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function loadLocaleCatalogs(absDir) {
+  const entries = await readdir3(absDir, { withFileTypes: true });
+  const catalogs = {};
+  const locales = [];
+  for (const entry of entries) {
+    if (!(entry.isFile() && entry.name.endsWith(".json")))
+      continue;
+    const locale = entry.name.slice(0, -".json".length);
+    if (!locale)
+      continue;
+    const catalog = await loadCatalog(join3(absDir, entry.name));
+    if (!catalog)
+      continue;
+    catalogs[locale] = catalog;
+    locales.push(locale);
+  }
+  return { catalogs, locales };
+}
+function sortLocales(locales, defaultLocale) {
+  locales.sort((a, b) => {
+    if (a === defaultLocale)
+      return -1;
+    if (b === defaultLocale)
+      return 1;
+    return a.localeCompare(b);
+  });
+}
+async function discoverI18n(cwd, options = {}) {
+  const localesDir = options.localesDir ?? DEFAULT_LOCALES_DIR;
+  const defaultLocale = options.defaultLocale ?? DEFAULT_LOCALE;
+  const cookie = options.cookie ?? DEFAULT_COOKIE;
+  const redirectContentOnNegotiate = options.redirectContentOnNegotiate ?? true;
+  const absDir = join3(cwd, localesDir);
+  const disabled = {
+    enabled: false,
+    defaultLocale,
+    locales: [],
+    localesDir,
+    cookie,
+    redirectContentOnNegotiate,
+    catalogs: {}
+  };
+  let catalogs;
+  let locales;
+  try {
+    ({ catalogs, locales } = await loadLocaleCatalogs(absDir));
+  } catch {
+    return disabled;
+  }
+  if (locales.length === 0) {
+    return disabled;
+  }
+  sortLocales(locales, defaultLocale);
+  if (!catalogs[defaultLocale]) {
+    console.warn(`[reroute/i18n] defaultLocale "${defaultLocale}" has no catalog; using "${locales[0]}"`);
+  }
+  return {
+    enabled: true,
+    defaultLocale: catalogs[defaultLocale] ? defaultLocale : locales[0],
+    locales,
+    localesDir,
+    cookie,
+    redirectContentOnNegotiate,
+    catalogs
+  };
+}
+var DEFAULT_LOCALE = "en-US", DEFAULT_LOCALES_DIR = "locales", DEFAULT_COOKIE = "reroute-locale";
+var init_discover = () => {};
+
+// packages/core/src/i18n/messages.ts
+import { IntlMessageFormat } from "intl-messageformat";
+function formatMessage(message, locale, values) {
+  if (!values || Object.keys(values).length === 0) {
+    if (!/\{[^}]+\}/.test(message))
+      return message;
+  }
+  const cacheKey = `${locale}\x00${message}`;
+  let formatter = formatterCache.get(cacheKey);
+  if (!formatter) {
+    formatter = new IntlMessageFormat(message, locale);
+    formatterCache.set(cacheKey, formatter);
+  }
+  try {
+    const result = formatter.format(values);
+    return typeof result === "string" ? result : String(result);
+  } catch {
+    return message;
+  }
+}
+function createTranslator(catalogs, locale, defaultLocale) {
+  return (key, values) => {
+    const message = lookupMessage(catalogs, locale, defaultLocale, key);
+    if (message == null)
+      return key;
+    return formatMessage(message, locale, values);
+  };
+}
+var formatterCache;
+var init_messages = __esm(() => {
+  init_catalog();
+  formatterCache = new Map;
+});
+
+// packages/core/src/i18n/negotiate.ts
+function negotiateLocale(acceptLanguage, availableLocales, defaultLocale) {
+  if (!availableLocales.length)
+    return defaultLocale;
+  if (!acceptLanguage)
+    return defaultLocale;
+  const availableLower = new Map(availableLocales.map((l) => [l.toLowerCase(), l]));
+  const byLang = new Map;
+  for (const locale of availableLocales) {
+    const lang = locale.split("-")[0].toLowerCase();
+    if (!byLang.has(lang))
+      byLang.set(lang, locale);
+  }
+  const ranges = acceptLanguage.split(",").map((part) => {
+    const [tag, ...params] = part.trim().split(";");
+    let q = 1;
+    for (const p of params) {
+      const [k, v] = p.trim().split("=");
+      if (k === "q" && v)
+        q = Number.parseFloat(v) || 0;
+    }
+    return { tag: tag.trim().toLowerCase(), q };
+  }).filter((r) => r.tag && r.q > 0).sort((a, b) => b.q - a.q);
+  for (const { tag } of ranges) {
+    if (tag === "*")
+      return defaultLocale;
+    const exact = availableLower.get(tag);
+    if (exact)
+      return exact;
+    const langOnly = byLang.get(tag.split("-")[0]);
+    if (langOnly)
+      return langOnly;
+  }
+  return defaultLocale;
+}
+function parseCookieValue(cookieHeader, name) {
+  if (!cookieHeader)
+    return;
+  const parts = cookieHeader.split(";");
+  for (const part of parts) {
+    const idx = part.indexOf("=");
+    if (idx === -1)
+      continue;
+    const key = part.slice(0, idx).trim();
+    if (key === name) {
+      return decodeURIComponent(part.slice(idx + 1).trim());
+    }
+  }
+  return;
+}
+function buildLocaleCookie(name, locale, maxAgeSeconds = 60 * 60 * 24 * 365) {
+  return `${name}=${encodeURIComponent(locale)}; Path=/; Max-Age=${maxAgeSeconds}; SameSite=Lax`;
+}
+var init_negotiate = () => {};
+
+// packages/core/src/i18n/pathname.ts
+var exports_pathname = {};
+__export(exports_pathname, {
+  toOgLocale: () => toOgLocale,
+  parseContentPath: () => parseContentPath,
+  normalizePathname: () => normalizePathname,
+  looksLikeLocale: () => looksLikeLocale,
+  localizeHref: () => localizeHref,
+  localizeContentHref: () => localizeContentHref,
+  hreflangTags: () => hreflangTags,
+  contentKey: () => contentKey
+});
+function looksLikeLocale(segment) {
+  return /^[a-z]{2}(?:-[A-Za-z0-9]{2,8})*$/i.test(segment);
+}
+function normalizePathname(pathname) {
+  const pathOnly = pathname.split("?")[0].split("#")[0];
+  if (!pathOnly || pathOnly === "/")
+    return "/";
+  return pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+}
+function parseContentPath(pathname, availableLocales = [], collections) {
+  const normalized = normalizePathname(pathname);
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length < 2)
+    return;
+  const [collection, second, third] = parts;
+  if (collections && !collections.includes(collection)) {
+    return;
+  }
+  const localeSet = new Set(availableLocales.map((l) => l.toLowerCase()));
+  if (parts.length >= 3 && third) {
+    const secondIsLocale = localeSet.size > 0 ? localeSet.has(second.toLowerCase()) : looksLikeLocale(second);
+    if (secondIsLocale) {
+      const locale = availableLocales.find((l) => l.toLowerCase() === second.toLowerCase()) || second;
+      return {
+        collection,
+        name: third,
+        locale,
+        routingPathname: `/${collection}/${third}`,
+        pathname: normalized
+      };
+    }
+  }
+  return {
+    collection,
+    name: second,
+    routingPathname: `/${collection}/${second}`,
+    pathname: normalized
+  };
+}
+function localizeContentHref(collection, name, locale, defaultLocale) {
+  if (!locale || locale === defaultLocale) {
+    return `/${collection}/${name}`;
+  }
+  return `/${collection}/${locale}/${name}`;
+}
+function localizeHref(to, locale, defaultLocale, availableLocales = [], collections) {
+  try {
+    const url = new URL(to, "http://local");
+    const parsed = parseContentPath(url.pathname, availableLocales, collections);
+    if (!parsed)
+      return to;
+    url.pathname = localizeContentHref(parsed.collection, parsed.name, locale, defaultLocale);
+    return `${url.pathname}${url.search}${url.hash}`;
+  } catch {
+    return to;
+  }
+}
+function contentKey(collection, name, locale, defaultLocale = "en-US") {
+  if (locale && locale !== defaultLocale) {
+    return `${collection}:${name}:${locale}`;
+  }
+  return `${collection}:${name}`;
+}
+function toOgLocale(locale) {
+  return locale.replace(/-/g, "_");
+}
+function hreflangTags(baseUrl, collection, name, locales, defaultLocale) {
+  const base = baseUrl.replace(/\/$/, "");
+  const tags = [];
+  for (const locale of locales) {
+    const path2 = localizeContentHref(collection, name, locale, defaultLocale);
+    tags.push(`<link rel="alternate" hreflang="${locale}" href="${base}${path2}" />`);
+  }
+  const defaultPath = localizeContentHref(collection, name, defaultLocale, defaultLocale);
+  tags.push(`<link rel="alternate" hreflang="x-default" href="${base}${defaultPath}" />`);
+  return tags.join(`
+`);
+}
+var init_pathname = () => {};
+
+// packages/core/src/i18n/resolve.ts
+function resolveLocale(input) {
+  const {
+    pathname,
+    cookieHeader,
+    acceptLanguage,
+    availableLocales,
+    defaultLocale,
+    cookieName = DEFAULT_COOKIE,
+    collections
+  } = input;
+  const parsed = parseContentPath(pathname, availableLocales, collections);
+  const availableLower = new Set(availableLocales.map((l) => l.toLowerCase()));
+  const isAvailable = (locale) => !!locale && availableLower.has(locale.toLowerCase());
+  if (parsed?.locale && isAvailable(parsed.locale)) {
+    const locale = availableLocales.find((l) => l.toLowerCase() === parsed.locale?.toLowerCase()) || parsed.locale;
+    if (locale === defaultLocale && parsed.pathname !== parsed.routingPathname) {
+      return {
+        locale,
+        routingPathname: parsed.routingPathname,
+        fromPath: true,
+        redirectTo: parsed.routingPathname,
+        parsed: { ...parsed, locale }
+      };
+    }
+    return {
+      locale,
+      routingPathname: parsed.routingPathname,
+      fromPath: true,
+      parsed: { ...parsed, locale }
+    };
+  }
+  const routingPathname = parsed?.routingPathname ?? pathname.split("?")[0];
+  const cookieLocale = parseCookieValue(cookieHeader, cookieName);
+  if (isAvailable(cookieLocale)) {
+    const locale = availableLocales.find((l) => l.toLowerCase() === cookieLocale.toLowerCase()) || cookieLocale;
+    return {
+      locale,
+      routingPathname,
+      fromPath: false,
+      parsed: parsed ? { ...parsed, locale: undefined } : undefined
+    };
+  }
+  const negotiated = negotiateLocale(acceptLanguage, availableLocales, defaultLocale);
+  return {
+    locale: negotiated,
+    routingPathname,
+    fromPath: false,
+    parsed: parsed ? { ...parsed, locale: undefined } : undefined
+  };
+}
+function contentNegotiateRedirect(resolution, defaultLocale, enabled) {
+  if (!enabled)
+    return;
+  if (resolution.fromPath)
+    return;
+  if (resolution.locale === defaultLocale)
+    return;
+  const parsed = resolution.parsed;
+  if (!parsed)
+    return;
+  return localizeContentHref(parsed.collection, parsed.name, resolution.locale, defaultLocale);
+}
+var init_resolve = __esm(() => {
+  init_discover();
+  init_negotiate();
+  init_pathname();
+});
+
+// packages/core/src/i18n/index.ts
+var init_i18n = __esm(() => {
+  init_catalog();
+  init_discover();
+  init_messages();
+  init_negotiate();
+  init_pathname();
+  init_resolve();
+});
+
 // packages/telemetry/src/server/context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 var contextStorage;
@@ -1112,6 +1488,148 @@ function compressStreamIfAccepted(stream, contentType, _acceptEncoding) {
 }
 var init_compression = () => {};
 
+// packages/core/src/ssr/lib/route-match.ts
+function getPatternParts(pattern) {
+  return pattern.split("/").filter(Boolean);
+}
+function isDynamicPatternPart(patternPart) {
+  return patternPart.startsWith(":");
+}
+function isCatchAllPatternPart(patternPart) {
+  return patternPart.startsWith(":...");
+}
+function isCatchAllParamName(paramName) {
+  return paramName.startsWith("...");
+}
+function getPatternPartSpecificity(patternPart) {
+  if (isCatchAllPatternPart(patternPart)) {
+    return 2;
+  }
+  if (isDynamicPatternPart(patternPart)) {
+    return 1;
+  }
+  return 0;
+}
+function compareRouteSpecificity(a, b) {
+  const aPatternParts = getPatternParts(a.pattern);
+  const bPatternParts = getPatternParts(b.pattern);
+  const aDepth = aPatternParts.length;
+  const bDepth = bPatternParts.length;
+  if (aDepth !== bDepth) {
+    return bDepth - aDepth;
+  }
+  for (let i = 0;i < aPatternParts.length; i++) {
+    const aSpecificity = getPatternPartSpecificity(aPatternParts[i]);
+    const bSpecificity = getPatternPartSpecificity(bPatternParts[i]);
+    if (aSpecificity !== bSpecificity) {
+      return aSpecificity - bSpecificity;
+    }
+    if (aSpecificity === 0 && aPatternParts[i] !== bPatternParts[i]) {
+      return aPatternParts[i].localeCompare(bPatternParts[i]);
+    }
+  }
+  return a.pattern.localeCompare(b.pattern);
+}
+function matchCatchAllParam(paramName, patternIndex, patternLength, pathnameParts, pathnameIndex, params) {
+  if (patternIndex !== patternLength - 1 || pathnameIndex >= pathnameParts.length) {
+    return false;
+  }
+  params[paramName.slice(3)] = pathnameParts.slice(pathnameIndex).join("/");
+  return true;
+}
+function matchDynamicParam(paramName, pathnameParts, pathnameIndex, params) {
+  const pathnamePart = pathnameParts[pathnameIndex];
+  if (pathnamePart === undefined) {
+    return null;
+  }
+  params[paramName] = pathnamePart;
+  return pathnameIndex + 1;
+}
+function matchPatternPart(patternPart, patternIndex, patternLength, pathnameParts, pathnameIndex, params) {
+  if (isDynamicPatternPart(patternPart)) {
+    const paramName = patternPart.slice(1);
+    if (isCatchAllParamName(paramName)) {
+      return matchCatchAllParam(paramName, patternIndex, patternLength, pathnameParts, pathnameIndex, params) ? "catch-all" : null;
+    }
+    return matchDynamicParam(paramName, pathnameParts, pathnameIndex, params);
+  }
+  if (patternPart !== pathnameParts[pathnameIndex]) {
+    return null;
+  }
+  return pathnameIndex + 1;
+}
+function matchRoutePattern(pattern, pathname) {
+  const patternParts = getPatternParts(pattern);
+  const pathnameParts = pathname.split("/").filter(Boolean);
+  const params = {};
+  let pathnameIndex = 0;
+  for (let i = 0;i < patternParts.length; i++) {
+    const nextPathnameIndex = matchPatternPart(patternParts[i], i, patternParts.length, pathnameParts, pathnameIndex, params);
+    if (nextPathnameIndex === null) {
+      return null;
+    }
+    if (nextPathnameIndex === "catch-all") {
+      return params;
+    }
+    pathnameIndex = nextPathnameIndex;
+  }
+  return pathnameIndex === pathnameParts.length ? params : null;
+}
+function matchRoutes(routes, pathname) {
+  for (const route of routes) {
+    const params = matchRoutePattern(route.pattern, pathname);
+    if (params) {
+      return { route, params };
+    }
+  }
+  return null;
+}
+
+// packages/core/src/ssr/lib/content-path.ts
+var exports_content_path = {};
+__export(exports_content_path, {
+  resolveContentPathParts: () => resolveContentPathParts
+});
+function resolveContentPathParts(pathname) {
+  const pathOnly = pathname.split("?")[0].split("#")[0];
+  const parts = pathOnly.split("/").filter(Boolean);
+  if (parts.length < 2)
+    return null;
+  const g = globalThis;
+  const locales = g.__REROUTE_I18N__?.locales || [];
+  const defaultLocale = g.__REROUTE_I18N__?.defaultLocale || "en-US";
+  const parsed = parseContentPath(pathOnly, locales);
+  if (parsed) {
+    const locale = parsed.locale || defaultLocale;
+    return {
+      collection: parsed.collection,
+      name: parsed.name,
+      locale: parsed.locale,
+      key: contentKey(parsed.collection, parsed.name, locale, defaultLocale),
+      routingPathname: parsed.routingPathname
+    };
+  }
+  if (parts.length >= 3 && looksLikeLocale(parts[1])) {
+    const locale = parts[1];
+    return {
+      collection: parts[0],
+      name: parts[2],
+      locale,
+      key: contentKey(parts[0], parts[2], locale, defaultLocale),
+      routingPathname: `/${parts[0]}/${parts[2]}`
+    };
+  }
+  return {
+    collection: parts[0],
+    name: parts[1],
+    key: `${parts[0]}:${parts[1]}`,
+    routingPathname: `/${parts[0]}/${parts[1]}`
+  };
+}
+var init_content_path = __esm(() => {
+  init_pathname();
+});
+
 // packages/core/src/ssr/lib/compute/content.ts
 function checkStatusCache(statusCacheKey, maxAgeMs) {
   if (maxAgeMs <= 0)
@@ -1164,6 +1682,14 @@ async function handleNonStreamingMode(ssrData, pathname, task, cacheKey, statusC
   }
   return result;
 }
+async function runContentDataTask(streaming, ssrData, pathname, task, set, cacheKey, statusCacheKey, maxAgeMs, pendingTasks) {
+  if (streaming) {
+    handleStreamingMode(ssrData, pathname, task, set, cacheKey, statusCacheKey, maxAgeMs, pendingTasks);
+  } else {
+    await handleNonStreamingMode(ssrData, pathname, task, cacheKey, statusCacheKey, maxAgeMs);
+  }
+  return set.status !== 200 ? set.status : undefined;
+}
 async function computeContentData(pathname, options, searchParams, sharedSsrData) {
   const streaming = options.streaming === true;
   const ssrData = streaming && sharedSsrData ? sharedSsrData : {};
@@ -1173,18 +1699,20 @@ async function computeContentData(pathname, options, searchParams, sharedSsrData
   const maxAge = options.maxAge || 0;
   const maxAgeMs = maxAge * 1000;
   try {
-    const parts = pathname.split("/").filter(Boolean);
-    if (parts.length < 2) {
+    const resolved = resolveContentPathParts(pathname);
+    if (!resolved) {
       return { data: ssrData, pendingTasks };
     }
+    const parts = [resolved.collection, resolved.name];
+    if (resolved.locale)
+      parts.splice(1, 0, resolved.locale);
     const g = globalThis;
-    const key = `${parts[0]}:${parts[1]}`;
-    const exp = g.__REROUTE_SSR_EXPORTS__?.[key];
+    const exp = g.__REROUTE_SSR_EXPORTS__?.[resolved.key];
     const dataFn = exp?.ssr?.data;
     if (typeof dataFn !== "function") {
       return { data: ssrData, pendingTasks };
     }
-    const cacheKey = `content:${pathname}:${parts[1]}`;
+    const cacheKey = `content:${pathname}:${resolved.name}:${resolved.locale || ""}`;
     const statusCacheKey = `status:${cacheKey}`;
     const cachedStatus = checkStatusCache(statusCacheKey, maxAgeMs);
     if (cachedStatus && cachedStatus !== 200) {
@@ -1197,22 +1725,13 @@ async function computeContentData(pathname, options, searchParams, sharedSsrData
     }
     const set = { status: 200 };
     const task = createDataTask(dataFn, pathname, parts, searchParams, set, options.headers);
-    if (streaming) {
-      handleStreamingMode(ssrData, pathname, task, set, cacheKey, statusCacheKey, maxAgeMs, pendingTasks);
-      if (set.status !== 200) {
-        statusOverride = set.status;
-      }
-    } else {
-      await handleNonStreamingMode(ssrData, pathname, task, cacheKey, statusCacheKey, maxAgeMs);
-      if (set.status !== 200) {
-        statusOverride = set.status;
-      }
-    }
+    statusOverride = await runContentDataTask(streaming, ssrData, pathname, task, set, cacheKey, statusCacheKey, maxAgeMs, pendingTasks) ?? statusOverride;
   } catch {}
   return { data: ssrData, error, statusOverride, pendingTasks };
 }
 var init_content2 = __esm(() => {
   init_cache();
+  init_content_path();
   init_imports();
 });
 
@@ -1411,7 +1930,8 @@ async function computeRouteData(pathname, clientDir, _cwd, isWatchMode, options,
     }).catch(() => {}));
   };
   try {
-    const pathnameOnly = pathname.split("?")[0];
+    const resolved = resolveContentPathParts(pathname);
+    const pathnameOnly = (resolved?.routingPathname || pathname).split("?")[0];
     const match = typeof routesModule?.matchRoute === "function" ? routesModule.matchRoute(pathnameOnly) : null;
     const route = match?.route;
     const params = match?.params || {};
@@ -1574,44 +2094,18 @@ function handleFlattenedResult(entries, set, ctx, cache, setError, setStatus) {
 }
 var init_routes = __esm(() => {
   init_cache();
+  init_content_path();
   init_imports();
 });
 
 // packages/core/src/ssr/lib/compute/index.ts
-function matchPatternUtil(pattern, pathname) {
-  const patternParts = pattern.split("/").filter(Boolean);
-  const pathnameParts = pathname.split("/").filter(Boolean);
-  if (patternParts.length !== pathnameParts.length) {
-    return null;
-  }
-  const params = {};
-  for (let i = 0;i < patternParts.length; i++) {
-    const patternPart = patternParts[i];
-    const pathnamePart = pathnameParts[i];
-    if (patternPart.startsWith(":")) {
-      params[patternPart.slice(1)] = pathnamePart;
-    } else if (patternPart !== pathnamePart) {
-      return null;
-    }
-  }
-  return params;
-}
 function createBundledRoutesModule(bundledRoutes, bundledLayouts) {
   const bundledNotFoundRoutes = globalThis.__REROUTE_NOT_FOUND_ROUTES__;
   return {
     routes: bundledRoutes,
     layouts: bundledLayouts,
     notFoundRoutes: bundledNotFoundRoutes,
-    matchRoute: (pathname) => {
-      for (const route of bundledRoutes) {
-        const pattern = String(route?.pattern || "");
-        const match = matchPatternUtil(pattern, pathname);
-        if (match) {
-          return { route, params: match };
-        }
-      }
-      return null;
-    }
+    matchRoute: (pathname) => matchRoutes(bundledRoutes, pathname)
   };
 }
 async function loadRoutesModule(cwd, isWatchMode) {
@@ -1693,33 +2187,31 @@ var init_compute = __esm(() => {
 });
 
 // packages/core/src/ssr/lib/modules.ts
-import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import { readdir as readdir4, stat as stat3 } from "node:fs/promises";
 async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode) {
   try {
-    const pathOnly = pathname.split("?")[0].split("#")[0];
-    const parts = pathOnly.split("/").filter(Boolean);
-    if (parts.length < 2)
+    const resolved = resolveContentPathParts(pathname);
+    if (!resolved)
       return null;
-    const collection = parts[0];
-    const name = parts[1];
-    const registryModule = await tryRegistryImport(collection, name, cwd, isWatchMode);
+    const { collection, name, locale } = resolved;
+    const registryModule = await tryRegistryImport(collection, name, cwd, isWatchMode, locale);
     if (registryModule)
       return registryModule;
     const chunkModule = await tryChunkImport(collection, name, cwd, isWatchMode);
     if (chunkModule)
       return chunkModule;
-    const sourceModule = await trySourceImport(collection, name, clientDir, isWatchMode);
+    const sourceModule = await trySourceImport(collection, name, clientDir, isWatchMode, locale);
     if (sourceModule)
       return sourceModule;
   } catch {}
   return null;
 }
-async function tryRegistryImport(collection, name, cwd, isWatchMode) {
+async function tryRegistryImport(collection, name, cwd, isWatchMode, locale) {
   try {
     const registryPath = join2(cwd, ".reroute", "content.ts");
     const reg = await dynamicImport(registryPath, isWatchMode);
     const get = reg?.getContentEntry;
-    const entry = typeof get === "function" ? get(collection, name) : undefined;
+    const entry = typeof get === "function" ? get(collection, name, locale) : undefined;
     const moduleUrl = entry?.module;
     if (!moduleUrl?.endsWith(".js"))
       return null;
@@ -1745,7 +2237,7 @@ async function tryRegistryImport(collection, name, cwd, isWatchMode) {
 async function tryChunkImport(collection, name, cwd, isWatchMode) {
   try {
     const chunkDir = join2(cwd, ".reroute", "chunks", collection);
-    const files = await readdir3(chunkDir);
+    const files = await readdir4(chunkDir);
     const matches = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
     if (!matches.length)
       return null;
@@ -1765,23 +2257,23 @@ async function tryChunkImport(collection, name, cwd, isWatchMode) {
   } catch {}
   return null;
 }
-async function trySourceImport(collection, name, clientDir, isWatchMode) {
+async function trySourceImport(collection, name, clientDir, isWatchMode, locale) {
   try {
-    const srcTsx = join2(clientDir, "routes", collection, "content", `${name}.tsx`);
-    const srcTs = join2(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;
+    const candidates = [];
+    if (locale) {
+      candidates.push(join2(clientDir, "routes", collection, "content", locale, `${name}.tsx`), join2(clientDir, "routes", collection, "content", locale, `${name}.ts`));
     }
-    if (absSrc) {
-      return await dynamicImport(absSrc, isWatchMode);
+    candidates.push(join2(clientDir, "routes", collection, "content", `${name}.tsx`), join2(clientDir, "routes", collection, "content", `${name}.ts`));
+    for (const absSrc of candidates) {
+      if (await Bun.file(absSrc).exists()) {
+        return await dynamicImport(absSrc, isWatchMode);
+      }
     }
   } catch {}
   return null;
 }
 var init_modules = __esm(() => {
+  init_content_path();
   init_imports();
 });
 
@@ -1812,14 +2304,11 @@ function touchModule(key) {
 }
 async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode) {
   try {
-    const pathOnly = pathname.split("?")[0].split("#")[0];
-    const parts = pathOnly.split("/").filter(Boolean);
-    if (parts.length < 2) {
+    const resolved = resolveContentPathParts(pathname);
+    if (!resolved) {
       return;
     }
-    const collection = parts[0];
-    const name = parts[1];
-    const key = `${collection}:${name}`;
+    const { key } = resolved;
     const mod = await importContentModuleForPath(pathname, clientDir, cwd, isWatchMode);
     if (!mod) {
       return;
@@ -1839,42 +2328,25 @@ async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode) {
 }
 var MAX_SSR_MODULES = 200, moduleAccessOrder;
 var init_seed = __esm(() => {
+  init_content_path();
   init_modules();
   moduleAccessOrder = [];
 });
 
 // packages/core/src/ssr/lib/data.ts
-function matchPattern(pattern, pathname) {
-  const patternParts = pattern.split("/").filter(Boolean);
-  const pathnameParts = pathname.split("/").filter(Boolean);
-  if (patternParts.length !== pathnameParts.length) {
-    return null;
-  }
-  const params = {};
-  for (let i = 0;i < patternParts.length; i++) {
-    const patternPart = patternParts[i];
-    const pathnamePart = pathnameParts[i];
-    if (patternPart.startsWith(":")) {
-      params[patternPart.slice(1)] = pathnamePart;
-    } else if (patternPart !== pathnamePart) {
-      return null;
-    }
-  }
-  return params;
-}
 function loadContentData(pathname, searchParams) {
   try {
-    const parts = pathname.split("/").filter(Boolean);
-    if (parts.length < 2)
+    const resolved = resolveContentPathParts(pathname);
+    if (!resolved)
       return null;
-    const key = `${parts[0]}:${parts[1]}`;
+    const key = resolved.key;
     const g = globalThis;
     const exp = g.__REROUTE_SSR_EXPORTS__?.[key];
     const dataFn = exp?.ssr?.data;
     if (typeof dataFn === "function") {
       const rawResult = dataFn({
         pathname,
-        params: { name: parts[1] },
+        params: { name: resolved.name },
         searchParams
       });
       const result = processDataResult(rawResult, pathname, pathname);
@@ -1896,16 +2368,7 @@ async function loadRouteDataInternal(pathname, clientDir, cwd, isWatchMode, sear
       routes = m?.routes;
       matchRouteFn = m?.matchRoute;
     } else {
-      matchRouteFn = (pathname2) => {
-        for (const route of routes || []) {
-          const pattern = String(route?.pattern || "");
-          const match2 = matchPattern(pattern, pathname2);
-          if (match2) {
-            return { route, params: match2 };
-          }
-        }
-        return null;
-      };
+      matchRouteFn = (pathname2) => matchRoutes(routes || [], pathname2);
     }
     const pathnameOnly = pathname.split("?")[0];
     const match = typeof matchRouteFn === "function" ? matchRouteFn(pathnameOnly) : null;
@@ -2046,6 +2509,7 @@ function createLazyMarker(pathname, key) {
   };
 }
 var init_data = __esm(() => {
+  init_content_path();
   init_imports();
   init_seed();
 });
@@ -2246,18 +2710,53 @@ function replaceAppRoot(html, appHtml, appId) {
 var init_html = () => {};
 
 // packages/core/src/og/discovery.ts
+import { readdir as readdir5 } from "node:fs/promises";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
+function isCatchAllRouteDirectory(name) {
+  return CATCH_ALL_ROUTE_DIRECTORY.test(name);
+}
+async function listDynamicRouteDirectories(baseDir) {
+  try {
+    const entries = await readdir5(baseDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => DYNAMIC_ROUTE_DIRECTORY.test(name)).sort((a, b) => {
+      const aIsCatchAll = isCatchAllRouteDirectory(a);
+      const bIsCatchAll = isCatchAllRouteDirectory(b);
+      if (aIsCatchAll !== bIsCatchAll) {
+        return Number(aIsCatchAll) - Number(bIsCatchAll);
+      }
+      return a.localeCompare(b);
+    });
+  } catch {
+    return [];
+  }
+}
+async function collectOGCandidatePaths(currentDir, parts, depth, pathsToTry, allowPartialFallback) {
+  if (depth === parts.length) {
+    pathsToTry.push(join2(currentDir, "[og].tsx"));
+    return;
+  }
+  const literalDir = join2(currentDir, parts[depth]);
+  try {
+    await readdir5(literalDir);
+    await collectOGCandidatePaths(literalDir, parts, depth + 1, pathsToTry, true);
+  } catch {}
+  const dynamicDirs = await listDynamicRouteDirectories(currentDir);
+  for (const dynamicDir of dynamicDirs) {
+    if (isCatchAllRouteDirectory(dynamicDir)) {
+      pathsToTry.push(join2(currentDir, dynamicDir, "[og].tsx"));
+      continue;
+    }
+    await collectOGCandidatePaths(join2(currentDir, dynamicDir), parts, depth + 1, pathsToTry, false);
+  }
+  if (allowPartialFallback) {
+    pathsToTry.push(join2(currentDir, "[og].tsx"));
+  }
+}
 async function findOGImageForPath(pathname, clientDir) {
   const parts = pathname.split("/").filter(Boolean).filter((p) => !p.startsWith("__reroute"));
   const routesDir = join2(clientDir, "routes");
   const pathsToTry = [];
-  if (parts.length > 0) {
-    for (let i = parts.length;i > 0; i--) {
-      const dirPath = join2(routesDir, ...parts.slice(0, i), "[og].tsx");
-      pathsToTry.push(dirPath);
-    }
-  }
-  pathsToTry.push(join2(routesDir, "[og].tsx"));
+  await collectOGCandidatePaths(routesDir, parts, 0, pathsToTry, true);
   const uniquePaths = [...new Set(pathsToTry)];
   for (const path2 of uniquePaths) {
     try {
@@ -2281,28 +2780,28 @@ async function loadOGImageComponent(ogPath, isWatchMode) {
 function extractParamsFromPath(pathname, ogPath, clientDir) {
   const params = {};
   const ogDir = ogPath.replace(/\/\[og\]\.tsx$/, "");
-  const pagesDir = join2(clientDir, "pages");
-  const relativePath = ogDir.replace(pagesDir, "").split("/").filter(Boolean);
+  const routesDir = join2(clientDir, "routes");
+  const relativePath = ogDir.replace(routesDir, "").split("/").filter(Boolean);
   const pathnameParts = pathname.split("/").filter(Boolean);
   for (let i = 0;i < relativePath.length && i < pathnameParts.length; i++) {
     const part = relativePath[i];
-    const match = part.match(/^\[([^\]]+)\]$/);
-    if (match) {
-      const paramName = match[1];
-      params[paramName] = pathnameParts[i];
+    const catchAllMatch = part.match(/^\[\.\.\.([^\]]+)\]$/);
+    if (catchAllMatch) {
+      params[catchAllMatch[1]] = pathnameParts.slice(i).join("/");
+      break;
     }
-  }
-  if (pathnameParts.length > relativePath.length && relativePath.length > 0) {
-    const lastRelativePart = relativePath[relativePath.length - 1];
-    const match = lastRelativePart.match(/^\[([^\]]+)\]$/);
-    if (match) {
-      const paramName = match[1];
-      params[paramName] = pathnameParts[relativePath.length - 1];
+    const dynamicMatch = part.match(/^\[([^\]]+)\]$/);
+    if (dynamicMatch) {
+      params[dynamicMatch[1]] = pathnameParts[i];
     }
   }
   return params;
 }
-var init_discovery2 = () => {};
+var CATCH_ALL_ROUTE_DIRECTORY, DYNAMIC_ROUTE_DIRECTORY;
+var init_discovery2 = __esm(() => {
+  CATCH_ALL_ROUTE_DIRECTORY = /^\[\.\.\.([^\]]+)\]$/;
+  DYNAMIC_ROUTE_DIRECTORY = /^\[(?:\.\.\.)?[^\]]+\]$/;
+});
 
 // packages/core/src/og/meta.ts
 async function generateOGImageMetaTags(pathname, clientDir, ogConfig) {
@@ -2393,7 +2892,9 @@ async function extractPageMetadata(pathname, clientDir, cwd, isWatchMode, curren
   let perPageHead = "";
   let pageLang;
   let statusOverride = currentStatusOverride;
-  await extractLayoutMetadata(pathname, clientDir, cwd, isWatchMode, (head) => {
+  const resolved = resolveContentPathParts(pathname);
+  const routingPathname = resolved?.routingPathname || pathname;
+  await extractLayoutMetadata(routingPathname, clientDir, cwd, isWatchMode, (head) => {
     perPageHead += head;
   }, (lang) => {
     if (!pageLang)
@@ -2428,8 +2929,8 @@ ${ogMetaTags}`;
     perPageHead += head;
   }, (lang) => {
     pageLang = lang;
-  }, ogConfig, titleSuffix);
-  const routeResult = await extractRouteMetadata(pathname, clientDir, cwd, isWatchMode, statusOverride, ssrData, ogConfig, titleSuffix);
+  }, ogConfig, titleSuffix, baseUrl);
+  const routeResult = await extractRouteMetadata(pathname, clientDir, cwd, isWatchMode, statusOverride, ssrData, ogConfig, titleSuffix, routingPathname);
   perPageHead += routeResult.head;
   if (routeResult.lang)
     pageLang = routeResult.lang;
@@ -2469,14 +2970,42 @@ async function extractLayoutMetadata(pathname, clientDir, cwd, isWatchMode, addH
     }
   } catch {}
 }
-function extractContentMetadata(pathname, addHead, setLang, ogConfig, titleSuffix) {
+function resolveContentLocales(collection, name, fallbackLocales) {
+  const g = globalThis;
+  const byCollection = g.__REROUTE_COLLECTIONS__;
+  const items = byCollection?.[collection] || [];
+  const localesForEntry = [
+    ...new Set(items.filter((it) => it.name === name && it.locale).map((it) => String(it.locale)))
+  ];
+  return localesForEntry.length > 0 ? localesForEntry : fallbackLocales;
+}
+function addContentI18nHead(addHead, baseUrl, collection, name, locales, defaultLocale, activeLocale) {
+  if (locales.length > 1) {
+    addHead(`
+${hreflangTags(baseUrl, collection, name, locales, defaultLocale)}`);
+  }
+  addHead(`
+<meta property="og:locale" content="${toOgLocale(activeLocale)}" />`);
+  for (const loc of locales) {
+    if (loc === activeLocale)
+      continue;
+    addHead(`
+<meta property="og:locale:alternate" content="${toOgLocale(loc)}" />`);
+  }
+  const canonicalPath = localizeContentHref(collection, name, activeLocale, defaultLocale);
+  const base = baseUrl.replace(/\/$/, "");
+  addHead(`
+<link rel="canonical" href="${base}${canonicalPath}" />`);
+  addHead(`
+<meta property="og:url" content="${base}${canonicalPath}" />`);
+}
+function extractContentMetadata(pathname, addHead, setLang, ogConfig, titleSuffix, baseUrl) {
   try {
-    const parts = pathname.split("/").filter(Boolean);
-    if (parts.length < 2)
+    const resolved = resolveContentPathParts(pathname);
+    if (!resolved)
       return;
-    const key = `${parts[0]}:${parts[1]}`;
     const g = globalThis;
-    const exp = g.__REROUTE_SSR_EXPORTS__?.[key];
+    const exp = g.__REROUTE_SSR_EXPORTS__?.[resolved.key];
     const meta = exp?.meta;
     const ssr = exp?.ssr;
     addHead(buildHeadFromMeta(meta, ogConfig, titleSuffix));
@@ -2487,15 +3016,20 @@ ${ssrHead}`);
     const lang = extractSSRLang(ssr);
     if (lang)
       setLang(lang);
+    const i18n = g.__REROUTE_I18N__;
+    if (i18n?.enabled && baseUrl && i18n.locales && i18n.locales.length > 1) {
+      const locales = resolveContentLocales(resolved.collection, resolved.name, i18n.locales);
+      addContentI18nHead(addHead, baseUrl, resolved.collection, resolved.name, locales, i18n.defaultLocale || "en-US", i18n.locale || i18n.defaultLocale || "en-US");
+    }
   } catch {}
 }
 function getContentMetaFromExports(pathname) {
   try {
-    const parts = pathname.split("/").filter(Boolean);
-    if (parts.length < 2)
+    const resolved = resolveContentPathParts(pathname);
+    if (!resolved)
       return;
-    const slug = parts[1];
-    const key = `${parts[0]}:${slug}`;
+    const slug = resolved.name;
+    const key = resolved.key;
     const g = globalThis;
     const exp = g.__REROUTE_SSR_EXPORTS__?.[key];
     const meta = exp?.meta;
@@ -2509,9 +3043,10 @@ function getContentMetaFromExports(pathname) {
     return;
   }
 }
-async function extractMatchedRouteMetadata(pathname, clientDir, m, isWatchMode, statusOverride, ssrData, ogConfig, titleSuffix) {
+async function extractMatchedRouteMetadata(pathname, clientDir, m, isWatchMode, statusOverride, ssrData, ogConfig, titleSuffix, routingPathname) {
   const pathnameOnly = pathname.split("?")[0];
-  const match = typeof m.matchRoute === "function" ? m.matchRoute(pathnameOnly) : null;
+  const matchPath = (routingPathname || pathname).split("?")[0];
+  const match = typeof m.matchRoute === "function" ? m.matchRoute(matchPath) : null;
   const r = match?.route;
   if (!r) {
     return { head: "", statusOverride: statusOverride || 404 };
@@ -2551,7 +3086,7 @@ ${ssrHead}`;
   }
   return { head: "", statusOverride };
 }
-async function extractRouteMetadata(pathname, clientDir, cwd, isWatchMode, currentStatusOverride, ssrData, ogConfig, titleSuffix) {
+async function extractRouteMetadata(pathname, clientDir, cwd, isWatchMode, currentStatusOverride, ssrData, ogConfig, titleSuffix, routingPathname) {
   let head = "";
   let lang;
   let statusOverride = currentStatusOverride;
@@ -2561,14 +3096,14 @@ async function extractRouteMetadata(pathname, clientDir, cwd, isWatchMode, curre
     if (!m) {
       return { head, lang, statusOverride: statusOverride || 404 };
     }
-    const pathnameOnly = pathname.split("?")[0];
-    const match = typeof m.matchRoute === "function" ? m.matchRoute(pathnameOnly) : null;
+    const matchPath = (routingPathname || pathname).split("?")[0];
+    const match = typeof m.matchRoute === "function" ? m.matchRoute(matchPath) : null;
     const r = match?.route;
     if (!r) {
       statusOverride = statusOverride || 404;
     }
     if (r && typeof r.path === "string") {
-      const result = await extractMatchedRouteMetadata(pathname, clientDir, m, isWatchMode, statusOverride, ssrData, ogConfig, titleSuffix);
+      const result = await extractMatchedRouteMetadata(pathname, clientDir, m, isWatchMode, statusOverride, ssrData, ogConfig, titleSuffix, routingPathname);
       head = result.head;
       lang = result.lang;
       statusOverride = result.statusOverride;
@@ -2743,34 +3278,34 @@ function applyTitleSuffixToHead(headContent, titleSuffix) {
 }
 var init_metadata2 = __esm(() => {
   init_metadata();
+  init_pathname();
   init_meta();
   init_compute();
+  init_content_path();
   init_imports();
 });
 
 // packages/core/src/ssr/lib/preload.ts
-import { readdir as readdir4, stat as stat4 } from "node:fs/promises";
+import { readdir as readdir6, stat as stat4 } from "node:fs/promises";
 async function preloadContentModule(pathname, clientDir, cwd, isWatchMode) {
   let extraHead = "";
   let hydrationScript = "";
   let statusOverride;
   try {
-    const pathOnly = pathname.split("?")[0].split("#")[0];
-    const parts = pathOnly.split("/").filter(Boolean);
-    if (parts.length < 2) {
+    const { resolveContentPathParts: resolveContentPathParts2 } = await Promise.resolve().then(() => (init_content_path(), exports_content_path));
+    const resolved = resolveContentPathParts2(pathname);
+    if (!resolved) {
       return { extraHead, hydrationScript };
     }
-    const collection = parts[0];
-    const name = parts[1];
+    const { collection, name, key, locale } = resolved;
     if (!await isContentCollection(clientDir, collection)) {
       return { extraHead, hydrationScript };
     }
-    const modulePath = await findContentModulePath(collection, name, clientDir, cwd, isWatchMode);
+    const modulePath = await findContentModulePath(collection, name, clientDir, cwd, isWatchMode, locale);
     if (!modulePath) {
       statusOverride = 404;
       return { extraHead, hydrationScript, statusOverride };
     }
-    const key = `${collection}:${name}`;
     extraHead += `
 <link rel="modulepreload" href="${modulePath}" />`;
     hydrationScript += `<script>
@@ -2812,12 +3347,12 @@ async function findLatestCandidate(chunkDir, candidates) {
   }
   return latest;
 }
-async function findContentModulePath(collection, name, clientDir, cwd, isWatchMode) {
+async function findContentModulePath(collection, name, clientDir, cwd, isWatchMode, locale) {
   try {
     const registryPath = join2(cwd, ".reroute", "content.ts");
     const reg = await dynamicImport(registryPath, isWatchMode);
     const get = reg?.getContentEntry;
-    const entry = typeof get === "function" ? get(collection, name) : undefined;
+    const entry = typeof get === "function" ? get(collection, name, locale) : undefined;
     const moduleUrl = entry?.module;
     if (moduleUrl?.endsWith(".js")) {
       return moduleUrl;
@@ -2825,7 +3360,7 @@ async function findContentModulePath(collection, name, clientDir, cwd, isWatchMo
   } catch {}
   try {
     const chunkDir = join2(cwd, ".reroute", "chunks", collection);
-    const files = await readdir4(chunkDir);
+    const files = await readdir6(chunkDir);
     const candidates = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
     if (candidates.length) {
       const latest = await findLatestCandidate(chunkDir, candidates);
@@ -2833,13 +3368,18 @@ async function findContentModulePath(collection, name, clientDir, cwd, isWatchMo
     }
   } catch {}
   try {
-    const tsx = join2(clientDir, "routes", collection, "content", `${name}.tsx`);
-    const ts = join2(clientDir, "routes", collection, "content", `${name}.ts`);
-    if (await Bun.file(tsx).exists()) {
-      return `/${join2("routes", collection, "content", `${name}.tsx`).replace(/\\+/g, "/")}`;
-    }
-    if (await Bun.file(ts).exists()) {
-      return `/${join2("routes", collection, "content", `${name}.ts`).replace(/\\+/g, "/")}`;
+    const contentRoot = join2(clientDir, "routes", collection, "content");
+    const candidates = locale ? [
+      join2(contentRoot, locale, `${name}.tsx`),
+      join2(contentRoot, locale, `${name}.ts`),
+      join2(contentRoot, `${name}.tsx`),
+      join2(contentRoot, `${name}.ts`)
+    ] : [join2(contentRoot, `${name}.tsx`), join2(contentRoot, `${name}.ts`)];
+    for (const abs of candidates) {
+      if (await Bun.file(abs).exists()) {
+        const rel = abs.startsWith(clientDir) ? abs.slice(clientDir.length).replace(/^[/\\]/, "") : join2("routes", collection, "content", `${name}.tsx`);
+        return `/${rel.replace(/\\+/g, "/")}`;
+      }
     }
   } catch {}
   return null;
@@ -3033,11 +3573,18 @@ function duplicateQueryParamData(ssrData) {
   return duplicated;
 }
 function getContentKeyFromPathname(pathname) {
-  const pathOnly = pathname.split("?")[0].split("#")[0];
-  const parts = pathOnly.split("/").filter(Boolean);
-  if (parts.length < 2)
-    return null;
-  return `${parts[0]}:${parts[1]}`;
+  return resolveContentPathParts(pathname)?.key ?? null;
+}
+function createI18nScript(i18n) {
+  if (!i18n?.enabled)
+    return "";
+  try {
+    const json2 = escapeJsonForScript(JSON.stringify(i18n));
+    return `<script>(function(){try{var w=(typeof window!=='undefined'?window:globalThis);w.__REROUTE_I18N__=${json2};}catch(e){}})();</script>`;
+  } catch (error) {
+    console.error("[reroute] Failed to serialize i18n hydration:", error);
+    return "";
+  }
 }
 function createContentCaptureScript() {
   return `<script>(function(){try{var w=window;w.__REROUTE_INITIAL_HYDRATION__=true;var h={};document.querySelectorAll('[data-reroute-key]').forEach(function(el){var k=el.getAttribute('data-reroute-key');if(k)h[k]=el.innerHTML;});w.__REROUTE_CONTENT_HTML__=h;var r=document.querySelector('[data-reroute-route="ssr"]');if(r)w.__REROUTE_ROUTE_HTML__=r.innerHTML;}catch(e){}})();</script>`;
@@ -3113,13 +3660,14 @@ function createSSRPathnameScript(pathname) {
     return "";
   }
 }
-function createDataScript(ssrData, errorMsg, pathname, browserTelemetryConfig, traceContext, titleSuffix) {
+function createDataScript(ssrData, errorMsg, pathname, browserTelemetryConfig, traceContext, titleSuffix, i18n) {
   let script = "";
   script += createContentCaptureScript();
   script += createSSRPathnameScript(pathname);
   if (pathname) {
     script += createSSRExportsScript(pathname);
   }
+  script += createI18nScript(i18n);
   script += createTelemetryConfigScript(browserTelemetryConfig);
   script += createTraceContextScript(traceContext);
   script += createTitleSuffixScript(titleSuffix);
@@ -3139,7 +3687,9 @@ function createDataScript(ssrData, errorMsg, pathname, browserTelemetryConfig, t
   }
   return script;
 }
-var init_data2 = () => {};
+var init_data2 = __esm(() => {
+  init_content_path();
+});
 
 // packages/core/src/ssr/lib/scripts/feeds.ts
 function createFeedsScript() {
@@ -3367,10 +3917,10 @@ function generateCollectionScripts(byCollectionForSSR) {
   } catch {}
   return "";
 }
-function generateHydrationScripts(ssrData, isWatchMode, ssrError, collectionScripts = "", preloadScript = "", bundleUrl = "", pathname = "", browserTelemetryConfig, traceContext, titleSuffix) {
+function generateHydrationScripts(ssrData, isWatchMode, ssrError, collectionScripts = "", preloadScript = "", bundleUrl = "", pathname = "", browserTelemetryConfig, traceContext, titleSuffix, i18n) {
   let scripts = preloadScript;
   scripts += collectionScripts;
-  scripts += createDataScript(ssrData, isWatchMode ? ssrError : undefined, pathname, browserTelemetryConfig, traceContext, titleSuffix);
+  scripts += createDataScript(ssrData, isWatchMode ? ssrError : undefined, pathname, browserTelemetryConfig, traceContext, titleSuffix, i18n);
   scripts += createFeedsScript();
   scripts += createLlmsScript();
   if (bundleUrl) {
@@ -3533,7 +4083,7 @@ async function renderSSRDocument(options) {
   const browserTelemetryConfig = serializeBrowserTelemetryConfig2(browserTelemetryConfigRaw);
   const traceContext = getTraceContextForInjection(options.parentSpan);
   const hydrationScript = await withSpan("ssr.generate.scripts", async (span) => {
-    const script = generateHydrationScripts(setup2.ssrData, isWatchMode, setup2.ssrError, collectionScripts, setup2.preloadHydrationScript, bundleUrl, pathname, browserTelemetryConfig, traceContext, options.titleSuffix);
+    const script = generateHydrationScripts(setup2.ssrData, isWatchMode, setup2.ssrError, collectionScripts, setup2.preloadHydrationScript, bundleUrl, pathname, browserTelemetryConfig, traceContext, options.titleSuffix, options.i18n);
     span.setAttribute("reroute.scripts.size", script.length);
     return script;
   });
@@ -3551,12 +4101,13 @@ async function renderSSRDocument(options) {
     dedent(setup2.metadataResult.perPageHead)
   ].filter(Boolean).join(`
 `));
+  const i18nLocale = options.i18n?.enabled ? String(options.i18n.locale || "") : "";
   const html2 = withSpanSync("ssr.apply.template", (span) => {
     const result = applyIndexTemplate(baseTemplate, appHtml, {
       head: [setup2.inlineStyleTag, combinedHead].filter(Boolean).join(`
 `),
       hydrationScript,
-      lang: setup2.metadataResult.pageLang || lang,
+      lang: setup2.metadataResult.pageLang || i18nLocale || lang,
       appId
     });
     span.setAttributes({
@@ -4734,6 +5285,55 @@ async function discoverRoutes(cwd, isWatchMode) {
   }
   return { staticRoutes, dynamicRoutes };
 }
+function groupNamedCollectionItems(items) {
+  const byName = new Map;
+  for (const item of items) {
+    const name = String(item.name || "");
+    if (!name)
+      continue;
+    const list = byName.get(name) || [];
+    list.push(item);
+    byName.set(name, list);
+  }
+  return byName;
+}
+function resolveItemHref(collection, item, defaultLocale, localize) {
+  const name = String(item.name || "");
+  const locale = item.locale || defaultLocale;
+  if (name)
+    return localize(collection, name, locale, defaultLocale);
+  return String(item.href || "");
+}
+function buildNamedCollectionSitemapEntries(collection, name, variants, defaultLocale, base, localize) {
+  const locales = [
+    ...new Set(variants.map((v) => v.locale || defaultLocale).filter(Boolean))
+  ];
+  const alternates = locales.length > 1 ? [
+    ...locales.map((locale) => ({
+      hreflang: locale,
+      href: `${base}${localize(collection, name, locale, defaultLocale)}`
+    })),
+    {
+      hreflang: "x-default",
+      href: `${base}${localize(collection, name, defaultLocale, defaultLocale)}`
+    }
+  ] : undefined;
+  const entries = [];
+  for (const item of variants) {
+    const href = resolveItemHref(collection, item, defaultLocale, localize);
+    if (!href)
+      continue;
+    const meta = item.meta || {};
+    entries.push({
+      loc: `${base}${href}`,
+      lastmod: meta.date ? new Date(meta.date).toISOString() : undefined,
+      changefreq: "weekly",
+      priority: 0.7,
+      alternates
+    });
+  }
+  return entries;
+}
 async function discoverCollectionContent(cwd, collection, isWatchMode, baseUrl) {
   const entries = [];
   try {
@@ -4745,18 +5345,26 @@ async function discoverCollectionContent(cwd, collection, isWatchMode, baseUrl)
     const url = `${Bun.pathToFileURL(collectionFile).href}${isWatchMode ? `?t=${Date.now()}` : ""}`;
     const mod = await import(url);
     const items = mod.items || [];
+    const defaultLocale = mod.defaultLocale || "en-US";
+    const { localizeContentHref: localizeContentHref2 } = await Promise.resolve().then(() => (init_pathname(), exports_pathname));
+    const base = baseUrl.replace(/\/$/, "");
+    const byName = groupNamedCollectionItems(items);
+    for (const [name, variants] of byName) {
+      entries.push(...buildNamedCollectionSitemapEntries(collection, name, variants, defaultLocale, base, localizeContentHref2));
+    }
     for (const item of items) {
+      if (item.name)
+        continue;
       const href = String(item.href || "");
+      if (!href)
+        continue;
       const meta = item.meta || {};
-      if (href) {
-        const entry = {
-          loc: `${baseUrl}${href}`,
-          lastmod: meta.date ? new Date(meta.date).toISOString() : undefined,
-          changefreq: "weekly",
-          priority: 0.7
-        };
-        entries.push(entry);
-      }
+      entries.push({
+        loc: `${base}${href}`,
+        lastmod: meta.date ? new Date(meta.date).toISOString() : undefined,
+        changefreq: "weekly",
+        priority: 0.7
+      });
     }
   } catch (error) {
     console.error(`[reroute] Failed to discover collection ${collection}:`, error);
@@ -5051,11 +5659,17 @@ async function discoverCollectionFeedItems(cwd, collection, isWatchMode, baseUrl
     const url = `${Bun.pathToFileURL(collectionFile).href}${isWatchMode ? `?t=${Date.now()}` : ""}`;
     const mod = await import(url);
     const contentItems = mod.items || [];
+    const defaultLocale = mod.defaultLocale || "en-US";
+    const { localizeContentHref: localizeContentHref2 } = await Promise.resolve().then(() => (init_pathname(), exports_pathname));
     for (const item of contentItems) {
-      const href = String(item.href || "");
+      const name = String(item.name || "");
+      const locale = item.locale || defaultLocale;
+      const href = name ? localizeContentHref2(collection, name, locale, defaultLocale) : String(item.href || "");
       const meta = item.meta || {};
       if (href) {
-        items.push(createRSSItemFromMetaAndHref(href, meta, baseUrl, item, rssConfig));
+        const rssItem = createRSSItemFromMetaAndHref(href, meta, baseUrl, item, rssConfig);
+        rssItem.locale = locale;
+        items.push(rssItem);
       }
     }
   } catch (error) {
@@ -5321,7 +5935,7 @@ function generateRSSXML(feed, options = {}) {
     <link>${escapeXml(feed.link)}</link>
     <description>${escapeXml(feed.description)}</description>
     <lastBuildDate>${lastBuildDate}</lastBuildDate>
-    <language>en</language>
+    <language>${escapeXml(feed.language || "en")}</language>
     <atom:link href="${escapeXml(feed.link)}" rel="self" type="application/rss+xml" />
 ${itemsXML}
   </channel>
@@ -5483,6 +6097,7 @@ async function generateSitemap(discovery4, baseUrl, options = {}) {
   return createSingleSitemap(allEntries);
 }
 function generateSitemapXML(entries) {
+  const hasAlternates = entries.some((e) => e.alternates && e.alternates.length > 0);
   const urlsetEntries = entries.map((entry) => {
     let xml = `  <url>
     <loc>${escapeXml2(entry.loc)}</loc>`;
@@ -5498,13 +6113,20 @@ function generateSitemapXML(entries) {
       xml += `
     <priority>${entry.priority.toFixed(1)}</priority>`;
     }
+    if (entry.alternates?.length) {
+      for (const alt of entry.alternates) {
+        xml += `
+    <xhtml:link rel="alternate" hreflang="${escapeXml2(alt.hreflang)}" href="${escapeXml2(alt.href)}" />`;
+      }
+    }
     xml += `
   </url>`;
     return xml;
   }).join(`
 `);
+  const xhtmlNs = hasAlternates ? ' xmlns:xhtml="http://www.w3.org/1999/xhtml"' : "";
   return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"${xhtmlNs}>
 ${urlsetEntries}
 </urlset>`;
 }
@@ -5602,7 +6224,8 @@ async function renderSSRDocumentStream(options) {
       ...parts
     };
   });
-  const pageLang = setup2.metadataResult.pageLang || lang;
+  const i18nLocale = options.i18n?.enabled ? String(options.i18n.locale || "") : "";
+  const pageLang = setup2.metadataResult.pageLang || i18nLocale || lang;
   let headWithLang = htmlHead.replace(/<html([^>]*)>/i, (_m, attrs) => {
     const hasLang = /(^|\s)lang\s*=/.test(attrs);
     const newAttrs = hasLang ? attrs.replace(/lang\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/i, `lang="${pageLang}"`) : `${attrs} lang="${pageLang}"`;
@@ -5645,7 +6268,8 @@ async function renderSSRDocumentStream(options) {
     parentSpan: options.parentSpan,
     timeout: options.timeout,
     ssrExport: setup2.metadataResult.ssrExport,
-    titleSuffix: options.titleSuffix
+    titleSuffix: options.titleSuffix,
+    i18n: options.i18n
   });
   if (debug)
     console.log(`[renderStream] ${pathname} - returning stream: ${(performance.now() - t0).toFixed(2)}ms`);
@@ -5758,7 +6382,7 @@ function buildStreamingScripts(ctx) {
       ssrDataSnapshot[key] = value;
     }
   }
-  const dataScript = createDataScript(ssrDataSnapshot, ctx.isWatchMode ? ctx.ssrError : undefined, ctx.pathname, ctx.browserTelemetryConfig, ctx.traceContext, ctx.titleSuffix);
+  const dataScript = createDataScript(ssrDataSnapshot, ctx.isWatchMode ? ctx.ssrError : undefined, ctx.pathname, ctx.browserTelemetryConfig, ctx.traceContext, ctx.titleSuffix, ctx.i18n);
   const feedsScript = createFeedsScript();
   const llmsScript = createLlmsScript();
   let allScripts = dataScript + feedsScript + llmsScript + collectionScripts + ctx.preloadHydrationScript;
@@ -5890,6 +6514,7 @@ var init_src = __esm(() => {
   init_bundler();
   init_config();
   init_content();
+  init_i18n();
   init_llms();
   init_og();
   init_robots();
@@ -5902,6 +6527,7 @@ var init_src = __esm(() => {
 var exports_core = {};
 __export(exports_core, {
   toPromise: () => toPromise,
+  toOgLocale: () => toOgLocale,
   toBytes: () => toBytes,
   stripStart: () => stripStart,
   stripHtmlTags: () => stripHtmlTags,
@@ -5913,6 +6539,7 @@ __export(exports_core, {
   setGlobalSSRData: () => setGlobalSSRData,
   setGlobalCollections: () => setGlobalCollections,
   seedSSRModuleForPath: () => seedSSRModuleForPath,
+  resolveLocale: () => resolveLocale,
   resetSSRAccessTracking: () => resetSSRAccessTracking,
   renderSSRDocumentStream: () => renderSSRDocumentStream,
   renderSSRDocument: () => renderSSRDocument,
@@ -5921,7 +6548,17 @@ __export(exports_core, {
   processCollections: () => processCollections,
   preloadContentModule: () => preloadContentModule,
   performSSRSetup: () => performSSRSetup,
+  parseCookieValue: () => parseCookieValue,
+  parseContentPath: () => parseContentPath,
+  normalizePathname: () => normalizePathname,
+  negotiateLocale: () => negotiateLocale,
   mergeLayoutData: () => mergeLayoutData,
+  matchRoutes: () => matchRoutes,
+  matchRoutePattern: () => matchRoutePattern,
+  lookupMessage: () => lookupMessage,
+  looksLikeLocale: () => looksLikeLocale,
+  localizeHref: () => localizeHref,
+  localizeContentHref: () => localizeContentHref,
   loadRoutesModule: () => loadRoutesModule,
   loadOGImageComponent: () => loadOGImageComponent,
   loadIndexHtml: () => loadIndexHtml,
@@ -5934,11 +6571,13 @@ __export(exports_core, {
   inlineTailwindCSS: () => inlineTailwindCSS,
   importContentModuleForPath: () => importContentModuleForPath,
   htmlToMarkdown: () => htmlToMarkdown,
+  hreflangTags: () => hreflangTags,
   gzipIfAccepted: () => gzipIfAccepted,
   getSitemapExcludedRoutes: () => getSitemapExcludedRoutes,
   getRedirectSourcePaths: () => getRedirectSourcePaths,
   getPatternDepth: () => getPatternDepth,
   getMimeType: () => getMimeType,
+  getMessage: () => getMessage,
   getMatchingLayouts: () => getMatchingLayouts,
   getContentMeta: () => getContentMeta,
   generateSitemapXML: () => generateSitemapXML,
@@ -5955,6 +6594,7 @@ __export(exports_core, {
   generateContentHash: () => generateContentHash,
   generateCollectionScripts: () => generateCollectionScripts,
   generateAtomXML: () => generateAtomXML,
+  formatMessage: () => formatMessage,
   formatAsText: () => formatAsText,
   formatAsMarkdown: () => formatAsMarkdown,
   findOGImageForPath: () => findOGImageForPath,
@@ -5974,10 +6614,12 @@ __export(exports_core, {
   discoverRoutes: () => discoverRoutes,
   discoverRobotsData: () => discoverRobotsData,
   discoverRSSData: () => discoverRSSData,
+  discoverI18n: () => discoverI18n,
   discoverCollections: () => discoverCollections,
   discoverCollectionContent: () => discoverCollectionContent,
   defineConfig: () => defineConfig,
   deduplicateMetaTags: () => deduplicateMetaTags,
+  createTranslator: () => createTranslator,
   createLlmsScript: () => createLlmsScript,
   createLayoutDataKey: () => createLayoutDataKey,
   createLayoutCacheKey: () => createLayoutCacheKey,
@@ -5985,13 +6627,17 @@ __export(exports_core, {
   createDataScript: () => createDataScript,
   createCollectionScript: () => createCollectionScript,
   createBundlePreload: () => createBundlePreload,
+  contentNegotiateRedirect: () => contentNegotiateRedirect,
+  contentKey: () => contentKey,
   computeSSRDataForPath: () => computeSSRDataForPath,
   computeSSRData: () => computeSSRData,
   computeRouteData: () => computeRouteData,
   computeLayoutData: () => computeLayoutData,
   computeContentData: () => computeContentData,
   compressStreamIfAccepted: () => compressStreamIfAccepted,
+  compareRouteSpecificity: () => compareRouteSpecificity,
   cleanupPathScopedSSRData: () => cleanupPathScopedSSRData,
+  buildLocaleCookie: () => buildLocaleCookie,
   buildHeadFromMeta: () => buildHeadFromMeta,
   blockSearchCrawlers: () => blockSearchCrawlers,
   blockAITrainingCrawlers: () => blockAITrainingCrawlers,
@@ -6007,6 +6653,9 @@ __export(exports_core, {
   SEARCH_CRAWLERS: () => SEARCH_CRAWLERS,
   LRUCache: () => LRUCache,
   DefaultOGTemplate: () => DefaultOGTemplate,
+  DEFAULT_LOCALES_DIR: () => DEFAULT_LOCALES_DIR,
+  DEFAULT_LOCALE: () => DEFAULT_LOCALE,
+  DEFAULT_COOKIE: () => DEFAULT_COOKIE,
   AI_CRAWLERS: () => AI_CRAWLERS
 });
 var init_core = __esm(() => {
@@ -6031,7 +6680,7 @@ function getNamingConfig(options) {
 
 // packages/cli/src/commands/lib/env.ts
 import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function parseEnvFile(content2) {
   const env = {};
   const lines = content2.split(`
@@ -6057,7 +6706,7 @@ function loadEnvFiles(cwd, mode = "development") {
   const env = {};
   const loadedFiles = [];
   for (const file of envFiles) {
-    const filePath = join3(cwd, file);
+    const filePath = join4(cwd, file);
     if (existsSync2(filePath)) {
       try {
         const content2 = readFileSync(filePath, "utf-8");
@@ -6101,11 +6750,11 @@ var init_env = () => {};
 
 // packages/cli/src/commands/lib/markdown/availability.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { dirname, join as join4 } from "node:path";
+import { dirname, join as join5 } from "node:path";
 function isPackageAvailable(cwd, packageName) {
   let currentDir = cwd;
   for (let i = 0;i < 5; i++) {
-    const packageJsonPath = join4(currentDir, "package.json");
+    const packageJsonPath = join5(currentDir, "package.json");
     if (existsSync3(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
@@ -6177,7 +6826,7 @@ var init_availability = () => {};
 
 // packages/cli/src/commands/lib/markdown/processor.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
-import { basename as basename2, dirname as dirname2, extname as extname2, join as join5, relative, resolve } from "node:path";
+import { basename as basename2, dirname as dirname2, extname as extname2, join as join6, relative, resolve } from "node:path";
 import matter from "gray-matter";
 function convertPropertiesToJsx(properties) {
   const newProperties = {};
@@ -6236,7 +6885,7 @@ function processMarkdownFile(filePath) {
 function isMdxAvailable2(cwd) {
   let currentDir = cwd;
   for (let i = 0;i < 5; i++) {
-    const packageJsonPath = join5(currentDir, "package.json");
+    const packageJsonPath = join6(currentDir, "package.json");
     if (existsSync4(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
@@ -6260,10 +6909,10 @@ function isMdxAvailable2(cwd) {
 }
 function tryLoadModule(cwd, moduleName) {
   const pathsToTry = [
-    join5(cwd, `node_modules/${moduleName}`),
-    join5(cwd, `../node_modules/${moduleName}`),
-    join5(cwd, `../../node_modules/${moduleName}`),
-    join5(cwd, `../../../node_modules/${moduleName}`)
+    join6(cwd, `node_modules/${moduleName}`),
+    join6(cwd, `../node_modules/${moduleName}`),
+    join6(cwd, `../../node_modules/${moduleName}`),
+    join6(cwd, `../../../node_modules/${moduleName}`)
   ];
   for (const modulePath of pathsToTry) {
     try {
@@ -6593,7 +7242,7 @@ function isProductionMode(args = []) {
 }
 
 // packages/cli/src/commands/lib/streaming/analyzer.ts
-import { dirname as dirname3, join as join6 } from "node:path";
+import { dirname as dirname3, join as join7 } from "node:path";
 function hasSSRDataExport(source) {
   if (SSR_DATA_INLINE_EXPORT_REGEX.test(source)) {
     return true;
@@ -6621,10 +7270,10 @@ async function analyzeRouteForStreaming(options) {
 }
 async function findSkeletonForTarget(routesDir, relativePath, type) {
   const dirName = normalizeRelativePath(dirname3(relativePath));
-  const baseDir = dirName === "." ? routesDir : join6(routesDir, dirName).replace(/\\/g, "/");
+  const baseDir = dirName === "." ? routesDir : join7(routesDir, dirName).replace(/\\/g, "/");
   const candidates = type === "layout" ? ["[layout+skeleton].tsx", "[layout+skeleton].ts"] : ["[skeleton].tsx", "[skeleton].ts"];
   for (const candidate of candidates) {
-    const candidatePath = join6(baseDir, candidate);
+    const candidatePath = join7(baseDir, candidate);
     try {
       const file = Bun.file(candidatePath);
       if (await file.exists()) {
@@ -6645,12 +7294,12 @@ var init_analyzer = __esm(() => {
 });
 
 // packages/cli/src/commands/lib/streaming/suspense.ts
-import { dirname as dirname4, join as join7, relative as relative2 } from "node:path";
+import { dirname as dirname4, join as join8, relative as relative2 } from "node:path";
 async function generateStreamingWrapper(options) {
   const { cwd, relativeFilePath, analysis, config: config2 } = options;
-  const streamingModulePath = join7(cwd, ".reroute", "streaming", relativeFilePath).replace(/\.(tsx|ts)$/, ".tsx");
+  const streamingModulePath = join8(cwd, ".reroute", "streaming", relativeFilePath).replace(/\.(tsx|ts)$/, ".tsx");
   const wrapperDir = dirname4(streamingModulePath);
-  const originalModuleWithoutExt = removeExtension(join7(cwd, "src", "client", "routes", relativeFilePath));
+  const originalModuleWithoutExt = removeExtension(join8(cwd, "src", "client", "routes", relativeFilePath));
   const originalImportPath = toImportPath(wrapperDir, originalModuleWithoutExt);
   const skeletonImportBlock = await resolveSkeletonBlock({
     analysis,
@@ -6692,7 +7341,7 @@ async function resolveSkeletonBlock(args) {
 }
 function resolveConfiguredSkeletonPath(value, cwd) {
   if (typeof value === "string" && value.trim().length > 0) {
-    return value.startsWith("/") ? value : join7(cwd, value);
+    return value.startsWith("/") ? value : join8(cwd, value);
   }
   if (value && !warnedSkeletonType) {
     console.warn("[reroute/streaming] default skeletons must be provided as string module paths in reroute.config.ts");
@@ -6729,13 +7378,13 @@ var init_suspense = () => {};
 // packages/cli/src/commands/lib/tailwind.ts
 import { spawn } from "node:child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function isTailwindAvailable(cwd) {
   const pathsToTry = [
-    join8(cwd, "package.json"),
-    join8(cwd, "../package.json"),
-    join8(cwd, "../../package.json"),
-    join8(cwd, "../../../package.json")
+    join9(cwd, "package.json"),
+    join9(cwd, "../package.json"),
+    join9(cwd, "../../package.json"),
+    join9(cwd, "../../../package.json")
   ];
   for (const packageJsonPath of pathsToTry) {
     if (!existsSync5(packageJsonPath)) {
@@ -6756,8 +7405,8 @@ function isTailwindAvailable(cwd) {
   return false;
 }
 function getTailwindPaths(cwd) {
-  const input = join8(cwd, "src/client/theme.css");
-  const output = join8(cwd, ".reroute/theme.css");
+  const input = join9(cwd, "src/client/theme.css");
+  const output = join9(cwd, ".reroute/theme.css");
   return { input, output };
 }
 function hasTailwindInput(cwd) {
@@ -6774,10 +7423,10 @@ function hasTailwindInput(cwd) {
 }
 function resolveTailwindBin(cwd) {
   const pathsToTry = [
-    join8(cwd, "node_modules/.bin/tailwindcss"),
-    join8(cwd, "../node_modules/.bin/tailwindcss"),
-    join8(cwd, "../../node_modules/.bin/tailwindcss"),
-    join8(cwd, "../../../node_modules/.bin/tailwindcss")
+    join9(cwd, "node_modules/.bin/tailwindcss"),
+    join9(cwd, "../node_modules/.bin/tailwindcss"),
+    join9(cwd, "../../node_modules/.bin/tailwindcss"),
+    join9(cwd, "../../../node_modules/.bin/tailwindcss")
   ];
   for (const binPath of pathsToTry) {
     if (existsSync5(binPath)) {
@@ -6848,12 +7497,12 @@ __export(exports_gen, {
   default: () => gen
 });
 import { watch } from "node:fs";
-import { mkdir as mkdir2, readdir as readdir5, rm } from "node:fs/promises";
-import { dirname as dirname5, join as join9 } from "node:path";
+import { mkdir as mkdir2, readdir as readdir7, rm } from "node:fs/promises";
+import { dirname as dirname5, join as join10 } from "node:path";
 import { pathToFileURL as pathToFileURL8 } from "node:url";
 async function bundleThemeCssIntoArtifacts(cwd) {
-  const themeCssPath = join9(cwd, ".reroute", "theme.css");
-  const artifactsPath = join9(cwd, OUTPUT_ARTIFACTS);
+  const themeCssPath = join10(cwd, ".reroute", "theme.css");
+  const artifactsPath = join10(cwd, OUTPUT_ARTIFACTS);
   try {
     const cssContent = await Bun.file(themeCssPath).text();
     if (!cssContent)
@@ -6879,11 +7528,11 @@ async function bundleThemeCssIntoArtifacts(cwd) {
 async function ensureOutputDir(cwd, options = {}) {
   const { clean = true } = options;
   try {
-    const outputPath = join9(cwd, OUTPUT_DIR);
+    const outputPath = join10(cwd, OUTPUT_DIR);
     if (clean) {
       let needsCleanup = false;
       try {
-        const entries = await readdir5(outputPath);
+        const entries = await readdir7(outputPath);
         needsCleanup = entries.length > 0;
       } catch {}
       if (needsCleanup) {
@@ -6892,9 +7541,9 @@ async function ensureOutputDir(cwd, options = {}) {
       }
     }
     await mkdir2(outputPath, { recursive: true });
-    await mkdir2(join9(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
-    await mkdir2(join9(cwd, ".reroute/bundles"), { recursive: true });
-    await mkdir2(join9(cwd, ".reroute/streaming"), { recursive: true });
+    await mkdir2(join10(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
+    await mkdir2(join10(cwd, ".reroute/bundles"), { recursive: true });
+    await mkdir2(join10(cwd, ".reroute/streaming"), { recursive: true });
   } catch {}
 }
 async function writeStubFiles(cwd) {
@@ -6952,11 +7601,11 @@ import './artifacts';
 import './routes'; // Import routes (bundles all route components)
 import '../src/index';
 `;
-  await Bun.write(join9(cwd, OUTPUT_ROUTES), STUB_ROUTES);
-  await Bun.write(join9(cwd, OUTPUT_CONTENT_TS), STUB_CONTENT);
-  await Bun.write(join9(cwd, OUTPUT_ARTIFACTS), STUB_ARTIFACTS);
-  await Bun.write(join9(cwd, OUTPUT_INDEX), STUB_INDEX);
-  await Bun.write(join9(cwd, ".reroute/entry.ts"), STUB_ENTRY);
+  await Bun.write(join10(cwd, OUTPUT_ROUTES), STUB_ROUTES);
+  await Bun.write(join10(cwd, OUTPUT_CONTENT_TS), STUB_CONTENT);
+  await Bun.write(join10(cwd, OUTPUT_ARTIFACTS), STUB_ARTIFACTS);
+  await Bun.write(join10(cwd, OUTPUT_INDEX), STUB_INDEX);
+  await Bun.write(join10(cwd, ".reroute/entry.ts"), STUB_ENTRY);
   console.log("[reroute/gen] Initialized stub files");
 }
 function shouldSkipFile(relativePath, entryName) {
@@ -6976,10 +7625,10 @@ function shouldSkipFile(relativePath, entryName) {
 }
 async function scanDirectory(dir, base = "") {
   const files = [];
-  const entries = await readdir5(dir, { withFileTypes: true });
+  const entries = await readdir7(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join9(dir, entry.name);
-    const relativePath = join9(base, entry.name);
+    const fullPath = join10(dir, entry.name);
+    const relativePath = join10(base, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "content")
         continue;
@@ -6995,10 +7644,10 @@ async function scanDirectory(dir, base = "") {
 }
 async function scan404Files(dir, base = "") {
   const files = [];
-  const entries = await readdir5(dir, { withFileTypes: true });
+  const entries = await readdir7(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join9(dir, entry.name);
-    const relativePath = join9(base, entry.name);
+    const fullPath = join10(dir, entry.name);
+    const relativePath = join10(base, entry.name);
     if (entry.isDirectory()) {
       const nested = await scan404Files(fullPath, relativePath);
       files.push(...nested);
@@ -7011,10 +7660,10 @@ async function scan404Files(dir, base = "") {
 }
 async function scanOgFiles(dir, base = "") {
   const files = [];
-  const entries = await readdir5(dir, { withFileTypes: true });
+  const entries = await readdir7(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join9(dir, entry.name);
-    const relativePath = join9(base, entry.name);
+    const fullPath = join10(dir, entry.name);
+    const relativePath = join10(base, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "content")
         continue;
@@ -7068,17 +7717,7 @@ function fileToRoute(filePath) {
   };
 }
 function sortRoutes(routes) {
-  return routes.sort((a, b) => {
-    const aDepth = a.pattern.split("/").length;
-    const bDepth = b.pattern.split("/").length;
-    if (aDepth !== bDepth)
-      return bDepth - aDepth;
-    const aDynamicCount = a.params.length;
-    const bDynamicCount = b.params.length;
-    if (aDynamicCount !== bDynamicCount)
-      return aDynamicCount - bDynamicCount;
-    return a.pattern.localeCompare(b.pattern);
-  });
+  return routes.sort((a, b) => compareRouteSpecificity(a, b));
 }
 function generateRouteTree(files) {
   const routes = [];
@@ -7237,26 +7876,38 @@ export function matchRoute(pathname: string): { route: Route; params: Record<str
 function matchPattern(route: Route, pathname: string): Record<string, string> | null {
   const patternParts = route.pattern.split('/').filter(Boolean);
   const pathnameParts = pathname.split('/').filter(Boolean);
-
-  if (patternParts.length !== pathnameParts.length) {
-    return null;
-  }
-
   const params: Record<string, string> = {};
+  let pathnameIndex = 0;
 
   for (let i = 0; i < patternParts.length; i++) {
     const patternPart = patternParts[i];
-    const pathnamePart = pathnameParts[i];
 
     if (patternPart.startsWith(':')) {
       const paramName = patternPart.slice(1);
+      if (paramName.startsWith('...')) {
+        if (i !== patternParts.length - 1 || pathnameIndex >= pathnameParts.length) {
+          return null;
+        }
+
+        params[paramName.slice(3)] = pathnameParts.slice(pathnameIndex).join('/');
+        return params;
+      }
+
+      const pathnamePart = pathnameParts[pathnameIndex];
+      if (pathnamePart === undefined) {
+        return null;
+      }
+
       params[paramName] = pathnamePart;
-    } else if (patternPart !== pathnamePart) {
+      pathnameIndex += 1;
+    } else if (patternPart !== pathnameParts[pathnameIndex]) {
       return null;
+    } else {
+      pathnameIndex += 1;
     }
   }
 
-  return params;
+  return pathnameIndex === pathnameParts.length ? params : null;
 }
 
 // Set globals for compiled binary support (sitemap/RSS/robots discovery)
@@ -7266,7 +7917,7 @@ function matchPattern(route: Route, pathname: string): Record<string, string> |
 `;
 }
 async function buildStreamingWrappersForTree(cwd, routesPath, tree, config2) {
-  const streamingDir = join9(cwd, ".reroute", "streaming");
+  const streamingDir = join10(cwd, ".reroute", "streaming");
   const analyses = new Map;
   const candidates = [
     ...tree.routes.map((route) => ({
@@ -7285,7 +7936,7 @@ async function buildStreamingWrappersForTree(cwd, routesPath, tree, config2) {
   for (const candidate of candidates) {
     if (!/\.(tsx|ts)$/.test(candidate.filePath))
       continue;
-    const absolutePath = join9(routesPath, candidate.filePath);
+    const absolutePath = join10(routesPath, candidate.filePath);
     const analysis = await analyzeRouteForStreaming({
       absolutePath,
       relativePath: candidate.filePath,
@@ -7294,7 +7945,7 @@ async function buildStreamingWrappersForTree(cwd, routesPath, tree, config2) {
     });
     if (!analysis.needsStreaming)
       continue;
-    const wrapperPath = join9(streamingDir, candidate.filePath).replace(/\.(tsx|ts)$/, ".tsx");
+    const wrapperPath = join10(streamingDir, candidate.filePath).replace(/\.(tsx|ts)$/, ".tsx");
     await mkdir2(dirname5(wrapperPath), { recursive: true });
     const code = await generateStreamingWrapper({
       cwd,
@@ -7311,10 +7962,42 @@ async function buildStreamingWrappersForTree(cwd, routesPath, tree, config2) {
   }
   return analyses;
 }
+function isLocaleDirName(name) {
+  return /^[a-z]{2}(?:-[A-Za-z0-9]{2,8})*$/i.test(name);
+}
+function isContentFileName(name) {
+  return /\.(tsx|ts|md|mdx)$/.test(name) && !name.startsWith("_");
+}
+async function listLocaleContentFiles(collectionDir, locale) {
+  try {
+    const nested = await readdir7(join10(collectionDir, locale), {
+      withFileTypes: true
+    });
+    const files = [];
+    for (const n of nested) {
+      if (n.isFile() && isContentFileName(n.name)) {
+        files.push({ relativePath: join10(locale, n.name), locale });
+      }
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
 async function listContentFiles2(collectionDir) {
   try {
-    const entries = await readdir5(collectionDir, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && /\.(tsx|ts|md|mdx)$/.test(e.name) && !e.name.startsWith("_")).map((e) => e.name);
+    const entries = await readdir7(collectionDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      if (entry.isFile() && isContentFileName(entry.name)) {
+        files.push({ relativePath: entry.name });
+        continue;
+      }
+      if (entry.isDirectory() && isLocaleDirName(entry.name)) {
+        files.push(...await listLocaleContentFiles(collectionDir, entry.name));
+      }
+    }
+    return files;
   } catch {
     return [];
   }
@@ -7371,11 +8054,14 @@ ${spaces}}`;
   }
   return serializeValue(config2);
 }
-async function buildSingleContentChunk(cwd, collection, file, contentDir, args) {
-  const name = file.replace(/\.(tsx|ts|md|mdx)$/, "");
-  const absSrc = join9(contentDir, file);
+async function buildSingleContentChunk(cwd, collection, fileRef, contentDir, args, defaultLocale) {
+  const file = fileRef.relativePath;
+  const locale = fileRef.locale || defaultLocale;
+  const baseName = file.split("/").pop() || file;
+  const name = baseName.replace(/\.(tsx|ts|md|mdx)$/, "");
+  const absSrc = join10(contentDir, file);
   const isMarkdown = /\.(md|mdx)$/.test(file);
-  const buildSrc = isMarkdown ? join9(cwd, ".reroute", "markdown", collection, "content", `${name}.tsx`) : absSrc;
+  const buildSrc = isMarkdown ? join10(cwd, ".reroute", "markdown", collection, "content", file.replace(/\.(md|mdx)$/, ".tsx")) : absSrc;
   if (isMarkdown) {
     try {
       const exists = await Bun.file(buildSrc).exists();
@@ -7421,10 +8107,11 @@ async function buildSingleContentChunk(cwd, collection, file, contentDir, args)
     return null;
   }
   const hash2 = await sha8(code);
-  const chunkRelDir = join9(".reroute", "bundles");
-  const chunkAbsDir = join9(cwd, chunkRelDir);
-  const outFile = `${collection}-${name}.${hash2}.js`;
-  const absOut = join9(chunkAbsDir, outFile);
+  const chunkRelDir = join10(".reroute", "bundles");
+  const chunkAbsDir = join10(cwd, chunkRelDir);
+  const localeSuffix = locale !== defaultLocale ? `${locale}-` : "";
+  const outFile = `${collection}-${localeSuffix}${name}.${hash2}.js`;
+  const absOut = join10(chunkAbsDir, outFile);
   if (sourcemapContent) {
     code = code.replace(/\/\/# sourceMappingURL=.*\.js\.map/, `//# sourceMappingURL=${outFile}.map`);
   }
@@ -7454,26 +8141,27 @@ async function buildSingleContentChunk(cwd, collection, file, contentDir, args)
     slug: name,
     href: `/${collection}/${name}`,
     moduleUrl: `/bundles/${outFile}`,
-    meta
+    meta,
+    locale
   };
 }
-async function buildContentChunks(cwd, args = []) {
-  const routesRoot = join9(cwd, ROUTES_DIR);
+async function buildContentChunks(cwd, args = [], defaultLocale = "en-US") {
+  const routesRoot = join10(cwd, ROUTES_DIR);
   console.log(`[reroute/content] scan ${routesRoot}`);
-  const collections2 = await readdir5(routesRoot, { withFileTypes: true });
+  const collections2 = await readdir7(routesRoot, { withFileTypes: true });
   const results = [];
   for (const c of collections2) {
     if (!c.isDirectory())
       continue;
     const collection = c.name;
-    const contentDir = join9(routesRoot, collection, "content");
+    const contentDir = join10(routesRoot, collection, "content");
     console.log(`[reroute/content] collection ${collection} dir ${contentDir}`);
     const files = await listContentFiles2(contentDir);
     console.log(`[reroute/content] files ${files.length}`);
     if (!files.length)
       continue;
     for (const file of files) {
-      const result = await buildSingleContentChunk(cwd, collection, file, contentDir, args);
+      const result = await buildSingleContentChunk(cwd, collection, file, contentDir, args, defaultLocale);
       if (result) {
         results.push(result);
       }
@@ -7486,7 +8174,7 @@ async function buildContentChunks(cwd, args = []) {
   lines.push("");
   lines.push("export const contents = [");
   for (const e of results) {
-    lines.push("  { collection: '" + e.collection + "', slug: '" + e.slug + "', name: '" + e.name + "', href: '" + e.href + "', module: '" + e.moduleUrl + "', meta: " + JSON.stringify(e.meta || {}) + " },");
+    lines.push("  { collection: '" + e.collection + "', slug: '" + e.slug + "', name: '" + e.name + "', href: '" + e.href + "', module: '" + e.moduleUrl + "', locale: '" + e.locale + "', meta: " + JSON.stringify(e.meta || {}) + " },");
   }
   lines.push("] as const;");
   lines.push("");
@@ -7494,20 +8182,31 @@ async function buildContentChunks(cwd, args = []) {
   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("for (const c of contents) {");
+  lines.push(`  const cur = (byCollectionAndName[c.collection] ||= {})[c.name];`);
+  lines.push(`  if (!cur || c.locale === ${JSON.stringify(defaultLocale)}) (byCollectionAndName[c.collection] ||= {})[c.name] = c as any;`);
+  lines.push("}");
+  lines.push("");
+  lines.push("export const byCollectionNameLocale: Record<string, Record<string, Record<string, any>>> = {};");
+  lines.push("for (const c of contents) { (((byCollectionNameLocale[c.collection] ||= {})[c.name] ||= {})[c.locale] = 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("export function getContentEntry<C extends string, N extends string>(collection: C, name: N, locale?: string) {");
+  lines.push("  if (locale) {");
+  lines.push("    const byLocale = (byCollectionNameLocale as any)[collection]?.[name];");
+  lines.push("    if (byLocale?.[locale]) return byLocale[locale];");
+  lines.push(`    if (byLocale?.[${JSON.stringify(defaultLocale)}]) return byLocale[${JSON.stringify(defaultLocale)}];`);
+  lines.push("  }");
   lines.push("  const m = (byCollectionAndName as any)[collection];");
   lines.push("  return m ? (m as Record<string, any>)[name] : undefined;");
   lines.push("}");
   lines.push("");
   const writes = [];
   writes.push({
-    path: join9(cwd, OUTPUT_CONTENT_TS),
+    path: join10(cwd, OUTPUT_CONTENT_TS),
     content: lines.join(`
 `)
   });
@@ -7519,20 +8218,29 @@ async function buildContentChunks(cwd, args = []) {
     js.push("");
     js.push("export const items = [");
     for (const e of items) {
-      js.push(`  { collection: '${e.collection}', slug: '${e.slug}', name: '${e.name}', href: '${e.href}', module: '${e.moduleUrl}', meta: ${JSON.stringify(e.meta || {})} },`);
+      js.push(`  { collection: '${e.collection}', slug: '${e.slug}', name: '${e.name}', href: '${e.href}', module: '${e.moduleUrl}', locale: '${e.locale}', 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("export const byNameLocale = {};");
+    js.push("for (const it of items) {");
+    js.push("  ((byNameLocale[it.name] ||= {})[it.locale] = it);");
+    js.push(`  if (!byName[it.name] || it.locale === ${JSON.stringify(defaultLocale)}) byName[it.name] = it;`);
+    js.push("}");
+    js.push("");
+    js.push(`export const defaultLocale = ${JSON.stringify(defaultLocale)};`);
     js.push("");
-    js.push("export function get(collectionName, name) {");
+    js.push("export function get(collectionName, name, locale) {");
     js.push(`  if (collectionName !== '${collection}') return undefined;`);
+    js.push("  if (locale && byNameLocale[name]) {");
+    js.push("    return byNameLocale[name][locale] || byNameLocale[name][defaultLocale] || byName[name];");
+    js.push("  }");
     js.push("  return byName[name];");
     js.push("}");
     js.push("");
     writes.push({
-      path: join9(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`),
+      path: join10(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`),
       content: js.join(`
 `)
     });
@@ -7556,8 +8264,10 @@ async function buildSearchIndex(cwd, config2, args = []) {
     minHeadingLevel = 1,
     maxHeadingLevel = 6
   } = searchConfig;
-  const routesRoot = join9(cwd, ROUTES_DIR);
-  const collections2 = await readdir5(routesRoot, { withFileTypes: true });
+  const routesRoot = join10(cwd, ROUTES_DIR);
+  const collections2 = await readdir7(routesRoot, { withFileTypes: true });
+  const i18n2 = await discoverI18n(cwd, config2.i18n);
+  const defaultLocale = i18n2.defaultLocale;
   const searchIndex = [];
   for (const c of collections2) {
     if (!c.isDirectory())
@@ -7566,14 +8276,17 @@ async function buildSearchIndex(cwd, config2, args = []) {
     if (targetCollections.length > 0 && !targetCollections.includes(collection)) {
       continue;
     }
-    const contentDir = join9(routesRoot, collection, "content");
+    const contentDir = join10(routesRoot, collection, "content");
     try {
-      const files = await readdir5(contentDir);
-      for (const file of files) {
+      const files = await listContentFiles2(contentDir);
+      for (const fileRef of files) {
+        const file = fileRef.relativePath;
         if (!/\.(md|mdx)$/.test(file))
           continue;
-        const name = file.replace(/\.(md|mdx)$/, "");
-        const filePath = join9(contentDir, file);
+        const baseName = file.split("/").pop() || file;
+        const name = baseName.replace(/\.(md|mdx)$/, "");
+        const locale = fileRef.locale || defaultLocale;
+        const filePath = join10(contentDir, file);
         try {
           const processed = processMarkdownFile(filePath);
           const { frontmatter, content: content2 } = processed;
@@ -7587,16 +8300,18 @@ async function buildSearchIndex(cwd, config2, args = []) {
             maxLevel: maxHeadingLevel
           });
           const excerpt = String(frontmatter?.excerpt || frontmatter?.description || stripMarkdown(content2).slice(0, 160));
+          const href = localizeContentHref(collection, name, locale, defaultLocale);
           const entry = {
-            id: `${collection}:${name}`,
+            id: locale !== defaultLocale ? `${collection}:${name}:${locale}` : `${collection}:${name}`,
             collection,
             name,
             slug: name,
-            href: `/${collection}/${name}`,
+            href,
             title: String(frontmatter?.title || name),
             excerpt,
             headings,
-            meta: {}
+            meta: {},
+            locale
           };
           for (const field of metaFields) {
             if (frontmatter[field] !== undefined) {
@@ -7619,13 +8334,13 @@ async function buildSearchIndex(cwd, config2, args = []) {
     generated: new Date().toISOString(),
     entries: searchIndex
   };
-  await Bun.write(join9(cwd, OUTPUT_SEARCH_INDEX), JSON.stringify(indexData, null, 2));
-  console.log(`[reroute/search] Generated search index with ${searchIndex.length} entries: ${join9(cwd, OUTPUT_SEARCH_INDEX)}`);
+  await Bun.write(join10(cwd, OUTPUT_SEARCH_INDEX), JSON.stringify(indexData, null, 2));
+  console.log(`[reroute/search] Generated search index with ${searchIndex.length} entries: ${join10(cwd, OUTPUT_SEARCH_INDEX)}`);
 }
 async function preprocessMarkdownFiles(cwd, config2) {
   console.log("[reroute/markdown] Starting markdown preprocessing...");
-  const routesPath = join9(cwd, ROUTES_DIR);
-  const markdownDir = join9(cwd, ".reroute", "markdown");
+  const routesPath = join10(cwd, ROUTES_DIR);
+  const markdownDir = join10(cwd, ".reroute", "markdown");
   try {
     await rm(markdownDir, { force: true, recursive: true });
   } catch {}
@@ -7633,10 +8348,10 @@ async function preprocessMarkdownFiles(cwd, config2) {
   async function scanMarkdown(dir, base = "") {
     const files = [];
     try {
-      const entries = await readdir5(dir, { withFileTypes: true });
+      const entries = await readdir7(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join9(dir, entry.name);
-        const relativePath = join9(base, entry.name);
+        const fullPath = join10(dir, entry.name);
+        const relativePath = join10(base, entry.name);
         if (entry.isDirectory()) {
           const nested = await scanMarkdown(fullPath, relativePath);
           files.push(...nested);
@@ -7658,8 +8373,8 @@ async function preprocessMarkdownFiles(cwd, config2) {
   }
   console.log(`[reroute/markdown] Found ${markdownFiles.length} markdown file(s)`);
   for (const file of markdownFiles) {
-    const sourcePath = join9(routesPath, file);
-    const targetPath = join9(markdownDir, file.replace(/\.mdx?$/, ".tsx"));
+    const sourcePath = join10(routesPath, file);
+    const targetPath = join10(markdownDir, file.replace(/\.mdx?$/, ".tsx"));
     try {
       const processed = processMarkdownFile(sourcePath);
       const isMdx = file.endsWith(".mdx");
@@ -7685,8 +8400,8 @@ async function preprocessMarkdownFiles(cwd, config2) {
 }
 async function buildEntrypointBundle(cwd, args = []) {
   const buildStartTime = performance.now();
-  const clientDir = join9(cwd, "src", "client");
-  const entrypoint = join9(clientDir, "index.tsx");
+  const clientDir = join10(cwd, "src", "client");
+  const entrypoint = join10(clientDir, "index.tsx");
   const exists = await Bun.file(entrypoint).exists();
   if (!exists) {
     console.log("[reroute/gen] No index.tsx found, skipping bundle build");
@@ -7694,7 +8409,7 @@ async function buildEntrypointBundle(cwd, args = []) {
   }
   console.log("[reroute/gen] Building entrypoint bundle...");
   const isProd = args.includes("--prod");
-  const bundlesDir = join9(cwd, ".reroute", "bundles");
+  const bundlesDir = join10(cwd, ".reroute", "bundles");
   await mkdir2(bundlesDir, { recursive: true });
   const mode = isProd ? "production" : "development";
   const publicEnv = getPublicEnvVars(cwd, mode);
@@ -7793,10 +8508,10 @@ async function buildEntrypointBundle(cwd, args = []) {
   }
   const newFiles = new Set(outputs.map((o) => o.fileName));
   try {
-    const existingFiles = await readdir5(bundlesDir);
+    const existingFiles = await readdir7(bundlesDir);
     for (const file of existingFiles) {
       if (/^(index|chunk|asset)\.[a-z0-9]+\.(js|css|js\.map|css\.map)(\.gz|\.br)?$/i.test(file) && !newFiles.has(file.replace(/\.(gz|br)$/, ""))) {
-        await rm(join9(bundlesDir, file), { force: true });
+        await rm(join10(bundlesDir, file), { force: true });
       }
     }
   } catch (_error) {}
@@ -7812,7 +8527,7 @@ async function buildEntrypointBundle(cwd, args = []) {
     }
   }
   await Promise.all(outputs.map(async (output) => {
-    const destPath = join9(bundlesDir, output.fileName);
+    const destPath = join10(bundlesDir, output.fileName);
     await Bun.write(destPath, output.content);
     if (shouldPreCompress) {
       const shouldCompress = /\.(js|css)$/i.test(output.fileName) && !output.fileName.endsWith(".map");
@@ -7881,7 +8596,7 @@ async function generate(cwd, args = [], options = {}) {
     await writeStubFiles(cwd);
   }
   await perfTrack("Markdown preprocessing", () => preprocessMarkdownFiles(cwd, config2));
-  const routesPath = join9(cwd, ROUTES_DIR);
+  const routesPath = join10(cwd, ROUTES_DIR);
   try {
     await perfTrack("Routes generation", async () => {
       const files = await scanDirectory(routesPath);
@@ -7890,19 +8605,36 @@ async function generate(cwd, args = [], options = {}) {
       const tree = generateRouteTree(all.map((f) => f.replace(/\\/g, "/")));
       const streamingAnalyses = streamingEnabled ? await buildStreamingWrappersForTree(cwd, routesPath, tree, config2) : new Map;
       const ts = generateTypeScript(tree, streamingAnalyses);
-      await Bun.write(join9(cwd, OUTPUT_ROUTES), ts);
+      await Bun.write(join10(cwd, OUTPUT_ROUTES), ts);
     });
     if (!showPerformance) {
-      console.log(`[reroute/gen] Generated routes: ${join9(cwd, OUTPUT_ROUTES)}`);
+      console.log(`[reroute/gen] Generated routes: ${join10(cwd, OUTPUT_ROUTES)}`);
     }
   } catch (error) {
     console.error("[reroute/gen] Failed to generate routes:", error);
     throw error;
   }
+  const i18n2 = await discoverI18n(cwd, config2.i18n);
+  const defaultLocale = i18n2.defaultLocale;
   try {
-    await perfTrack("Content building", () => buildContentChunks(cwd, args));
+    await Bun.write(join10(cwd, ".reroute", "i18n.json"), JSON.stringify({
+      enabled: i18n2.enabled,
+      defaultLocale: i18n2.defaultLocale,
+      locales: i18n2.locales,
+      cookie: i18n2.cookie,
+      redirectContentOnNegotiate: i18n2.redirectContentOnNegotiate,
+      catalogs: i18n2.catalogs
+    }, null, 2));
+    if (i18n2.enabled && !showPerformance) {
+      console.log(`[reroute/gen] i18n enabled: ${i18n2.locales.join(", ")} (default ${i18n2.defaultLocale})`);
+    }
+  } catch (error) {
+    console.warn("[reroute/gen] Failed to write i18n.json:", error);
+  }
+  try {
+    await perfTrack("Content building", () => buildContentChunks(cwd, args, defaultLocale));
     if (!showPerformance) {
-      console.log(`[reroute/gen] Generated content: ${join9(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
+      console.log(`[reroute/gen] Generated content: ${join10(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
     }
   } catch (error) {
     console.error("[reroute/gen] Failed to generate content:", error);
@@ -7910,22 +8642,25 @@ async function generate(cwd, args = [], options = {}) {
   }
   try {
     await perfTrack("Manifest generation", async () => {
-      const routesPath2 = join9(cwd, OUTPUT_ROUTES);
+      const routesPath2 = join10(cwd, OUTPUT_ROUTES);
       const routesModule = await import(`file://${routesPath2}?t=${Date.now()}`);
       const routes = routesModule.routes || [];
       const staticRoutes = routes.filter((r) => !r.params || r.params.length === 0).map((r) => r.pattern);
       const contentRoutes = [];
-      const collectionsDir = join9(cwd, ".reroute", "collections");
+      const collectionsDir = join10(cwd, ".reroute", "collections");
       try {
-        const collectionFiles = await readdir5(collectionsDir);
+        const collectionFiles = await readdir7(collectionsDir);
         for (const file of collectionFiles) {
           if (file.endsWith(".js")) {
-            const collectionPath = join9(collectionsDir, file);
+            const collectionPath = join10(collectionsDir, file);
             const collectionModule = await import(`file://${collectionPath}?t=${Date.now()}`);
             const items = collectionModule.items || [];
             for (const item of items) {
               if (item.href) {
                 contentRoutes.push(item.href);
+                if (i18n2.enabled && item.locale && item.locale !== defaultLocale && item.name) {
+                  contentRoutes.push(localizeContentHref(item.collection || file.replace(/\.js$/, ""), item.name, item.locale, defaultLocale));
+                }
               }
             }
           }
@@ -7942,7 +8677,7 @@ async function generate(cwd, args = [], options = {}) {
         dynamicRoutes,
         version: 1
       };
-      await Bun.write(join9(cwd, ".reroute", "manifest.json"), JSON.stringify(manifest, null, 2));
+      await Bun.write(join10(cwd, ".reroute", "manifest.json"), JSON.stringify(manifest, null, 2));
     });
   } catch (error) {
     console.error("[reroute/gen] Failed to generate manifest:", error);
@@ -7963,7 +8698,7 @@ async function generate(cwd, args = [], options = {}) {
     mdComponentsLines.push("");
     mdComponentsLines.push(`import markdownComponents from '${componentsPath}';`);
     mdComponentsLines.push("export { markdownComponents };");
-    await Bun.write(join9(cwd, ".reroute/markdown-components.ts"), mdComponentsLines.join(`
+    await Bun.write(join10(cwd, ".reroute/markdown-components.ts"), mdComponentsLines.join(`
 `));
   }
   const indexLines = [];
@@ -7983,7 +8718,7 @@ async function generate(cwd, args = [], options = {}) {
     const ogTemplatePath = config2.ogImage.defaultTemplate.startsWith(".") ? `../${config2.ogImage.defaultTemplate}` : config2.ogImage.defaultTemplate;
     indexLines.push(`import OGTemplate from '${ogTemplatePath}';`);
   }
-  const ogFiles = await scanOgFiles(join9(cwd, ROUTES_DIR));
+  const ogFiles = await scanOgFiles(join10(cwd, ROUTES_DIR));
   const ogImports = [];
   for (let i = 0;i < ogFiles.length; i++) {
     const ogFile = ogFiles[i];
@@ -8029,7 +8764,7 @@ async function generate(cwd, args = [], options = {}) {
     }
     indexLines.push("};");
   }
-  const templatePath = join9(cwd, "src", "client", "index.html");
+  const templatePath = join10(cwd, "src", "client", "index.html");
   try {
     const templateContent = await Bun.file(templatePath).text();
     indexLines.push("");
@@ -8041,7 +8776,7 @@ async function generate(cwd, args = [], options = {}) {
   indexLines.push(`(globalThis as any).__REROUTE_CONFIG__ = ${serializeConfig(config2)};`);
   indexLines.push("");
   indexLines.push("export type RerouteBundle = typeof bundle;");
-  await Bun.write(join9(cwd, OUTPUT_ARTIFACTS), indexLines.join(`
+  await Bun.write(join10(cwd, OUTPUT_ARTIFACTS), indexLines.join(`
 `));
   const barrelLines = [
     "// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8",
@@ -8051,7 +8786,7 @@ async function generate(cwd, args = [], options = {}) {
     "",
     "export * from './artifacts';"
   ];
-  await Bun.write(join9(cwd, OUTPUT_INDEX), barrelLines.join(`
+  await Bun.write(join10(cwd, OUTPUT_INDEX), barrelLines.join(`
 `));
   const entryLines = [
     "// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8",
@@ -8067,10 +8802,10 @@ async function generate(cwd, args = [], options = {}) {
     "import './routes'; // Import routes (bundles all route components)",
     "import '../src/index'; // Import user's server entry"
   ];
-  await Bun.write(join9(cwd, ".reroute/entry.ts"), entryLines.join(`
+  await Bun.write(join10(cwd, ".reroute/entry.ts"), entryLines.join(`
 `));
   if (!showPerformance) {
-    console.log(`[reroute/gen] Generated artifacts: ${join9(cwd, OUTPUT_ARTIFACTS)}`);
+    console.log(`[reroute/gen] Generated artifacts: ${join10(cwd, OUTPUT_ARTIFACTS)}`);
   }
   await perfTrack("Bundle building", () => buildEntrypointBundle(cwd, args));
   const endTime = performance.now();
@@ -8197,7 +8932,7 @@ async function gen(args) {
   const mediumDebounce = createDebouncer(150);
   const slowDebounce = createDebouncer(300);
   const loadedConfig = await loadConfig(cwd);
-  const configPath = join9(cwd, "reroute.config.ts");
+  const configPath = join10(cwd, "reroute.config.ts");
   let configWatcher = null;
   try {
     configWatcher = watch(configPath, () => {
@@ -8219,7 +8954,7 @@ async function gen(args) {
   ];
   const envWatchers = [];
   for (const envFile of envFiles) {
-    const envPath = join9(cwd, envFile);
+    const envPath = join10(cwd, envFile);
     try {
       const envWatcher = watch(envPath, () => {
         mediumDebounce(() => {
@@ -8238,15 +8973,15 @@ async function gen(args) {
   let packagesWatcher = null;
   const isRerouteWorkspace = async () => {
     try {
-      const packagesPath = join9(cwd, "..", "..", "packages");
-      const exists = await Bun.file(join9(packagesPath, "core", "index.ts")).exists();
+      const packagesPath = join10(cwd, "..", "..", "packages");
+      const exists = await Bun.file(join10(packagesPath, "core", "index.ts")).exists();
       return exists;
     } catch {
       return false;
     }
   };
   if (await isRerouteWorkspace()) {
-    const packagesPath = join9(cwd, "..", "..", "packages");
+    const packagesPath = join10(cwd, "..", "..", "packages");
     console.log("[reroute/watch] \uD83D\uDD27 Workspace development mode enabled");
     console.log(`[reroute/watch] \uD83D\uDD27 Watching ${packagesPath}...`);
     packagesWatcher = watch(packagesPath, { recursive: true }, (_ev, filename) => {
@@ -8269,7 +9004,7 @@ async function gen(args) {
       });
     });
   }
-  const routesPath = join9(cwd, ROUTES_DIR);
+  const routesPath = join10(cwd, ROUTES_DIR);
   console.log(`[reroute/watch] \uD83D\uDCC1 Watching ${routesPath}...`);
   const routesWatcher = watch(routesPath, { recursive: true }, (_ev, filename) => {
     if (!filename)
@@ -8291,7 +9026,16 @@ async function gen(args) {
           }
           console.log("[reroute/watch]   ├─ Building content chunks...");
           const contentStart = performance.now();
-          await buildContentChunks(cwd, args);
+          const watchI18n = await discoverI18n(cwd, loadedConfig.i18n);
+          await Bun.write(join10(cwd, ".reroute", "i18n.json"), JSON.stringify({
+            enabled: watchI18n.enabled,
+            defaultLocale: watchI18n.defaultLocale,
+            locales: watchI18n.locales,
+            cookie: watchI18n.cookie,
+            redirectContentOnNegotiate: watchI18n.redirectContentOnNegotiate,
+            catalogs: watchI18n.catalogs
+          }, null, 2));
+          await buildContentChunks(cwd, args, watchI18n.defaultLocale);
           const contentTime = ((performance.now() - contentStart) / 1000).toFixed(2);
           console.log(`[reroute/watch]   └─ Content: ${contentTime}s`);
           if (loadedConfig.search?.enabled) {
@@ -8320,7 +9064,7 @@ async function gen(args) {
       }, "routes change");
     });
   });
-  const clientPath = join9(cwd, "src", "client");
+  const clientPath = join10(cwd, "src", "client");
   console.log(`[reroute/watch] \uD83D\uDCE6 Watching ${clientPath}...`);
   const twWatcher = watch(clientPath, { recursive: true }, (_ev, filename) => {
     if (!filename)
@@ -13178,7 +13922,7 @@ var require_program = __commonJS((exports, module) => {
           }
           break;
         case "underline":
-          if (!blink) {} else {}
+          if (!blink) {}
           break;
         case "line":
           if (!blink) {
@@ -100442,7 +101186,7 @@ var require_lodash = __commonJS((exports, module) => {
         }
         return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
       });
-      function join10(array, separator) {
+      function join11(array, separator) {
         return array == null ? "" : nativeJoin.call(array, separator);
       }
       function last(array) {
@@ -102374,7 +103118,7 @@ __p += '`;
       lodash.isUndefined = isUndefined;
       lodash.isWeakMap = isWeakMap;
       lodash.isWeakSet = isWeakSet;
-      lodash.join = join10;
+      lodash.join = join11;
       lodash.kebabCase = kebabCase;
       lodash.last = last;
       lodash.lastIndexOf = lastIndexOf;
@@ -103056,19 +103800,19 @@ __export(exports_dev, {
 });
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync6 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function getRerouteCommand() {
-  const binPath = join10(import.meta.dir, "..", "..", "bin.ts");
+  const binPath = join11(import.meta.dir, "..", "..", "bin.ts");
   const isBunDev = existsSync6(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join10(cwd, "node_modules", ".bin", "reroute"),
-    join10(cwd, "..", "node_modules", ".bin", "reroute"),
-    join10(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join10(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join11(cwd, "node_modules", ".bin", "reroute"),
+    join11(cwd, "..", "node_modules", ".bin", "reroute"),
+    join11(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join11(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
     if (existsSync6(binPath2)) {
@@ -103224,19 +103968,19 @@ __export(exports_start, {
 });
 import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync7 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function getRerouteCommand2() {
-  const binPath = join11(import.meta.dir, "..", "..", "bin.ts");
+  const binPath = join12(import.meta.dir, "..", "..", "bin.ts");
   const isBunDev = existsSync7(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join11(cwd, "node_modules", ".bin", "reroute"),
-    join11(cwd, "..", "node_modules", ".bin", "reroute"),
-    join11(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join11(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join12(cwd, "node_modules", ".bin", "reroute"),
+    join12(cwd, "..", "node_modules", ".bin", "reroute"),
+    join12(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join12(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
     if (existsSync7(binPath2)) {
@@ -103364,12 +104108,12 @@ import {
   mkdirSync,
   readdirSync
 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function copyAssetsToReroute(cwd, sourceAssetsDir, rerouteAssetsDir) {
   if (!existsSync8(sourceAssetsDir)) {
     return 0;
   }
-  const rerouteDir = join12(cwd, ".reroute");
+  const rerouteDir = join13(cwd, ".reroute");
   if (!existsSync8(rerouteDir)) {
     mkdirSync(rerouteDir, { recursive: true });
   }
@@ -103381,7 +104125,7 @@ function countFiles(dir) {
   const entries = readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      count += countFiles(join12(dir, entry.name));
+      count += countFiles(join13(dir, entry.name));
     } else {
       count++;
     }
@@ -103397,19 +104141,19 @@ __export(exports_build, {
 });
 import { spawn as spawn4 } from "node:child_process";
 import { existsSync as existsSync9, readFileSync as readFileSync5, rmSync, unlinkSync } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function getRerouteCommand3() {
-  const binPath = join13(import.meta.dir, "..", "..", "bin.ts");
+  const binPath = join14(import.meta.dir, "..", "..", "bin.ts");
   const isBunDev = existsSync9(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join13(cwd, "node_modules", ".bin", "reroute"),
-    join13(cwd, "..", "node_modules", ".bin", "reroute"),
-    join13(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join13(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join14(cwd, "node_modules", ".bin", "reroute"),
+    join14(cwd, "..", "node_modules", ".bin", "reroute"),
+    join14(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join14(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
     if (existsSync9(binPath2)) {
@@ -103420,7 +104164,7 @@ function getRerouteCommand3() {
 }
 function getOutputName() {
   const cwd = process.cwd();
-  const packageJsonPath = join13(cwd, "package.json");
+  const packageJsonPath = join14(cwd, "package.json");
   if (existsSync9(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
@@ -103452,7 +104196,7 @@ function parseBuildArgs(args) {
   return { outfile, compileBinary, noCompression, externalArgs };
 }
 function cleanDistFolder(cwd) {
-  const distDir = join13(cwd, "dist");
+  const distDir = join14(cwd, "dist");
   if (existsSync9(distDir)) {
     process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Cleaning dist folder...
 `));
@@ -103460,7 +104204,7 @@ function cleanDistFolder(cwd) {
   }
 }
 async function cleanRerouteFolder(cwd) {
-  const rerouteDir = join13(cwd, ".reroute");
+  const rerouteDir = join14(cwd, ".reroute");
   if (existsSync9(rerouteDir)) {
     process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Cleaning .reroute folder...
 `));
@@ -103517,8 +104261,8 @@ async function copyAssets(cwd) {
   const appSrc = config2.app?.src ?? "./src/client/App";
   const dirname6 = __require("node:path").dirname;
   const assetsPath = dirname6(appSrc);
-  const sourceAssetsDir = join13(cwd, assetsPath, "assets");
-  const rerouteAssetsDir = join13(cwd, ".reroute", "assets");
+  const sourceAssetsDir = join14(cwd, assetsPath, "assets");
+  const rerouteAssetsDir = join14(cwd, ".reroute", "assets");
   process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Copying assets...
 `));
   const fileCount = copyAssetsToReroute(cwd, sourceAssetsDir, rerouteAssetsDir);
@@ -103533,9 +104277,9 @@ async function copyAssets(cwd) {
 async function buildBundle(cwd, buildArgs) {
   const external = [...buildArgs.externalArgs, "sharp", "@vercel/og"];
   const buildResult = await Bun.build({
-    entrypoints: [join13(cwd, ".reroute/entry.ts")],
+    entrypoints: [join14(cwd, ".reroute/entry.ts")],
     target: "bun",
-    outdir: join13(cwd, "dist"),
+    outdir: join14(cwd, "dist"),
     sourcemap: "external",
     ...getCommonBuildOptions(),
     external,
@@ -103578,7 +104322,7 @@ function cleanupBundledFiles(rerouteDir) {
     "markdown-components.ts"
   ];
   for (const file of tsFilesToRemove) {
-    const filePath = join13(rerouteDir, file);
+    const filePath = join14(rerouteDir, file);
     if (existsSync9(filePath)) {
       try {
         unlinkSync(filePath);
@@ -103588,7 +104332,7 @@ function cleanupBundledFiles(rerouteDir) {
   }
   const dirsToRemove = ["markdown", "streaming"];
   for (const dir of dirsToRemove) {
-    const dirPath = join13(rerouteDir, dir);
+    const dirPath = join14(rerouteDir, dir);
     if (existsSync9(dirPath)) {
       try {
         rmSync(dirPath, { recursive: true });
@@ -103622,7 +104366,7 @@ async function build(args) {
     await runGenCommand(rerouteCmd, useShell, buildArgs.noCompression);
     await copyAssets(cwd);
     await buildBundle(cwd, buildArgs);
-    const rerouteDir = join13(cwd, ".reroute");
+    const rerouteDir = join14(cwd, ".reroute");
     cleanupBundledFiles(rerouteDir);
     logBuildComplete(buildStartTime, buildArgs);
     process.exit(0);
@@ -103644,19 +104388,19 @@ __export(exports_command, {
   getRerouteCommand: () => getRerouteCommand4
 });
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function getRerouteCommand4() {
-  const binPath = join14(import.meta.dir, "..", "..", "bin.ts");
+  const binPath = join15(import.meta.dir, "..", "..", "bin.ts");
   const isBunDev = existsSync10(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join14(cwd, "node_modules", ".bin", "reroute"),
-    join14(cwd, "..", "node_modules", ".bin", "reroute"),
-    join14(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join14(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join15(cwd, "node_modules", ".bin", "reroute"),
+    join15(cwd, "..", "node_modules", ".bin", "reroute"),
+    join15(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join15(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
     if (existsSync10(binPath2)) {
@@ -103673,24 +104417,24 @@ __export(exports_analyze, {
   default: () => analyze
 });
 import { existsSync as existsSync11, statSync } from "node:fs";
-import { readdir as readdir6, readFile, stat as stat5, writeFile } from "node:fs/promises";
-import { basename as basename3, join as join15, relative as relative3 } from "node:path";
+import { readdir as readdir8, readFile, stat as stat5, writeFile } from "node:fs/promises";
+import { basename as basename3, join as join16, relative as relative3 } from "node:path";
 import Table from "cli-table3";
 async function findChunkBundles(cwd) {
   const bundles = [];
-  const chunksDir = join15(cwd, ".reroute", "chunks");
+  const chunksDir = join16(cwd, ".reroute", "chunks");
   if (!existsSync11(chunksDir))
     return bundles;
-  const collections2 = await readdir6(chunksDir, { withFileTypes: true });
+  const collections2 = await readdir8(chunksDir, { withFileTypes: true });
   for (const collection of collections2) {
     if (!collection.isDirectory())
       continue;
-    const collectionDir = join15(chunksDir, collection.name);
-    const files = await readdir6(collectionDir);
+    const collectionDir = join16(chunksDir, collection.name);
+    const files = await readdir8(collectionDir);
     for (const file of files) {
       if (!file.endsWith(".js"))
         continue;
-      const filePath = join15(collectionDir, file);
+      const filePath = join16(collectionDir, file);
       const stats = await stat5(filePath);
       const content2 = await Bun.file(filePath).arrayBuffer();
       const gzippedSize = Bun.gzipSync(new Uint8Array(content2)).length;
@@ -103708,12 +104452,12 @@ async function findChunkBundles(cwd) {
 }
 async function findDistBundles(cwd) {
   const bundles = [];
-  const distDir = join15(cwd, "dist");
+  const distDir = join16(cwd, "dist");
   if (!existsSync11(distDir))
     return bundles;
-  const files = await readdir6(distDir);
+  const files = await readdir8(distDir);
   for (const file of files) {
-    const filePath = join15(distDir, file);
+    const filePath = join16(distDir, file);
     const stats = statSync(filePath);
     if (stats.isFile() && !file.endsWith(".map") && !file.endsWith(".d.ts")) {
       const content2 = await Bun.file(filePath).arrayBuffer();
@@ -103739,9 +104483,9 @@ async function findBundles(cwd) {
 }
 async function findBrowserEntry(cwd) {
   try {
-    const clientDir = join15(cwd, "src", "client");
-    const tsxEntry = join15(clientDir, "index.tsx");
-    const tsEntry = join15(clientDir, "index.ts");
+    const clientDir = join16(cwd, "src", "client");
+    const tsxEntry = join16(clientDir, "index.tsx");
+    const tsEntry = join16(clientDir, "index.ts");
     let sourceEntry = null;
     if (existsSync11(tsxEntry)) {
       sourceEntry = tsxEntry;
@@ -103774,12 +104518,12 @@ async function findBrowserEntry(cwd) {
       console.warn("[reroute/analyze] Browser build produced no outputs");
       return null;
     }
-    const tempDir = join15(cwd, ".reroute", "browser");
+    const tempDir = join16(cwd, ".reroute", "browser");
     await import("node:fs/promises").then((fs) => fs.mkdir(tempDir, { recursive: true }));
     const output = result.outputs[0];
     const code = await output.text();
     const actualHash = await generateContentHash2(code);
-    const bundlePath = join15(tempDir, `index.${actualHash}.js`);
+    const bundlePath = join16(tempDir, `index.${actualHash}.js`);
     await writeFile(bundlePath, code, "utf-8");
     const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
     if (mapOutput) {
@@ -103831,7 +104575,7 @@ function calculateStats(bundles) {
 }
 async function getInstalledPackageSizes(cwd) {
   const packageSizes = new Map;
-  const nodeModulesDir = join15(cwd, "node_modules");
+  const nodeModulesDir = join16(cwd, "node_modules");
   if (!existsSync11(nodeModulesDir))
     return packageSizes;
   try {
@@ -103887,7 +104631,7 @@ async function buildDependencyTree(entryPath, cwd) {
         if (!pkgNode) {
           pkgNode = {
             name: pkgName || "unknown",
-            path: join15(cwd, "node_modules", pkgName || ""),
+            path: join16(cwd, "node_modules", pkgName || ""),
             size: 0,
             children: []
           };
@@ -103908,7 +104652,7 @@ async function buildDependencyTree(entryPath, cwd) {
           if (!child) {
             child = {
               name: part,
-              path: join15(cwd, ...parts.slice(0, i + 1)),
+              path: join16(cwd, ...parts.slice(0, i + 1)),
               size: 0,
               children: []
             };
@@ -103939,7 +104683,7 @@ async function buildDependencyTree(entryPath, cwd) {
       const modulePattern = /\/\/\s*(.+?\.(?:ts|tsx|js|jsx|mjs|cjs))\s*$/gm;
       const nodeModulesNode = {
         name: "node_modules",
-        path: join15(cwd, "node_modules"),
+        path: join16(cwd, "node_modules"),
         size: 0,
         children: []
       };
@@ -104005,7 +104749,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
       if (sourcePath.startsWith("/") || sourcePath.match(/^[A-Za-z]:\\/))
         return sourcePath;
       const bundleDir = bundlePath.substring(0, bundlePath.lastIndexOf("/"));
-      return join15(bundleDir, sourceRoot || "", sourcePath);
+      return join16(bundleDir, sourceRoot || "", sourcePath);
     }, computeSizes = function(node) {
       if (node.children && node.children.length > 0) {
         node.size = node.children.reduce((s, c) => s + computeSizes(c), 0);
@@ -104077,7 +104821,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
     };
     const nodeModulesNode = {
       name: "node_modules",
-      path: join15(cwd, "node_modules"),
+      path: join16(cwd, "node_modules"),
       size: 0,
       children: []
     };
@@ -104117,7 +104861,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
         if (!pkgNode) {
           pkgNode = {
             name: pkgName || "unknown",
-            path: join15(cwd, "node_modules", pkgName || ""),
+            path: join16(cwd, "node_modules", pkgName || ""),
             size: 0,
             children: []
           };
@@ -104138,7 +104882,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
           if (!child) {
             child = {
               name: part,
-              path: join15(cwd, ...parts.slice(0, i2 + 1)),
+              path: join16(cwd, ...parts.slice(0, i2 + 1)),
               size: 0,
               children: []
             };
@@ -104168,11 +104912,11 @@ async function generateHTMLReport(stats, depTree, mainInfo, browserDepTree, brow
   let actualServerBinarySize = null;
   let actualServerBinaryGzipped = null;
   try {
-    const distDir = join15(process.cwd(), "dist");
+    const distDir = join16(process.cwd(), "dist");
     if (existsSync11(distDir)) {
-      const files = await readdir6(distDir);
+      const files = await readdir8(distDir);
       for (const file of files) {
-        const filePath = join15(distDir, file);
+        const filePath = join16(distDir, file);
         const stats2 = statSync(filePath);
         if (stats2.isFile() && !file.includes(".")) {
           actualServerBinarySize = stats2.size;
@@ -105654,11 +106398,11 @@ async function printConsoleReport(stats, depTree, mainInfo, browserDepTree, brow
   let actualServerBinarySize = null;
   let actualServerBinaryGzipped = null;
   try {
-    const distDir = join15(process.cwd(), "dist");
+    const distDir = join16(process.cwd(), "dist");
     if (existsSync11(distDir)) {
-      const files = await readdir6(distDir);
+      const files = await readdir8(distDir);
       for (const file of files) {
-        const filePath = join15(distDir, file);
+        const filePath = join16(distDir, file);
         const stats2 = statSync(filePath);
         if (stats2.isFile() && !file.includes(".")) {
           actualServerBinarySize = stats2.size;
@@ -105692,7 +106436,7 @@ async function analyze(args) {
     const isProd = isProductionMode(args);
     const searchIndex = args.indexOf("--search");
     const initialSearch = searchIndex !== -1 && args[searchIndex + 1] ? args[searchIndex + 1] : "";
-    const rerouteIndexPath = join15(cwd, ".reroute", "index.ts");
+    const rerouteIndexPath = join16(cwd, ".reroute", "index.ts");
     if (!existsSync11(rerouteIndexPath)) {
       console.log(colorizeLogPrefixAnsi(`[reroute/analyze] .reroute artifacts not found, running build...
 `));
@@ -105755,12 +106499,12 @@ async function analyze(args) {
     let entry = null;
     let depTree = null;
     let mainInfo = null;
-    const srcEntry = join15(cwd, "src", "index.ts");
+    const srcEntry = join16(cwd, "src", "index.ts");
     if (existsSync11(srcEntry)) {
       console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Building server binary for analysis...
 `));
       const { mkdir: mkdir3 } = await import("node:fs/promises");
-      const serverAnalysisDir = join15(cwd, ".reroute", "server");
+      const serverAnalysisDir = join16(cwd, ".reroute", "server");
       await mkdir3(serverAnalysisDir, { recursive: true });
       const result = await Bun.build({
         entrypoints: [srcEntry],
@@ -105773,7 +106517,7 @@ async function analyze(args) {
       if (result.success && result.outputs.length > 0) {
         const output = result.outputs[0];
         const code = await output.text();
-        const analysisEntry = join15(serverAnalysisDir, "index.js");
+        const analysisEntry = join16(serverAnalysisDir, "index.js");
         await writeFile(analysisEntry, code, "utf-8");
         const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
         if (mapOutput) {
@@ -105791,7 +106535,7 @@ async function analyze(args) {
 `));
       const installedSizes = await getInstalledPackageSizes(cwd);
       if (depTree) {
-        const packageJsonPath = join15(cwd, "package.json");
+        const packageJsonPath = join16(cwd, "package.json");
         if (existsSync11(packageJsonPath)) {
           try {
             const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
@@ -105803,7 +106547,7 @@ async function analyze(args) {
                 if (!trackedPkgs.has(pkgName) && installedSizes.has(pkgName)) {
                   nodeModulesNode.children?.push({
                     name: pkgName,
-                    path: join15(cwd, "node_modules", pkgName),
+                    path: join16(cwd, "node_modules", pkgName),
                     size: installedSizes.get(pkgName) || 0
                   });
                 }
@@ -105834,10 +106578,10 @@ async function analyze(args) {
     const fullOutput = args.includes("--full");
     await printConsoleReport(stats, depTree, mainInfo, browserDepTree, browserInfo, fullOutput);
     if (outputHtml || openBrowser) {
-      const htmlPath = join15(cwd, ".reroute", "analysis.html");
+      const htmlPath = join16(cwd, ".reroute", "analysis.html");
       const html2 = await generateHTMLReport(stats, depTree, mainInfo, browserDepTree, browserInfo, initialSearch);
       const { mkdir: mkdir3 } = await import("node:fs/promises");
-      await mkdir3(join15(cwd, ".reroute"), { recursive: true });
+      await mkdir3(join16(cwd, ".reroute"), { recursive: true });
       await writeFile(htmlPath, html2, "utf-8");
       console.log(colorizeLogPrefixAnsi(`[reroute/analyze] HTML report generated: ${relative3(cwd, htmlPath)}
 `));
@@ -105900,8 +106644,8 @@ __export(exports_og, {
   default: () => og2
 });
 import { spawn as spawn5 } from "node:child_process";
-import { readdir as readdir7 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { readdir as readdir9 } from "node:fs/promises";
+import { join as join17 } from "node:path";
 function getPortFromConfig(baseUrl) {
   if (!baseUrl)
     return 3000;
@@ -105978,10 +106722,10 @@ Error output:`, errorOutput);
 }
 async function scanForOgTemplates(dir, base, routes) {
   try {
-    const entries = await readdir7(dir, { withFileTypes: true });
+    const entries = await readdir9(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join16(dir, entry.name);
-      const relativePath = join16(base, entry.name);
+      const fullPath = join17(dir, entry.name);
+      const relativePath = join17(base, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "content")
           continue;
@@ -105998,13 +106742,13 @@ function findFirstContentFile(contentFiles) {
 }
 async function addContentRoutes(routesPath, routes) {
   try {
-    const entries = await readdir7(routesPath, { withFileTypes: true });
+    const entries = await readdir9(routesPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const contentDir = join16(routesPath, entry.name, "content");
+      const contentDir = join17(routesPath, entry.name, "content");
       try {
-        const contentFiles = await readdir7(contentDir);
+        const contentFiles = await readdir9(contentDir);
         if (contentFiles.length === 0)
           continue;
         const firstFile = findFirstContentFile(contentFiles);
@@ -106019,7 +106763,7 @@ async function addContentRoutes(routesPath, routes) {
 async function findRoutesWithOG(cwd) {
   const routes = [];
   try {
-    const manifestPath = join16(cwd, ".reroute", "manifest.json");
+    const manifestPath = join17(cwd, ".reroute", "manifest.json");
     const manifestFile = Bun.file(manifestPath);
     const manifest = await manifestFile.json();
     if (manifest.staticRoutes && Array.isArray(manifest.staticRoutes)) {
@@ -106030,7 +106774,7 @@ async function findRoutesWithOG(cwd) {
     }
   } catch {
     console.warn("⚠️  .reroute/manifest.json not found, scanning routes directory...");
-    const routesPath = join16(cwd, ROUTES_DIR2);
+    const routesPath = join17(cwd, ROUTES_DIR2);
     await scanForOgTemplates(routesPath, "", routes);
     await addContentRoutes(routesPath, routes);
   }
@@ -106282,7 +107026,7 @@ async function getVersionString2() {
 }
 async function getVersion2() {
   if (true) {
-    return "0.45.11";
+    return "0.46.0";
   }
   const possiblePaths = [
     path3.join(import.meta.dir, "../../../package.json"),
@@ -106299,10 +107043,10 @@ async function getVersion2() {
 }
 async function getCommit2() {
   if (true) {
-    return "c2463d3";
+    return "9116acf";
   }
   return "dev";
 }
 main();
 
-//# debugId=AD9BC92E9CCB37B264756E2164756E21
+//# debugId=0B12295AB270224764756E2164756E21