scribe-cms 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,2289 @@
+#!/usr/bin/env node
+import path4 from 'path';
+import 'url';
+import fs2 from 'fs';
+import Database from 'better-sqlite3';
+import { z } from 'zod';
+import matter from 'gray-matter';
+import { createJiti } from 'jiti';
+import { createHash } from 'crypto';
+import { GoogleGenAI } from '@google/genai';
+import dotenv from 'dotenv';
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var init_esm_shims = __esm({
+  "../../node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+
+// src/storage/sqlite.ts
+var sqlite_exports = {};
+__export(sqlite_exports, {
+  closeStore: () => closeStore,
+  openStore: () => openStore,
+  resolveStorePath: () => resolveStorePath
+});
+function resolveStorePath(config) {
+  return config.storePath;
+}
+function openStore(config, mode = "readwrite") {
+  const storePath = resolveStorePath(config);
+  fs2.mkdirSync(path4.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));
+}
+function closeStore(db) {
+  db.close();
+}
+var SCHEMA_VERSION, MIGRATIONS;
+var init_sqlite = __esm({
+  "src/storage/sqlite.ts"() {
+    init_esm_shims();
+    SCHEMA_VERSION = 2;
+    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)
+  )`
+    ];
+  }
+});
+
+// cli/index.ts
+init_esm_shims();
+
+// src/index.ts
+init_esm_shims();
+
+// src/core/field.ts
+init_esm_shims();
+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/types.ts
+init_esm_shims();
+
+// src/create-scribe.ts
+init_esm_shims();
+
+// src/config/resolve-config.ts
+init_esm_shims();
+
+// src/i18n/build-url.ts
+init_esm_shims();
+var SLUG_PLACEHOLDER = "{slug}";
+function isRoutableType(type) {
+  return typeof type.path === "string" && type.path.length > 0;
+}
+function assertValidPathTemplate(path11, typeId) {
+  if (!path11.startsWith("/")) {
+    throw new Error(`Content type "${typeId}": path must start with / (got "${path11}")`);
+  }
+  const count = (path11.match(/\{slug\}/g) ?? []).length;
+  if (count !== 1) {
+    throw new Error(
+      `Content type "${typeId}": path must contain exactly one {slug} (got "${path11}")`
+    );
+  }
+}
+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 = path4.resolve(baseDir ?? process.cwd(), raw.rootDir);
+  const contentRoot = path4.resolve(projectRoot, raw.contentDir ?? "content");
+  const storePath = path4.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/create-project.ts
+init_esm_shims();
+
+// src/core/introspect-schema.ts
+init_esm_shims();
+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 path11 of paths) {
+    const value = getAtPath(data, path11);
+    if (value !== void 0) {
+      setAtPath(out, path11.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, path11) {
+  let current = obj;
+  for (const segment of path11) {
+    if (segment === "*") {
+      if (!Array.isArray(current)) return void 0;
+      return current.map(
+        (item) => typeof item === "object" && item !== null ? getAtPath(item, path11.slice(path11.indexOf("*") + 1)) : void 0
+      );
+    }
+    if (typeof current !== "object" || current === null || Array.isArray(current)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function setAtPath(obj, path11, value) {
+  if (path11.length === 0) return;
+  if (path11.length === 1) {
+    obj[path11[0]] = value;
+    return;
+  }
+  const [head, ...rest] = path11;
+  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");
+}
+
+// src/loader/create-loader.ts
+init_esm_shims();
+
+// src/core/builtin-fields.ts
+init_esm_shims();
+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 /");
+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 = 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 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
+  };
+}
+
+// src/loader/create-loader.ts
+init_sqlite();
+
+// src/storage/translations.ts
+init_esm_shims();
+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);
+}
+function listRevisions(db, contentType, enSlug, locale) {
+  if (locale) {
+    return db.prepare(
+      `SELECT * FROM revisions
+         WHERE content_type = ? AND en_slug = ? AND locale = ?
+         ORDER BY created_at DESC, id DESC`
+    ).all(contentType, enSlug, locale);
+  }
+  return db.prepare(
+    `SELECT * FROM revisions
+       WHERE content_type = ? AND en_slug = ?
+       ORDER BY created_at DESC, id DESC`
+  ).all(contentType, enSlug);
+}
+
+// src/loader/normalize-en.ts
+init_esm_shims();
+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) => path4.join(contentDir, f));
+}
+function slugFromPath(filePath) {
+  return path4.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 = path4.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 = path4.join(
+    /* turbopackIgnore: true */
+    config.rootDir,
+    type.contentDir
+  );
+  for (const ext of [".mdx", ".md"]) {
+    const filePath = path4.join(contentDir, `${enSlug}${ext}`);
+    if (!fs2.existsSync(filePath)) continue;
+    const { document } = parseEnMdx(filePath, config, type);
+    return document;
+  }
+  return null;
+}
+function getTranslatablePayload(doc, type) {
+  return {
+    frontmatter: pickTranslatable(doc.frontmatter, type.schema),
+    body: doc.content
+  };
+}
+
+// src/i18n/resolve-document.ts
+init_esm_shims();
+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());
+    }
+  };
+}
+
+// src/sitemap/generate-sitemap.ts
+init_esm_shims();
+
+// src/redirects/build-redirects.ts
+init_esm_shims();
+
+// src/core/slug-aliases.ts
+init_esm_shims();
+
+// src/core/alias-helpers.ts
+init_esm_shims();
+function enFileExists(config, type, enSlug) {
+  const dir = path4.join(config.rootDir, type.contentDir);
+  return fs2.existsSync(path4.join(dir, `${enSlug}.mdx`)) || fs2.existsSync(path4.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 = path4.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
+init_sqlite();
+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/redirects/translation-index.ts
+init_esm_shims();
+
+// src/i18n/translation-index.ts
+init_esm_shims();
+
+// src/redirects/translation-index.ts
+init_sqlite();
+
+// src/sitemap/join-base-url.ts
+init_esm_shims();
+
+// src/config/load-config.ts
+init_esm_shims();
+function findConfigPath(cwd) {
+  const candidates = [
+    path4.join(
+      /* turbopackIgnore: true */
+      cwd,
+      "scribe.config.ts"
+    ),
+    path4.join(
+      /* turbopackIgnore: true */
+      cwd,
+      "scribe.config.mts"
+    ),
+    path4.join(
+      /* turbopackIgnore: true */
+      cwd,
+      "scribe.config.js"
+    )
+  ];
+  for (const candidate of candidates) {
+    if (fs2.existsSync(candidate) && fs2.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 = createJiti(import.meta.url, {
+    interopDefault: true,
+    moduleCache: false
+  });
+  const loaded = jiti(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, path4.dirname(configPath));
+}
+
+// src/validate/validate-project.ts
+init_esm_shims();
+
+// src/hash/page-hash.ts
+init_esm_shims();
+function sha256(input) {
+  return 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
+init_esm_shims();
+init_sqlite();
+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;
+}
+
+// src/validate/validate-project.ts
+init_sqlite();
+
+// src/validate/validate-relations.ts
+init_esm_shims();
+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 = path4.join(rootDir, contentDir);
+  if (!fs2.existsSync(dir)) return [];
+  return fs2.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
+init_esm_shims();
+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 = path4.join(rootDir, contentDir);
+  if (!fs2.existsSync(dir)) return [];
+  return fs2.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.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 };
+}
+
+// src/translate/worklist.ts
+init_esm_shims();
+init_sqlite();
+function listEnSlugs3(rootDir, contentDir) {
+  const dir = path4.join(rootDir, contentDir);
+  if (!fs2.existsSync(dir)) return [];
+  return fs2.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);
+}
+
+// src/translate/page-translator.ts
+init_esm_shims();
+init_sqlite();
+
+// src/translate/gemini-client.ts
+init_esm_shims();
+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 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
+init_esm_shims();
+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
+init_esm_shims();
+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;
+}
+
+// src/config/load-env.ts
+init_esm_shims();
+var ENV_FILES = [".env", ".env.local"];
+function loadEnvFromCwd(cwd) {
+  for (const file of ENV_FILES) {
+    const envPath = path4.join(
+      /* turbopackIgnore: true */
+      cwd,
+      file
+    );
+    if (!fs2.existsSync(envPath)) continue;
+    dotenv.config({ path: envPath, override: false });
+  }
+}
+
+// studio/server.ts
+init_esm_shims();
+init_sqlite();
+function renderLayout(title, body) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${title} \u2014 Scribe Studio</title>
+  <style>
+    body { font-family: ui-sans-serif, system-ui, sans-serif; margin: 0; background: #0b0d10; color: #e8eaed; }
+    header { padding: 16px 24px; border-bottom: 1px solid #222; display: flex; gap: 16px; }
+    header a { color: #9ecbff; text-decoration: none; }
+    main { padding: 24px; }
+    table { border-collapse: collapse; width: 100%; }
+    th, td { border: 1px solid #333; padding: 8px 10px; text-align: left; vertical-align: top; }
+    th { background: #151922; }
+    .muted { color: #9aa0a6; }
+    .stale { color: #ffb4a2; }
+    .ok { color: #8ce99a; }
+    .card { background: #151922; border: 1px solid #333; border-radius: 8px; padding: 16px; margin-bottom: 16px; }
+  </style>
+</head>
+<body>
+  <header>
+    <strong>Scribe Studio</strong>
+    <a href="/">Browser</a>
+    <a href="/staleness">Staleness</a>
+    <a href="/history">History</a>
+  </header>
+  <main>${body}</main>
+</body>
+</html>`;
+}
+async function startStudio(project, options = {}) {
+  const app = new Hono();
+  const config = project.config;
+  app.get("/", (c) => {
+    const cards = project.listTypes().map((type) => {
+      const localeRows = config.locales.map((locale) => {
+        const count = type.load().get(locale)?.bySlug.size ?? 0;
+        return `<li>${locale}: ${count}</li>`;
+      }).join("");
+      return `<div class="card"><h2>${type.config.label}</h2><ul>${localeRows}</ul></div>`;
+    });
+    return c.html(renderLayout("Browser", cards.join("")));
+  });
+  app.get("/staleness", (c) => {
+    const worklist = buildWorklist(config);
+    const rows = worklist.slice(0, 500).map(
+      (item) => `<tr><td>${item.contentType}</td><td>${item.enSlug}</td><td>${item.locale}</td><td class="stale">${item.reason}</td></tr>`
+    ).join("");
+    const html = `<h1>Translation staleness</h1><p class="muted">${worklist.length} stale/missing entries (showing up to 500)</p>
+      <table><thead><tr><th>Type</th><th>EN slug</th><th>Locale</th><th>Status</th></tr></thead><tbody>${rows}</tbody></table>`;
+    return c.html(renderLayout("Staleness", html));
+  });
+  app.get("/history", (c) => {
+    const typeId = c.req.query("type") ?? project.listTypes()[0]?.id;
+    const enSlug = c.req.query("slug");
+    if (!typeId) return c.html(renderLayout("History", "<p>No content types.</p>"));
+    const db = openStore(config, "readonly");
+    let body = `<h1>History</h1><form><label>Type <select name="type">${project.listTypes().map((t) => `<option value="${t.id}" ${t.id === typeId ? "selected" : ""}>${t.id}</option>`).join("")}</select></label> <label>EN slug <input name="slug" value="${enSlug ?? ""}" /></label> <button>View</button></form>`;
+    if (enSlug) {
+      const rows = listRevisions(db, typeId, enSlug).slice(0, 100).map(
+        (row) => `<tr><td>${row.created_at}</td><td>${row.revision_kind}</td><td>${row.locale ?? "en"}</td><td>${row.en_hash.slice(0, 8)}</td><td class="muted">${row.body_preview ?? ""}</td></tr>`
+      ).join("");
+      body += `<table><thead><tr><th>When</th><th>Kind</th><th>Locale</th><th>EN hash</th><th>Preview</th></tr></thead><tbody>${rows}</tbody></table>`;
+    } else {
+      const translations = listTranslationsForType(db, typeId).slice(0, 100);
+      body += `<ul>${translations.map((row) => `<li><a href="/history?type=${typeId}&slug=${row.en_slug}">${row.en_slug}</a> (${row.locale})</li>`).join("")}</ul>`;
+    }
+    db.close();
+    return c.html(renderLayout("History", body));
+  });
+  app.get("/api/staleness-matrix", (c) => {
+    const matrix = {};
+    for (const type of project.listTypes()) {
+      matrix[type.id] = {};
+      for (const locale of config.locales) {
+        if (locale === config.defaultLocale) continue;
+        const enSlugs = type.list().map((doc) => doc.slug);
+        let stale = 0;
+        for (const enSlug of enSlugs) {
+          const enDoc = readEnDocument(config, type.config, enSlug);
+          if (!enDoc) continue;
+          const payload = getTranslatablePayload(enDoc, type.config);
+          const hash = computePageEnHash(payload.frontmatter, payload.body);
+          const db = openStore(config, "readonly");
+          const row = db.prepare(
+            `SELECT en_hash FROM translations WHERE content_type = ? AND en_slug = ? AND locale = ?`
+          ).get(type.id, enSlug, locale);
+          db.close();
+          if (!row || row.en_hash !== hash) stale++;
+        }
+        matrix[type.id][locale] = stale;
+      }
+    }
+    return c.json(matrix);
+  });
+  const port = options.port ?? 3600;
+  const host = options.host ?? "127.0.0.1";
+  serve({ fetch: app.fetch, port, hostname: host }, () => {
+    console.log(`Scribe studio listening on http://${host}:${port}`);
+  });
+}
+
+// cli/index.ts
+function parseArgs(argv) {
+  const options = { cwd: process.cwd() };
+  const positional = [];
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--config") {
+      options.config = argv[++i];
+      i++;
+      continue;
+    }
+    if (arg === "--locale") {
+      const locales = [];
+      while (argv[i + 1] && !argv[i + 1].startsWith("--")) {
+        locales.push(argv[++i]);
+      }
+      options.locale = locales;
+      i++;
+      continue;
+    }
+    if (arg === "--preset") {
+      options.preset = argv[++i];
+      i++;
+      continue;
+    }
+    if (arg === "--type") {
+      options.type = argv[++i];
+      i++;
+      continue;
+    }
+    if (arg === "--slug") {
+      options.slug = argv[++i];
+      i++;
+      continue;
+    }
+    if (arg === "--model") {
+      options.model = argv[++i];
+      i++;
+      continue;
+    }
+    if (arg === "--port") {
+      options.port = Number(argv[++i]);
+      i++;
+      continue;
+    }
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+      i++;
+      continue;
+    }
+    if (arg === "--force") {
+      options.force = true;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      throw new Error(`Unknown flag: ${arg}`);
+    }
+    positional.push(arg);
+    i++;
+  }
+  const [command = "help", ...rest] = positional;
+  return { command, options, rest };
+}
+function loadProject(options) {
+  const config = loadConfigSync({
+    cwd: options.cwd,
+    configPath: options.config
+  });
+  return createProject(config);
+}
+async function main() {
+  const { command, options, rest } = parseArgs(process.argv.slice(2));
+  loadEnvFromCwd(options.cwd);
+  if (command === "help" || command === "--help") {
+    console.log(`Usage: scribe <command>
+
+Commands:
+  status                 Show EN docs + translation counts
+  validate               Validate EN files and sqlite consistency
+  translate              Translate stale/missing locale pages
+  history <type> <slug>  Show revision timeline
+  studio                 Start read-only local studio
+`);
+    return;
+  }
+  const project = loadProject(options);
+  const config = project.config;
+  switch (command) {
+    case "status": {
+      for (const type of project.listTypes()) {
+        const enCount = type.list().length;
+        console.log(`${type.id}: ${enCount} EN docs`);
+        for (const locale of config.locales) {
+          if (locale === config.defaultLocale) continue;
+          const count = type.load().get(locale)?.bySlug.size ?? 0;
+          console.log(`  ${locale}: ${count}`);
+        }
+      }
+      console.log(`store: ${project.storePath}`);
+      break;
+    }
+    case "validate": {
+      const result = validateProject(config);
+      for (const issue of result.issues) {
+        console.log(
+          `[${issue.level}] ${issue.contentType ?? ""} ${issue.enSlug ?? ""} ${issue.locale ?? ""} ${issue.message}`
+        );
+      }
+      if (!result.ok) process.exitCode = 1;
+      break;
+    }
+    case "translate": {
+      const locales = resolveLocalesFromPreset(config, options.preset, options.locale);
+      const worklist = buildWorklist(config, {
+        contentType: options.type,
+        locales,
+        enSlug: options.slug
+      });
+      console.log(`Translating ${worklist.length} page(s)...`);
+      const results = await translateWorklist(config, worklist, {
+        model: options.model,
+        dryRun: options.dryRun,
+        force: options.force
+      });
+      for (const result of results) {
+        console.log(
+          `${result.contentType}/${result.enSlug}@${result.locale}: ${result.skipped ? "skipped" : "translated"}${result.model ? ` (${result.model})` : ""}`
+        );
+      }
+      break;
+    }
+    case "history": {
+      const [typeId, enSlug, locale] = rest;
+      if (!typeId || !enSlug) {
+        throw new Error("Usage: scribe history <type> <en-slug> [locale]");
+      }
+      const { openStore: openStore2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
+      const db = openStore2(config, "readonly");
+      const rows = listRevisions(db, typeId, enSlug, locale);
+      db.close();
+      for (const row of rows) {
+        console.log(
+          `${row.created_at} ${row.revision_kind} locale=${row.locale ?? "en"} en_hash=${row.en_hash.slice(0, 8)} body_hash=${row.body_hash.slice(0, 8)}`
+        );
+      }
+      break;
+    }
+    case "studio": {
+      await startStudio(project, { port: options.port ?? 3600 });
+      break;
+    }
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map