scribe-cms 0.0.7 → 0.0.9

package/dist/index.cjs

@@ -139,14 +139,14 @@ var SLUG_PLACEHOLDER = "{slug}";
 function isRoutableType(type) {
   return typeof type.path === "string" && type.path.length > 0;
 }
-function assertValidPathTemplate(path11, typeId) {
-  if (!path11.startsWith("/")) {
-    throw new Error(`Content type "${typeId}": path must start with / (got "${path11}")`);
+function assertValidPathTemplate(path13, typeId) {
+  if (!path13.startsWith("/")) {
+    throw new Error(`Content type "${typeId}": path must start with / (got "${path13}")`);
   }
-  const count = (path11.match(/\{slug\}/g) ?? []).length;
+  const count = (path13.match(/\{slug\}/g) ?? []).length;
   if (count !== 1) {
     throw new Error(
-      `Content type "${typeId}": path must contain exactly one {slug} (got "${path11}")`
+      `Content type "${typeId}": path must contain exactly one {slug} (got "${path13}")`
     );
   }
 }
@@ -160,19 +160,69 @@ function pathSuffix(template) {
   if (idx === -1) throw new Error(`Invalid path template (missing {slug}): ${template}`);
   return template.slice(idx + SLUG_PLACEHOLDER.length);
 }
-function resolvePath(template, slug, locale, defaultLocale) {
-  const relative = template.replace(SLUG_PLACEHOLDER, slug);
-  if (locale === defaultLocale) return relative;
-  return `/${locale}${relative}`;
-}
-function extractSlugFromResolvedPath(template, resolvedPath) {
-  const prefix = pathPrefix(template);
-  const suffix = pathSuffix(template);
-  if (!resolvedPath.startsWith(prefix)) return null;
-  if (suffix && !resolvedPath.endsWith(suffix)) return null;
-  const slugEnd = suffix ? resolvedPath.length - suffix.length : resolvedPath.length;
-  const slug = resolvedPath.slice(prefix.length, slugEnd);
-  return slug.length > 0 ? slug : null;
+function resolveDefaultLocaleRouting() {
+  return { strategy: "path-prefix", prefixDefaultLocale: false };
+}
+function splitPathAndSearch(pathname) {
+  const q = pathname.indexOf("?");
+  if (q === -1) return { pathname, search: "" };
+  return { pathname: pathname.slice(0, q), search: pathname.slice(q) };
+}
+function createUrlBuilder(config) {
+  const localeRouting = config.localeRouting ?? resolveDefaultLocaleRouting();
+  const defaultLocale = config.defaultLocale;
+  const prefixedLocales = localeRouting.strategy === "path-prefix" ? localeRouting.prefixDefaultLocale ? [...config.locales] : config.locales.filter((locale) => locale !== defaultLocale) : config.locales.filter((locale) => locale !== defaultLocale);
+  function applyLocaleToPath(pathname, locale) {
+    if (locale === defaultLocale) {
+      if (localeRouting.strategy === "path-prefix" && localeRouting.prefixDefaultLocale) {
+        return `/${defaultLocale}${pathname}`;
+      }
+      return pathname;
+    }
+    if (localeRouting.strategy === "search-param") {
+      const { pathname: base, search } = splitPathAndSearch(pathname);
+      const params = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
+      params.set(localeRouting.param, locale);
+      const qs = params.toString();
+      return qs ? `${base}?${qs}` : base;
+    }
+    return `/${locale}${pathname}`;
+  }
+  function resolvePath(template, slug, locale) {
+    const relative = template.replace(SLUG_PLACEHOLDER, slug);
+    return applyLocaleToPath(relative, locale);
+  }
+  function extractSlugFromResolvedPath(template, resolvedPath) {
+    let pathname = resolvedPath;
+    if (localeRouting.strategy === "search-param") {
+      pathname = splitPathAndSearch(resolvedPath).pathname;
+    } else if (localeRouting.strategy === "path-prefix") {
+      for (const locale of config.locales) {
+        if (locale === defaultLocale && !localeRouting.prefixDefaultLocale) continue;
+        const prefix2 = `/${locale}`;
+        if (pathname === prefix2 || pathname.startsWith(`${prefix2}/`)) {
+          pathname = pathname.slice(prefix2.length) || "/";
+          break;
+        }
+      }
+    }
+    const prefix = pathPrefix(template);
+    const suffix = pathSuffix(template);
+    if (!pathname.startsWith(prefix)) return null;
+    if (suffix && !pathname.endsWith(suffix)) return null;
+    const slugEnd = suffix ? pathname.length - suffix.length : pathname.length;
+    const slug = pathname.slice(prefix.length, slugEnd);
+    return slug.length > 0 ? slug : null;
+  }
+  return {
+    defaultLocale,
+    locales: config.locales,
+    localeRouting,
+    prefixedLocales,
+    resolvePath,
+    extractSlugFromResolvedPath,
+    applyLocaleToPath
+  };
 }
 
 // src/config/resolve-config.ts
@@ -195,6 +245,13 @@ function resolveConfig(input, baseDir) {
       `scribe config: defaultLocale "${defaultLocale}" is not in locales [${raw.locales.join(", ")}]`
     );
   }
+  const localeRouting = raw.localeRouting ?? {
+    strategy: "path-prefix",
+    prefixDefaultLocale: false
+  };
+  if (localeRouting.strategy === "search-param" && !localeRouting.param) {
+    throw new Error('scribe config: localeRouting search-param requires a "param" name');
+  }
   const projectRoot = path3__default.default.resolve(baseDir ?? process.cwd(), raw.rootDir);
   const contentRoot = path3__default.default.resolve(projectRoot, raw.contentDir ?? "content");
   const storePath = path3__default.default.resolve(projectRoot, raw.store ?? ".scribe/store.sqlite");
@@ -222,6 +279,7 @@ function resolveConfig(input, baseDir) {
     assetsPath,
     locales: [...raw.locales],
     defaultLocale,
+    localeRouting,
     localePresets: raw.localePresets,
     translate: raw.translate,
     types
@@ -272,10 +330,10 @@ function introspectSchema(schema, prefix = []) {
 }
 function extractByPaths(data, paths) {
   const out = {};
-  for (const path11 of paths) {
-    const value = getAtPath(data, path11);
+  for (const path13 of paths) {
+    const value = getAtPath(data, path13);
     if (value !== void 0) {
-      setAtPath(out, path11.filter((p) => p !== "*"), value);
+      setAtPath(out, path13.filter((p) => p !== "*"), value);
     }
   }
   return out;
@@ -293,13 +351,13 @@ function mergeStructuralOntoLocale(localeData, enData, schema) {
   const translatable = pickTranslatable(localeData, schema);
   return deepMerge(structural, translatable);
 }
-function getAtPath(obj, path11) {
+function getAtPath(obj, path13) {
   let current = obj;
-  for (const segment of path11) {
+  for (const segment of path13) {
     if (segment === "*") {
       if (!Array.isArray(current)) return void 0;
       return current.map(
-        (item) => typeof item === "object" && item !== null ? getAtPath(item, path11.slice(path11.indexOf("*") + 1)) : void 0
+        (item) => typeof item === "object" && item !== null ? getAtPath(item, path13.slice(path13.indexOf("*") + 1)) : void 0
       );
     }
     if (typeof current !== "object" || current === null || Array.isArray(current)) return void 0;
@@ -307,13 +365,13 @@ function getAtPath(obj, path11) {
   }
   return current;
 }
-function setAtPath(obj, path11, value) {
-  if (path11.length === 0) return;
-  if (path11.length === 1) {
-    obj[path11[0]] = value;
+function setAtPath(obj, path13, value) {
+  if (path13.length === 0) return;
+  if (path13.length === 1) {
+    obj[path13[0]] = value;
     return;
   }
-  const [head, ...rest] = path11;
+  const [head, ...rest] = path13;
   if (!(head in obj) || typeof obj[head] !== "object" || obj[head] === null) {
     obj[head] = {};
   }
@@ -358,45 +416,23 @@ var LOCALE_BUILTIN_KEYS = [
   ["translationOf", "translationOf is internal; remove from locale translation"],
   ["enSlug", "enSlug is internal; remove from locale translation"]
 ];
-function extractBuiltinEnFields(data, pathTemplate, enSlug, defaultLocale) {
+var DEPRECATED_REDIRECT_FIELDS = [
+  [
+    "aliases",
+    "aliases frontmatter is removed \u2014 add redirects to content/<type>/_redirects.json instead"
+  ],
+  [
+    "redirect_to",
+    "redirect_to frontmatter is removed \u2014 add redirects to content/<type>/_redirects.json instead"
+  ]
+];
+function extractBuiltinEnFields(data, _pathTemplate, _enSlug, _defaultLocale) {
   const issues = [];
   const rest = { ...data };
-  const aliasesResult = zod.z.array(slugPatternSchema).max(20).optional().default([]).safeParse(rest.aliases ?? []);
-  delete rest.aliases;
-  const redirectRaw = rest.redirect_to;
-  delete rest.redirect_to;
-  let redirectTo;
-  if (redirectRaw !== void 0 && redirectRaw !== null && redirectRaw !== "") {
-    if (typeof redirectRaw !== "string") {
-      issues.push({
-        field: "redirect_to",
-        message: "redirect_to must be a string path",
-        level: "error"
-      });
-    } else if (!pathTemplate) {
-      issues.push({
-        field: "redirect_to",
-        message: "redirect_to is not allowed on reference-only content types",
-        level: "error"
-      });
-    } else if (!extractSlugFromResolvedPath(pathTemplate, redirectRaw)) {
-      issues.push({
-        field: "redirect_to",
-        message: `redirect_to must match path template "${pathTemplate}" (prefix "${pathPrefix(pathTemplate)}"${pathSuffix(pathTemplate) ? `, suffix "${pathSuffix(pathTemplate)}"` : ""})`,
-        level: "error"
-      });
-    } else {
-      redirectTo = redirectRaw;
-    }
-  }
-  const aliases = aliasesResult.success ? aliasesResult.data : [];
-  if (!aliasesResult.success) {
-    for (const issue of aliasesResult.error.issues) {
-      issues.push({
-        field: `aliases.${issue.path.join(".")}`,
-        message: issue.message,
-        level: "error"
-      });
+  for (const [field2, message] of DEPRECATED_REDIRECT_FIELDS) {
+    if (rest[field2] !== void 0) {
+      issues.push({ field: field2, message, level: "error" });
+      delete rest[field2];
     }
   }
   let publishedAt;
@@ -458,8 +494,6 @@ function extractBuiltinEnFields(data, pathTemplate, enSlug, defaultLocale) {
   }
   return {
     builtin: {
-      aliases,
-      redirectTo,
       publishedAt,
       updatedAt,
       noindex,
@@ -484,20 +518,24 @@ function documentLastModified(doc) {
   const date = new Date(raw);
   return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
 }
-function resolveCanonicalPathname(type, doc, defaultLocale) {
+function resolveCanonicalPathname(type, doc, defaultLocale, localeRouting) {
+  const urlBuilder = createUrlBuilder({
+    locales: [defaultLocale, ...doc.locale !== defaultLocale ? [doc.locale] : []],
+    defaultLocale,
+    localeRouting: localeRouting ?? { strategy: "path-prefix", prefixDefaultLocale: false }
+  });
   if (doc.canonicalPathOverride) {
-    if (doc.locale === defaultLocale) return doc.canonicalPathOverride;
-    return `/${doc.locale}${doc.canonicalPathOverride}`;
+    return urlBuilder.applyLocaleToPath(doc.canonicalPathOverride, doc.locale);
   }
   if (!type.path) return `/${doc.slug}`;
-  return resolvePath(type.path, doc.slug, doc.locale, defaultLocale);
+  return urlBuilder.resolvePath(type.path, doc.slug, doc.locale);
 }
-function mergeBuiltinsIntoFrontmatter(frontmatter, doc, type, defaultLocale) {
+function mergeBuiltinsIntoFrontmatter(frontmatter, doc, type, defaultLocale, localeRouting) {
   const out = { ...frontmatter };
   if (doc.publishedAt !== void 0) out.publishedAt = doc.publishedAt;
   if (doc.updatedAt !== void 0) out.updatedAt = doc.updatedAt;
   out.noindex = doc.noindex;
-  out.canonicalPath = resolveCanonicalPathname(type, doc, defaultLocale);
+  out.canonicalPath = resolveCanonicalPathname(type, doc, defaultLocale, localeRouting);
   return out;
 }
 function seoFieldsFromEn(enDoc) {
@@ -505,8 +543,7 @@ function seoFieldsFromEn(enDoc) {
     publishedAt: enDoc.publishedAt,
     updatedAt: enDoc.updatedAt,
     noindex: enDoc.noindex,
-    canonicalPathOverride: enDoc.canonicalPathOverride,
-    redirectTo: enDoc.redirectTo
+    canonicalPathOverride: enDoc.canonicalPathOverride
   };
 }
 var SCHEMA_VERSION = 4;
@@ -736,7 +773,8 @@ function parseEnMdx(filePath, config, type) {
       locale: config.defaultLocale
     },
     type,
-    config.defaultLocale
+    config.defaultLocale,
+    config.localeRouting
   );
   const crossIssues = type.crossValidate?.(result.data, {
     locale: config.defaultLocale,
@@ -750,8 +788,6 @@ function parseEnMdx(filePath, config, type) {
     slug,
     enSlug: slug,
     locale: config.defaultLocale,
-    aliases: builtin.aliases,
-    redirectTo: builtin.redirectTo,
     publishedAt: builtin.publishedAt,
     updatedAt: builtin.updatedAt,
     noindex: builtin.noindex,
@@ -762,7 +798,7 @@ function parseEnMdx(filePath, config, type) {
   };
   return { document: document2, issues };
 }
-function buildDocumentFromTranslation(row, enDoc, type) {
+function buildDocumentFromTranslation(row, enDoc, type, config) {
   const localeFm = JSON.parse(row.frontmatter_json);
   const merged = mergeStructuralOntoLocale(localeFm, enDoc.frontmatter, type.schema);
   const seo = seoFieldsFromEn(enDoc);
@@ -770,14 +806,13 @@ function buildDocumentFromTranslation(row, enDoc, type) {
     merged,
     { ...seo, slug: row.slug, locale: row.locale },
     type,
-    enDoc.locale
+    config.defaultLocale,
+    config.localeRouting
   );
   return {
     slug: row.slug,
     enSlug: row.en_slug,
     locale: row.locale,
-    aliases: [],
-    redirectTo: seo.redirectTo,
     publishedAt: seo.publishedAt,
     updatedAt: seo.updatedAt,
     noindex: seo.noindex,
@@ -855,7 +890,7 @@ function createContentLoader(config, type) {
       for (const row of rowsByLocale.get(locale) ?? []) {
         const enDoc = englishBySlug.get(row.en_slug);
         if (!enDoc) continue;
-        const doc = buildDocumentFromTranslation(row, enDoc, type);
+        const doc = buildDocumentFromTranslation(row, enDoc, type, config);
         bySlug.set(doc.slug, doc);
         byEnSlug.set(row.en_slug, doc);
       }
@@ -903,56 +938,16 @@ function getTranslatablePayload(doc, type) {
 }
 
 // src/i18n/resolve-document.ts
-function findEnDocByAlias(slug, allDocs, defaultLocale) {
-  const enIdx = allDocs.get(defaultLocale);
-  if (!enIdx) return null;
-  for (const doc of enIdx.bySlug.values()) {
-    if (doc.aliases.includes(slug)) return doc;
-  }
-  return null;
-}
-function enCanonicalDoc(doc, allDocs, defaultLocale) {
-  if (doc.locale === defaultLocale) return doc;
-  return allDocs.get(defaultLocale)?.bySlug.get(doc.enSlug) ?? doc;
-}
-function redirectPathForDocument(doc, locale, defaultLocale, allDocs, type) {
-  if (!type.path) return void 0;
-  const enDoc = enCanonicalDoc(doc, allDocs, defaultLocale);
-  if (!enDoc.redirectTo) return void 0;
-  const targetEnSlug = extractSlugFromResolvedPath(type.path, enDoc.redirectTo);
-  if (!targetEnSlug) return void 0;
-  const targetEnDoc = allDocs.get(defaultLocale)?.bySlug.get(targetEnSlug);
-  const targetSlug = targetEnDoc ? getSlugForLocale(targetEnDoc, defaultLocale, locale, allDocs, defaultLocale) ?? targetEnSlug : targetEnSlug;
-  return resolvePath(type.path, targetSlug, locale, defaultLocale);
-}
-function withRedirectTo(result, locale, defaultLocale, allDocs, type) {
-  if (result.shouldRedirectTo || !result.document) return result;
-  const redirect = redirectPathForDocument(result.document, locale, defaultLocale, allDocs, type);
-  if (!redirect) return result;
-  return {
-    document: null,
-    actualLocale: result.actualLocale,
-    shouldRedirectTo: redirect
-  };
-}
-function resolveLocalizedDocument(slug, locale, defaultLocale, allDocs, type) {
+function resolveLocalizedDocument(slug, locale, defaultLocale, allDocs, type, localeRouting) {
+  const urlBuilder = createUrlBuilder({
+    locales: [defaultLocale, locale],
+    defaultLocale,
+    localeRouting: localeRouting ?? { strategy: "path-prefix", prefixDefaultLocale: false }
+  });
   const idx = allDocs.get(locale);
   const direct = idx?.bySlug.get(slug);
   if (direct) {
-    return withRedirectTo({ document: direct, actualLocale: locale }, locale, defaultLocale, allDocs, type);
-  }
-  const aliasDoc = findEnDocByAlias(slug, allDocs, defaultLocale);
-  if (aliasDoc && type.path) {
-    const canonicalSlug = aliasDoc.slug;
-    const localizedSlug = getSlugForLocale(aliasDoc, defaultLocale, locale, allDocs, defaultLocale);
-    const targetSlug = localizedSlug ?? canonicalSlug;
-    if (targetSlug !== slug) {
-      return {
-        document: null,
-        actualLocale: locale,
-        shouldRedirectTo: resolvePath(type.path, targetSlug, locale, defaultLocale)
-      };
-    }
+    return { document: direct, actualLocale: locale };
   }
   for (const [docLocale, docIdx] of allDocs) {
     const found = docIdx.bySlug.get(slug);
@@ -965,17 +960,11 @@ function resolveLocalizedDocument(slug, locale, defaultLocale, allDocs, type) {
       return {
         document: null,
         actualLocale: locale,
-        shouldRedirectTo: resolvePath(type.path, correctSlug, locale, defaultLocale)
+        shouldRedirectTo: urlBuilder.resolvePath(type.path, correctSlug, locale)
       };
     }
     if (docLocale === defaultLocale) {
-      return withRedirectTo(
-        { document: found, actualLocale: defaultLocale },
-        locale,
-        defaultLocale,
-        allDocs,
-        type
-      );
+      return { document: found, actualLocale: defaultLocale };
     }
     if (!type.path) {
       return { document: null, actualLocale: locale };
@@ -983,39 +972,21 @@ function resolveLocalizedDocument(slug, locale, defaultLocale, allDocs, type) {
     return {
       document: null,
       actualLocale: locale,
-      shouldRedirectTo: resolvePath(type.path, found.enSlug, locale, defaultLocale)
+      shouldRedirectTo: urlBuilder.resolvePath(type.path, found.enSlug, locale)
     };
   }
   if (locale !== defaultLocale) {
     const enDoc = allDocs.get(defaultLocale)?.bySlug.get(slug);
     if (enDoc && type.indexFallback === "en") {
-      return withRedirectTo(
-        { document: enDoc, actualLocale: defaultLocale },
-        locale,
-        defaultLocale,
-        allDocs,
-        type
-      );
+      return { document: enDoc, actualLocale: defaultLocale };
     }
     const byEn = idx?.byEnSlug.get(slug);
     if (byEn) {
-      return withRedirectTo(
-        { document: byEn, actualLocale: locale },
-        locale,
-        defaultLocale,
-        allDocs,
-        type
-      );
+      return { document: byEn, actualLocale: locale };
     }
     const fallback = allDocs.get(defaultLocale)?.bySlug.get(slug);
     if (fallback && type.indexFallback === "en") {
-      return withRedirectTo(
-        { document: fallback, actualLocale: defaultLocale },
-        locale,
-        defaultLocale,
-        allDocs,
-        type
-      );
+      return { document: fallback, actualLocale: defaultLocale };
     }
   }
   return { document: null, actualLocale: locale };
@@ -1057,6 +1028,7 @@ function buildRuntime(config, type, getRuntime) {
     }
     return type.path;
   }
+  const urlBuilder = createUrlBuilder(config);
   const runtime = {
     id: type.id,
     config: type,
@@ -1072,15 +1044,21 @@ function buildRuntime(config, type, getRuntime) {
       return load().get(locale)?.bySlug.get(slug) ?? null;
     },
     resolve(slug, locale) {
-      const result = resolveLocalizedDocument(slug, locale, config.defaultLocale, load(), type);
+      const result = resolveLocalizedDocument(
+        slug,
+        locale,
+        config.defaultLocale,
+        load(),
+        type,
+        config.localeRouting
+      );
       if (result.document && type.path) {
         return {
           ...result,
-          canonicalPath: resolvePath(
+          canonicalPath: urlBuilder.resolvePath(
             type.path,
             result.document.slug,
-            result.actualLocale,
-            config.defaultLocale
+            result.actualLocale
           )
         };
       }
@@ -1104,10 +1082,9 @@ function buildRuntime(config, type, getRuntime) {
     alternates(doc) {
       const pathTemplate = assertRoutable("alternates");
       const out = {
-        [config.defaultLocale]: resolvePath(
+        [config.defaultLocale]: urlBuilder.resolvePath(
           pathTemplate,
           doc.enSlug,
-          config.defaultLocale,
           config.defaultLocale
         )
       };
@@ -1116,7 +1093,7 @@ function buildRuntime(config, type, getRuntime) {
         if (locale === config.defaultLocale) continue;
         const translated = all.get(locale)?.byEnSlug.get(doc.enSlug);
         if (translated) {
-          out[locale] = resolvePath(pathTemplate, translated.slug, locale, config.defaultLocale);
+          out[locale] = urlBuilder.resolvePath(pathTemplate, translated.slug, locale);
         }
       }
       return out;
@@ -1131,7 +1108,7 @@ function buildRuntime(config, type, getRuntime) {
     },
     url(slug, locale) {
       const pathTemplate = assertRoutable("url");
-      return resolvePath(pathTemplate, slug, locale, config.defaultLocale);
+      return urlBuilder.resolvePath(pathTemplate, slug, locale);
     },
     related(doc, fieldName, locale) {
       const meta = relationFields.get(fieldName);
@@ -1187,6 +1164,9 @@ function createProject(config) {
     getType: getRuntime,
     listTypes() {
       return Array.from(runtimes.values());
+    },
+    listRoutableTypes() {
+      return Array.from(runtimes.values()).filter((runtime) => isRoutableType(runtime.config));
     }
   };
 }
@@ -1194,207 +1174,329 @@ function enFileExists(config, type, enSlug) {
   const dir = path3__default.default.join(config.rootDir, type.contentDir);
   return fs2__default.default.existsSync(path3__default.default.join(dir, `${enSlug}.mdx`)) || fs2__default.default.existsSync(path3__default.default.join(dir, `${enSlug}.md`));
 }
-function sqliteHasTranslations(db, contentTypeId, enSlug) {
-  return listTranslationsForEnSlug(db, contentTypeId, enSlug).length > 0;
-}
-function isAliasKnown(config, type, aliasEnSlug, db) {
-  return enFileExists(config, type, aliasEnSlug) || sqliteHasTranslations(db, type.id, aliasEnSlug);
-}
 function listEnSlugs(rootDir, contentDir) {
   const dir = path3__default.default.join(rootDir, contentDir);
   if (!fs2__default.default.existsSync(dir)) return [];
   return fs2__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
 }
 
-// src/core/slug-aliases.ts
-function buildGlobalAliasIndex(project) {
-  const { config } = project;
-  const aliasToTarget = /* @__PURE__ */ new Map();
-  const allAliasSlugs = /* @__PURE__ */ new Set();
-  const issues = [];
-  const canonicalSlugsByType = /* @__PURE__ */ new Map();
-  for (const type of config.types) {
-    const slugs = listEnSlugs(config.rootDir, type.contentDir);
-    canonicalSlugsByType.set(type.id, new Set(slugs));
+// src/i18n/translation-index.ts
+function buildTranslationIndex(allDocs, locales, defaultLocale) {
+  const index = /* @__PURE__ */ new Map();
+  for (const locale of locales) {
+    if (locale === defaultLocale) continue;
+    const idx = allDocs.get(locale);
+    if (!idx) continue;
+    const localeMap = /* @__PURE__ */ new Map();
+    for (const [enSlug, doc] of idx.byEnSlug) {
+      localeMap.set(enSlug, doc.slug);
+    }
+    index.set(locale, localeMap);
   }
+  return index;
+}
+var redirectFromSchema = zod.z.union([
+  slugPatternSchema,
+  zod.z.array(slugPatternSchema).min(1).max(20)
+]);
+var typeRedirectEntrySchema = zod.z.object({
+  from: redirectFromSchema,
+  toSlug: slugPatternSchema.optional(),
+  toType: zod.z.string().min(1).optional(),
+  toUrl: zod.z.string().min(1).optional(),
+  permanent: zod.z.boolean().optional()
+}).superRefine((entry, ctx) => {
+  const hasToSlug = entry.toSlug !== void 0;
+  const hasToUrl = entry.toUrl !== void 0;
+  const hasToType = entry.toType !== void 0;
+  const targetCount = Number(hasToSlug) + Number(hasToUrl);
+  if (targetCount !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Each redirect must specify exactly one of toSlug/toType+toSlug or toUrl",
+      path: ["toSlug"]
+    });
+    return;
+  }
+  if (hasToUrl && hasToType) {
+    ctx.addIssue({
+      code: "custom",
+      message: "toUrl cannot be combined with toType",
+      path: ["toUrl"]
+    });
+  }
+  if (hasToType && !hasToSlug) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Cross-type redirects require both toType and toSlug",
+      path: ["toSlug"]
+    });
+  }
+});
+var typeRedirectsFileSchema = zod.z.object({
+  redirects: zod.z.array(typeRedirectEntrySchema).max(500)
+});
+function normalizeRedirectFrom(from) {
+  return Array.isArray(from) ? from : [from];
+}
+function parseRedirectEntry(entry) {
+  const fromSlugs = normalizeRedirectFrom(entry.from);
+  if (entry.toUrl !== void 0) {
+    return {
+      fromSlugs,
+      kind: "anywhere",
+      toUrl: entry.toUrl,
+      permanent: entry.permanent ?? true
+    };
+  }
+  if (entry.toType !== void 0) {
+    return {
+      fromSlugs,
+      kind: "cross-type",
+      toType: entry.toType,
+      toSlug: entry.toSlug,
+      permanent: entry.permanent ?? true
+    };
+  }
+  return {
+    fromSlugs,
+    kind: "same-type",
+    toSlug: entry.toSlug,
+    permanent: entry.permanent ?? true
+  };
+}
+
+// src/redirects/load-type-redirects.ts
+var TYPE_REDIRECTS_FILENAME = "_redirects.json";
+function redirectsFilePath(config, type) {
+  return path3__default.default.join(config.rootDir, type.contentDir, TYPE_REDIRECTS_FILENAME);
+}
+function loadTypeRedirectsFile(config, type) {
+  const filePath = redirectsFilePath(config, type);
+  if (!fs2__default.default.existsSync(filePath)) return null;
+  let raw;
+  try {
+    raw = JSON.parse(fs2__default.default.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `${type.id}: failed to parse ${TYPE_REDIRECTS_FILENAME}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const parsed = typeRedirectsFileSchema.safeParse(raw);
+  if (!parsed.success) {
+    const details = parsed.error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ");
+    throw new Error(`${type.id}: invalid ${TYPE_REDIRECTS_FILENAME}: ${details}`);
+  }
+  return {
+    contentTypeId: type.id,
+    contentDir: type.contentDir,
+    filePath,
+    entries: parsed.data.redirects.map(parseRedirectEntry)
+  };
+}
+function loadAllTypeRedirects(config) {
+  const out = [];
   for (const type of config.types) {
-    if (!type.path) continue;
-    const canonicalSlugs = canonicalSlugsByType.get(type.id) ?? /* @__PURE__ */ new Set();
-    for (const enSlug of canonicalSlugs) {
-      const doc = readEnDocument(config, type, enSlug);
-      if (!doc) continue;
-      for (const alias of doc.aliases) {
-        if (alias === enSlug) {
-          issues.push({
-            contentTypeId: type.id,
-            enSlug,
-            field: "aliases",
-            message: `Alias "${alias}" must not equal the canonical slug`,
-            level: "error"
-          });
-          continue;
-        }
-        if (canonicalSlugs.has(alias)) {
-          issues.push({
-            contentTypeId: type.id,
-            enSlug,
-            field: "aliases",
-            message: `Alias "${alias}" collides with another document's canonical slug`,
-            level: "error"
-          });
-          continue;
-        }
-        const existing = aliasToTarget.get(alias);
-        if (existing) {
-          issues.push({
-            contentTypeId: type.id,
-            enSlug,
-            field: "aliases",
-            message: `Alias "${alias}" is already claimed by ${existing.contentTypeId}/${existing.canonicalSlug}`,
-            level: "error"
-          });
-          continue;
-        }
-        aliasToTarget.set(alias, {
-          contentTypeId: type.id,
-          canonicalSlug: enSlug,
-          path: type.path
-        });
-        allAliasSlugs.add(alias);
+    const loaded = loadTypeRedirectsFile(config, type);
+    if (loaded) out.push(loaded);
+  }
+  return out;
+}
+function collectRedirectSourceSlugs(loaded) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const file of loaded) {
+    for (const entry of file.entries) {
+      for (const from of entry.fromSlugs) {
+        slugs.add(from);
       }
     }
   }
-  return { aliasToTarget, allAliasSlugs, issues };
+  return slugs;
 }
-function validateAliasCoverage(project) {
-  const { config } = project;
-  const { aliasToTarget } = buildGlobalAliasIndex(project);
-  const issues = [];
-  const db = openStore(config, "readonly");
-  try {
-    for (const [alias, target] of aliasToTarget) {
-      const type = config.types.find((t) => t.id === target.contentTypeId);
-      if (!type) continue;
-      const known = isAliasKnown(config, type, alias, db);
-      if (!known) {
-        issues.push({
-          contentTypeId: type.id,
-          enSlug: target.canonicalSlug,
-          field: "aliases",
-          message: `Alias "${alias}" is unknown (no EN file or sqlite translations) \u2014 only EN redirect will work`,
-          level: "warning"
-        });
-      }
-      if (enFileExists(config, type, alias)) {
-        issues.push({
-          contentTypeId: type.id,
-          enSlug: target.canonicalSlug,
-          field: "aliases",
-          message: `Alias "${alias}" still has an EN file on disk \u2014 delete it manually`,
-          level: "warning"
-        });
+function collectOutboundRedirectSourcesByType(loaded) {
+  const out = /* @__PURE__ */ new Map();
+  for (const file of loaded) {
+    const set = out.get(file.contentTypeId) ?? /* @__PURE__ */ new Set();
+    for (const entry of file.entries) {
+      for (const from of entry.fromSlugs) {
+        set.add(from);
       }
-      const sqliteRows = listTranslationsForEnSlug(db, type.id, alias);
-      if (sqliteRows.length > 0) {
-        issues.push({
-          contentTypeId: type.id,
-          enSlug: target.canonicalSlug,
-          field: "aliases",
-          message: `${sqliteRows.length} sqlite translation(s) for alias "${alias}" retained for locale redirects and history`,
-          level: "info"
-        });
+    }
+    out.set(file.contentTypeId, set);
+  }
+  return out;
+}
+
+// src/redirects/build-json-redirects.ts
+function localizedSlug(db, contentTypeId, enSlug, locale, defaultLocale) {
+  if (locale === defaultLocale) return enSlug;
+  const row = listTranslationsForEnSlug(db, contentTypeId, enSlug).find(
+    (translation) => translation.locale === locale
+  );
+  return row?.slug ?? enSlug;
+}
+function resolveSlugTargetDestination(project, db, targetType, toSlug, locale, urlBuilder) {
+  const targetSlug = localizedSlug(
+    db,
+    targetType.id,
+    toSlug,
+    locale,
+    project.config.defaultLocale
+  );
+  return urlBuilder.resolvePath(targetType.path, targetSlug, locale);
+}
+function buildEntryRules(project, sourceType, entry, db, urlBuilder) {
+  if (!isRoutableType(sourceType)) return [];
+  const out = [];
+  const { defaultLocale } = project.config;
+  let targetType = sourceType;
+  if (entry.kind === "cross-type") {
+    const resolvedTarget = project.config.types.find((type) => type.id === entry.toType);
+    if (!resolvedTarget?.path) return out;
+    targetType = resolvedTarget;
+  }
+  for (const fromEnSlug of entry.fromSlugs) {
+    const locales = project.config.locales;
+    for (const locale of locales) {
+      const fromSlug = localizedSlug(db, sourceType.id, fromEnSlug, locale, defaultLocale);
+      const source = urlBuilder.resolvePath(sourceType.path, fromSlug, locale);
+      let destination;
+      if (entry.kind === "anywhere") {
+        destination = entry.toUrl;
+      } else {
+        destination = resolveSlugTargetDestination(
+          project,
+          db,
+          entry.kind === "cross-type" ? targetType : sourceType,
+          entry.toSlug,
+          locale,
+          urlBuilder
+        );
       }
-      for (const locale of config.locales) {
-        if (locale === config.defaultLocale) continue;
-        const canonicalRow = listTranslationsForEnSlug(db, type.id, target.canonicalSlug).find(
-          (r) => r.locale === locale
+      if (source === destination) continue;
+      out.push({
+        source,
+        destination,
+        permanent: entry.permanent
+      });
+    }
+    if (sourceType.id === "blog") {
+      let destinationEn;
+      if (entry.kind === "anywhere") {
+        destinationEn = entry.toUrl;
+      } else {
+        destinationEn = resolveSlugTargetDestination(
+          project,
+          db,
+          entry.kind === "cross-type" ? targetType : sourceType,
+          entry.toSlug,
+          defaultLocale,
+          urlBuilder
         );
-        if (!canonicalRow) continue;
-        const aliasRow = sqliteRows.find((r) => r.locale === locale);
-        if (!aliasRow && known) {
-          issues.push({
-            contentTypeId: type.id,
-            enSlug: target.canonicalSlug,
-            field: "aliases",
-            message: `Alias "${alias}" has no locale slug mapping for ${locale} \u2014 old localized URL may miss redirect`,
-            level: "warning"
-          });
+      }
+      out.push({
+        source: `/${fromEnSlug}`,
+        destination: destinationEn,
+        permanent: entry.permanent
+      });
+      for (const locale of urlBuilder.prefixedLocales) {
+        const fromSlug = localizedSlug(db, sourceType.id, fromEnSlug, locale, defaultLocale);
+        let destination;
+        if (entry.kind === "anywhere") {
+          destination = entry.toUrl;
+        } else {
+          destination = resolveSlugTargetDestination(
+            project,
+            db,
+            entry.kind === "cross-type" ? targetType : sourceType,
+            entry.toSlug,
+            locale,
+            urlBuilder
+          );
         }
+        out.push({
+          source: `/${locale}/${fromSlug}`,
+          destination,
+          permanent: entry.permanent
+        });
+        out.push({
+          source: `/${locale}/${fromEnSlug}`,
+          destination,
+          permanent: entry.permanent
+        });
+      }
+    }
+  }
+  return out;
+}
+function buildJsonRedirects(project) {
+  const urlBuilder = createUrlBuilder(project.config);
+  const db = openStore(project.config, "readonly");
+  const out = [];
+  try {
+    for (const type of project.config.types) {
+      if (!isRoutableType(type)) continue;
+      const loaded = loadTypeRedirectsFile(project.config, type);
+      if (!loaded) continue;
+      for (const entry of loaded.entries) {
+        out.push(...buildEntryRules(project, type, entry, db, urlBuilder));
       }
     }
   } finally {
     db.close();
   }
-  return issues;
+  return out;
 }
-function validateAliasRedirectChains(project) {
-  const { config } = project;
-  const { aliasToTarget, allAliasSlugs } = buildGlobalAliasIndex(project);
-  const issues = [];
-  for (const [alias, target] of aliasToTarget) {
-    const doc = readEnDocument(
-      config,
-      project.getType(target.contentTypeId).config,
-      target.canonicalSlug
-    );
-    if (doc?.redirectTo) {
-      issues.push({
-        contentTypeId: target.contentTypeId,
-        enSlug: target.canonicalSlug,
-        field: "aliases",
-        message: `Alias "${alias}" points at "${target.canonicalSlug}" which has redirect_to \u2014 resolve to the final canonical slug`,
-        level: "error"
-      });
+function buildRedirectSourceSlugSet(project) {
+  const out = /* @__PURE__ */ new Set();
+  for (const type of project.config.types) {
+    const loaded = loadTypeRedirectsFile(project.config, type);
+    if (!loaded) continue;
+    for (const entry of loaded.entries) {
+      for (const from of entry.fromSlugs) {
+        out.add(`${type.id}:${from}`);
+      }
     }
   }
-  for (const type of config.types) {
-    if (!type.path) continue;
-    for (const enSlug of listEnSlugs(config.rootDir, type.contentDir)) {
-      const doc = readEnDocument(config, type, enSlug);
-      if (!doc?.redirectTo) continue;
-      const targetSlug = extractSlugFromResolvedPath(type.path, doc.redirectTo);
-      if (targetSlug && allAliasSlugs.has(targetSlug)) {
-        issues.push({
-          contentTypeId: type.id,
-          enSlug,
-          field: "redirect_to",
-          message: `redirect_to target "${targetSlug}" is an alias slug \u2014 chain detected`,
-          level: "error"
-        });
-      }
-      const targetDoc = targetSlug ? readEnDocument(config, type, targetSlug) : null;
-      if (targetDoc?.redirectTo) {
-        issues.push({
-          contentTypeId: type.id,
+  return out;
+}
+function buildLegacyNoBlogPathRedirects(project, redirectSourceKeys) {
+  const blogType = project.config.types.find((type) => type.id === "blog" && type.path);
+  if (!blogType?.path) return [];
+  const urlBuilder = createUrlBuilder(project.config);
+  const db = openStore(project.config, "readonly");
+  const out = [];
+  try {
+    for (const enSlug of listEnSlugs(project.config.rootDir, blogType.contentDir)) {
+      if (redirectSourceKeys.has(`blog:${enSlug}`)) continue;
+      out.push({
+        source: `/${enSlug}`,
+        destination: urlBuilder.resolvePath(blogType.path, enSlug, project.config.defaultLocale),
+        permanent: true
+      });
+      for (const locale of urlBuilder.prefixedLocales) {
+        const translatedSlug = localizedSlug(
+          db,
+          blogType.id,
           enSlug,
-          field: "redirect_to",
-          message: `redirect_to chain detected: "${enSlug}" \u2192 "${targetSlug}" \u2192 "${targetDoc.redirectTo}"`,
-          level: "error"
+          locale,
+          project.config.defaultLocale
+        );
+        out.push({
+          source: `/${locale}/${enSlug}`,
+          destination: urlBuilder.resolvePath(blogType.path, translatedSlug, locale),
+          permanent: true
         });
       }
     }
+  } finally {
+    db.close();
   }
-  return issues;
-}
-
-// src/i18n/translation-index.ts
-function buildTranslationIndex(allDocs, locales, defaultLocale) {
-  const index = /* @__PURE__ */ new Map();
-  for (const locale of locales) {
-    if (locale === defaultLocale) continue;
-    const idx = allDocs.get(locale);
-    if (!idx) continue;
-    const localeMap = /* @__PURE__ */ new Map();
-    for (const [enSlug, doc] of idx.byEnSlug) {
-      localeMap.set(enSlug, doc.slug);
-    }
-    index.set(locale, localeMap);
-  }
-  return index;
+  return out;
 }
 
-// src/redirects/translation-index.ts
-function buildRedirectTranslationIndex(project, typeId) {
+// src/redirects/build-redirects.ts
+function buildRedirectTranslationIndex(project, typeId, redirectSourceSlugs) {
   const runtime = project.getType(typeId);
   const { config } = project;
   const merged = buildTranslationIndex(
@@ -1402,11 +1504,9 @@ function buildRedirectTranslationIndex(project, typeId) {
     config.locales,
     config.defaultLocale
   );
-  const { aliasToTarget } = buildGlobalAliasIndex(project);
   const db = openStore(project.config, "readonly");
   try {
-    for (const [alias, target] of aliasToTarget) {
-      if (target.contentTypeId !== typeId) continue;
+    for (const alias of redirectSourceSlugs) {
       for (const row of listTranslationsForEnSlug(db, typeId, alias)) {
         const localeMap = merged.get(row.locale) ?? /* @__PURE__ */ new Map();
         if (!localeMap.has(alias)) {
@@ -1420,168 +1520,63 @@ function buildRedirectTranslationIndex(project, typeId) {
   }
   return merged;
 }
-
-// src/redirects/build-redirects.ts
-function buildAliasRedirects(type, aliasIndex, translationIndex, prefixedLocales, defaultLocale) {
-  const out = [];
-  const { aliasToTarget } = aliasIndex;
-  const pathTemplate = type.path;
-  for (const [alias, target] of aliasToTarget) {
-    if (target.contentTypeId !== type.id) continue;
-    const canonical = target.canonicalSlug;
-    out.push({
-      source: resolvePath(pathTemplate, alias, defaultLocale, defaultLocale),
-      destination: resolvePath(pathTemplate, canonical, defaultLocale, defaultLocale),
-      permanent: true
-    });
-    for (const locale of prefixedLocales) {
-      const localeMap = translationIndex.get(locale);
-      const toLocale = localeMap?.get(canonical) ?? canonical;
-      const fromLocale = localeMap?.get(alias);
-      if (fromLocale) {
-        out.push({
-          source: resolvePath(pathTemplate, fromLocale, locale, defaultLocale),
-          destination: resolvePath(pathTemplate, toLocale, locale, defaultLocale),
-          permanent: true
-        });
-      }
-      out.push({
-        source: resolvePath(pathTemplate, alias, locale, defaultLocale),
-        destination: resolvePath(pathTemplate, toLocale, locale, defaultLocale),
-        permanent: true
-      });
-    }
-  }
-  return out;
-}
-function buildAliasLegacyNoBlogPathRedirects(type, aliasIndex, translationIndex, prefixedLocales, defaultLocale) {
-  if (type.id !== "blog") return [];
-  const out = [];
-  for (const [alias, target] of aliasIndex.aliasToTarget) {
-    if (target.contentTypeId !== type.id) continue;
-    for (const locale of prefixedLocales) {
-      const localeMap = translationIndex.get(locale);
-      const toLocale = localeMap?.get(target.canonicalSlug) ?? target.canonicalSlug;
-      out.push({
-        source: `/${locale}/${alias}`,
-        destination: resolvePath(type.path, toLocale, locale, defaultLocale),
-        permanent: true
-      });
-    }
-  }
-  return out;
-}
-function buildRedirectToRules(type, config, translationIndex, prefixedLocales, defaultLocale) {
-  const out = [];
-  const pathTemplate = type.path;
-  for (const enSlug of listEnSlugs(config.rootDir, type.contentDir)) {
-    const doc = readEnDocument(config, type, enSlug);
-    if (!doc?.redirectTo) continue;
-    out.push({
-      source: resolvePath(pathTemplate, enSlug, defaultLocale, defaultLocale),
-      destination: doc.redirectTo,
-      permanent: true
-    });
-    for (const locale of prefixedLocales) {
-      const localeMap = translationIndex.get(locale);
-      const fromLocale = localeMap?.get(enSlug);
-      if (!fromLocale) continue;
-      const targetEnSlug = extractSlugFromResolvedPath(pathTemplate, doc.redirectTo);
-      if (!targetEnSlug) continue;
-      const toLocale = localeMap?.get(targetEnSlug) ?? targetEnSlug;
-      out.push({
-        source: resolvePath(pathTemplate, fromLocale, locale, defaultLocale),
-        destination: resolvePath(pathTemplate, toLocale, locale, defaultLocale),
-        permanent: true
-      });
-    }
-  }
-  return out;
-}
-function buildCrossLocaleSlugRedirects(type, translationIndex, aliasSourceSlugs, defaultLocale) {
+function buildCrossLocaleSlugRedirects(project, typeId, redirectSourceSlugs) {
+  const type = project.getType(typeId).config;
+  if (!isRoutableType(type)) return [];
+  const urlBuilder = createUrlBuilder(project.config);
+  const translationIndex = buildRedirectTranslationIndex(project, typeId, redirectSourceSlugs);
   const out = [];
   const pathTemplate = type.path;
   for (const [locale, localeMap] of translationIndex) {
     for (const [enSlug, translatedSlug] of localeMap) {
       if (enSlug === translatedSlug) continue;
-      if (aliasSourceSlugs.has(enSlug)) continue;
+      if (redirectSourceSlugs.has(enSlug)) continue;
       out.push({
-        source: resolvePath(pathTemplate, enSlug, locale, defaultLocale),
-        destination: resolvePath(pathTemplate, translatedSlug, locale, defaultLocale),
+        source: urlBuilder.resolvePath(pathTemplate, enSlug, locale),
+        destination: urlBuilder.resolvePath(pathTemplate, translatedSlug, locale),
         permanent: true
       });
     }
   }
   return out;
 }
-function buildLegacyNoBlogPathRedirects(type, config, translationIndex, prefixedLocales, defaultLocale) {
-  if (type.id !== "blog") return [];
-  const out = [];
-  const enSlugs = listEnSlugs(config.rootDir, type.contentDir);
-  const pathTemplate = type.path;
-  for (const enSlug of enSlugs) {
-    out.push({
-      source: `/${enSlug}`,
-      destination: resolvePath(pathTemplate, enSlug, defaultLocale, defaultLocale),
-      permanent: true
-    });
-    for (const locale of prefixedLocales) {
-      const translatedSlug = translationIndex.get(locale)?.get(enSlug);
-      const canonicalSlug = translatedSlug ?? enSlug;
-      out.push({
-        source: `/${locale}/${enSlug}`,
-        destination: resolvePath(pathTemplate, canonicalSlug, locale, defaultLocale),
-        permanent: true
-      });
+function buildTypeRedirects(project, typeId) {
+  const loaded = loadAllTypeRedirects(project.config).find((file) => file.contentTypeId === typeId);
+  const redirectSourceSlugs = /* @__PURE__ */ new Set();
+  if (loaded) {
+    for (const entry of loaded.entries) {
+      for (const from of entry.fromSlugs) {
+        redirectSourceSlugs.add(from);
+      }
     }
   }
-  return out;
-}
-function buildTypeRedirects(project, typeId, aliasIndex, options) {
-  const type = project.getType(typeId).config;
-  if (!isRoutableType(type)) return [];
-  const { defaultLocale } = project.config;
-  const translationIndex = buildRedirectTranslationIndex(project, typeId);
-  const aliasSourceSlugs = /* @__PURE__ */ new Set();
-  for (const [alias, target] of aliasIndex.aliasToTarget) {
-    if (target.contentTypeId === typeId) aliasSourceSlugs.add(alias);
-  }
   return [
-    ...buildAliasRedirects(type, aliasIndex, translationIndex, options.prefixedLocales, defaultLocale),
-    ...buildAliasLegacyNoBlogPathRedirects(
-      type,
-      aliasIndex,
-      translationIndex,
-      options.prefixedLocales,
-      defaultLocale
-    ),
-    ...buildRedirectToRules(type, project.config, translationIndex, options.prefixedLocales, defaultLocale),
-    ...buildCrossLocaleSlugRedirects(type, translationIndex, aliasSourceSlugs, defaultLocale),
-    ...buildLegacyNoBlogPathRedirects(type, project.config, translationIndex, options.prefixedLocales, defaultLocale)
+    ...buildCrossLocaleSlugRedirects(project, typeId, redirectSourceSlugs)
   ];
 }
-function buildAllContentRedirects(project, options) {
-  const aliasIndex = buildGlobalAliasIndex(project);
-  const out = [];
+function buildAllContentRedirects(project, _options = {}) {
+  const redirectSourceKeys = buildRedirectSourceSlugSet(project);
+  const out = [
+    ...buildJsonRedirects(project),
+    ...buildLegacyNoBlogPathRedirects(project, redirectSourceKeys)
+  ];
   for (const type of project.config.types) {
     if (!isRoutableType(type)) continue;
-    out.push(...buildTypeRedirects(project, type.id, aliasIndex, options));
+    out.push(...buildTypeRedirects(project, type.id));
   }
   return out;
 }
 function getRedirectSourceSlugs(project) {
-  const aliasIndex = buildGlobalAliasIndex(project);
-  const outboundByType = /* @__PURE__ */ new Map();
+  const loaded = loadAllTypeRedirects(project.config);
+  const aliasSlugs = collectRedirectSourceSlugs(loaded);
+  const outboundByType = collectOutboundRedirectSourcesByType(loaded);
   for (const type of project.config.types) {
-    const outbound = /* @__PURE__ */ new Set();
-    for (const enSlug of listEnSlugs(project.config.rootDir, type.contentDir)) {
-      const doc = readEnDocument(project.config, type, enSlug);
-      if (doc?.redirectTo) outbound.add(enSlug);
+    if (!outboundByType.has(type.id)) {
+      outboundByType.set(type.id, /* @__PURE__ */ new Set());
     }
-    outboundByType.set(type.id, outbound);
   }
   return {
-    aliasSlugs: aliasIndex.allAliasSlugs,
+    aliasSlugs,
     outboundByType
   };
 }
@@ -1589,13 +1584,12 @@ function getRedirectSourceSlugs(project) {
 // src/sitemap/join-base-url.ts
 function joinBaseUrl(baseUrl, pathname) {
   const origin = baseUrl.replace(/\/$/, "");
-  const path11 = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  return `${origin}${path11}`;
+  const path13 = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${origin}${path13}`;
 }
 
 // src/sitemap/generate-sitemap.ts
 function shouldIncludeEnDoc(enDoc, enSlug, redirectSources, contentTypeId, excludeNoindex) {
-  if (enDoc.redirectTo) return false;
   if (redirectSources.aliasSlugs.has(enSlug)) return false;
   const outbound = redirectSources.outboundByType.get(contentTypeId);
   if (outbound?.has(enSlug)) return false;
@@ -1682,6 +1676,7 @@ function createScribe(input) {
     project,
     getType: project.getType,
     listTypes: project.listTypes,
+    listRoutableTypes: project.listRoutableTypes,
     sitemap(options) {
       return generateSitemap(project, options);
     }
@@ -1734,6 +1729,168 @@ function loadConfigSync(options = {}) {
   }
   return resolveConfig(config, path3__default.default.dirname(configPath));
 }
+function liveDocExists(config, typeId, enSlug) {
+  const type = config.types.find((entry) => entry.id === typeId);
+  if (!type) return false;
+  return enFileExists(config, type, enSlug);
+}
+function resolveRedirectTarget(project, sourceTypeId, entry) {
+  if (entry.kind === "anywhere") return null;
+  if (entry.kind === "cross-type") {
+    return { typeId: entry.toType, enSlug: entry.toSlug };
+  }
+  return { typeId: sourceTypeId, enSlug: entry.toSlug };
+}
+function matchRoutableTarget(project, toUrl) {
+  const urlBuilder = createUrlBuilder(project.config);
+  for (const type of project.config.types) {
+    if (!type.path) continue;
+    const enSlug = urlBuilder.extractSlugFromResolvedPath(type.path, toUrl);
+    if (enSlug && liveDocExists(project.config, type.id, enSlug)) {
+      return { typeId: type.id, enSlug };
+    }
+  }
+  return null;
+}
+function validateTypeRedirects(project) {
+  const issues = [];
+  const globalFrom = /* @__PURE__ */ new Map();
+  for (const type of project.config.types) {
+    const filePath = path3__default.default.join(project.config.rootDir, type.contentDir, TYPE_REDIRECTS_FILENAME);
+    if (!fs2__default.default.existsSync(filePath)) continue;
+    let loaded;
+    try {
+      loaded = loadTypeRedirectsFile(project.config, type);
+    } catch (error) {
+      issues.push({
+        level: "error",
+        contentType: type.id,
+        field: TYPE_REDIRECTS_FILENAME,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    if (!loaded) continue;
+    if (!isRoutableType(type)) {
+      issues.push({
+        level: "error",
+        contentType: type.id,
+        field: TYPE_REDIRECTS_FILENAME,
+        message: `Redirects are only supported on routable content types (missing path)`
+      });
+      continue;
+    }
+    for (const entry of loaded.entries) {
+      for (const from of entry.fromSlugs) {
+        if (from === entry.toSlug) {
+          issues.push({
+            level: "error",
+            contentType: type.id,
+            enSlug: from,
+            field: TYPE_REDIRECTS_FILENAME,
+            message: `Redirect source "${from}" must not equal its target slug`
+          });
+        }
+        if (liveDocExists(project.config, type.id, from)) {
+          issues.push({
+            level: "error",
+            contentType: type.id,
+            enSlug: from,
+            field: TYPE_REDIRECTS_FILENAME,
+            message: `Redirect source "${from}" still has a live EN file \u2014 delete or rename the MDX first`
+          });
+        }
+        const existing = globalFrom.get(from);
+        if (existing && existing.typeId !== type.id) {
+          issues.push({
+            level: "error",
+            contentType: type.id,
+            enSlug: from,
+            field: TYPE_REDIRECTS_FILENAME,
+            message: `Redirect source "${from}" is already claimed by ${existing.typeId}`
+          });
+        } else if (existing) {
+          issues.push({
+            level: "error",
+            contentType: type.id,
+            enSlug: from,
+            field: TYPE_REDIRECTS_FILENAME,
+            message: `Duplicate redirect source "${from}" in ${TYPE_REDIRECTS_FILENAME}`
+          });
+        } else {
+          globalFrom.set(from, { typeId: type.id, filePath: loaded.filePath });
+        }
+      }
+      if (entry.kind === "cross-type") {
+        const targetType = project.config.types.find((candidate) => candidate.id === entry.toType);
+        if (!targetType) {
+          issues.push({
+            level: "error",
+            contentType: type.id,
+            field: TYPE_REDIRECTS_FILENAME,
+            message: `Unknown redirect target type "${entry.toType}"`
+          });
+          continue;
+        }
+        if (!isRoutableType(targetType)) {
+          issues.push({
+            level: "error",
+            contentType: type.id,
+            field: TYPE_REDIRECTS_FILENAME,
+            message: `Redirect target type "${entry.toType}" is not routable (missing path)`
+          });
+          continue;
+        }
+      }
+      const target = resolveRedirectTarget(project, type.id, entry);
+      if (target) {
+        if (!liveDocExists(project.config, target.typeId, target.enSlug)) {
+          issues.push({
+            level: "error",
+            contentType: type.id,
+            field: TYPE_REDIRECTS_FILENAME,
+            message: `Redirect target ${target.typeId}/${target.enSlug} does not exist`
+          });
+        }
+        continue;
+      }
+      if (entry.kind === "anywhere" && entry.toUrl?.startsWith("/")) {
+        const matched = matchRoutableTarget(project, entry.toUrl);
+        if (matched && !liveDocExists(project.config, matched.typeId, matched.enSlug)) {
+          issues.push({
+            level: "error",
+            contentType: type.id,
+            field: TYPE_REDIRECTS_FILENAME,
+            message: `Redirect toUrl "${entry.toUrl}" does not resolve to a live document`
+          });
+        }
+      }
+    }
+  }
+  const allLoaded = loadAllTypeRedirects(project.config);
+  for (const file of allLoaded) {
+    for (const entry of file.entries) {
+      if (entry.kind === "anywhere" || !entry.toSlug) continue;
+      const targetTypeId = entry.kind === "cross-type" ? entry.toType : file.contentTypeId;
+      const targetType = project.config.types.find((type) => type.id === targetTypeId);
+      if (!targetType?.path) continue;
+      for (const from of entry.fromSlugs) {
+        if (globalFrom.get(from)?.typeId !== file.contentTypeId) continue;
+        const chainTarget = globalFrom.get(entry.toSlug);
+        if (chainTarget) {
+          issues.push({
+            level: "error",
+            contentType: file.contentTypeId,
+            enSlug: from,
+            field: TYPE_REDIRECTS_FILENAME,
+            message: `Redirect chain detected: "${from}" \u2192 "${entry.toSlug}" \u2192 existing redirect source`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
 function getAtPath2(obj, fieldPath) {
   let current = obj;
   for (const segment of fieldPath) {
@@ -1923,7 +2080,7 @@ function validateTranslationSlugSuffixes(config, db) {
 }
 
 // src/validate/validate-project.ts
-function listEnSlugs2(rootDir, contentDir) {
+function listEnSlugs3(rootDir, contentDir) {
   const dir = path3__default.default.join(rootDir, contentDir);
   if (!fs2__default.default.existsSync(dir)) return [];
   return fs2__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
@@ -1941,7 +2098,7 @@ function validateProject(config) {
   }
   const db = openStore(config, "readonly");
   for (const type of config.types) {
-    const enSlugs = listEnSlugs2(config.rootDir, type.contentDir);
+    const enSlugs = listEnSlugs3(config.rootDir, type.contentDir);
     const englishSlugs = new Set(enSlugs);
     if (!type.translate && isRoutableType(type)) {
       issues.push({
@@ -2023,33 +2180,8 @@ function validateProject(config) {
     }
   }
   db.close();
-  const aliasIndex = buildGlobalAliasIndex(project);
-  for (const issue of aliasIndex.issues) {
-    issues.push({
-      level: issue.level,
-      contentType: issue.contentTypeId,
-      enSlug: issue.enSlug,
-      field: issue.field,
-      message: issue.message
-    });
-  }
-  for (const issue of validateAliasRedirectChains(project)) {
-    issues.push({
-      level: issue.level,
-      contentType: issue.contentTypeId,
-      enSlug: issue.enSlug,
-      field: issue.field,
-      message: issue.message
-    });
-  }
-  for (const issue of validateAliasCoverage(project)) {
-    issues.push({
-      level: issue.level,
-      contentType: issue.contentTypeId,
-      enSlug: issue.enSlug,
-      field: issue.field,
-      message: issue.message
-    });
+  for (const issue of validateTypeRedirects(project)) {
+    issues.push(issue);
   }
   for (const issue of validateRelations(project)) {
     issues.push({
@@ -2086,7 +2218,7 @@ function computePageEnHash(translatableFrontmatter, body) {
 }
 
 // src/translate/worklist.ts
-function listEnSlugs3(rootDir, contentDir) {
+function listEnSlugs4(rootDir, contentDir) {
   const dir = path3__default.default.join(rootDir, contentDir);
   if (!fs2__default.default.existsSync(dir)) return [];
   return fs2__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
@@ -2097,7 +2229,7 @@ function buildWorklist(config, options = {}) {
   const locales = options.locales ?? config.locales.filter((locale) => locale !== config.defaultLocale);
   for (const type of config.types) {
     if (options.contentType && type.id !== options.contentType) continue;
-    const enSlugs = options.enSlug ? [options.enSlug] : listEnSlugs3(config.rootDir, type.contentDir);
+    const enSlugs = options.enSlug ? [options.enSlug] : listEnSlugs4(config.rootDir, type.contentDir);
     for (const enSlug of enSlugs) {
       const enDoc = readEnDocument(config, type, enSlug);
       if (!enDoc) continue;
@@ -2369,11 +2501,12 @@ function buildGeminiResponseSchema(schema, slugStrategy) {
 function slugStrategyRules(slugStrategy, preserveTerms) {
   if (slugStrategy === "localized") {
     const rules = [
-      "Provide a URL slug in JSON field `slug` that is TRANSLATED into the target language.",
+      "Provide a URL slug in JSON field `slug` that is Localized into the target language.",
       "Base the slug on the meaning of the translated title \u2014 do NOT reuse the English slug words.",
       "Slug MUST be ASCII only: a-z, 0-9, hyphens. No uppercase, accents, underscores, or spaces.",
       "For non-Latin languages, write the words in the target language and transliterate them into Latin script (e.g. Russian -> romanized Russian, not English).",
-      "Do NOT append locale codes to the slug (e.g. -fr, -he, -zh-cn). Locale routing is handled by the URL prefix, not the slug."
+      "Do NOT append locale codes to the slug (e.g. -fr, -he, -zh-cn). Locale routing is handled by the URL prefix, not the slug.",
+      'In JSX attributes (e.g. FaqItem question="..."), use single quotes when the value contains double-quote characters (e.g. Hebrew \u05D3\u05D5\u05D0"\u05DC), or escape them as \\".'
     ];
     if (preserveTerms?.length) {
       rules.push(
@@ -2406,6 +2539,95 @@ function resolveTranslateConfig(config, type) {
   return mergeTranslateConfig(config.translate, type.translate, type.slugStrategy);
 }
 
+// src/translate/sanitize-mdx-jsx.ts
+function sanitizeMdxJsxAttributeQuotes(body) {
+  let adjusted = false;
+  let out = "";
+  let i = 0;
+  while (i < body.length) {
+    if (body[i] !== "<" || !/[\w.]/.test(body[i + 1] ?? "")) {
+      out += body[i];
+      i += 1;
+      continue;
+    }
+    const tagStart = i;
+    i += 1;
+    while (i < body.length && /[\w.-]/.test(body[i] ?? "")) i += 1;
+    const tagName = body.slice(tagStart + 1, i);
+    let tagOut = `<${tagName}`;
+    let tagAdjusted = false;
+    while (i < body.length && body[i] !== ">" && body[i] !== "/") {
+      while (i < body.length && /\s/.test(body[i] ?? "")) {
+        tagOut += body[i];
+        i += 1;
+      }
+      if (i >= body.length || body[i] === ">" || body[i] === "/") break;
+      const attrStart = i;
+      while (i < body.length && /[\w:.-]/.test(body[i] ?? "")) i += 1;
+      body.slice(attrStart, i);
+      while (i < body.length && /\s/.test(body[i] ?? "")) i += 1;
+      if (body[i] !== "=") {
+        tagOut += body.slice(attrStart, i);
+        continue;
+      }
+      tagOut += body.slice(attrStart, i);
+      tagOut += "=";
+      i += 1;
+      while (i < body.length && /\s/.test(body[i] ?? "")) i += 1;
+      const quote = body[i];
+      if (quote !== '"' && quote !== "'") {
+        continue;
+      }
+      if (quote === "'") {
+        const valStart2 = i + 1;
+        i += 1;
+        while (i < body.length) {
+          if (body[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (body[i] === "'") break;
+          i += 1;
+        }
+        tagOut += body.slice(valStart2 - 1, i + 1);
+        i += 1;
+        continue;
+      }
+      const valStart = i + 1;
+      i += 1;
+      let closeIdx = -1;
+      for (let scan = valStart; scan < body.length; scan += 1) {
+        if (body[scan] !== '"') continue;
+        let j = scan + 1;
+        while (j < body.length && /\s/.test(body[j] ?? "")) j += 1;
+        if (j < body.length && (body[j] === ">" || body[j] === "/" || /[a-zA-Z]/.test(body[j] ?? ""))) {
+          closeIdx = scan;
+          break;
+        }
+      }
+      if (closeIdx === -1) {
+        tagOut += body.slice(valStart - 1, i);
+        break;
+      }
+      const value = body.slice(valStart, closeIdx);
+      const hasInternalQuote = value.includes('"');
+      if (hasInternalQuote) {
+        const escaped = value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+        tagOut += `'${escaped}'`;
+        tagAdjusted = true;
+      } else {
+        tagOut += `"${value}"`;
+      }
+      i = closeIdx + 1;
+    }
+    if (tagAdjusted) adjusted = true;
+    tagOut += body[i] ?? "";
+    out += tagOut;
+    i += 1;
+  }
+  return { body: out, adjusted };
+}
+
 // src/translate/validate-translation.ts
 function formatZodIssues(error) {
   return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
@@ -2539,6 +2761,9 @@ async function translatePage(config, item, options = {}) {
     if (!validated.ok) {
       throw new Error(`Translation validation failed: ${validated.error}`);
     }
+    const { body: translatedBody, adjusted: mdxAdjusted } = sanitizeMdxJsxAttributeQuotes(
+      result.parsed.body
+    );
     const writeDb = openStore(config, "readwrite");
     const snapshotId = recordEnSnapshot(
       config,
@@ -2557,7 +2782,7 @@ async function translatePage(config, item, options = {}) {
       locale: item.locale,
       slug,
       frontmatter: validated.frontmatter,
-      body: result.parsed.body,
+      body: translatedBody,
       enHash: currentEnHash,
       translatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       model: result.model,
@@ -2576,7 +2801,8 @@ async function translatePage(config, item, options = {}) {
       usage: result.usage,
       estimatedCostUsd,
       durationMs: Date.now() - startedAt,
-      slugAdjusted
+      slugAdjusted,
+      mdxAdjusted: mdxAdjusted || void 0
     };
   } catch (error) {
     return {
@@ -2653,6 +2879,7 @@ function buildStaticRawExports(project, options = {}) {
   const excludeNoindex = options.excludeNoindex ?? false;
   const typeFilter = options.types ? new Set(options.types) : null;
   const out = [];
+  const urlBuilder = createUrlBuilder(config);
   for (const type of project.listTypes()) {
     if (!isRoutableType(type.config)) continue;
     if (typeFilter && !typeFilter.has(type.id)) continue;
@@ -2668,7 +2895,7 @@ function buildStaticRawExports(project, options = {}) {
         if (excludeNoindex && resolved.document.noindex) continue;
         const doc = resolved.document;
         const slugWithExt = `${doc.slug}${extension}`;
-        const urlPath = resolvePath(pathTemplate, slugWithExt, locale, config.defaultLocale);
+        const urlPath = urlBuilder.resolvePath(pathTemplate, slugWithExt, locale);
         out.push({
           relativePath: urlPath.slice(1),
           urlPath,
@@ -2716,6 +2943,7 @@ exports.buildStaticRawExports = buildStaticRawExports;
 exports.buildWorklist = buildWorklist;
 exports.createProject = createProject;
 exports.createScribe = createScribe;
+exports.createUrlBuilder = createUrlBuilder;
 exports.defineConfig = defineConfig;
 exports.defineContentType = defineContentType;
 exports.exportDirSegment = exportDirSegment;
@@ -2727,6 +2955,7 @@ exports.getRedirectSourceSlugs = getRedirectSourceSlugs;
 exports.getRelationTarget = getRelationTarget;
 exports.getStaticExportRoots = getStaticExportRoots;
 exports.isResolvedConfig = isResolvedConfig;
+exports.isRoutableType = isRoutableType;
 exports.loadConfigSync = loadConfigSync;
 exports.resolveConfig = resolveConfig;
 exports.resolveLocalesFromPreset = resolveLocalesFromPreset;