reroute-js 0.45.11 → 0.46.0

package/elysia/index.js

@@ -1,21 +1,25 @@
 /**
- * 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
  */
 import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
+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);
@@ -196,6 +200,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 readdir2 } from "node:fs/promises";
+import { join as join2 } 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 readdir2(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(join2(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 = join2(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 path = localizeContentHref(collection, name, locale, defaultLocale);
+    tags.push(`<link rel="alternate" hreflang="${locale}" href="${base}${path}" />`);
+  }
+  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;
@@ -790,6 +1152,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)
@@ -842,6 +1346,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 : {};
@@ -851,18 +1363,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) {
@@ -875,22 +1389,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();
 });
 
@@ -1089,7 +1594,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 || {};
@@ -1252,44 +1758,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) {
@@ -1371,33 +1851,31 @@ var init_compute = __esm(() => {
 });
 
 // packages/core/src/ssr/lib/modules.ts
-import { readdir as readdir2, stat as stat3 } from "node:fs/promises";
+import { readdir as readdir3, 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 = join(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;
@@ -1423,7 +1901,7 @@ async function tryRegistryImport(collection, name, cwd, isWatchMode) {
 async function tryChunkImport(collection, name, cwd, isWatchMode) {
   try {
     const chunkDir = join(cwd, ".reroute", "chunks", collection);
-    const files = await readdir2(chunkDir);
+    const files = await readdir3(chunkDir);
     const matches = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
     if (!matches.length)
       return null;
@@ -1443,23 +1921,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 = join(clientDir, "routes", collection, "content", `${name}.tsx`);
-    const srcTs = join(clientDir, "routes", collection, "content", `${name}.ts`);
-    let absSrc = null;
-    if (await Bun.file(srcTsx).exists()) {
-      absSrc = srcTsx;
-    } else if (await Bun.file(srcTs).exists()) {
-      absSrc = srcTs;
+    const candidates = [];
+    if (locale) {
+      candidates.push(join(clientDir, "routes", collection, "content", locale, `${name}.tsx`), join(clientDir, "routes", collection, "content", locale, `${name}.ts`));
     }
-    if (absSrc) {
-      return await dynamicImport(absSrc, isWatchMode);
+    candidates.push(join(clientDir, "routes", collection, "content", `${name}.tsx`), join(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();
 });
 
@@ -1490,14 +1968,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;
@@ -1517,42 +1992,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);
@@ -1574,16 +2032,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;
@@ -1724,6 +2173,7 @@ function createLazyMarker(pathname, key) {
   };
 }
 var init_data = __esm(() => {
+  init_content_path();
   init_imports();
   init_seed();
 });
@@ -1924,18 +2374,53 @@ function replaceAppRoot(html, appHtml, appId) {
 var init_html = () => {};
 
 // packages/core/src/og/discovery.ts
+import { readdir as readdir4 } 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 readdir4(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(join(currentDir, "[og].tsx"));
+    return;
+  }
+  const literalDir = join(currentDir, parts[depth]);
+  try {
+    await readdir4(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(join(currentDir, dynamicDir, "[og].tsx"));
+      continue;
+    }
+    await collectOGCandidatePaths(join(currentDir, dynamicDir), parts, depth + 1, pathsToTry, false);
+  }
+  if (allowPartialFallback) {
+    pathsToTry.push(join(currentDir, "[og].tsx"));
+  }
+}
 async function findOGImageForPath(pathname, clientDir) {
   const parts = pathname.split("/").filter(Boolean).filter((p) => !p.startsWith("__reroute"));
   const routesDir = join(clientDir, "routes");
   const pathsToTry = [];
-  if (parts.length > 0) {
-    for (let i = parts.length;i > 0; i--) {
-      const dirPath = join(routesDir, ...parts.slice(0, i), "[og].tsx");
-      pathsToTry.push(dirPath);
-    }
-  }
-  pathsToTry.push(join(routesDir, "[og].tsx"));
+  await collectOGCandidatePaths(routesDir, parts, 0, pathsToTry, true);
   const uniquePaths = [...new Set(pathsToTry)];
   for (const path of uniquePaths) {
     try {
@@ -1959,28 +2444,28 @@ async function loadOGImageComponent(ogPath, isWatchMode) {
 function extractParamsFromPath(pathname, ogPath, clientDir) {
   const params = {};
   const ogDir = ogPath.replace(/\/\[og\]\.tsx$/, "");
-  const pagesDir = join(clientDir, "pages");
-  const relativePath = ogDir.replace(pagesDir, "").split("/").filter(Boolean);
+  const routesDir = join(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) {
@@ -2071,7 +2556,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)
@@ -2106,8 +2593,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;
@@ -2147,14 +2634,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));
@@ -2165,15 +2680,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;
@@ -2187,9 +2707,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 };
@@ -2229,7 +2750,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;
@@ -2239,14 +2760,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;
@@ -2421,34 +2942,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 readdir3, stat as stat4 } from "node:fs/promises";
+import { readdir as readdir5, 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>
@@ -2490,12 +3011,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 = join(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;
@@ -2503,7 +3024,7 @@ async function findContentModulePath(collection, name, clientDir, cwd, isWatchMo
   } catch {}
   try {
     const chunkDir = join(cwd, ".reroute", "chunks", collection);
-    const files = await readdir3(chunkDir);
+    const files = await readdir5(chunkDir);
     const candidates = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
     if (candidates.length) {
       const latest = await findLatestCandidate(chunkDir, candidates);
@@ -2511,13 +3032,18 @@ async function findContentModulePath(collection, name, clientDir, cwd, isWatchMo
     }
   } catch {}
   try {
-    const tsx = join(clientDir, "routes", collection, "content", `${name}.tsx`);
-    const ts = join(clientDir, "routes", collection, "content", `${name}.ts`);
-    if (await Bun.file(tsx).exists()) {
-      return `/${join("routes", collection, "content", `${name}.tsx`).replace(/\\+/g, "/")}`;
-    }
-    if (await Bun.file(ts).exists()) {
-      return `/${join("routes", collection, "content", `${name}.ts`).replace(/\\+/g, "/")}`;
+    const contentRoot = join(clientDir, "routes", collection, "content");
+    const candidates = locale ? [
+      join(contentRoot, locale, `${name}.tsx`),
+      join(contentRoot, locale, `${name}.ts`),
+      join(contentRoot, `${name}.tsx`),
+      join(contentRoot, `${name}.ts`)
+    ] : [join(contentRoot, `${name}.tsx`), join(contentRoot, `${name}.ts`)];
+    for (const abs of candidates) {
+      if (await Bun.file(abs).exists()) {
+        const rel = abs.startsWith(clientDir) ? abs.slice(clientDir.length).replace(/^[/\\]/, "") : join("routes", collection, "content", `${name}.tsx`);
+        return `/${rel.replace(/\\+/g, "/")}`;
+      }
     }
   } catch {}
   return null;
@@ -2711,11 +3237,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 json = escapeJsonForScript(JSON.stringify(i18n));
+    return `<script>(function(){try{var w=(typeof window!=='undefined'?window:globalThis);w.__REROUTE_I18N__=${json};}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>`;
@@ -2791,13 +3324,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);
@@ -2817,7 +3351,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() {
@@ -3045,10 +3581,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) {
@@ -3211,7 +3747,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;
   });
@@ -3229,12 +3765,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({
@@ -4412,6 +4949,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 {
@@ -4423,18 +5009,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);
@@ -4729,11 +5323,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) {
@@ -4999,7 +5599,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>
@@ -5161,6 +5761,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>`;
@@ -5176,13 +5777,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>`;
 }
@@ -5280,7 +5888,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}"`;
@@ -5323,7 +5932,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`);
@@ -5436,7 +6046,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;
@@ -5568,6 +6178,7 @@ var init_src = __esm(() => {
   init_bundler();
   init_config();
   init_content();
+  init_i18n();
   init_llms();
   init_og();
   init_robots();
@@ -5580,6 +6191,7 @@ var init_src = __esm(() => {
 var exports_core = {};
 __export(exports_core, {
   toPromise: () => toPromise,
+  toOgLocale: () => toOgLocale,
   toBytes: () => toBytes,
   stripStart: () => stripStart,
   stripHtmlTags: () => stripHtmlTags,
@@ -5591,6 +6203,7 @@ __export(exports_core, {
   setGlobalSSRData: () => setGlobalSSRData,
   setGlobalCollections: () => setGlobalCollections,
   seedSSRModuleForPath: () => seedSSRModuleForPath,
+  resolveLocale: () => resolveLocale,
   resetSSRAccessTracking: () => resetSSRAccessTracking,
   renderSSRDocumentStream: () => renderSSRDocumentStream,
   renderSSRDocument: () => renderSSRDocument,
@@ -5599,7 +6212,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,
@@ -5612,11 +6235,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,
@@ -5633,6 +6258,7 @@ __export(exports_core, {
   generateContentHash: () => generateContentHash,
   generateCollectionScripts: () => generateCollectionScripts,
   generateAtomXML: () => generateAtomXML,
+  formatMessage: () => formatMessage,
   formatAsText: () => formatAsText,
   formatAsMarkdown: () => formatAsMarkdown,
   findOGImageForPath: () => findOGImageForPath,
@@ -5652,10 +6278,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,
@@ -5663,13 +6291,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,
@@ -5685,6 +6317,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(() => {
@@ -5699,7 +6334,7 @@ import { createElement as createElement2 } from "react";
 
 // packages/elysia/src/libs/image.ts
 import { existsSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 import sharp from "sharp";
 var imageCache = new Map;
 var MAX_CACHE_SIZE = 100;
@@ -5742,8 +6377,8 @@ async function loadFromDiskCache(cacheKey) {
   if (!diskCacheDir)
     return null;
   try {
-    const cachePath = join2(diskCacheDir, `${cacheKey}.json`);
-    const imagePath = join2(diskCacheDir, `${cacheKey}.img`);
+    const cachePath = join3(diskCacheDir, `${cacheKey}.json`);
+    const imagePath = join3(diskCacheDir, `${cacheKey}.img`);
     if (!(existsSync(cachePath) && existsSync(imagePath))) {
       return null;
     }
@@ -5765,8 +6400,8 @@ async function saveToDiskCache(cacheKey, result) {
   if (!diskCacheDir)
     return;
   try {
-    const cachePath = join2(diskCacheDir, `${cacheKey}.json`);
-    const imagePath = join2(diskCacheDir, `${cacheKey}.img`);
+    const cachePath = join3(diskCacheDir, `${cacheKey}.json`);
+    const imagePath = join3(diskCacheDir, `${cacheKey}.img`);
     await Bun.write(cachePath, JSON.stringify({
       contentType: result.contentType,
       format: result.format,
@@ -6187,7 +6822,7 @@ function registerContentRoutes(app, cwd, collectionCache, directive, maxAge, isW
 // packages/elysia/src/routes/image.ts
 init_core();
 import { existsSync as existsSync2 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function parseNumericParam(value) {
   if (!value)
     return;
@@ -6234,8 +6869,8 @@ function registerImageRoutes(app, options) {
   }
   function resolveInternalImagePath(url, clientDir2) {
     const cleanUrl = url.startsWith("/") ? url.slice(1) : url;
-    const imagePath = join3(clientDir2, cleanUrl);
-    const normalizedPath = join3(clientDir2, cleanUrl);
+    const imagePath = join4(clientDir2, cleanUrl);
+    const normalizedPath = join4(clientDir2, cleanUrl);
     if (!normalizedPath.startsWith(clientDir2)) {
       return { error: "Access denied" };
     }
@@ -7213,44 +7848,60 @@ async function loadContentMeta(clientDir, collection, slug, isWatchMode, meta) {
       return;
   }
 }
-async function loadOgImageFromRoute(_cwd, clientDir, pathname, isWatchMode) {
+async function loadMatchedRouteModule(clientDir, routePath, isWatchMode) {
+  const { existsSync: existsSync3 } = await import("node:fs");
+  const { pathToFileURL: pathToFileURL8 } = await import("node:url");
+  const normalizedRoutePath = routePath === "" ? "index" : routePath;
+  const possiblePaths = [
+    `${clientDir}/routes/${normalizedRoutePath}.tsx`,
+    `${clientDir}/routes/${normalizedRoutePath}/index.tsx`,
+    `${clientDir}/routes/${normalizedRoutePath}.ts`,
+    `${clientDir}/routes/${normalizedRoutePath}/index.ts`,
+    `${clientDir}/routes/${normalizedRoutePath}.mdx`,
+    `${clientDir}/routes/${normalizedRoutePath}/index.mdx`,
+    `${clientDir}/routes/${normalizedRoutePath}.md`,
+    `${clientDir}/routes/${normalizedRoutePath}/index.md`
+  ];
+  for (const possiblePath of possiblePaths) {
+    if (existsSync3(possiblePath)) {
+      return await import(pathToFileURL8(possiblePath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
+    }
+  }
+  return null;
+}
+async function loadOgImageFromRoute(cwd, clientDir, pathname, isWatchMode) {
   try {
+    const pathnameOnly = pathname.split("?")[0];
     const routesGlobal = globalThis.__REROUTE_ROUTES__;
     if (routesGlobal && Array.isArray(routesGlobal)) {
-      const matchedRoute = routesGlobal.find((r) => {
-        if (r.isDynamic) {
-          const pattern = r.pattern.replace(/:[^/]+/g, "[^/]+");
-          const regex = new RegExp(`^${pattern}$`);
-          return regex.test(pathname);
-        }
-        return r.pattern === pathname;
-      });
-      if (matchedRoute) {
+      const matchedRoute2 = matchRoutes(routesGlobal, pathnameOnly)?.route;
+      if (matchedRoute2) {
         return {
-          meta: matchedRoute.meta,
-          ogImage: matchedRoute.ssr?.ogImage
+          meta: matchedRoute2.meta,
+          ogImage: matchedRoute2.ssr?.ogImage
         };
       }
     }
     const { pathToFileURL: pathToFileURL8 } = await import("node:url");
-    const { existsSync: existsSync3 } = await import("node:fs");
-    const pathnameOnly = pathname.split("?")[0];
-    const cleanPath = pathnameOnly === "/" ? "index" : pathnameOnly.replace(/^\//, "").replace(/\/$/, "");
-    const possiblePaths = [
-      `${clientDir}/routes/${cleanPath}.tsx`,
-      `${clientDir}/routes/${cleanPath}/index.tsx`,
-      `${clientDir}/routes/${cleanPath}.ts`,
-      `${clientDir}/routes/${cleanPath}/index.ts`
-    ];
-    for (const routePath of possiblePaths) {
-      if (existsSync3(routePath)) {
-        const routeMod = await import(pathToFileURL8(routePath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
+    const routesPath = `${cwd}/.reroute/routes.ts`;
+    const routesMod = await import(pathToFileURL8(routesPath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
+    const match = typeof routesMod.matchRoute === "function" ? routesMod.matchRoute(pathnameOnly) : Array.isArray(routesMod.routes) ? matchRoutes(routesMod.routes, pathnameOnly) : null;
+    const matchedRoute = match?.route;
+    if (matchedRoute && typeof matchedRoute.path === "string") {
+      const routeMod = await loadMatchedRouteModule(clientDir, String(matchedRoute.path), isWatchMode);
+      if (routeMod) {
         return {
           meta: routeMod.meta,
           ogImage: routeMod.ssr?.ogImage
         };
       }
     }
+    if (matchedRoute) {
+      return {
+        meta: matchedRoute.meta,
+        ogImage: matchedRoute.ssr?.ogImage
+      };
+    }
   } catch (error) {
     console.warn("[reroute/og] Error loading route metadata:", error);
   }
@@ -7323,14 +7974,14 @@ function registerOGRoutes(app, options) {
     }
     return;
   }
-  function getFontPaths(fontPath, baseDir, join4) {
+  function getFontPaths(fontPath, baseDir, join5) {
     const fontRelativePath = fontPath.replace(/^(\.\/)?src\/client\/assets\//, "").replace(/^assets\//, "");
     return [
-      join4(clientDir, "assets", fontRelativePath),
-      join4(baseDir, ".reroute", "assets", fontRelativePath),
-      join4(cwd, ".reroute", "assets", fontRelativePath),
-      join4(cwd, fontPath),
-      join4(baseDir, fontPath)
+      join5(clientDir, "assets", fontRelativePath),
+      join5(baseDir, ".reroute", "assets", fontRelativePath),
+      join5(cwd, ".reroute", "assets", fontRelativePath),
+      join5(cwd, fontPath),
+      join5(baseDir, fontPath)
     ];
   }
   async function tryLoadFont(font, possiblePaths, existsSync3) {
@@ -7353,14 +8004,14 @@ function registerOGRoutes(app, options) {
     if (!ogConfig.fonts || ogConfig.fonts.length === 0) {
       return [];
     }
-    const { join: join4, dirname } = await import("node:path");
+    const { join: join5, dirname } = await import("node:path");
     const { existsSync: existsSync3 } = await import("node:fs");
     const isCompiledBinary = typeof Bun !== "undefined" && process.argv[0]?.endsWith(process.argv[1]);
     const baseDir = isCompiledBinary ? dirname(process.argv[1]) : cwd;
     const loadedFonts = [];
     for (const font of ogConfig.fonts) {
       try {
-        const possiblePaths = getFontPaths(font.path, baseDir, join4);
+        const possiblePaths = getFontPaths(font.path, baseDir, join5);
         const loadedFont = await tryLoadFont(font, possiblePaths, existsSync3);
         if (loadedFont) {
           loadedFonts.push(loadedFont);
@@ -7688,42 +8339,52 @@ async function registerMainFeedRoute(app, cwd, collections2, baseUrl, isWatchMod
 function registerCollectionFeedRoutes(app, collections2, options) {
   for (const collection of collections2) {
     options.availableFeeds.push(`/${collection}/feed.xml`);
-    app.get(`/${collection}/feed.xml`, async () => {
-      const cacheKey = `rss:${collection}`;
-      try {
-        const cached = options.rssCache.get(cacheKey);
-        if (cached) {
-          return feedResponse(cached, options.format, {
-            maxAge: options.maxAge,
-            cacheStatus: "HIT"
-          });
-        }
-        const discovery5 = await getOrDiscoverRSSData(options.cwd, [collection], options.baseUrl, options.isWatchMode, options.rssConfig);
-        const items = discovery5.collections.get(collection) ?? [];
-        if (items.length === 0)
-          throw new NotFoundError8;
-        const feed = {
-          title: createFeedTitle(options.rssConfig?.title, collection),
-          link: `${options.baseUrl}/${collection}/feed.xml`,
-          description: options.rssConfig?.description ?? `Latest ${collection} updates`,
-          items
-        };
-        const xml = generateFeed(feed, {
-          format: options.format,
-          limit: options.limit
-        });
-        options.rssCache.set(cacheKey, xml);
-        return feedResponse(xml, options.format, {
-          maxAge: options.maxAge,
-          cacheStatus: "MISS"
-        });
-      } catch (error) {
-        if (error instanceof NotFoundError8)
-          throw error;
-        console.error(`[reroute] Failed to generate ${collection} feed:`, error);
-        throw new NotFoundError8;
-      }
+    app.get(`/${collection}/feed.xml`, async ({ request }) => handleCollectionFeed(collection, request, options));
+  }
+}
+function filterFeedItemsByLang(items, lang) {
+  if (!lang)
+    return items;
+  return items.filter((item) => !item.locale || item.locale === lang);
+}
+function buildCollectionFeed(collection, items, lang, options) {
+  return {
+    title: createFeedTitle(options.rssConfig?.title, collection),
+    link: lang ? `${options.baseUrl}/${collection}/feed.xml?lang=${encodeURIComponent(lang)}` : `${options.baseUrl}/${collection}/feed.xml`,
+    description: options.rssConfig?.description ?? `Latest ${collection} updates`,
+    items,
+    language: lang || items[0]?.locale || "en"
+  };
+}
+async function handleCollectionFeed(collection, request, options) {
+  const lang = new URL(request.url).searchParams.get("lang") || undefined;
+  const cacheKey = lang ? `rss:${collection}:${lang}` : `rss:${collection}`;
+  try {
+    const cached = options.rssCache.get(cacheKey);
+    if (cached) {
+      return feedResponse(cached, options.format, {
+        maxAge: options.maxAge,
+        cacheStatus: "HIT"
+      });
+    }
+    const discovery5 = await getOrDiscoverRSSData(options.cwd, [collection], options.baseUrl, options.isWatchMode, options.rssConfig);
+    const items = filterFeedItemsByLang(discovery5.collections.get(collection) ?? [], lang);
+    if (items.length === 0)
+      throw new NotFoundError8;
+    const xml = generateFeed(buildCollectionFeed(collection, items, lang, options), {
+      format: options.format,
+      limit: options.limit
     });
+    options.rssCache.set(cacheKey, xml);
+    return feedResponse(xml, options.format, {
+      maxAge: options.maxAge,
+      cacheStatus: "MISS"
+    });
+  } catch (error) {
+    if (error instanceof NotFoundError8)
+      throw error;
+    console.error(`[reroute] Failed to generate ${collection} feed:`, error);
+    throw new NotFoundError8;
   }
 }
 async function discoverRoutesWithFeeds(ssrDataRoutes, collections2, options) {
@@ -7899,11 +8560,11 @@ function scoreEntry(entry, terms) {
   return { score, matchedHeadings };
 }
 function searchEntries(entries, query, options = {}) {
-  const { collections: collections2, page = 1, pageSize = 20 } = options;
+  const { collections: collections2, page = 1, pageSize = 20, locale } = options;
   const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 1);
   if (terms.length === 0)
     return { results: [], total: 0 };
-  const scored = entries.filter((entry) => !collections2?.length || collections2.includes(entry.collection)).map((entry) => ({ entry, ...scoreEntry(entry, terms) })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
+  const scored = entries.filter((entry) => !collections2?.length || collections2.includes(entry.collection)).filter((entry) => !(locale && entry.locale) || entry.locale === locale).map((entry) => ({ entry, ...scoreEntry(entry, terms) })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
   const total = scored.length;
   const startIndex = (page - 1) * pageSize;
   const paginatedScored = scored.slice(startIndex, startIndex + pageSize);
@@ -7954,10 +8615,12 @@ function registerSearchRoute(app, cwd, directive, maxAge, searchConfig) {
     const page = query.page ? Math.max(1, Number.parseInt(String(query.page), 10)) : 1;
     const requestedPageSize = query.pageSize ? Number.parseInt(String(query.pageSize), 10) : defaultPageSize;
     const pageSize = Math.min(Math.max(1, requestedPageSize), maxPageSize);
+    const locale = query.lang ? String(query.lang) : undefined;
     const { results, total } = searchEntries(index.entries, searchQuery, {
       collections: collections2,
       page,
-      pageSize
+      pageSize,
+      locale
     });
     return Response.json({
       total,
@@ -8061,9 +8724,115 @@ function registerSitemapRoutes(app, options) {
 // packages/elysia/src/routes/ssr.ts
 init_core();
 init_server2();
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 import { trace as trace4 } from "@opentelemetry/api";
 import { NotFoundError as NotFoundError10 } from "elysia";
+
+// packages/elysia/src/libs/i18n.ts
+init_core();
+import { join as join5 } from "node:path";
+var cachedI18n = null;
+async function loadI18nState(cwd) {
+  const path2 = join5(cwd, ".reroute", "i18n.json");
+  try {
+    const file = Bun.file(path2);
+    if (!await file.exists()) {
+      return {
+        enabled: false,
+        defaultLocale: "en-US",
+        locales: [],
+        localesDir: "locales",
+        cookie: "reroute-locale",
+        redirectContentOnNegotiate: true,
+        catalogs: {}
+      };
+    }
+    const stat5 = await file.stat();
+    const mtime = stat5?.mtime?.getTime?.() ?? Date.now();
+    if (cachedI18n && cachedI18n.cwd === cwd && cachedI18n.mtime === mtime) {
+      return cachedI18n.data;
+    }
+    const data = await file.json();
+    cachedI18n = { cwd, data, mtime };
+    return data;
+  } catch {
+    return {
+      enabled: false,
+      defaultLocale: "en-US",
+      locales: [],
+      localesDir: "locales",
+      cookie: "reroute-locale",
+      redirectContentOnNegotiate: true,
+      catalogs: {}
+    };
+  }
+}
+async function listContentCollections(cwd) {
+  try {
+    const { readdir: readdir6 } = await import("node:fs/promises");
+    const dir = join5(cwd, ".reroute", "collections");
+    const entries = await readdir6(dir);
+    return entries.filter((f) => f.endsWith(".js")).map((f) => f.replace(/\.js$/, ""));
+  } catch {
+    return [];
+  }
+}
+async function resolveI18nForRequest(cwd, pathname, headers2, collections2) {
+  const i18n2 = await loadI18nState(cwd);
+  const disabled = {
+    enabled: false,
+    locale: i18n2.defaultLocale,
+    defaultLocale: i18n2.defaultLocale,
+    locales: [],
+    cookie: i18n2.cookie,
+    catalogs: {},
+    hydration: { enabled: false }
+  };
+  if (!i18n2.enabled || i18n2.locales.length === 0) {
+    return disabled;
+  }
+  const knownCollections = collections2?.length ? collections2 : await listContentCollections(cwd);
+  const resolution = resolveLocale({
+    pathname,
+    cookieHeader: headers2.cookie,
+    acceptLanguage: headers2["accept-language"],
+    availableLocales: i18n2.locales,
+    defaultLocale: i18n2.defaultLocale,
+    cookieName: i18n2.cookie,
+    collections: knownCollections.length > 0 ? knownCollections : undefined
+  });
+  let redirectTo = resolution.redirectTo;
+  if (!redirectTo && i18n2.redirectContentOnNegotiate && knownCollections.length > 0) {
+    redirectTo = contentNegotiateRedirect(resolution, i18n2.defaultLocale, true);
+  }
+  const cookieValue = buildLocaleCookie(i18n2.cookie, resolution.locale);
+  const hydration = {
+    enabled: true,
+    locale: resolution.locale,
+    defaultLocale: i18n2.defaultLocale,
+    locales: i18n2.locales,
+    cookie: i18n2.cookie,
+    catalogs: i18n2.catalogs,
+    collections: knownCollections
+  };
+  try {
+    globalThis.__REROUTE_I18N__ = hydration;
+  } catch {}
+  return {
+    enabled: true,
+    locale: resolution.locale,
+    defaultLocale: i18n2.defaultLocale,
+    locales: i18n2.locales,
+    cookie: i18n2.cookie,
+    catalogs: i18n2.catalogs,
+    collections: knownCollections,
+    setCookie: cookieValue,
+    redirectTo,
+    hydration
+  };
+}
+
+// packages/elysia/src/routes/ssr.ts
 if (typeof process !== "undefined") {
   process.on("unhandledRejection", (reason, _promise) => {
     console.error("[reroute] Unhandled Promise Rejection:", reason);
@@ -8085,6 +8854,28 @@ function isOtelAvailable3() {
     return false;
   }
 }
+async function applyI18nForSSR(cwd, pathname, headers2, set, fallbackLang) {
+  const i18nResult = await resolveI18nForRequest(cwd, pathname, headers2);
+  if (i18nResult.redirectTo && i18nResult.redirectTo !== pathname) {
+    const redirectHeaders = {
+      Location: i18nResult.redirectTo
+    };
+    if (i18nResult.setCookie) {
+      redirectHeaders["Set-Cookie"] = i18nResult.setCookie;
+    }
+    return {
+      redirect: new Response(null, { status: 302, headers: redirectHeaders }),
+      effectiveLang: fallbackLang
+    };
+  }
+  if (i18nResult.setCookie) {
+    set.headers["set-cookie"] = i18nResult.setCookie;
+  }
+  return {
+    hydration: i18nResult.enabled ? i18nResult.hydration : undefined,
+    effectiveLang: i18nResult.enabled ? i18nResult.locale : fallbackLang
+  };
+}
 function registerSSRRoutes(app, options) {
   const {
     rootComponent,
@@ -8124,7 +8915,7 @@ function registerSSRRoutes(app, options) {
   let contentRoutes = [];
   let dynamicRoutes = [];
   try {
-    const manifestPath = join4(cwd, ".reroute", "manifest.json");
+    const manifestPath = join6(cwd, ".reroute", "manifest.json");
     const { readFileSync } = __require("node:fs");
     const manifestText = readFileSync(manifestPath, "utf-8");
     const manifest = JSON.parse(manifestText);
@@ -8160,6 +8951,9 @@ function registerSSRRoutes(app, options) {
     request.headers.forEach((value, key) => {
       headers2[key.toLowerCase()] = value;
     });
+    const i18n2 = await applyI18nForSSR(cwd, pathname, headers2, set, lang);
+    if (i18n2.redirect)
+      return i18n2.redirect;
     const parentSpan = store.telemetrySpan;
     return withParentSpan(parentSpan, async () => {
       let isFirstStreamingRequest = false;
@@ -8242,7 +9036,7 @@ function registerSSRRoutes(app, options) {
             cachedIndexHtml,
             debug,
             head,
-            lang,
+            lang: i18n2.effectiveLang,
             appId,
             maxAge: serverMaxAge,
             searchParams,
@@ -8253,7 +9047,8 @@ function registerSSRRoutes(app, options) {
             parentSpan: renderSpan,
             headers: headers2,
             timeout: options.streamingTimeout,
-            titleSuffix: options.titleSuffix
+            titleSuffix: options.titleSuffix,
+            i18n: i18n2.hydration
           });
           renderSpan?.setAttribute("http.response.status_code", result.status);
           if (debug)
@@ -8424,7 +9219,7 @@ function registerSSRRoutes(app, options) {
               isWatchMode,
               bundleUrl,
               head,
-              lang,
+              lang: i18n2.effectiveLang,
               appId,
               maxAge: serverMaxAge,
               searchParams,
@@ -8434,7 +9229,8 @@ function registerSSRRoutes(app, options) {
               autoCanonical: options.autoCanonical,
               parentSpan: renderSpan,
               headers: headers2,
-              titleSuffix: options.titleSuffix
+              titleSuffix: options.titleSuffix,
+              i18n: i18n2.hydration
             });
             renderSpan?.setAttribute("http.response.status_code", renderResult.status);
             return renderResult;
@@ -9012,4 +9808,4 @@ export {
   reroute
 };
 
-//# debugId=46D34975F51945E064756E2164756E21
+//# debugId=27029E2CFF5EA81E64756E2164756E21