reroute-js 0.45.11 → 0.46.0

package/core/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();
@@ -5584,6 +6195,7 @@ init_core();
 
 export {
   toPromise,
+  toOgLocale,
   toBytes,
   stripStart,
   stripHtmlTags,
@@ -5595,6 +6207,7 @@ export {
   setGlobalSSRData,
   setGlobalCollections,
   seedSSRModuleForPath,
+  resolveLocale,
   resetSSRAccessTracking,
   renderSSRDocumentStream,
   renderSSRDocument,
@@ -5603,7 +6216,17 @@ export {
   processCollections,
   preloadContentModule,
   performSSRSetup,
+  parseCookieValue,
+  parseContentPath,
+  normalizePathname,
+  negotiateLocale,
   mergeLayoutData,
+  matchRoutes,
+  matchRoutePattern,
+  lookupMessage,
+  looksLikeLocale,
+  localizeHref,
+  localizeContentHref,
   loadRoutesModule,
   loadOGImageComponent,
   loadIndexHtml,
@@ -5616,11 +6239,13 @@ export {
   inlineTailwindCSS,
   importContentModuleForPath,
   htmlToMarkdown,
+  hreflangTags,
   gzipIfAccepted,
   getSitemapExcludedRoutes,
   getRedirectSourcePaths,
   getPatternDepth,
   getMimeType,
+  getMessage,
   getMatchingLayouts,
   getContentMeta,
   generateSitemapXML,
@@ -5637,6 +6262,7 @@ export {
   generateContentHash,
   generateCollectionScripts,
   generateAtomXML,
+  formatMessage,
   formatAsText,
   formatAsMarkdown,
   findOGImageForPath,
@@ -5656,10 +6282,12 @@ export {
   discoverRoutes,
   discoverRobotsData,
   discoverRSSData,
+  discoverI18n,
   discoverCollections,
   discoverCollectionContent,
   defineConfig,
   deduplicateMetaTags,
+  createTranslator,
   createLlmsScript,
   createLayoutDataKey,
   createLayoutCacheKey,
@@ -5667,13 +6295,17 @@ export {
   createDataScript,
   createCollectionScript,
   createBundlePreload,
+  contentNegotiateRedirect,
+  contentKey,
   computeSSRDataForPath,
   computeSSRData,
   computeRouteData,
   computeLayoutData,
   computeContentData,
   compressStreamIfAccepted,
+  compareRouteSpecificity,
   cleanupPathScopedSSRData,
+  buildLocaleCookie,
   buildHeadFromMeta,
   blockSearchCrawlers,
   blockAITrainingCrawlers,
@@ -5689,7 +6321,10 @@ export {
   SEARCH_CRAWLERS,
   LRUCache,
   DefaultOGTemplate,
+  DEFAULT_LOCALES_DIR,
+  DEFAULT_LOCALE,
+  DEFAULT_COOKIE,
   AI_CRAWLERS
 };
 
-//# debugId=994655E761DF84E564756E2164756E21
+//# debugId=C4F445FA1614E66D64756E2164756E21