scribe-cms 0.0.1

package/dist/studio/server.cjs

@@ -0,0 +1,673 @@
+'use strict';
+
+var nodeServer = require('@hono/node-server');
+var hono = require('hono');
+var crypto = require('crypto');
+var fs2 = require('fs');
+var path2 = require('path');
+var matter = require('gray-matter');
+var zod = require('zod');
+var Database = require('better-sqlite3');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var matter__default = /*#__PURE__*/_interopDefault(matter);
+var Database__default = /*#__PURE__*/_interopDefault(Database);
+
+// studio/server.ts
+function sha256(input) {
+  return crypto.createHash("sha256").update(input, "utf8").digest("hex");
+}
+function computePageEnHash(translatableFrontmatter, body) {
+  const payload = JSON.stringify({ frontmatter: translatableFrontmatter, body });
+  return sha256(payload);
+}
+
+// src/i18n/build-url.ts
+var SLUG_PLACEHOLDER = "{slug}";
+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/core/builtin-fields.ts
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var slugPatternSchema = zod.z.string().regex(SLUG_PATTERN, "slug must be lowercase-kebab-case");
+var isoDateSchema = zod.z.string().regex(/^\d{4}-\d{2}-\d{2}(T[\d:.Z+-]*)?$/, "Use ISO date YYYY-MM-DD or full ISO 8601");
+var canonicalPathSchema = zod.z.string().regex(/^\//, "canonicalPath must start with /");
+function extractBuiltinEnFields(data, pathTemplate, enSlug, defaultLocale) {
+  const issues = [];
+  const rest = { ...data };
+  const aliasesResult = zod.z.array(slugPatternSchema).max(20).optional().default([]).safeParse(rest.aliases ?? []);
+  delete rest.aliases;
+  const redirectRaw = rest.redirect_to;
+  delete rest.redirect_to;
+  let redirectTo;
+  if (redirectRaw !== void 0 && redirectRaw !== null && redirectRaw !== "") {
+    if (typeof redirectRaw !== "string") {
+      issues.push({
+        field: "redirect_to",
+        message: "redirect_to must be a string path",
+        level: "error"
+      });
+    } else if (!pathTemplate) {
+      issues.push({
+        field: "redirect_to",
+        message: "redirect_to is not allowed on reference-only content types",
+        level: "error"
+      });
+    } else if (!extractSlugFromResolvedPath(pathTemplate, redirectRaw)) {
+      issues.push({
+        field: "redirect_to",
+        message: `redirect_to must match path template "${pathTemplate}" (prefix "${pathPrefix(pathTemplate)}"${pathSuffix(pathTemplate) ? `, suffix "${pathSuffix(pathTemplate)}"` : ""})`,
+        level: "error"
+      });
+    } else {
+      redirectTo = redirectRaw;
+    }
+  }
+  const aliases = aliasesResult.success ? aliasesResult.data : [];
+  if (!aliasesResult.success) {
+    for (const issue of aliasesResult.error.issues) {
+      issues.push({
+        field: `aliases.${issue.path.join(".")}`,
+        message: issue.message,
+        level: "error"
+      });
+    }
+  }
+  let publishedAt;
+  if (rest.publishedAt !== void 0 && rest.publishedAt !== null && rest.publishedAt !== "") {
+    const parsed = isoDateSchema.safeParse(rest.publishedAt);
+    if (parsed.success) {
+      publishedAt = parsed.data;
+    } else {
+      for (const issue of parsed.error.issues) {
+        issues.push({ field: "publishedAt", message: issue.message, level: "error" });
+      }
+    }
+    delete rest.publishedAt;
+  }
+  let updatedAt;
+  if (rest.updatedAt !== void 0 && rest.updatedAt !== null && rest.updatedAt !== "") {
+    const parsed = isoDateSchema.safeParse(rest.updatedAt);
+    if (parsed.success) {
+      updatedAt = parsed.data;
+    } else {
+      for (const issue of parsed.error.issues) {
+        issues.push({ field: "updatedAt", message: issue.message, level: "error" });
+      }
+    }
+    delete rest.updatedAt;
+  } else if (publishedAt) {
+    updatedAt = publishedAt;
+  }
+  let noindex = false;
+  if (rest.noindex !== void 0 && rest.noindex !== null && rest.noindex !== "") {
+    if (typeof rest.noindex === "boolean") {
+      noindex = rest.noindex;
+    } else {
+      issues.push({ field: "noindex", message: "noindex must be a boolean", level: "error" });
+    }
+    delete rest.noindex;
+  }
+  let canonicalPathOverride;
+  if (rest.canonicalPath !== void 0 && rest.canonicalPath !== null && rest.canonicalPath !== "") {
+    const parsed = canonicalPathSchema.safeParse(rest.canonicalPath);
+    if (parsed.success) {
+      canonicalPathOverride = parsed.data;
+    } else {
+      for (const issue of parsed.error.issues) {
+        issues.push({ field: "canonicalPath", message: issue.message, level: "error" });
+      }
+    }
+    delete rest.canonicalPath;
+  }
+  for (const internalKey of ["translationOf", "enSlug"]) {
+    if (rest[internalKey] !== void 0) {
+      issues.push({
+        field: internalKey,
+        message: `${internalKey} is managed internally by Scribe; remove from frontmatter`,
+        level: "warning"
+      });
+      delete rest[internalKey];
+    }
+  }
+  return {
+    builtin: {
+      aliases,
+      redirectTo,
+      publishedAt,
+      updatedAt,
+      noindex,
+      canonicalPathOverride
+    },
+    rest,
+    issues
+  };
+}
+function 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;
+}
+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 path4 of paths) {
+    const value = getAtPath(data, path4);
+    if (value !== void 0) {
+      setAtPath(out, path4.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 getAtPath(obj, path4) {
+  let current = obj;
+  for (const segment of path4) {
+    if (segment === "*") {
+      if (!Array.isArray(current)) return void 0;
+      return current.map(
+        (item) => typeof item === "object" && item !== null ? getAtPath(item, path4.slice(path4.indexOf("*") + 1)) : void 0
+      );
+    }
+    if (typeof current !== "object" || current === null || Array.isArray(current)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function setAtPath(obj, path4, value) {
+  if (path4.length === 0) return;
+  if (path4.length === 1) {
+    obj[path4[0]] = value;
+    return;
+  }
+  const [head, ...rest] = path4;
+  if (!(head in obj) || typeof obj[head] !== "object" || obj[head] === null) {
+    obj[head] = {};
+  }
+  setAtPath(obj[head], rest, value);
+}
+var SCHEMA_VERSION = 2;
+var MIGRATIONS = [
+  `CREATE TABLE IF NOT EXISTS meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS translations (
+    content_type TEXT NOT NULL,
+    en_slug TEXT NOT NULL,
+    locale TEXT NOT NULL,
+    slug TEXT NOT NULL,
+    frontmatter_json TEXT NOT NULL,
+    body TEXT NOT NULL,
+    en_hash TEXT NOT NULL,
+    translated_at TEXT NOT NULL,
+    model TEXT NOT NULL,
+    PRIMARY KEY (content_type, en_slug, locale)
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_translations_type_locale
+    ON translations(content_type, locale)`,
+  `CREATE TABLE IF NOT EXISTS revisions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    content_type TEXT NOT NULL,
+    en_slug TEXT NOT NULL,
+    locale TEXT,
+    revision_kind TEXT NOT NULL,
+    en_hash TEXT NOT NULL,
+    body_hash TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    model TEXT,
+    body_preview TEXT
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_revisions_lookup
+    ON revisions(content_type, en_slug, locale, created_at DESC)`,
+  `CREATE TABLE IF NOT EXISTS slug_aliases (
+    content_type TEXT NOT NULL,
+    canonical_en_slug TEXT NOT NULL,
+    alias_en_slug TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (content_type, alias_en_slug)
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_slug_aliases_canonical
+    ON slug_aliases(content_type, canonical_en_slug)`,
+  `CREATE TABLE IF NOT EXISTS alias_locale_slugs (
+    content_type TEXT NOT NULL,
+    alias_en_slug TEXT NOT NULL,
+    locale TEXT NOT NULL,
+    locale_slug TEXT NOT NULL,
+    captured_at TEXT NOT NULL,
+    PRIMARY KEY (content_type, alias_en_slug, locale)
+  )`
+];
+function resolveStorePath(config) {
+  return config.storePath;
+}
+function openStore(config, mode = "readwrite") {
+  const storePath = resolveStorePath(config);
+  fs2__default.default.mkdirSync(path2__default.default.dirname(storePath), { recursive: true });
+  const db = new Database__default.default(storePath, { readonly: mode === "readonly" });
+  if (mode === "readwrite") {
+    migrate(db);
+  }
+  return db;
+}
+function migrate(db) {
+  for (const sql of MIGRATIONS) {
+    db.exec(sql);
+  }
+  db.prepare(
+    `INSERT INTO meta(key, value) VALUES('schema_version', ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(String(SCHEMA_VERSION));
+}
+
+// src/storage/translations.ts
+function 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 listRevisions(db, 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
+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 slugFromPath(filePath) {
+  return path2__default.default.basename(filePath).replace(/\.(md|mdx)$/, "");
+}
+function parseEnMdx(filePath, config, type) {
+  const raw = fs2__default.default.readFileSync(filePath, "utf8");
+  const parsed = matter__default.default(raw);
+  const slug = slugFromPath(filePath);
+  const normalized = normalizeEnFrontmatter(parsed.data);
+  const { builtin, rest, issues: builtinIssues } = extractBuiltinEnFields(
+    normalized,
+    type.path,
+    slug,
+    config.defaultLocale
+  );
+  const issues = builtinIssues.map((issue) => ({
+    field: issue.field,
+    message: issue.message,
+    level: issue.level
+  }));
+  const result = type.schema.safeParse(rest);
+  if (!result.success) {
+    return {
+      document: null,
+      issues: [
+        ...issues,
+        ...result.error.issues.map((issue) => ({
+          field: issue.path.join("."),
+          message: issue.message,
+          level: "error"
+        }))
+      ]
+    };
+  }
+  if (issues.some((i) => i.level === "error")) {
+    return { document: null, issues };
+  }
+  const frontmatter = mergeBuiltinsIntoFrontmatter(
+    result.data,
+    {
+      publishedAt: builtin.publishedAt,
+      updatedAt: builtin.updatedAt,
+      noindex: builtin.noindex,
+      canonicalPathOverride: builtin.canonicalPathOverride,
+      slug,
+      locale: config.defaultLocale
+    },
+    type,
+    config.defaultLocale
+  );
+  const crossIssues = type.crossValidate?.(result.data, {
+    locale: config.defaultLocale,
+    defaultLocale: config.defaultLocale,
+    slug,
+    enSlug: slug,
+    knownLocales: config.locales
+  }) ?? [];
+  issues.push(...crossIssues);
+  const 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 readEnDocument(config, type, enSlug) {
+  const contentDir = path2__default.default.join(
+    /* turbopackIgnore: true */
+    config.rootDir,
+    type.contentDir
+  );
+  for (const ext of [".mdx", ".md"]) {
+    const filePath = path2__default.default.join(contentDir, `${enSlug}${ext}`);
+    if (!fs2__default.default.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
+  };
+}
+function listEnSlugs(rootDir, contentDir) {
+  const dir = path2__default.default.join(rootDir, contentDir);
+  if (!fs2__default.default.existsSync(dir)) return [];
+  return fs2__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
+}
+function buildWorklist(config, options = {}) {
+  const db = openStore(config, "readonly");
+  const items = [];
+  const locales = options.locales ?? config.locales.filter((locale) => locale !== config.defaultLocale);
+  for (const type of config.types) {
+    if (options.contentType && type.id !== options.contentType) continue;
+    const enSlugs = options.enSlug ? [options.enSlug] : listEnSlugs(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;
+}
+
+// studio/server.ts
+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.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";
+  nodeServer.serve({ fetch: app.fetch, port, hostname: host }, () => {
+    console.log(`Scribe studio listening on http://${host}:${port}`);
+  });
+}
+
+exports.startStudio = startStudio;
+//# sourceMappingURL=server.cjs.map
+//# sourceMappingURL=server.cjs.map