scribe-cms 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2268 @@
+'use strict';
+
+var zod = require('zod');
+var path3 = require('path');
+var fs2 = require('fs');
+var matter = require('gray-matter');
+var Database = require('better-sqlite3');
+var jiti = require('jiti');
+var crypto = require('crypto');
+var genai = require('@google/genai');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path3__default = /*#__PURE__*/_interopDefault(path3);
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var matter__default = /*#__PURE__*/_interopDefault(matter);
+var Database__default = /*#__PURE__*/_interopDefault(Database);
+
+// ../../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+var FIELD_KIND = /* @__PURE__ */ Symbol.for("@genlook/scribe/fieldKind");
+var RELATION_META = /* @__PURE__ */ Symbol.for("@genlook/scribe/relationMeta");
+function getFieldKind(schema) {
+  const tagged = schema;
+  return tagged[FIELD_KIND] ?? "structural";
+}
+function getRelationTarget(schema) {
+  let current = schema;
+  for (let i = 0; i < 8; i++) {
+    const tagged = current;
+    if (tagged[RELATION_META]) {
+      return tagged[RELATION_META];
+    }
+    if (typeof tagged.unwrap === "function") {
+      current = tagged.unwrap();
+      continue;
+    }
+    if (typeof tagged.removeDefault === "function") {
+      current = tagged.removeDefault();
+      continue;
+    }
+    if (tagged._def?.innerType) {
+      current = tagged._def.innerType;
+      continue;
+    }
+    break;
+  }
+  return null;
+}
+function mark(schema, kind) {
+  Object.defineProperty(schema, FIELD_KIND, {
+    value: kind,
+    enumerable: false,
+    configurable: true
+  });
+  return schema;
+}
+function markRelation(schema, meta) {
+  Object.defineProperty(schema, RELATION_META, {
+    value: meta,
+    enumerable: false,
+    configurable: true
+  });
+  return mark(schema, "structural");
+}
+var field = {
+  translatable: (schema) => mark(schema, "translatable"),
+  structural: (schema) => mark(schema, "structural"),
+  relation: (typeId, options) => {
+    const multiple = options?.multiple ?? false;
+    const optional = options?.optional ?? false;
+    if ((options?.min !== void 0 || options?.max !== void 0) && !multiple) {
+      throw new Error(
+        `field.relation("${typeId}"): min/max require { multiple: true }`
+      );
+    }
+    let inner;
+    if (multiple) {
+      let arr = zod.z.array(zod.z.string().min(1));
+      if (options?.min !== void 0) arr = arr.min(options.min);
+      if (options?.max !== void 0) arr = arr.max(options.max);
+      inner = arr;
+    } else {
+      inner = zod.z.string().min(1);
+    }
+    markRelation(inner, { typeId, multiple, optional });
+    const schema = optional ? inner.optional() : inner;
+    return schema;
+  }
+};
+function unwrapSchema(schema) {
+  let current = schema;
+  for (let i = 0; i < 8; i++) {
+    const anySchema = current;
+    if (typeof anySchema.unwrap === "function") {
+      current = anySchema.unwrap();
+      continue;
+    }
+    if (typeof anySchema.removeDefault === "function") {
+      current = anySchema.removeDefault();
+      continue;
+    }
+    if (anySchema._def?.innerType) {
+      current = anySchema._def.innerType;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+
+// src/core/types.ts
+function defineConfig(config) {
+  return config;
+}
+function defineContentType(config) {
+  return config;
+}
+
+// src/i18n/build-url.ts
+var SLUG_PLACEHOLDER = "{slug}";
+function isRoutableType(type) {
+  return typeof type.path === "string" && type.path.length > 0;
+}
+function assertValidPathTemplate(path9, typeId) {
+  if (!path9.startsWith("/")) {
+    throw new Error(`Content type "${typeId}": path must start with / (got "${path9}")`);
+  }
+  const count = (path9.match(/\{slug\}/g) ?? []).length;
+  if (count !== 1) {
+    throw new Error(
+      `Content type "${typeId}": path must contain exactly one {slug} (got "${path9}")`
+    );
+  }
+}
+function pathPrefix(template) {
+  const idx = template.indexOf(SLUG_PLACEHOLDER);
+  if (idx === -1) throw new Error(`Invalid path template (missing {slug}): ${template}`);
+  return template.slice(0, idx);
+}
+function pathSuffix(template) {
+  const idx = template.indexOf(SLUG_PLACEHOLDER);
+  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;
+}
+
+// src/config/resolve-config.ts
+var RESOLVED = /* @__PURE__ */ Symbol.for("@genlook/scribe/resolvedConfig");
+function isResolvedConfig(config) {
+  return typeof config === "object" && config !== null && config[RESOLVED] === true;
+}
+function resolveConfig(input, baseDir) {
+  if (isResolvedConfig(input)) return input;
+  const raw = input;
+  if (!raw.rootDir) {
+    throw new Error("scribe config: rootDir is required");
+  }
+  if (!raw.locales || raw.locales.length === 0) {
+    throw new Error("scribe config: locales must be a non-empty array");
+  }
+  const defaultLocale = raw.defaultLocale ?? "en";
+  if (!raw.locales.includes(defaultLocale)) {
+    throw new Error(
+      `scribe config: defaultLocale "${defaultLocale}" is not in locales [${raw.locales.join(", ")}]`
+    );
+  }
+  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");
+  const seenIds = /* @__PURE__ */ new Set();
+  const types = raw.types.map((type) => {
+    if (seenIds.has(type.id)) {
+      throw new Error(`scribe config: duplicate content type id "${type.id}"`);
+    }
+    seenIds.add(type.id);
+    if (type.path) {
+      assertValidPathTemplate(type.path, type.id);
+    }
+    return {
+      ...type,
+      contentDir: type.contentDir ?? type.id,
+      label: type.label ?? type.id.charAt(0).toUpperCase() + type.id.slice(1),
+      slugStrategy: type.slugStrategy ?? "fixed",
+      indexFallback: type.indexFallback ?? (type.path ? "en" : "none")
+    };
+  });
+  const config = {
+    rootDir: contentRoot,
+    storePath,
+    locales: [...raw.locales],
+    defaultLocale,
+    localePresets: raw.localePresets,
+    translate: raw.translate,
+    types
+  };
+  Object.defineProperty(config, RESOLVED, {
+    value: true,
+    enumerable: false
+  });
+  return config;
+}
+
+// src/core/introspect-schema.ts
+function introspectSchema(schema, prefix = []) {
+  const relation = getRelationTarget(schema);
+  if (relation && prefix.length > 0) {
+    return [
+      {
+        path: prefix,
+        kind: "relation",
+        relationTarget: relation.typeId,
+        relationMultiple: relation.multiple,
+        relationOptional: relation.optional
+      }
+    ];
+  }
+  const base = unwrapSchema(schema);
+  if (base instanceof Object && "shape" in base) {
+    const shape = base.shape;
+    const fields = [];
+    for (const [key, child] of Object.entries(shape)) {
+      fields.push(...introspectSchema(child, [...prefix, key]));
+    }
+    return fields;
+  }
+  if (base instanceof Object && "element" in base) {
+    const element = base.element;
+    const elementBase = unwrapSchema(element);
+    if (elementBase instanceof Object && "shape" in elementBase) {
+      const shape = elementBase.shape;
+      const fields = [];
+      for (const [key, child] of Object.entries(shape)) {
+        fields.push(...introspectSchema(child, [...prefix, "*", key]));
+      }
+      return fields;
+    }
+  }
+  return [{ path: prefix, kind: getFieldKind(schema) }];
+}
+function extractByPaths(data, paths) {
+  const out = {};
+  for (const path9 of paths) {
+    const value = getAtPath(data, path9);
+    if (value !== void 0) {
+      setAtPath(out, path9.filter((p) => p !== "*"), value);
+    }
+  }
+  return out;
+}
+function pickTranslatable(data, schema) {
+  const translatablePaths = introspectSchema(schema).filter((f) => f.kind === "translatable").map((f) => f.path);
+  return extractByPaths(data, translatablePaths);
+}
+function pickStructural(data, schema) {
+  const structuralPaths = introspectSchema(schema).filter((f) => f.kind === "structural" || f.kind === "relation").map((f) => f.path);
+  return extractByPaths(data, structuralPaths);
+}
+function mergeStructuralOntoLocale(localeData, enData, schema) {
+  const structural = pickStructural(enData, schema);
+  const translatable = pickTranslatable(localeData, schema);
+  return deepMerge(structural, translatable);
+}
+function getAtPath(obj, path9) {
+  let current = obj;
+  for (const segment of path9) {
+    if (segment === "*") {
+      if (!Array.isArray(current)) return void 0;
+      return current.map(
+        (item) => typeof item === "object" && item !== null ? getAtPath(item, path9.slice(path9.indexOf("*") + 1)) : void 0
+      );
+    }
+    if (typeof current !== "object" || current === null || Array.isArray(current)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function setAtPath(obj, path9, value) {
+  if (path9.length === 0) return;
+  if (path9.length === 1) {
+    obj[path9[0]] = value;
+    return;
+  }
+  const [head, ...rest] = path9;
+  if (!(head in obj) || typeof obj[head] !== "object" || obj[head] === null) {
+    obj[head] = {};
+  }
+  setAtPath(obj[head], rest, value);
+}
+function deepMerge(base, overlay) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && out[key] && typeof out[key] === "object" && !Array.isArray(out[key])) {
+      out[key] = deepMerge(out[key], value);
+    } else if (Array.isArray(value) && Array.isArray(out[key])) {
+      out[key] = mergeArrayOverlay(out[key], value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function mergeArrayOverlay(base, overlay) {
+  return base.map((item, index) => {
+    const overlayItem = overlay[index];
+    if (item && typeof item === "object" && !Array.isArray(item) && overlayItem && typeof overlayItem === "object" && !Array.isArray(overlayItem)) {
+      return deepMerge(item, overlayItem);
+    }
+    return overlayItem ?? item;
+  });
+}
+function listRelationFields(schema) {
+  return introspectSchema(schema).filter((f) => f.kind === "relation");
+}
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var slugPatternSchema = zod.z.string().regex(SLUG_PATTERN, "slug must be lowercase-kebab-case");
+var isoDateSchema = zod.z.string().regex(/^\d{4}-\d{2}-\d{2}(T[\d:.Z+-]*)?$/, "Use ISO date YYYY-MM-DD or full ISO 8601");
+var canonicalPathSchema = zod.z.string().regex(/^\//, "canonicalPath must start with /");
+var LOCALE_BUILTIN_KEYS = [
+  ["publishedAt", "publishedAt is EN-only; inherited from the EN parent at load time"],
+  ["updatedAt", "updatedAt is EN-only; inherited from the EN parent at load time"],
+  ["noindex", "noindex is EN-only; inherited from the EN parent at load time"],
+  ["canonicalPath", "canonicalPath is EN-only; inherited from the EN parent at load time"],
+  ["aliases", "aliases is EN-only; remove from locale translation"],
+  ["redirect_to", "redirect_to is EN-only; remove from locale translation"],
+  ["translationOf", "translationOf is internal; remove from locale translation"],
+  ["enSlug", "enSlug is internal; remove from locale translation"]
+];
+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"
+      });
+    }
+  }
+  let publishedAt;
+  if (rest.publishedAt !== void 0 && rest.publishedAt !== null && rest.publishedAt !== "") {
+    const parsed = isoDateSchema.safeParse(rest.publishedAt);
+    if (parsed.success) {
+      publishedAt = parsed.data;
+    } else {
+      for (const issue of parsed.error.issues) {
+        issues.push({ field: "publishedAt", message: issue.message, level: "error" });
+      }
+    }
+    delete rest.publishedAt;
+  }
+  let updatedAt;
+  if (rest.updatedAt !== void 0 && rest.updatedAt !== null && rest.updatedAt !== "") {
+    const parsed = isoDateSchema.safeParse(rest.updatedAt);
+    if (parsed.success) {
+      updatedAt = parsed.data;
+    } else {
+      for (const issue of parsed.error.issues) {
+        issues.push({ field: "updatedAt", message: issue.message, level: "error" });
+      }
+    }
+    delete rest.updatedAt;
+  } else if (publishedAt) {
+    updatedAt = publishedAt;
+  }
+  let noindex = false;
+  if (rest.noindex !== void 0 && rest.noindex !== null && rest.noindex !== "") {
+    if (typeof rest.noindex === "boolean") {
+      noindex = rest.noindex;
+    } else {
+      issues.push({ field: "noindex", message: "noindex must be a boolean", level: "error" });
+    }
+    delete rest.noindex;
+  }
+  let canonicalPathOverride;
+  if (rest.canonicalPath !== void 0 && rest.canonicalPath !== null && rest.canonicalPath !== "") {
+    const parsed = canonicalPathSchema.safeParse(rest.canonicalPath);
+    if (parsed.success) {
+      canonicalPathOverride = parsed.data;
+    } else {
+      for (const issue of parsed.error.issues) {
+        issues.push({ field: "canonicalPath", message: issue.message, level: "error" });
+      }
+    }
+    delete rest.canonicalPath;
+  }
+  for (const internalKey of ["translationOf", "enSlug"]) {
+    if (rest[internalKey] !== void 0) {
+      issues.push({
+        field: internalKey,
+        message: `${internalKey} is managed internally by Scribe; remove from frontmatter`,
+        level: "warning"
+      });
+      delete rest[internalKey];
+    }
+  }
+  return {
+    builtin: {
+      aliases,
+      redirectTo,
+      publishedAt,
+      updatedAt,
+      noindex,
+      canonicalPathOverride
+    },
+    rest,
+    issues
+  };
+}
+function validateLocaleBuiltinFields(data) {
+  const issues = [];
+  for (const [key, message] of LOCALE_BUILTIN_KEYS) {
+    if (data[key] !== void 0) {
+      issues.push({ field: key, message, level: "error" });
+    }
+  }
+  return issues;
+}
+function documentLastModified(doc) {
+  const raw = doc.updatedAt ?? doc.publishedAt;
+  if (!raw) return void 0;
+  const date = new Date(raw);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+function resolveCanonicalPathname(type, doc, defaultLocale) {
+  if (doc.canonicalPathOverride) {
+    if (doc.locale === defaultLocale) return doc.canonicalPathOverride;
+    return `/${doc.locale}${doc.canonicalPathOverride}`;
+  }
+  if (!type.path) return `/${doc.slug}`;
+  return resolvePath(type.path, doc.slug, doc.locale, defaultLocale);
+}
+function mergeBuiltinsIntoFrontmatter(frontmatter, doc, type, defaultLocale) {
+  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);
+  return out;
+}
+function seoFieldsFromEn(enDoc) {
+  return {
+    publishedAt: enDoc.publishedAt,
+    updatedAt: enDoc.updatedAt,
+    noindex: enDoc.noindex,
+    canonicalPathOverride: enDoc.canonicalPathOverride,
+    redirectTo: enDoc.redirectTo
+  };
+}
+var SCHEMA_VERSION = 2;
+var MIGRATIONS = [
+  `CREATE TABLE IF NOT EXISTS meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS translations (
+    content_type TEXT NOT NULL,
+    en_slug TEXT NOT NULL,
+    locale TEXT NOT NULL,
+    slug TEXT NOT NULL,
+    frontmatter_json TEXT NOT NULL,
+    body TEXT NOT NULL,
+    en_hash TEXT NOT NULL,
+    translated_at TEXT NOT NULL,
+    model TEXT NOT NULL,
+    PRIMARY KEY (content_type, en_slug, locale)
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_translations_type_locale
+    ON translations(content_type, locale)`,
+  `CREATE TABLE IF NOT EXISTS revisions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    content_type TEXT NOT NULL,
+    en_slug TEXT NOT NULL,
+    locale TEXT,
+    revision_kind TEXT NOT NULL,
+    en_hash TEXT NOT NULL,
+    body_hash TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    model TEXT,
+    body_preview TEXT
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_revisions_lookup
+    ON revisions(content_type, en_slug, locale, created_at DESC)`,
+  `CREATE TABLE IF NOT EXISTS slug_aliases (
+    content_type TEXT NOT NULL,
+    canonical_en_slug TEXT NOT NULL,
+    alias_en_slug TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (content_type, alias_en_slug)
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_slug_aliases_canonical
+    ON slug_aliases(content_type, canonical_en_slug)`,
+  `CREATE TABLE IF NOT EXISTS alias_locale_slugs (
+    content_type TEXT NOT NULL,
+    alias_en_slug TEXT NOT NULL,
+    locale TEXT NOT NULL,
+    locale_slug TEXT NOT NULL,
+    captured_at TEXT NOT NULL,
+    PRIMARY KEY (content_type, alias_en_slug, locale)
+  )`
+];
+function resolveStorePath(config) {
+  return config.storePath;
+}
+function openStore(config, mode = "readwrite") {
+  const storePath = resolveStorePath(config);
+  fs2__default.default.mkdirSync(path3__default.default.dirname(storePath), { recursive: true });
+  const db = new Database__default.default(storePath, { readonly: mode === "readonly" });
+  if (mode === "readwrite") {
+    migrate(db);
+  }
+  return db;
+}
+function migrate(db) {
+  for (const sql of MIGRATIONS) {
+    db.exec(sql);
+  }
+  db.prepare(
+    `INSERT INTO meta(key, value) VALUES('schema_version', ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(String(SCHEMA_VERSION));
+}
+
+// src/storage/translations.ts
+function upsertTranslation(db, input) {
+  db.prepare(
+    `INSERT INTO translations (
+      content_type, en_slug, locale, slug, frontmatter_json, body, en_hash, translated_at, model
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(content_type, en_slug, locale) DO UPDATE SET
+      slug = excluded.slug,
+      frontmatter_json = excluded.frontmatter_json,
+      body = excluded.body,
+      en_hash = excluded.en_hash,
+      translated_at = excluded.translated_at,
+      model = excluded.model`
+  ).run(
+    input.contentType,
+    input.enSlug,
+    input.locale,
+    input.slug,
+    JSON.stringify(input.frontmatter),
+    input.body,
+    input.enHash,
+    input.translatedAt,
+    input.model
+  );
+}
+function getTranslation(db, contentType, enSlug, locale) {
+  return db.prepare(
+    `SELECT * FROM translations WHERE content_type = ? AND en_slug = ? AND locale = ?`
+  ).get(contentType, enSlug, locale);
+}
+function listTranslationsForType(db, contentType) {
+  return db.prepare(`SELECT * FROM translations WHERE content_type = ? ORDER BY en_slug, locale`).all(contentType);
+}
+function listTranslationsForEnSlug(db, contentType, enSlug) {
+  return db.prepare(
+    `SELECT * FROM translations WHERE content_type = ? AND en_slug = ? ORDER BY locale`
+  ).all(contentType, enSlug);
+}
+function bulkLoadTranslations(db) {
+  return db.prepare(`SELECT * FROM translations ORDER BY content_type, en_slug, locale`).all();
+}
+function appendRevision(db, input) {
+  const result = db.prepare(
+    `INSERT INTO revisions (
+        content_type, en_slug, locale, revision_kind, en_hash, body_hash, created_at, model, body_preview
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    input.contentType,
+    input.enSlug,
+    input.locale,
+    input.revisionKind,
+    input.enHash,
+    input.bodyHash,
+    input.createdAt,
+    input.model ?? null,
+    input.bodyPreview ?? null
+  );
+  return Number(result.lastInsertRowid);
+}
+
+// src/loader/normalize-en.ts
+function normalizeEnFrontmatter(data) {
+  const out = { ...data };
+  if (!out.publishedAt && typeof out.date === "string") {
+    out.publishedAt = out.date;
+  }
+  if (!out.heroImage && typeof out.image === "string" && out.image.startsWith("/")) {
+    out.heroImage = out.image;
+  }
+  if (!out.updatedAt && typeof out.publishedAt === "string") {
+    out.updatedAt = out.publishedAt;
+  }
+  return out;
+}
+function isPublishableContentFile(name) {
+  if (!name.endsWith(".md") && !name.endsWith(".mdx")) return false;
+  const first = name.charAt(0);
+  return first === first.toLowerCase() && first !== "_";
+}
+
+// src/loader/create-loader.ts
+function isPostFile(name) {
+  return isPublishableContentFile(name);
+}
+function listEnFiles(contentDir) {
+  if (!fs2__default.default.existsSync(contentDir)) return [];
+  return fs2__default.default.readdirSync(contentDir).filter(isPostFile).map((f) => path3__default.default.join(contentDir, f));
+}
+function slugFromPath(filePath) {
+  return path3__default.default.basename(filePath).replace(/\.(md|mdx)$/, "");
+}
+function parseEnMdx(filePath, config, type) {
+  const raw = fs2__default.default.readFileSync(filePath, "utf8");
+  const parsed = matter__default.default(raw);
+  const slug = slugFromPath(filePath);
+  const normalized = normalizeEnFrontmatter(parsed.data);
+  const { builtin, rest, issues: builtinIssues } = extractBuiltinEnFields(
+    normalized,
+    type.path,
+    slug,
+    config.defaultLocale
+  );
+  const issues = builtinIssues.map((issue) => ({
+    field: issue.field,
+    message: issue.message,
+    level: issue.level
+  }));
+  const result = type.schema.safeParse(rest);
+  if (!result.success) {
+    return {
+      document: null,
+      issues: [
+        ...issues,
+        ...result.error.issues.map((issue) => ({
+          field: issue.path.join("."),
+          message: issue.message,
+          level: "error"
+        }))
+      ]
+    };
+  }
+  if (issues.some((i) => i.level === "error")) {
+    return { document: null, issues };
+  }
+  const frontmatter = mergeBuiltinsIntoFrontmatter(
+    result.data,
+    {
+      publishedAt: builtin.publishedAt,
+      updatedAt: builtin.updatedAt,
+      noindex: builtin.noindex,
+      canonicalPathOverride: builtin.canonicalPathOverride,
+      slug,
+      locale: config.defaultLocale
+    },
+    type,
+    config.defaultLocale
+  );
+  const crossIssues = type.crossValidate?.(result.data, {
+    locale: config.defaultLocale,
+    defaultLocale: config.defaultLocale,
+    slug,
+    enSlug: slug,
+    knownLocales: config.locales
+  }) ?? [];
+  issues.push(...crossIssues);
+  const document2 = {
+    slug,
+    enSlug: slug,
+    locale: config.defaultLocale,
+    aliases: builtin.aliases,
+    redirectTo: builtin.redirectTo,
+    publishedAt: builtin.publishedAt,
+    updatedAt: builtin.updatedAt,
+    noindex: builtin.noindex,
+    canonicalPathOverride: builtin.canonicalPathOverride,
+    frontmatter,
+    content: parsed.content,
+    filePath
+  };
+  return { document: document2, issues };
+}
+function buildDocumentFromTranslation(row, enDoc, type) {
+  const localeFm = JSON.parse(row.frontmatter_json);
+  const merged = mergeStructuralOntoLocale(localeFm, enDoc.frontmatter, type.schema);
+  const seo = seoFieldsFromEn(enDoc);
+  const frontmatter = mergeBuiltinsIntoFrontmatter(
+    merged,
+    { ...seo, slug: row.slug, locale: row.locale },
+    type,
+    enDoc.locale
+  );
+  return {
+    slug: row.slug,
+    enSlug: row.en_slug,
+    locale: row.locale,
+    aliases: [],
+    redirectTo: seo.redirectTo,
+    publishedAt: seo.publishedAt,
+    updatedAt: seo.updatedAt,
+    noindex: seo.noindex,
+    canonicalPathOverride: seo.canonicalPathOverride,
+    frontmatter,
+    content: row.body
+  };
+}
+var DEV_REVALIDATE_MS = 1500;
+function createContentLoader(config, type) {
+  let cached = null;
+  let signature = "";
+  let lastCheck = 0;
+  const contentDir = path3__default.default.join(
+    /* turbopackIgnore: true */
+    config.rootDir,
+    type.contentDir
+  );
+  const storePath = resolveStorePath(config);
+  const isProd = process.env.NODE_ENV === "production";
+  function computeSignature() {
+    const files = listEnFiles(contentDir);
+    let newest = 0;
+    for (const f of files) {
+      try {
+        newest = Math.max(newest, fs2__default.default.statSync(f).mtimeMs);
+      } catch {
+      }
+    }
+    let store = 0;
+    try {
+      store = fs2__default.default.statSync(storePath).mtimeMs;
+    } catch {
+    }
+    return `${files.length}:${newest}:${store}`;
+  }
+  function build() {
+    const out = /* @__PURE__ */ new Map();
+    const englishBySlug = /* @__PURE__ */ new Map();
+    for (const file of listEnFiles(contentDir)) {
+      const { document: document2, issues } = parseEnMdx(file, config, type);
+      if (document2) {
+        englishBySlug.set(document2.slug, document2);
+        if (issues.length > 0) {
+          for (const issue of issues) {
+            console.warn(
+              `[scribe:${type.id}] ${file} ${issue.level}: ${issue.field}: ${issue.message}`
+            );
+          }
+        }
+      } else {
+        console.warn(
+          `[scribe:${type.id}] Skipping ${file} \u2014 validation failed:
+` + issues.map((i) => `  - ${i.field}: ${i.message}`).join("\n")
+        );
+      }
+    }
+    out.set(config.defaultLocale, {
+      bySlug: englishBySlug,
+      byEnSlug: englishBySlug
+    });
+    const db = openStore(config, "readonly");
+    const rows = listTranslationsForType(db, type.id);
+    db.close();
+    const rowsByLocale = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const list = rowsByLocale.get(row.locale) ?? [];
+      list.push(row);
+      rowsByLocale.set(row.locale, list);
+    }
+    for (const locale of config.locales) {
+      if (locale === config.defaultLocale) continue;
+      const bySlug = /* @__PURE__ */ new Map();
+      const byEnSlug = /* @__PURE__ */ new Map();
+      for (const row of rowsByLocale.get(locale) ?? []) {
+        const enDoc = englishBySlug.get(row.en_slug);
+        if (!enDoc) continue;
+        const doc = buildDocumentFromTranslation(row, enDoc, type);
+        bySlug.set(doc.slug, doc);
+        byEnSlug.set(row.en_slug, doc);
+      }
+      out.set(locale, { bySlug, byEnSlug });
+    }
+    return out;
+  }
+  return () => {
+    if (cached) {
+      if (isProd) return cached;
+      const now = Date.now();
+      if (now - lastCheck < DEV_REVALIDATE_MS) return cached;
+      lastCheck = now;
+      const sig = computeSignature();
+      if (sig === signature) return cached;
+      cached = build();
+      signature = sig;
+      return cached;
+    }
+    lastCheck = Date.now();
+    cached = build();
+    signature = isProd ? "" : computeSignature();
+    return cached;
+  };
+}
+function readEnDocument(config, type, enSlug) {
+  const contentDir = path3__default.default.join(
+    /* turbopackIgnore: true */
+    config.rootDir,
+    type.contentDir
+  );
+  for (const ext of [".mdx", ".md"]) {
+    const filePath = path3__default.default.join(contentDir, `${enSlug}${ext}`);
+    if (!fs2__default.default.existsSync(filePath)) continue;
+    const { document: document2 } = parseEnMdx(filePath, config, type);
+    return document2;
+  }
+  return null;
+}
+function getTranslatablePayload(doc, type) {
+  return {
+    frontmatter: pickTranslatable(doc.frontmatter, type.schema),
+    body: doc.content
+  };
+}
+
+// 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) {
+  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)
+      };
+    }
+  }
+  for (const [docLocale, docIdx] of allDocs) {
+    const found = docIdx.bySlug.get(slug);
+    if (!found) continue;
+    const correctSlug = getSlugForLocale(found, docLocale, locale, allDocs, defaultLocale);
+    if (correctSlug && correctSlug !== slug) {
+      if (!type.path) {
+        return { document: null, actualLocale: locale };
+      }
+      return {
+        document: null,
+        actualLocale: locale,
+        shouldRedirectTo: resolvePath(type.path, correctSlug, locale, defaultLocale)
+      };
+    }
+    if (docLocale === defaultLocale) {
+      return withRedirectTo(
+        { document: found, actualLocale: defaultLocale },
+        locale,
+        defaultLocale,
+        allDocs,
+        type
+      );
+    }
+    if (!type.path) {
+      return { document: null, actualLocale: locale };
+    }
+    return {
+      document: null,
+      actualLocale: locale,
+      shouldRedirectTo: resolvePath(type.path, found.enSlug, locale, defaultLocale)
+    };
+  }
+  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
+      );
+    }
+    const byEn = idx?.byEnSlug.get(slug);
+    if (byEn) {
+      return withRedirectTo(
+        { document: byEn, actualLocale: locale },
+        locale,
+        defaultLocale,
+        allDocs,
+        type
+      );
+    }
+    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: null, actualLocale: locale };
+}
+function getSlugForLocale(document2, sourceLocale, targetLocale, allDocs, defaultLocale) {
+  if (sourceLocale === targetLocale) return document2.slug;
+  const englishSlug = sourceLocale === defaultLocale ? document2.slug : document2.enSlug;
+  if (!englishSlug) return null;
+  if (targetLocale === defaultLocale) return englishSlug;
+  return allDocs.get(targetLocale)?.byEnSlug.get(englishSlug)?.slug ?? null;
+}
+
+// src/create-project.ts
+function comparatorFor(orderBy) {
+  if (typeof orderBy === "function") return orderBy;
+  switch (orderBy) {
+    case "publishedAt":
+      return (a, b) => (a.publishedAt ?? "").localeCompare(b.publishedAt ?? "");
+    case "-publishedAt":
+      return (a, b) => (b.publishedAt ?? "").localeCompare(a.publishedAt ?? "");
+    case "updatedAt":
+      return (a, b) => (a.updatedAt ?? "").localeCompare(b.updatedAt ?? "");
+    case "-updatedAt":
+      return (a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "");
+    default:
+      return (a, b) => a.slug.localeCompare(b.slug);
+  }
+}
+function buildRuntime(config, type, getRuntime) {
+  const load = createContentLoader(config, type);
+  const relationFields = new Map(
+    listRelationFields(type.schema).filter((f) => f.path.length === 1).map((f) => [f.path[0], f])
+  );
+  function assertRoutable(method) {
+    if (!type.path) {
+      throw new Error(
+        `Content type "${type.id}" has no path template \u2014 ${method}() requires one`
+      );
+    }
+    return type.path;
+  }
+  const runtime = {
+    id: type.id,
+    config: type,
+    load,
+    list(locale = config.defaultLocale, options = {}) {
+      const idx = load().get(locale);
+      if (!idx) return [];
+      const docs = Array.from(idx.bySlug.values());
+      docs.sort(comparatorFor(options.orderBy ?? type.orderBy ?? "slug"));
+      return options.limit !== void 0 ? docs.slice(0, options.limit) : docs;
+    },
+    get(slug, locale = config.defaultLocale) {
+      return load().get(locale)?.bySlug.get(slug) ?? null;
+    },
+    resolve(slug, locale) {
+      const result = resolveLocalizedDocument(slug, locale, config.defaultLocale, load(), type);
+      if (result.document && type.path) {
+        return {
+          ...result,
+          canonicalPath: resolvePath(
+            type.path,
+            result.document.slug,
+            result.actualLocale,
+            config.defaultLocale
+          )
+        };
+      }
+      return result;
+    },
+    staticParams(options = {}) {
+      assertRoutable("staticParams");
+      const all = load();
+      const enIdx = all.get(config.defaultLocale);
+      if (!enIdx) return [];
+      const params = [];
+      for (const locale of options.locales ?? config.locales) {
+        const localeIdx = all.get(locale);
+        for (const doc of enIdx.bySlug.values()) {
+          const slug = locale === config.defaultLocale ? doc.slug : localeIdx?.byEnSlug.get(doc.slug)?.slug ?? doc.slug;
+          params.push({ locale, slug });
+        }
+      }
+      return params;
+    },
+    alternates(doc) {
+      const pathTemplate = assertRoutable("alternates");
+      const out = {
+        [config.defaultLocale]: resolvePath(
+          pathTemplate,
+          doc.enSlug,
+          config.defaultLocale,
+          config.defaultLocale
+        )
+      };
+      const all = load();
+      for (const locale of config.locales) {
+        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);
+        }
+      }
+      return out;
+    },
+    translation(doc, targetLocale) {
+      if (targetLocale === doc.locale) return doc;
+      const all = load();
+      if (targetLocale === config.defaultLocale) {
+        return all.get(config.defaultLocale)?.bySlug.get(doc.enSlug) ?? null;
+      }
+      return all.get(targetLocale)?.byEnSlug.get(doc.enSlug) ?? null;
+    },
+    url(slug, locale) {
+      const pathTemplate = assertRoutable("url");
+      return resolvePath(pathTemplate, slug, locale, config.defaultLocale);
+    },
+    related(doc, fieldName, locale) {
+      const meta = relationFields.get(fieldName);
+      if (!meta) {
+        throw new Error(
+          `Content type "${type.id}" has no top-level relation field "${fieldName}"`
+        );
+      }
+      const target = getRuntime(meta.relationTarget);
+      const lookupLocale = locale ?? doc.locale;
+      const value = doc.frontmatter[fieldName];
+      const deref = (enSlug) => {
+        const all = target.load();
+        return all.get(lookupLocale)?.byEnSlug.get(enSlug) ?? all.get(config.defaultLocale)?.bySlug.get(enSlug) ?? null;
+      };
+      if (meta.relationMultiple) {
+        if (!Array.isArray(value)) return [];
+        return value.filter((slug) => typeof slug === "string" && slug.length > 0).map(deref).filter((d) => d !== null);
+      }
+      if (typeof value !== "string" || value.length === 0) {
+        if (meta.relationOptional) return null;
+        throw new Error(
+          `${type.id} "${doc.enSlug}": required relation "${fieldName}" is missing`
+        );
+      }
+      const resolved = deref(value);
+      if (!resolved && !meta.relationOptional) {
+        throw new Error(
+          `${type.id} "${doc.enSlug}": relation "${fieldName}" references missing ${meta.relationTarget} "${value}" \u2014 run \`scribe validate\``
+        );
+      }
+      return resolved;
+    }
+  };
+  return runtime;
+}
+function createProject(config) {
+  const runtimes = /* @__PURE__ */ new Map();
+  const getRuntime = (id) => {
+    const runtime = runtimes.get(id);
+    if (!runtime) {
+      throw new Error(`Unknown content type "${id}"`);
+    }
+    return runtime;
+  };
+  for (const type of config.types) {
+    runtimes.set(type.id, buildRuntime(config, type, getRuntime));
+  }
+  return {
+    config,
+    rootDir: config.rootDir,
+    storePath: config.storePath,
+    getType: getRuntime,
+    listTypes() {
+      return Array.from(runtimes.values());
+    }
+  };
+}
+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));
+  }
+  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);
+      }
+    }
+  }
+  return { aliasToTarget, allAliasSlugs, issues };
+}
+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"
+        });
+      }
+      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"
+        });
+      }
+      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 (!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"
+          });
+        }
+      }
+    }
+  } finally {
+    db.close();
+  }
+  return issues;
+}
+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"
+      });
+    }
+  }
+  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,
+          enSlug,
+          field: "redirect_to",
+          message: `redirect_to chain detected: "${enSlug}" \u2192 "${targetSlug}" \u2192 "${targetDoc.redirectTo}"`,
+          level: "error"
+        });
+      }
+    }
+  }
+  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;
+}
+
+// src/redirects/translation-index.ts
+function buildRedirectTranslationIndex(project, typeId) {
+  const runtime = project.getType(typeId);
+  const { config } = project;
+  const merged = buildTranslationIndex(
+    runtime.load(),
+    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 row of listTranslationsForEnSlug(db, typeId, alias)) {
+        const localeMap = merged.get(row.locale) ?? /* @__PURE__ */ new Map();
+        if (!localeMap.has(alias)) {
+          localeMap.set(alias, row.slug);
+        }
+        merged.set(row.locale, localeMap);
+      }
+    }
+  } finally {
+    db.close();
+  }
+  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) {
+  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;
+      out.push({
+        source: resolvePath(pathTemplate, enSlug, locale, defaultLocale),
+        destination: resolvePath(pathTemplate, translatedSlug, locale, defaultLocale),
+        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
+      });
+    }
+  }
+  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)
+  ];
+}
+function buildAllContentRedirects(project, options) {
+  const aliasIndex = buildGlobalAliasIndex(project);
+  const out = [];
+  for (const type of project.config.types) {
+    if (!isRoutableType(type)) continue;
+    out.push(...buildTypeRedirects(project, type.id, aliasIndex, options));
+  }
+  return out;
+}
+function getRedirectSourceSlugs(project) {
+  const aliasIndex = buildGlobalAliasIndex(project);
+  const outboundByType = /* @__PURE__ */ new Map();
+  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);
+    }
+    outboundByType.set(type.id, outbound);
+  }
+  return {
+    aliasSlugs: aliasIndex.allAliasSlugs,
+    outboundByType
+  };
+}
+
+// src/sitemap/join-base-url.ts
+function joinBaseUrl(baseUrl, pathname) {
+  const origin = baseUrl.replace(/\/$/, "");
+  const path9 = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${origin}${path9}`;
+}
+
+// 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;
+  if (excludeNoindex && enDoc.noindex) return false;
+  return true;
+}
+function resolveSitemapOptions(options) {
+  return {
+    ...options,
+    resolveUrl: options.resolveUrl ?? ((_locale, pathname) => joinBaseUrl(options.baseUrl, pathname))
+  };
+}
+async function buildClusterEntry(type, enSlug, enDoc, allDocs, config, options) {
+  const { defaultLocale, locales } = config;
+  const excludeNoindex = options.excludeNoindex !== false;
+  const includeXDefault = options.includeXDefault !== false;
+  const typeDefaults = options.typeDefaults?.[type.id];
+  const pathnameFor = (doc) => options.resolvePathname?.(type, doc, defaultLocale) ?? resolveCanonicalPathname(type, doc, defaultLocale);
+  const alternates = {};
+  for (const locale of locales) {
+    const idx = allDocs.get(locale);
+    if (!idx) continue;
+    const doc = locale === defaultLocale ? idx.bySlug.get(enSlug) : idx.byEnSlug.get(enSlug);
+    if (!doc) continue;
+    if (excludeNoindex && doc.noindex) continue;
+    const pathname = pathnameFor(doc);
+    alternates[locale] = await options.resolveUrl(locale, pathname);
+  }
+  if (Object.keys(alternates).length === 0) return null;
+  const mainUrl = alternates[defaultLocale] ?? alternates[Object.keys(alternates)[0]];
+  if (includeXDefault && alternates[defaultLocale]) {
+    alternates["x-default"] = alternates[defaultLocale];
+  }
+  const lastModified = documentLastModified(enDoc);
+  return {
+    url: mainUrl,
+    ...lastModified ? { lastModified } : {},
+    ...typeDefaults?.changeFrequency ? { changeFrequency: typeDefaults.changeFrequency } : {},
+    ...typeDefaults?.priority !== void 0 ? { priority: typeDefaults.priority } : {},
+    alternates: { languages: alternates }
+  };
+}
+async function generateSitemap(project, options) {
+  const resolvedOptions = resolveSitemapOptions(options);
+  const { config } = project;
+  const redirectSources = getRedirectSourceSlugs(project);
+  const excludeNoindex = options.excludeNoindex !== false;
+  const typeIds = options.contentTypes ?? config.types.filter(isRoutableType).map((t) => t.id);
+  const entries = [];
+  for (const typeId of typeIds) {
+    const runtime = project.getType(typeId);
+    const type = runtime.config;
+    if (!isRoutableType(type)) continue;
+    const allDocs = runtime.load();
+    const enIndex = allDocs.get(config.defaultLocale);
+    if (!enIndex) continue;
+    const processed = /* @__PURE__ */ new Set();
+    for (const [enSlug, enDoc] of enIndex.bySlug) {
+      if (processed.has(enSlug)) continue;
+      processed.add(enSlug);
+      if (!shouldIncludeEnDoc(enDoc, enSlug, redirectSources, typeId, excludeNoindex)) {
+        continue;
+      }
+      const entry = await buildClusterEntry(
+        type,
+        enSlug,
+        enDoc,
+        allDocs,
+        config,
+        resolvedOptions
+      );
+      if (entry) entries.push(entry);
+    }
+  }
+  return entries;
+}
+
+// src/create-scribe.ts
+function createScribe(input) {
+  const config = resolveConfig(input);
+  const project = createProject(config);
+  const scribe = {
+    config,
+    project,
+    getType: project.getType,
+    listTypes: project.listTypes,
+    sitemap(options) {
+      return generateSitemap(project, options);
+    }
+  };
+  for (const type of config.types) {
+    scribe[type.id] = project.getType(type.id);
+  }
+  return scribe;
+}
+function findConfigPath(cwd) {
+  const candidates = [
+    path3__default.default.join(
+      /* turbopackIgnore: true */
+      cwd,
+      "scribe.config.ts"
+    ),
+    path3__default.default.join(
+      /* turbopackIgnore: true */
+      cwd,
+      "scribe.config.mts"
+    ),
+    path3__default.default.join(
+      /* turbopackIgnore: true */
+      cwd,
+      "scribe.config.js"
+    )
+  ];
+  for (const candidate of candidates) {
+    if (fs2__default.default.existsSync(candidate) && fs2__default.default.statSync(candidate).isFile()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function loadConfigSync(options = {}) {
+  const cwd = options.cwd ?? /* turbopackIgnore: true */
+  process.cwd();
+  const configPath = options.configPath ?? findConfigPath(cwd);
+  if (!configPath) {
+    throw new Error(`No scribe.config.ts found in ${cwd} (pass --config)`);
+  }
+  const jiti$1 = jiti.createJiti(importMetaUrl, {
+    interopDefault: true,
+    moduleCache: false
+  });
+  const loaded = jiti$1(configPath);
+  const config = "default" in loaded ? loaded.default : loaded;
+  if (!config?.rootDir) {
+    throw new Error(`Invalid scribe config at ${configPath}: missing rootDir`);
+  }
+  return resolveConfig(config, path3__default.default.dirname(configPath));
+}
+function sha256(input) {
+  return crypto.createHash("sha256").update(input, "utf8").digest("hex");
+}
+function computePageEnHash(translatableFrontmatter, body) {
+  const payload = JSON.stringify({ frontmatter: translatableFrontmatter, body });
+  return sha256(payload);
+}
+function computeBodyHash(body) {
+  return sha256(body);
+}
+
+// src/history/record-revision.ts
+function recordRevision(config, input) {
+  const db = openStore(config, "readwrite");
+  const id = appendRevision(db, {
+    contentType: input.contentType,
+    enSlug: input.enSlug,
+    locale: input.locale,
+    revisionKind: input.revisionKind,
+    enHash: input.enHash,
+    bodyHash: computeBodyHash(input.body),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    model: input.model,
+    bodyPreview: input.body.slice(0, 200)
+  });
+  db.close();
+  return id;
+}
+function getAtPath2(obj, fieldPath) {
+  let current = obj;
+  for (const segment of fieldPath) {
+    if (typeof current !== "object" || current === null || Array.isArray(current)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function buildEnSlugIndex(config) {
+  const index = /* @__PURE__ */ new Map();
+  for (const type of config.types) {
+    const slugs = new Set(listEnSlugs(config.rootDir, type.contentDir));
+    index.set(type.id, slugs);
+  }
+  return index;
+}
+function listEnSlugsForType(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)$/, ""));
+}
+function validateRelations(project) {
+  const { config } = project;
+  const slugIndex = buildEnSlugIndex(config);
+  const issues = [];
+  const typeIds = new Set(config.types.map((t) => t.id));
+  for (const type of config.types) {
+    const relationFields = listRelationFields(type.schema);
+    if (relationFields.length === 0) continue;
+    for (const enSlug of listEnSlugsForType(config.rootDir, type.contentDir)) {
+      const doc = readEnDocument(config, type, enSlug);
+      if (!doc) continue;
+      for (const fieldMeta of relationFields) {
+        const targetTypeId = fieldMeta.relationTarget;
+        const danglingLevel = fieldMeta.relationOptional || fieldMeta.relationMultiple ? "warning" : "error";
+        if (!typeIds.has(targetTypeId)) {
+          issues.push({
+            contentTypeId: type.id,
+            enSlug,
+            field: fieldMeta.path.join("."),
+            message: `Relation target type "${targetTypeId}" is not registered`,
+            level: "error"
+          });
+          continue;
+        }
+        const value = getAtPath2(doc.frontmatter, fieldMeta.path);
+        if (value === void 0 || value === null || value === "") continue;
+        const targetSlugs = slugIndex.get(targetTypeId) ?? /* @__PURE__ */ new Set();
+        const fieldLabel = fieldMeta.path.join(".");
+        if (fieldMeta.relationMultiple) {
+          if (!Array.isArray(value)) continue;
+          for (const slug of value) {
+            if (typeof slug !== "string" || !slug) continue;
+            if (!targetSlugs.has(slug)) {
+              issues.push({
+                contentTypeId: type.id,
+                enSlug,
+                field: fieldLabel,
+                message: `${fieldLabel} references "${slug}" \u2014 no ${targetTypeId} doc with that slug`,
+                level: danglingLevel
+              });
+            }
+          }
+        } else if (typeof value === "string") {
+          if (!targetSlugs.has(value)) {
+            issues.push({
+              contentTypeId: type.id,
+              enSlug,
+              field: fieldLabel,
+              message: `${fieldLabel} references "${value}" \u2014 no ${targetTypeId} doc with slug "${value}"`,
+              level: danglingLevel
+            });
+          }
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+// src/validate/validate-slug-suffix.ts
+function validateTranslationSlugSuffixes(config, db) {
+  const issues = [];
+  const localeCodes = config.locales.filter((l) => l !== config.defaultLocale);
+  for (const row of bulkLoadTranslations(db)) {
+    if (row.locale === config.defaultLocale) continue;
+    for (const code of localeCodes) {
+      if (row.slug.endsWith(`-${code}`)) {
+        issues.push({
+          contentTypeId: row.content_type,
+          enSlug: row.en_slug,
+          locale: row.locale,
+          slug: row.slug,
+          message: `Translation slug "${row.slug}" ends with locale code "-${code}"`
+        });
+        break;
+      }
+    }
+  }
+  return issues;
+}
+
+// src/validate/validate-project.ts
+function listEnSlugs2(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)$/, ""));
+}
+function validateProject(config) {
+  const issues = [];
+  const project = createProject(config);
+  const storePath = project.storePath;
+  if (!fs2__default.default.existsSync(storePath)) {
+    issues.push({
+      level: "error",
+      message: `Missing store.sqlite at ${storePath}`
+    });
+    return { ok: false, issues };
+  }
+  const db = openStore(config, "readonly");
+  for (const type of config.types) {
+    const enSlugs = listEnSlugs2(config.rootDir, type.contentDir);
+    const englishSlugs = new Set(enSlugs);
+    if (!type.translate && isRoutableType(type)) {
+      issues.push({
+        level: "warning",
+        contentType: type.id,
+        message: `No translate config on content type "${type.id}" \u2014 using Scribe defaults`
+      });
+    }
+    for (const enSlug of enSlugs) {
+      const enDoc = readEnDocument(config, type, enSlug);
+      if (!enDoc) {
+        issues.push({
+          level: "error",
+          contentType: type.id,
+          enSlug,
+          message: "Failed to parse EN document"
+        });
+        continue;
+      }
+      const payload = getTranslatablePayload(enDoc, type);
+      const currentEnHash = computePageEnHash(payload.frontmatter, payload.body);
+      const crossIssues = type.crossValidate?.(enDoc.frontmatter, {
+        locale: config.defaultLocale,
+        defaultLocale: config.defaultLocale,
+        slug: enSlug,
+        enSlug,
+        knownLocales: config.locales,
+        englishSlugs
+      }) ?? [];
+      for (const issue of crossIssues) {
+        issues.push({
+          level: issue.level,
+          contentType: type.id,
+          enSlug,
+          field: issue.field,
+          message: issue.message
+        });
+      }
+      for (const locale of config.locales) {
+        if (locale === config.defaultLocale) continue;
+        const row = getTranslation(db, type.id, enSlug, locale);
+        if (!row) continue;
+        if (row.en_hash !== currentEnHash) {
+          issues.push({
+            level: "warning",
+            contentType: type.id,
+            enSlug,
+            locale,
+            field: "en_hash",
+            message: "Translation is stale (en_hash mismatch)"
+          });
+          recordRevision(config, {
+            contentType: type.id,
+            enSlug,
+            locale,
+            revisionKind: "en_edit_detected",
+            enHash: currentEnHash,
+            body: row.body
+          });
+        }
+        const localeFm = JSON.parse(row.frontmatter_json);
+        for (const issue of validateLocaleBuiltinFields(localeFm)) {
+          issues.push({
+            level: issue.level,
+            contentType: type.id,
+            enSlug,
+            locale,
+            field: issue.field,
+            message: issue.message
+          });
+        }
+      }
+    }
+    try {
+      project.getType(type.id).load();
+    } catch (error) {
+      issues.push({
+        level: "error",
+        contentType: type.id,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  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 validateRelations(project)) {
+    issues.push({
+      level: issue.level,
+      contentType: issue.contentTypeId,
+      enSlug: issue.enSlug,
+      field: issue.field,
+      message: issue.message
+    });
+  }
+  const dbForSuffix = openStore(config, "readonly");
+  try {
+    for (const issue of validateTranslationSlugSuffixes(config, dbForSuffix)) {
+      issues.push({
+        level: "error",
+        contentType: issue.contentTypeId,
+        enSlug: issue.enSlug,
+        locale: issue.locale,
+        field: "slug",
+        message: issue.message
+      });
+    }
+  } finally {
+    dbForSuffix.close();
+  }
+  return { ok: issues.every((i) => i.level !== "error"), issues };
+}
+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)$/, ""));
+}
+function buildWorklist(config, options = {}) {
+  const db = openStore(config, "readonly");
+  const items = [];
+  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);
+    for (const enSlug of enSlugs) {
+      const enDoc = readEnDocument(config, type, enSlug);
+      if (!enDoc) continue;
+      const payload = getTranslatablePayload(enDoc, type);
+      const currentEnHash = computePageEnHash(payload.frontmatter, payload.body);
+      for (const locale of locales) {
+        if (locale === config.defaultLocale) continue;
+        const existing = getTranslation(db, type.id, enSlug, locale);
+        if (!existing) {
+          items.push({
+            contentType: type.id,
+            enSlug,
+            locale,
+            reason: "missing",
+            currentEnHash
+          });
+          continue;
+        }
+        if (existing.en_hash !== currentEnHash) {
+          items.push({
+            contentType: type.id,
+            enSlug,
+            locale,
+            reason: "stale",
+            currentEnHash,
+            storedEnHash: existing.en_hash
+          });
+        }
+      }
+    }
+  }
+  db.close();
+  return items;
+}
+function resolveLocalesFromPreset(config, preset, explicitLocales) {
+  if (explicitLocales?.length) return explicitLocales;
+  if (preset && config.localePresets?.[preset]) {
+    return config.localePresets[preset].filter((l) => l !== config.defaultLocale);
+  }
+  return config.locales.filter((l) => l !== config.defaultLocale);
+}
+var DEFAULT_MODEL = "gemini-2.5-pro";
+function extractJson(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fenced?.[1]) return fenced[1].trim();
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start >= 0 && end > start) return text.slice(start, end + 1);
+  return text.trim();
+}
+async function translatePageWithGemini(input) {
+  const apiKey = input.apiKey ?? process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new Error("GEMINI_API_KEY is required for scribe translate");
+  }
+  const model = input.model ?? process.env.PROSE_GEMINI_MODEL ?? DEFAULT_MODEL;
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const response = await ai.models.generateContent({
+    model,
+    contents: input.prompt,
+    config: {
+      responseMimeType: "application/json"
+    }
+  });
+  const raw = response.text ?? "";
+  const parsed = JSON.parse(extractJson(raw));
+  if (!parsed.frontmatter || typeof parsed.body !== "string") {
+    throw new Error("Gemini response missing frontmatter/body");
+  }
+  return { model, raw, parsed };
+}
+
+// src/translate/prompts/translation-prompt.ts
+var LOCALE_NAMES = {
+  fr: "French",
+  es: "Spanish",
+  de: "German",
+  nl: "Dutch",
+  uk: "Ukrainian",
+  tr: "Turkish",
+  da: "Danish",
+  he: "Hebrew",
+  "zh-CN": "Simplified Chinese",
+  "zh-TW": "Traditional Chinese",
+  pt: "Portuguese",
+  ja: "Japanese",
+  ru: "Russian",
+  it: "Italian",
+  ar: "Arabic"
+};
+function defaultLocalizationPrompt(localeName, locale) {
+  return [
+    `Localize the content below into natural ${localeName} (${locale}).`,
+    "Do not translate word-for-word.",
+    "Preserve the source tone and brand voice.",
+    "Write as if a native speaker authored it for the target market."
+  ].join(" ");
+}
+function buildPageTranslationPrompt(input) {
+  const localeName = LOCALE_NAMES[input.targetLocale] ?? input.targetLocale;
+  const prompt = input.resolved.promptOverride ?? defaultLocalizationPrompt(localeName, input.targetLocale);
+  const lines = [
+    prompt,
+    "",
+    ...input.resolved.context ? ["## Context", input.resolved.context, ""] : [],
+    "## Rules",
+    ...input.resolved.rules.map((rule) => `- ${rule}`),
+    "",
+    "## Output format",
+    "Return ONLY valid JSON with keys:",
+    input.slugStrategy === "localized" ? "`frontmatter` (object with translated frontmatter fields), `body` (string, full MDX body), `slug` (string)." : "`frontmatter` (object), `body` (string).",
+    "",
+    "## EN metadata",
+    `title: ${input.enTitle}`,
+    `description: ${input.enDescription}`,
+    "",
+    "## EN translatable frontmatter (JSON)",
+    JSON.stringify(input.translatableFrontmatter, null, 2),
+    "",
+    "## EN body (MDX)",
+    input.enBody
+  ];
+  return lines.join("\n");
+}
+
+// src/translate/resolve-translate-config.ts
+function slugStrategyRules(slugStrategy, preserveTerms) {
+  if (slugStrategy === "localized") {
+    const rules = [
+      "Provide a localized URL slug in JSON field `slug`.",
+      "Slug MUST be ASCII only: a-z, 0-9, hyphens. No uppercase, accents, underscores, or spaces.",
+      "For non-Latin locales, transliterate into Latin script."
+    ];
+    if (preserveTerms?.length) {
+      rules.push(
+        `Preserve these terms verbatim in slugs (lowercase): ${preserveTerms.join(", ")}.`
+      );
+    } else {
+      rules.push("Preserve 4-digit years and proper nouns in slugs.");
+    }
+    return rules;
+  }
+  return ["Do NOT output a slug \u2014 slugStrategy is fixed."];
+}
+function mergeContext(project, type) {
+  const parts = [project?.context, type?.context].filter(Boolean);
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+function mergeTranslateConfig(project, type, slugStrategy) {
+  return {
+    promptOverride: type?.prompt ?? project?.prompt,
+    context: mergeContext(project, type),
+    rules: [
+      ...project?.rules ?? [],
+      ...type?.rules ?? [],
+      ...slugStrategyRules(slugStrategy, project?.slugPreserveTerms)
+    ],
+    model: type?.model ?? project?.defaultModel
+  };
+}
+function resolveTranslateConfig(config, type) {
+  return mergeTranslateConfig(config.translate, type.translate, type.slugStrategy);
+}
+
+// src/translate/page-translator.ts
+async function translatePage(config, item, options = {}) {
+  const type = config.types.find((t) => t.id === item.contentType);
+  if (!type) throw new Error(`Unknown content type ${item.contentType}`);
+  const enDoc = readEnDocument(config, type, item.enSlug);
+  if (!enDoc) throw new Error(`EN document not found: ${item.enSlug}`);
+  const payload = getTranslatablePayload(enDoc, type);
+  const currentEnHash = computePageEnHash(payload.frontmatter, payload.body);
+  const db = openStore(config, "readonly");
+  const existing = getTranslation(db, type.id, item.enSlug, item.locale);
+  db.close();
+  if (!options.force && existing && existing.en_hash === currentEnHash) {
+    return {
+      contentType: item.contentType,
+      enSlug: item.enSlug,
+      locale: item.locale,
+      skipped: true,
+      reason: "fresh"
+    };
+  }
+  const resolvedTranslate = resolveTranslateConfig(config, type);
+  const prompt = buildPageTranslationPrompt({
+    resolved: resolvedTranslate,
+    targetLocale: item.locale,
+    enTitle: String(enDoc.frontmatter.title ?? item.enSlug),
+    enDescription: String(enDoc.frontmatter.description ?? ""),
+    translatableFrontmatter: payload.frontmatter,
+    enBody: payload.body,
+    slugStrategy: type.slugStrategy
+  });
+  if (options.dryRun) {
+    return {
+      contentType: item.contentType,
+      enSlug: item.enSlug,
+      locale: item.locale,
+      skipped: false,
+      model: options.model
+    };
+  }
+  const result = await translatePageWithGemini({
+    prompt,
+    model: options.model ?? resolvedTranslate.model
+  });
+  const slug = type.slugStrategy === "localized" ? result.parsed.slug ?? existing?.slug ?? item.enSlug : item.enSlug;
+  const writeDb = openStore(config, "readwrite");
+  upsertTranslation(writeDb, {
+    contentType: type.id,
+    enSlug: item.enSlug,
+    locale: item.locale,
+    slug,
+    frontmatter: result.parsed.frontmatter,
+    body: result.parsed.body,
+    enHash: currentEnHash,
+    translatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    model: result.model
+  });
+  writeDb.close();
+  recordRevision(config, {
+    contentType: type.id,
+    enSlug: item.enSlug,
+    locale: item.locale,
+    revisionKind: "translation",
+    enHash: currentEnHash,
+    body: result.parsed.body,
+    model: result.model
+  });
+  return {
+    contentType: item.contentType,
+    enSlug: item.enSlug,
+    locale: item.locale,
+    skipped: false,
+    model: result.model
+  };
+}
+async function translateWorklist(config, items, options = {}) {
+  const results = [];
+  for (const item of items) {
+    results.push(await translatePage(config, item, options));
+  }
+  return results;
+}
+
+exports.buildAllContentRedirects = buildAllContentRedirects;
+exports.buildWorklist = buildWorklist;
+exports.createProject = createProject;
+exports.createScribe = createScribe;
+exports.defineConfig = defineConfig;
+exports.defineContentType = defineContentType;
+exports.field = field;
+exports.findConfigPath = findConfigPath;
+exports.generateSitemap = generateSitemap;
+exports.getFieldKind = getFieldKind;
+exports.getRedirectSourceSlugs = getRedirectSourceSlugs;
+exports.getRelationTarget = getRelationTarget;
+exports.isResolvedConfig = isResolvedConfig;
+exports.loadConfigSync = loadConfigSync;
+exports.resolveConfig = resolveConfig;
+exports.resolveLocalesFromPreset = resolveLocalesFromPreset;
+exports.translatePage = translatePage;
+exports.translateWorklist = translateWorklist;
+exports.unwrapSchema = unwrapSchema;
+exports.validateProject = validateProject;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map