reroute-js 0.45.12-beta.1 → 0.46.0

package/elysia/index.js

@@ -1,9 +1,9 @@
 /**
- * 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
  */
@@ -200,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;
@@ -891,6 +1249,51 @@ function matchRoutes(routes, pathname) {
   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)
@@ -943,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 : {};
@@ -952,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) {
@@ -976,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();
 });
 
@@ -1190,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 || {};
@@ -1353,6 +1758,7 @@ function handleFlattenedResult(entries, set, ctx, cache, setError, setStatus) {
 }
 var init_routes = __esm(() => {
   init_cache();
+  init_content_path();
   init_imports();
 });
 
@@ -1445,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;
@@ -1497,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;
@@ -1517,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();
 });
 
@@ -1564,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;
@@ -1591,6 +1992,7 @@ async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode) {
 }
 var MAX_SSR_MODULES = 200, moduleAccessOrder;
 var init_seed = __esm(() => {
+  init_content_path();
   init_modules();
   moduleAccessOrder = [];
 });
@@ -1598,17 +2000,17 @@ var init_seed = __esm(() => {
 // packages/core/src/ssr/lib/data.ts
 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);
@@ -1771,6 +2173,7 @@ function createLazyMarker(pathname, key) {
   };
 }
 var init_data = __esm(() => {
+  init_content_path();
   init_imports();
   init_seed();
 });
@@ -1971,14 +2374,14 @@ function replaceAppRoot(html, appHtml, appId) {
 var init_html = () => {};
 
 // packages/core/src/og/discovery.ts
-import { readdir as readdir3 } from "node:fs/promises";
+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 readdir3(baseDir, { withFileTypes: true });
+    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);
@@ -1998,7 +2401,7 @@ async function collectOGCandidatePaths(currentDir, parts, depth, pathsToTry, all
   }
   const literalDir = join(currentDir, parts[depth]);
   try {
-    await readdir3(literalDir);
+    await readdir4(literalDir);
     await collectOGCandidatePaths(literalDir, parts, depth + 1, pathsToTry, true);
   } catch {}
   const dynamicDirs = await listDynamicRouteDirectories(currentDir);
@@ -2153,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)
@@ -2188,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;
@@ -2229,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));
@@ -2247,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;
@@ -2269,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 };
@@ -2311,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;
@@ -2321,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;
@@ -2503,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 readdir4, 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>
@@ -2572,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;
@@ -2585,7 +3024,7 @@ async function findContentModulePath(collection, name, clientDir, cwd, isWatchMo
   } catch {}
   try {
     const chunkDir = join(cwd, ".reroute", "chunks", collection);
-    const files = await readdir4(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);
@@ -2593,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;
@@ -2793,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>`;
@@ -2873,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);
@@ -2899,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() {
@@ -3127,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) {
@@ -3293,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;
   });
@@ -3311,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({
@@ -4494,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 {
@@ -4505,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);
@@ -4811,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) {
@@ -5081,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>
@@ -5243,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>`;
@@ -5258,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>`;
 }
@@ -5362,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}"`;
@@ -5405,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`);
@@ -5518,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;
@@ -5650,6 +6178,7 @@ var init_src = __esm(() => {
   init_bundler();
   init_config();
   init_content();
+  init_i18n();
   init_llms();
   init_og();
   init_robots();
@@ -5662,6 +6191,7 @@ var init_src = __esm(() => {
 var exports_core = {};
 __export(exports_core, {
   toPromise: () => toPromise,
+  toOgLocale: () => toOgLocale,
   toBytes: () => toBytes,
   stripStart: () => stripStart,
   stripHtmlTags: () => stripHtmlTags,
@@ -5673,6 +6203,7 @@ __export(exports_core, {
   setGlobalSSRData: () => setGlobalSSRData,
   setGlobalCollections: () => setGlobalCollections,
   seedSSRModuleForPath: () => seedSSRModuleForPath,
+  resolveLocale: () => resolveLocale,
   resetSSRAccessTracking: () => resetSSRAccessTracking,
   renderSSRDocumentStream: () => renderSSRDocumentStream,
   renderSSRDocument: () => renderSSRDocument,
@@ -5681,9 +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,
@@ -5696,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,
@@ -5717,6 +6258,7 @@ __export(exports_core, {
   generateContentHash: () => generateContentHash,
   generateCollectionScripts: () => generateCollectionScripts,
   generateAtomXML: () => generateAtomXML,
+  formatMessage: () => formatMessage,
   formatAsText: () => formatAsText,
   formatAsMarkdown: () => formatAsMarkdown,
   findOGImageForPath: () => findOGImageForPath,
@@ -5736,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,
@@ -5747,6 +6291,8 @@ __export(exports_core, {
   createDataScript: () => createDataScript,
   createCollectionScript: () => createCollectionScript,
   createBundlePreload: () => createBundlePreload,
+  contentNegotiateRedirect: () => contentNegotiateRedirect,
+  contentKey: () => contentKey,
   computeSSRDataForPath: () => computeSSRDataForPath,
   computeSSRData: () => computeSSRData,
   computeRouteData: () => computeRouteData,
@@ -5755,6 +6301,7 @@ __export(exports_core, {
   compressStreamIfAccepted: () => compressStreamIfAccepted,
   compareRouteSpecificity: () => compareRouteSpecificity,
   cleanupPathScopedSSRData: () => cleanupPathScopedSSRData,
+  buildLocaleCookie: () => buildLocaleCookie,
   buildHeadFromMeta: () => buildHeadFromMeta,
   blockSearchCrawlers: () => blockSearchCrawlers,
   blockAITrainingCrawlers: () => blockAITrainingCrawlers,
@@ -5770,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(() => {
@@ -5784,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;
@@ -5827,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;
     }
@@ -5850,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,
@@ -6272,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;
@@ -6319,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" };
     }
@@ -7424,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) {
@@ -7454,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);
@@ -7789,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) {
@@ -8000,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);
@@ -8055,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,
@@ -8162,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);
@@ -8186,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,
@@ -8225,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);
@@ -8261,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;
@@ -8343,7 +9036,7 @@ function registerSSRRoutes(app, options) {
             cachedIndexHtml,
             debug,
             head,
-            lang,
+            lang: i18n2.effectiveLang,
             appId,
             maxAge: serverMaxAge,
             searchParams,
@@ -8354,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)
@@ -8525,7 +9219,7 @@ function registerSSRRoutes(app, options) {
               isWatchMode,
               bundleUrl,
               head,
-              lang,
+              lang: i18n2.effectiveLang,
               appId,
               maxAge: serverMaxAge,
               searchParams,
@@ -8535,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;
@@ -9113,4 +9808,4 @@ export {
   reroute
 };
 
-//# debugId=C4FE93DB6E1B24E664756E2164756E21
+//# debugId=27029E2CFF5EA81E64756E2164756E21