scribe-cms 0.0.1

package/dist/runtime.js

@@ -0,0 +1,1207 @@
+import path3 from 'path';
+import { z } from 'zod';
+import fs2 from 'fs';
+import matter from 'gray-matter';
+import Database from 'better-sqlite3';
+
+// src/config/resolve-config.ts
+
+// src/i18n/build-url.ts
+var SLUG_PLACEHOLDER = "{slug}";
+function isRoutableType(type) {
+  return typeof type.path === "string" && type.path.length > 0;
+}
+function assertValidPathTemplate(path5, typeId) {
+  if (!path5.startsWith("/")) {
+    throw new Error(`Content type "${typeId}": path must start with / (got "${path5}")`);
+  }
+  const count = (path5.match(/\{slug\}/g) ?? []).length;
+  if (count !== 1) {
+    throw new Error(
+      `Content type "${typeId}": path must contain exactly one {slug} (got "${path5}")`
+    );
+  }
+}
+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.resolve(process.cwd(), raw.rootDir);
+  const contentRoot = path3.resolve(projectRoot, raw.contentDir ?? "content");
+  const storePath = path3.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;
+}
+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 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/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 path5 of paths) {
+    const value = getAtPath(data, path5);
+    if (value !== void 0) {
+      setAtPath(out, path5.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, path5) {
+  let current = obj;
+  for (const segment of path5) {
+    if (segment === "*") {
+      if (!Array.isArray(current)) return void 0;
+      return current.map(
+        (item) => typeof item === "object" && item !== null ? getAtPath(item, path5.slice(path5.indexOf("*") + 1)) : void 0
+      );
+    }
+    if (typeof current !== "object" || current === null || Array.isArray(current)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function setAtPath(obj, path5, value) {
+  if (path5.length === 0) return;
+  if (path5.length === 1) {
+    obj[path5[0]] = value;
+    return;
+  }
+  const [head, ...rest] = path5;
+  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 = z.string().regex(SLUG_PATTERN, "slug must be lowercase-kebab-case");
+var isoDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T[\d:.Z+-]*)?$/, "Use ISO date YYYY-MM-DD or full ISO 8601");
+var canonicalPathSchema = z.string().regex(/^\//, "canonicalPath must start with /");
+function extractBuiltinEnFields(data, pathTemplate, enSlug, defaultLocale) {
+  const issues = [];
+  const rest = { ...data };
+  const aliasesResult = 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 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.mkdirSync(path3.dirname(storePath), { recursive: true });
+  const db = new Database(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 listTranslationsForType(db, contentType) {
+  return db.prepare(`SELECT * FROM translations WHERE content_type = ? ORDER BY en_slug, locale`).all(contentType);
+}
+
+// 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.existsSync(contentDir)) return [];
+  return fs2.readdirSync(contentDir).filter(isPostFile).map((f) => path3.join(contentDir, f));
+}
+function slugFromPath(filePath) {
+  return path3.basename(filePath).replace(/\.(md|mdx)$/, "");
+}
+function parseEnMdx(filePath, config, type) {
+  const raw = fs2.readFileSync(filePath, "utf8");
+  const parsed = matter(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 document = {
+    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, 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.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.statSync(f).mtimeMs);
+      } catch {
+      }
+    }
+    let store = 0;
+    try {
+      store = fs2.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, issues } = parseEnMdx(file, config, type);
+      if (document) {
+        englishBySlug.set(document.slug, document);
+        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.join(
+    /* turbopackIgnore: true */
+    config.rootDir,
+    type.contentDir
+  );
+  for (const ext of [".mdx", ".md"]) {
+    const filePath = path3.join(contentDir, `${enSlug}${ext}`);
+    if (!fs2.existsSync(filePath)) continue;
+    const { document } = parseEnMdx(filePath, config, type);
+    return document;
+  }
+  return null;
+}
+
+// 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(document, sourceLocale, targetLocale, allDocs, defaultLocale) {
+  if (sourceLocale === targetLocale) return document.slug;
+  const englishSlug = sourceLocale === defaultLocale ? document.slug : document.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 listEnSlugs(rootDir, contentDir) {
+  const dir = path3.join(rootDir, contentDir);
+  if (!fs2.existsSync(dir)) return [];
+  return fs2.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 };
+}
+
+// src/redirects/build-redirects.ts
+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 path5 = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${origin}${path5}`;
+}
+
+// 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;
+}
+
+export { createScribe };
+//# sourceMappingURL=runtime.js.map
+//# sourceMappingURL=runtime.js.map