scribe-cms 0.0.2 → 0.0.4

package/dist/cli/index.cjs

@@ -12,6 +12,7 @@ var genai = require('@google/genai');
 var dotenv = require('dotenv');
 var nodeServer = require('@hono/node-server');
 var hono = require('hono');
+var prompts = require('@inquirer/prompts');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -23,6 +24,7 @@ var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -30,6 +32,7 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // ../../node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl, importMetaUrl;
@@ -52,17 +55,27 @@ function resolveStorePath(config) {
 }
 function openStore(config, mode = "readwrite") {
   const storePath = resolveStorePath(config);
-  fs2__default.default.mkdirSync(path3__default.default.dirname(storePath), { recursive: true });
+  if (mode === "readwrite") {
+    fs2__default.default.mkdirSync(path3__default.default.dirname(storePath), { recursive: true });
+  }
   const db = new Database__default.default(storePath, { readonly: mode === "readonly" });
   if (mode === "readwrite") {
     migrate(db);
   }
   return db;
 }
+function addColumnIfMissing(db, table, column, ddlType) {
+  const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (!columns.some((c) => c.name === column)) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddlType}`);
+  }
+}
 function migrate(db) {
   for (const sql of MIGRATIONS) {
     db.exec(sql);
   }
+  addColumnIfMissing(db, "revisions", "frontmatter_json", "TEXT");
+  addColumnIfMissing(db, "revisions", "body", "TEXT");
   db.prepare(
     `INSERT INTO meta(key, value) VALUES('schema_version', ?)
      ON CONFLICT(key) DO UPDATE SET value = excluded.value`
@@ -75,7 +88,7 @@ var SCHEMA_VERSION, MIGRATIONS;
 var init_sqlite = __esm({
   "src/storage/sqlite.ts"() {
     init_cjs_shims();
-    SCHEMA_VERSION = 2;
+    SCHEMA_VERSION = 3;
     MIGRATIONS = [
       `CREATE TABLE IF NOT EXISTS meta (
     key TEXT PRIMARY KEY,
@@ -187,6 +200,22 @@ function unwrapSchema(schema) {
   }
   return current;
 }
+function peelOptionalWrappers(schema) {
+  let current = schema;
+  for (let i = 0; i < 8; i++) {
+    const type = current._def?.type;
+    if (type === "optional" || type === "nullable") {
+      current = current.unwrap();
+      continue;
+    }
+    if (type === "default") {
+      current = current.removeDefault();
+      continue;
+    }
+    break;
+  }
+  return current;
+}
 
 // src/core/types.ts
 init_cjs_shims();
@@ -203,14 +232,14 @@ var SLUG_PLACEHOLDER = "{slug}";
 function isRoutableType(type) {
   return typeof type.path === "string" && type.path.length > 0;
 }
-function assertValidPathTemplate(path10, typeId) {
-  if (!path10.startsWith("/")) {
-    throw new Error(`Content type "${typeId}": path must start with / (got "${path10}")`);
+function assertValidPathTemplate(path11, typeId) {
+  if (!path11.startsWith("/")) {
+    throw new Error(`Content type "${typeId}": path must start with / (got "${path11}")`);
   }
-  const count = (path10.match(/\{slug\}/g) ?? []).length;
+  const count = (path11.match(/\{slug\}/g) ?? []).length;
   if (count !== 1) {
     throw new Error(
-      `Content type "${typeId}": path must contain exactly one {slug} (got "${path10}")`
+      `Content type "${typeId}": path must contain exactly one {slug} (got "${path11}")`
     );
   }
 }
@@ -338,10 +367,10 @@ function introspectSchema(schema, prefix = []) {
 }
 function extractByPaths(data, paths) {
   const out = {};
-  for (const path10 of paths) {
-    const value = getAtPath(data, path10);
+  for (const path11 of paths) {
+    const value = getAtPath(data, path11);
     if (value !== void 0) {
-      setAtPath(out, path10.filter((p) => p !== "*"), value);
+      setAtPath(out, path11.filter((p) => p !== "*"), value);
     }
   }
   return out;
@@ -359,13 +388,13 @@ function mergeStructuralOntoLocale(localeData, enData, schema) {
   const translatable = pickTranslatable(localeData, schema);
   return deepMerge(structural, translatable);
 }
-function getAtPath(obj, path10) {
+function getAtPath(obj, path11) {
   let current = obj;
-  for (const segment of path10) {
+  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, path10.slice(path10.indexOf("*") + 1)) : void 0
+        (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;
@@ -373,13 +402,13 @@ function getAtPath(obj, path10) {
   }
   return current;
 }
-function setAtPath(obj, path10, value) {
-  if (path10.length === 0) return;
-  if (path10.length === 1) {
-    obj[path10[0]] = value;
+function setAtPath(obj, path11, value) {
+  if (path11.length === 0) return;
+  if (path11.length === 1) {
+    obj[path11[0]] = value;
     return;
   }
-  const [head, ...rest] = path10;
+  const [head, ...rest] = path11;
   if (!(head in obj) || typeof obj[head] !== "object" || obj[head] === null) {
     obj[head] = {};
   }
@@ -618,14 +647,18 @@ function listTranslationsForEnSlug(db, contentType, enSlug) {
     `SELECT * FROM translations WHERE content_type = ? AND en_slug = ? ORDER BY locale`
   ).all(contentType, enSlug);
 }
+function listTranslationsForLocale(db, contentType, locale) {
+  return db.prepare(`SELECT * FROM translations WHERE content_type = ? AND locale = ? ORDER BY en_slug`).all(contentType, locale);
+}
 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 (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        content_type, en_slug, locale, revision_kind, en_hash, body_hash, created_at,
+        model, body_preview, frontmatter_json, body
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   ).run(
     input.contentType,
     input.enSlug,
@@ -635,7 +668,9 @@ function appendRevision(db, input) {
     input.bodyHash,
     input.createdAt,
     input.model ?? null,
-    input.bodyPreview ?? null
+    input.bodyPreview ?? null,
+    input.frontmatterJson ?? null,
+    input.body ?? null
   );
   return Number(result.lastInsertRowid);
 }
@@ -1473,7 +1508,9 @@ function recordRevision(config, input) {
     bodyHash: computeBodyHash(input.body),
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     model: input.model,
-    bodyPreview: input.body.slice(0, 200)
+    bodyPreview: input.body.slice(0, 200),
+    frontmatterJson: input.frontmatter ? JSON.stringify(input.frontmatter) : null,
+    body: input.body
   });
   db.close();
   return id;
@@ -1664,7 +1701,8 @@ function validateProject(config) {
             locale,
             revisionKind: "en_edit_detected",
             enHash: currentEnHash,
-            body: row.body
+            body: row.body,
+            frontmatter: JSON.parse(row.frontmatter_json)
           });
         }
         const localeFm = JSON.parse(row.frontmatter_json);
@@ -1793,6 +1831,10 @@ function buildWorklist(config, options = {}) {
     }
   }
   db.close();
+  const strategy = options.strategy ?? "all";
+  if (strategy === "missing-only") {
+    return items.filter((item) => item.reason === "missing");
+  }
   return items;
 }
 function resolveLocalesFromPreset(config, preset, explicitLocales) {
@@ -1809,7 +1851,31 @@ init_sqlite();
 
 // src/translate/gemini-client.ts
 init_cjs_shims();
-var DEFAULT_MODEL = "gemini-2.5-pro";
+
+// src/translate/gemini-models.ts
+init_cjs_shims();
+var GEMINI_MODEL_IDS = {
+  "gemini-2.5-pro": "gemini-2.5-pro",
+  "gemini-3.1-pro": "gemini-3.1-pro-preview"
+};
+var DEFAULT_GEMINI_MODEL = "gemini-3.1-pro";
+function stripModelsPrefix(model) {
+  return model.replace(/^models\//, "");
+}
+function resolveGeminiModelId(model) {
+  const name = stripModelsPrefix(model);
+  return GEMINI_MODEL_IDS[name] ?? name;
+}
+function normalizeGeminiDisplayName(model) {
+  const name = stripModelsPrefix(model);
+  if (name in GEMINI_MODEL_IDS) return name;
+  const alias = Object.entries(GEMINI_MODEL_IDS).find(([, apiId]) => apiId === name);
+  if (alias) return alias[0];
+  return name;
+}
+
+// src/translate/gemini-client.ts
+var DEFAULT_MODEL = DEFAULT_GEMINI_MODEL;
 function extractJson(text) {
   const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
   if (fenced?.[1]) return fenced[1].trim();
@@ -1823,13 +1889,17 @@ async function translatePageWithGemini(input) {
   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 displayModel = normalizeGeminiDisplayName(
+    input.model ?? process.env.PROSE_GEMINI_MODEL ?? DEFAULT_MODEL
+  );
+  const apiModel = resolveGeminiModelId(displayModel);
   const ai = new genai.GoogleGenAI({ apiKey });
   const response = await ai.models.generateContent({
-    model,
+    model: apiModel,
     contents: input.prompt,
     config: {
-      responseMimeType: "application/json"
+      responseMimeType: "application/json",
+      ...input.responseSchema ? { responseSchema: input.responseSchema } : {}
     }
   });
   const raw = response.text ?? "";
@@ -1837,7 +1907,50 @@ async function translatePageWithGemini(input) {
   if (!parsed.frontmatter || typeof parsed.body !== "string") {
     throw new Error("Gemini response missing frontmatter/body");
   }
-  return { model, raw, parsed };
+  const usageMetadata = response.usageMetadata;
+  const usage = {
+    inputTokens: usageMetadata?.promptTokenCount ?? 0,
+    outputTokens: usageMetadata?.candidatesTokenCount ?? 0,
+    totalTokens: usageMetadata?.totalTokenCount ?? 0
+  };
+  return { model: displayModel, raw, parsed, usage };
+}
+
+// src/translate/gemini-pricing.ts
+init_cjs_shims();
+var CONTEXT_TIER_TOKENS = 2e5;
+var GEMINI_PRICING_USD = {
+  "gemini-3.1-pro": { input: [2, 4], output: [12, 18] }
+};
+function normalizeModelId(model) {
+  return model.replace(/^models\//, "").toLowerCase();
+}
+function tierRate(tokens, tiers) {
+  return tokens <= CONTEXT_TIER_TOKENS ? tiers[0] : tiers[1];
+}
+function resolveModelPricing(model) {
+  const id = normalizeModelId(model);
+  if (GEMINI_PRICING_USD[id]) return GEMINI_PRICING_USD[id];
+  const match = Object.entries(GEMINI_PRICING_USD).find(([key]) => id.includes(key));
+  return match?.[1];
+}
+function estimateTranslationCostUsd(model, inputTokens, outputTokens) {
+  const pricing = resolveModelPricing(model);
+  if (!pricing) return void 0;
+  const inputRate = tierRate(inputTokens, pricing.input);
+  const outputRate = tierRate(outputTokens, pricing.output);
+  return inputTokens / 1e6 * inputRate + outputTokens / 1e6 * outputRate;
+}
+function formatTokenCount(tokens) {
+  if (tokens >= 1e6) return `${(tokens / 1e6).toFixed(2)}M`;
+  if (tokens >= 1e3) return `${(tokens / 1e3).toFixed(1)}k`;
+  return String(tokens);
+}
+function formatUsd(amount) {
+  if (amount === void 0) return "n/a";
+  if (amount >= 1) return `$${amount.toFixed(2)}`;
+  if (amount >= 0.01) return `$${amount.toFixed(3)}`;
+  return `$${amount.toFixed(4)}`;
 }
 
 // src/translate/prompts/translation-prompt.ts
@@ -1874,6 +1987,7 @@ function buildPageTranslationPrompt(input) {
     prompt,
     "",
     ...input.resolved.context ? ["## Context", input.resolved.context, ""] : [],
+    ...input.contextLabel ? [`Document: ${input.contextLabel}`, ""] : [],
     "## Rules",
     ...input.resolved.rules.map((rule) => `- ${rule}`),
     "",
@@ -1881,10 +1995,6 @@ function buildPageTranslationPrompt(input) {
     "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),
     "",
@@ -1894,6 +2004,74 @@ function buildPageTranslationPrompt(input) {
   return lines.join("\n");
 }
 
+// src/translate/response-schema.ts
+init_cjs_shims();
+function getObjectShape(schema) {
+  const base = peelOptionalWrappers(schema);
+  if (base instanceof Object && "shape" in base) {
+    return base.shape;
+  }
+  return null;
+}
+function getArraySchema(schema) {
+  const base = peelOptionalWrappers(schema);
+  if (base instanceof Object && "element" in base && base._def?.type === "array") {
+    return base;
+  }
+  return null;
+}
+function extractTranslatableFromStructural(schema) {
+  const arraySchema = getArraySchema(schema);
+  if (arraySchema) {
+    const inner = buildTranslatableSubschema(arraySchema.element);
+    if (inner) return zod.z.array(inner);
+    return null;
+  }
+  if (getObjectShape(schema)) {
+    return buildTranslatableSubschema(schema);
+  }
+  return null;
+}
+function buildTranslatableSubschema(schema) {
+  const shape = getObjectShape(schema);
+  if (!shape) return null;
+  const out = {};
+  for (const [key, child] of Object.entries(shape)) {
+    const childSchema = child;
+    const kind = getFieldKind(childSchema);
+    if (kind === "translatable") {
+      out[key] = peelOptionalWrappers(childSchema);
+    } else if (kind === "structural") {
+      const nested = extractTranslatableFromStructural(childSchema);
+      if (nested) out[key] = nested;
+    }
+  }
+  if (Object.keys(out).length === 0) return null;
+  return zod.z.object(out);
+}
+function buildGeminiResponseSchema(schema, slugStrategy) {
+  try {
+    const translatable = buildTranslatableSubschema(schema);
+    if (!translatable) return null;
+    const responseShape = {
+      frontmatter: translatable,
+      body: zod.z.string()
+    };
+    if (slugStrategy === "localized") {
+      responseShape.slug = zod.z.string();
+    }
+    const jsonSchema = zod.z.toJSONSchema(zod.z.object(responseShape), {
+      target: "draft-2020-12",
+      unrepresentable: "any",
+      io: "output"
+    });
+    delete jsonSchema.$schema;
+    return jsonSchema;
+  } catch {
+    return null;
+  }
+}
+
 // src/translate/resolve-translate-config.ts
 init_cjs_shims();
 function slugStrategyRules(slugStrategy, preserveTerms) {
@@ -1934,86 +2112,313 @@ function resolveTranslateConfig(config, type) {
   return mergeTranslateConfig(config.translate, type.translate, type.slugStrategy);
 }
 
+// src/translate/validate-translation.ts
+init_cjs_shims();
+function formatZodIssues(error) {
+  return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+}
+function sanitizeTranslatedFrontmatter(rawFrontmatter, schema) {
+  return pickTranslatable(rawFrontmatter, schema);
+}
+function validateTranslatedFrontmatter(enDoc, localeFrontmatter, typeSchema) {
+  const frontmatter = sanitizeTranslatedFrontmatter(localeFrontmatter, typeSchema);
+  const merged = mergeStructuralOntoLocale(
+    frontmatter,
+    enDoc.frontmatter,
+    typeSchema
+  );
+  const parsed = typeSchema.safeParse(merged);
+  if (!parsed.success) {
+    return { ok: false, error: formatZodIssues(parsed.error) };
+  }
+  return { ok: true, frontmatter };
+}
+
 // src/translate/page-translator.ts
+function summarizeResults(results, durationMs) {
+  return results.reduce(
+    (totals, result) => {
+      if (result.failed) totals.failed += 1;
+      else if (result.skipped) totals.skipped += 1;
+      else totals.translated += 1;
+      totals.inputTokens += result.usage?.inputTokens ?? 0;
+      totals.outputTokens += result.usage?.outputTokens ?? 0;
+      totals.estimatedCostUsd += result.estimatedCostUsd ?? 0;
+      return totals;
+    },
+    {
+      translated: 0,
+      skipped: 0,
+      failed: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCostUsd: 0,
+      durationMs
+    }
+  );
+}
+function formatTranslateError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  try {
+    const parsed = JSON.parse(message);
+    if (parsed.error?.message) return parsed.error.message;
+  } catch {
+  }
+  const embedded = message.match(/"message"\s*:\s*"((?:\\.|[^"\\])*)"/);
+  if (embedded?.[1]) {
+    return embedded[1].replace(/\\"/g, '"').replace(/\\n/g, "\n");
+  }
+  return message.length > 160 ? `${message.slice(0, 157)}\u2026` : message;
+}
+async function runPool(items, concurrency, worker) {
+  if (items.length === 0) return;
+  let nextIndex = 0;
+  const runners = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      await worker(items[index], index);
+    }
+  });
+  await Promise.all(runners);
+}
+function resolveContextLabel(enDoc, enSlug) {
+  const fm = enDoc.frontmatter;
+  for (const key of ["title", "name", "h1"]) {
+    const value = fm[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return enSlug;
+}
 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,
+  const startedAt = Date.now();
+  const base = {
+    contentType: item.contentType,
+    enSlug: item.enSlug,
+    locale: item.locale
+  };
+  try {
+    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 {
+        ...base,
+        skipped: true,
+        reason: "fresh",
+        durationMs: Date.now() - startedAt
+      };
+    }
+    const resolvedTranslate = resolveTranslateConfig(config, type);
+    const model = options.model ?? resolvedTranslate.model;
+    const prompt = buildPageTranslationPrompt({
+      resolved: resolvedTranslate,
+      targetLocale: item.locale,
+      contextLabel: resolveContextLabel(enDoc, item.enSlug),
+      translatableFrontmatter: payload.frontmatter,
+      enBody: payload.body,
+      slugStrategy: type.slugStrategy
+    });
+    if (options.dryRun) {
+      return {
+        ...base,
+        skipped: false,
+        model,
+        durationMs: Date.now() - startedAt
+      };
+    }
+    const responseSchema = buildGeminiResponseSchema(type.schema, type.slugStrategy);
+    const result = await translatePageWithGemini({
+      prompt,
+      model,
+      responseSchema: responseSchema ?? void 0
+    });
+    const slug = type.slugStrategy === "localized" ? result.parsed.slug ?? existing?.slug ?? item.enSlug : item.enSlug;
+    const validated = validateTranslatedFrontmatter(enDoc, result.parsed.frontmatter, type.schema);
+    if (!validated.ok) {
+      throw new Error(`Translation validation failed: ${validated.error}`);
+    }
+    const writeDb = openStore(config, "readwrite");
+    upsertTranslation(writeDb, {
+      contentType: type.id,
       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,
+      slug,
+      frontmatter: validated.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,
+      frontmatter: validated.frontmatter,
+      model: result.model
+    });
+    const estimatedCostUsd = estimateTranslationCostUsd(
+      normalizeGeminiDisplayName(result.model),
+      result.usage.inputTokens,
+      result.usage.outputTokens
+    );
+    return {
+      ...base,
       skipped: false,
-      model: options.model
+      model: result.model,
+      usage: result.usage,
+      estimatedCostUsd,
+      durationMs: Date.now() - startedAt
+    };
+  } catch (error) {
+    return {
+      ...base,
+      skipped: false,
+      failed: true,
+      error: formatTranslateError(error),
+      durationMs: Date.now() - startedAt
     };
   }
-  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
+}
+function labelForItem(item) {
+  return `${item.contentType}/${item.enSlug}@${item.locale}`;
+}
+async function translateWorklist(config, items, options = {}) {
+  const concurrency = Math.max(1, options.concurrency ?? 3);
+  const startedAt = Date.now();
+  const results = new Array(items.length);
+  const active = /* @__PURE__ */ new Set();
+  options.onProgress?.({
+    type: "start",
+    total: items.length,
+    concurrency,
+    dryRun: Boolean(options.dryRun),
+    model: options.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
+  await runPool(items, concurrency, async (item, index) => {
+    const label = labelForItem(item);
+    active.add(label);
+    options.onProgress?.({ type: "item-start", item, active: [...active] });
+    const result = await translatePage(config, item, options);
+    results[index] = result;
+    active.delete(label);
+    options.onProgress?.({ type: "item-done", result });
   });
-  return {
-    contentType: item.contentType,
-    enSlug: item.enSlug,
-    locale: item.locale,
-    skipped: false,
-    model: result.model
-  };
+  const totals = summarizeResults(results, Date.now() - startedAt);
+  options.onProgress?.({ type: "done", results, totals });
+  return results;
 }
-async function translateWorklist(config, items, options = {}) {
-  const results = [];
-  for (const item of items) {
-    results.push(await translatePage(config, item, options));
+
+// src/export/build-static-raw-exports.ts
+init_cjs_shims();
+
+// src/loader/parse-mdx.ts
+init_cjs_shims();
+function serializeMdx(frontmatter, content) {
+  return matter__default.default.stringify(content, frontmatter);
+}
+
+// src/export/build-static-raw-exports.ts
+function normalizeExtension(ext) {
+  return ext.startsWith(".") ? ext : `.${ext}`;
+}
+function exportDirSegment(pathTemplate) {
+  const prefix = pathPrefix(pathTemplate);
+  return prefix.replace(/^\/+|\/+$/g, "");
+}
+function getStaticExportRoots(project, options = {}) {
+  const { config } = project;
+  const locales = options.locales ?? config.locales;
+  const typeFilter = options.types ? new Set(options.types) : null;
+  const roots = /* @__PURE__ */ new Set();
+  for (const type of project.listTypes()) {
+    if (!isRoutableType(type.config)) continue;
+    if (typeFilter && !typeFilter.has(type.id)) continue;
+    const segment = exportDirSegment(type.config.path);
+    roots.add(`${segment}/`);
+    for (const locale of locales) {
+      if (locale === config.defaultLocale) continue;
+      roots.add(`${locale}/${segment}/`);
+    }
   }
-  return results;
+  return [...roots].sort();
+}
+function buildStaticRawExports(project, options = {}) {
+  const { config } = project;
+  const extension = normalizeExtension(options.extension ?? ".mdx");
+  const locales = options.locales ?? config.locales;
+  const excludeRedirected = options.excludeRedirected ?? true;
+  const excludeNoindex = options.excludeNoindex ?? false;
+  const typeFilter = options.types ? new Set(options.types) : null;
+  const out = [];
+  for (const type of project.listTypes()) {
+    if (!isRoutableType(type.config)) continue;
+    if (typeFilter && !typeFilter.has(type.id)) continue;
+    const pathTemplate = type.config.path;
+    const all = type.load();
+    const enIdx = all.get(config.defaultLocale);
+    if (!enIdx) continue;
+    for (const locale of locales) {
+      for (const enDoc of enIdx.bySlug.values()) {
+        const resolved = type.resolve(enDoc.slug, locale);
+        if (!resolved.document) continue;
+        if (excludeRedirected && resolved.shouldRedirectTo) continue;
+        if (excludeNoindex && resolved.document.noindex) continue;
+        const doc = resolved.document;
+        const slugWithExt = `${doc.slug}${extension}`;
+        const urlPath = resolvePath(pathTemplate, slugWithExt, locale, config.defaultLocale);
+        out.push({
+          relativePath: urlPath.slice(1),
+          urlPath,
+          locale,
+          typeId: type.id,
+          enSlug: doc.enSlug,
+          source: serializeMdx(doc.frontmatter, doc.content)
+        });
+      }
+    }
+  }
+  return out;
+}
+
+// src/export/write-static-raw-exports.ts
+init_cjs_shims();
+function rmDirIfExists(dir) {
+  if (fs2__default.default.existsSync(dir)) {
+    fs2__default.default.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function writeStaticRawExports(project, options = {}) {
+  const outDir = path3__default.default.resolve(options.outDir ?? "public");
+  const typeFilter = options.types;
+  for (const root of getStaticExportRoots(project, {
+    types: typeFilter,
+    locales: options.locales
+  })) {
+    rmDirIfExists(path3__default.default.join(outDir, root));
+  }
+  const exports = buildStaticRawExports(project, options);
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of exports) {
+    const filePath = path3__default.default.join(outDir, item.relativePath);
+    fs2__default.default.mkdirSync(path3__default.default.dirname(filePath), { recursive: true });
+    fs2__default.default.writeFileSync(filePath, item.source, "utf8");
+    const key = `${item.typeId}/${item.locale}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  for (const [key, count] of [...counts.entries()].sort()) {
+    console.log(`  ${key}: ${count}`);
+  }
+  return { exports, written: exports.length };
 }
 
 // src/config/load-env.ts
@@ -2034,99 +2439,464 @@ function loadEnvFromCwd(cwd) {
 // studio/server.ts
 init_cjs_shims();
 init_sqlite();
-function renderLayout(title, body) {
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+function statusDot(status) {
+  const labels = {
+    source: "en",
+    "up-to-date": "ok",
+    stale: "stale",
+    missing: "\u2014"
+  };
+  return `<span class="status" title="${status}"><span class="dot dot-${status}"></span>${labels[status]}</span>`;
+}
+function documentStatus(config, db, type, enSlug, locale) {
+  if (locale === config.defaultLocale) {
+    return { status: "source" };
+  }
+  const enDoc = readEnDocument(config, type.config, enSlug);
+  if (!enDoc) {
+    return { status: "missing" };
+  }
+  const payload = getTranslatablePayload(enDoc, type.config);
+  const currentEnHash = computePageEnHash(payload.frontmatter, payload.body);
+  const row = getTranslation(db, type.id, enSlug, locale);
+  if (!row) {
+    return { status: "missing", currentEnHash };
+  }
+  if (row.en_hash !== currentEnHash) {
+    return { status: "stale", currentEnHash, storedEnHash: row.en_hash };
+  }
+  return { status: "up-to-date", currentEnHash, storedEnHash: row.en_hash };
+}
+function flattenFrontmatter(data, prefix = "") {
+  const rows = [];
+  for (const [key, value] of Object.entries(data)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      rows.push(...flattenFrontmatter(value, fullKey));
+    } else {
+      const display = typeof value === "string" ? value : value === void 0 ? "" : JSON.stringify(value, null, 2);
+      rows.push({ key: fullKey, value: display });
+    }
+  }
+  return rows;
+}
+function translatableKeySet(schema) {
+  return new Set(
+    introspectSchema(schema).filter((field2) => field2.kind === "translatable").map((field2) => field2.path.join("."))
+  );
+}
+function renderFrontmatterTable(frontmatter, schema) {
+  const translatable = translatableKeySet(schema);
+  const rows = flattenFrontmatter(frontmatter).map((row) => {
+    const flag = translatable.has(row.key) ? `<span class="flag t" title="Translatable">T</span>` : `<span class="flag s" title="Structural">S</span>`;
+    return `<tr>
+        <td class="k">${flag}${escapeHtml(row.key)}</td>
+        <td class="v">${escapeHtml(row.value)}</td>
+      </tr>`;
+  }).join("");
+  return `<table class="kv">
+    <tbody>${rows || `<tr><td colspan="2" class="dim">\u2014</td></tr>`}</tbody>
+  </table>`;
+}
+function renderRevisionSnapshot(revision) {
+  if (revision.frontmatter_json && revision.body) {
+    let frontmatter = {};
+    try {
+      frontmatter = JSON.parse(revision.frontmatter_json);
+    } catch {
+      frontmatter = {};
+    }
+    const fmRows = flattenFrontmatter(frontmatter).map(
+      (row) => `<tr><td class="k">${escapeHtml(row.key)}</td><td class="v">${escapeHtml(row.value)}</td></tr>`
+    ).join("");
+    return `<table class="kv"><tbody>${fmRows}</tbody></table>
+      <pre class="code">${escapeHtml(revision.body)}</pre>`;
+  }
+  return `<p class="dim">${escapeHtml(revision.body_preview ?? "(no snapshot)")}</p>`;
+}
+function renderRevisionTimeline(revisions) {
+  if (revisions.length === 0) {
+    return `<p class="dim">No history.</p>`;
+  }
+  const items = revisions.map(
+    (row) => `<tr>
+        <td class="dim">${escapeHtml(row.created_at.slice(0, 19))}</td>
+        <td>${escapeHtml(row.revision_kind)}</td>
+        <td class="dim">${row.model ? escapeHtml(row.model) : "\u2014"}</td>
+        <td class="dim mono">${escapeHtml(row.en_hash.slice(0, 8))}</td>
+        <td><details><summary>view</summary>${renderRevisionSnapshot(row)}</details></td>
+      </tr>`
+  ).join("");
+  return `<table class="data"><thead><tr>
+    <th>When</th><th>Kind</th><th>Model</th><th>Hash</th><th></th>
+  </tr></thead><tbody>${items}</tbody></table>`;
+}
+function renderLayout(title, body, project, options = {}) {
+  const typeLinks = project.listTypes().map((type) => {
+    const active = type.id === options.activeTypeId ? " active" : "";
+    return `<a class="tree-item${active}" href="/type/${encodePathSegment(type.id)}">
+        <span class="tree-label">${escapeHtml(type.config.label)}</span>
+        <span class="tree-meta">${escapeHtml(type.id)}</span>
+      </a>`;
+  }).join("");
   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>
+  <title>${escapeHtml(title)} \u2014 Scribe</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; }
+    :root {
+      --bg: #1e1e1e;
+      --sidebar: #252526;
+      --bar: #333333;
+      --panel: #1e1e1e;
+      --border: #3c3c3c;
+      --text: #cccccc;
+      --dim: #858585;
+      --accent: #3794ff;
+      --hover: #2a2d2e;
+      --active: #37373d;
+      --ok: #89d185;
+      --stale: #cca700;
+      --missing: #f48771;
+      --source: #75beff;
+      --mono: ui-monospace, "Cascadia Code", "SF Mono", Menlo, monospace;
+      --ui: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      --fs: 13px;
+      --fs-sm: 11px;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font: var(--fs)/1.4 var(--ui); background: var(--bg); color: var(--text); }
+    a { color: var(--accent); text-decoration: none; }
+    a:hover { text-decoration: underline; }
+    .app { display: flex; height: 100vh; overflow: hidden; }
+
+    /* activity bar */
+    .actbar {
+      width: 48px; flex-shrink: 0; background: var(--bar);
+      display: flex; flex-direction: column; align-items: center;
+      padding: 8px 0; gap: 4px; border-right: 1px solid var(--border);
+    }
+    .actbar a {
+      width: 48px; height: 48px; display: flex; align-items: center; justify-content: center;
+      color: var(--dim); font-size: 18px; text-decoration: none; position: relative;
+    }
+    .actbar a:hover { color: var(--text); }
+    .actbar a.active { color: var(--text); }
+    .actbar a.active::before {
+      content: ""; position: absolute; left: 0; top: 8px; bottom: 8px;
+      width: 2px; background: var(--accent);
+    }
+
+    /* sidebar */
+    .sidebar {
+      width: 200px; flex-shrink: 0; background: var(--sidebar);
+      border-right: 1px solid var(--border); display: flex; flex-direction: column;
+      overflow: hidden;
+    }
+    .sidebar-head {
+      padding: 8px 12px; font-size: var(--fs-sm); font-weight: 600;
+      text-transform: uppercase; letter-spacing: 0.04em; color: var(--dim);
+    }
+    .sidebar-body { flex: 1; overflow-y: auto; padding: 2px 0; }
+    .tree-item {
+      display: flex; flex-direction: column; padding: 3px 12px 3px 20px;
+      color: var(--text); text-decoration: none; line-height: 1.3;
+    }
+    .tree-item:hover { background: var(--hover); text-decoration: none; }
+    .tree-item.active { background: var(--active); }
+    .tree-label { font-size: var(--fs); }
+    .tree-meta { font-size: var(--fs-sm); color: var(--dim); }
+
+    /* main */
+    .main { flex: 1; display: flex; flex-direction: column; overflow: hidden; }
+    .toolbar {
+      display: flex; align-items: center; gap: 6px; padding: 0 12px;
+      height: 35px; background: var(--sidebar); border-bottom: 1px solid var(--border);
+      font-size: var(--fs-sm); color: var(--dim); flex-shrink: 0; overflow: hidden;
+    }
+    .toolbar a { color: var(--dim); }
+    .toolbar a:hover { color: var(--text); }
+    .toolbar .sep { color: var(--border); }
+    .content { flex: 1; overflow-y: auto; padding: 0; }
+
+    /* tabs (locale switcher) */
+    .tabs {
+      display: flex; background: var(--sidebar); border-bottom: 1px solid var(--border);
+      overflow-x: auto; flex-shrink: 0;
+    }
+    .tab {
+      display: flex; align-items: center; gap: 6px; padding: 6px 12px;
+      font-size: var(--fs-sm); color: var(--dim); border-right: 1px solid var(--border);
+      text-decoration: none; white-space: nowrap;
+    }
+    .tab:hover { background: var(--hover); color: var(--text); text-decoration: none; }
+    .tab.active {
+      background: var(--bg); color: var(--text);
+      border-bottom: 1px solid var(--bg); margin-bottom: -1px;
+    }
+
+    /* status dots */
+    .status { display: inline-flex; align-items: center; gap: 4px; font-size: var(--fs-sm); color: var(--dim); }
+    .dot { width: 6px; height: 6px; border-radius: 50%; flex-shrink: 0; }
+    .dot-source { background: var(--source); }
+    .dot-up-to-date { background: var(--ok); }
+    .dot-stale { background: var(--stale); }
+    .dot-missing { background: var(--missing); opacity: 0.7; }
+
+    /* sections */
+    .section { border-bottom: 1px solid var(--border); }
+    .section-head {
+      padding: 4px 12px; font-size: var(--fs-sm); font-weight: 600;
+      text-transform: uppercase; letter-spacing: 0.04em; color: var(--dim);
+      background: var(--sidebar);
+    }
+    .section-body { padding: 0; }
+
+    /* tables */
+    table { border-collapse: collapse; width: 100%; font-size: var(--fs); }
+    .data th, .data td { padding: 2px 12px; text-align: left; border-bottom: 1px solid var(--border); vertical-align: top; }
+    .data th { font-size: var(--fs-sm); font-weight: 600; color: var(--dim); background: var(--sidebar); height: 22px; }
+    .data tr:hover td { background: var(--hover); }
+    .data .mono { font-family: var(--mono); font-size: var(--fs-sm); }
+
+    /* key-value (frontmatter) */
+    .kv td { padding: 1px 12px; font-family: var(--mono); font-size: var(--fs-sm); vertical-align: top; border-bottom: 1px solid var(--border); }
+    .kv .k { width: 160px; color: #9cdcfe; white-space: nowrap; }
+    .kv .v { color: #ce9178; white-space: pre-wrap; word-break: break-word; }
+    .flag { font-size: 9px; font-weight: 700; margin-right: 4px; opacity: 0.5; }
+    .flag.t { color: var(--ok); }
+    .flag.s { color: var(--dim); }
+
+    /* code block */
+    .code {
+      margin: 0; padding: 8px 12px; font: var(--fs-sm)/1.5 var(--mono);
+      white-space: pre-wrap; word-break: break-word; color: var(--text);
+      background: var(--bg); border: none;
+    }
+
+    /* meta row */
+    .meta { display: flex; flex-wrap: wrap; font-size: var(--fs-sm); border-bottom: 1px solid var(--border); padding: 4px 0; }
+    .meta dt { padding: 0 4px 0 12px; color: var(--dim); }
+    .meta dt::after { content: ":"; }
+    .meta dd { padding: 0 12px 0 0; font-family: var(--mono); }
+
+    /* misc */
+    .dim { color: var(--dim); }
+    .page-title { padding: 8px 12px 4px; font-size: 14px; font-weight: 400; }
+    .page-sub { padding: 0 12px 8px; font-size: var(--fs-sm); color: var(--dim); }
+    details summary { cursor: pointer; color: var(--accent); font-size: var(--fs-sm); }
+    details[open] summary { margin-bottom: 4px; }
+    .tag { font-size: var(--fs-sm); color: var(--dim); margin-left: 6px; }
+    .tag-warn { color: var(--stale); }
+    .tag-err { color: var(--missing); }
   </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>
+  <div class="app">
+    <nav class="actbar">
+      <a href="/" title="Overview">\u2302</a>
+      <a href="/staleness" title="Staleness">\u26A0</a>
+    </nav>
+    <aside class="sidebar">
+      <div class="sidebar-head">Types</div>
+      <div class="sidebar-body">${typeLinks || `<span class="dim" style="padding:8px 12px">\u2014</span>`}</div>
+    </aside>
+    <div class="main">
+      <div class="content">${body}</div>
+    </div>
+  </div>
 </body>
 </html>`;
 }
+function docTitleFromFrontmatter(frontmatter, enSlug) {
+  const title = frontmatter.title;
+  if (typeof title === "string" && title.trim()) return title;
+  return enSlug;
+}
 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>`;
+    const db = openStore(config, "readonly");
+    const worklist = buildWorklist(config);
+    const rows = project.listTypes().map((type) => {
+      const enCount = type.list().length;
+      const localeCells = config.locales.filter((locale) => locale !== config.defaultLocale).map((locale) => {
+        const translated = listTranslationsForLocale(db, type.id, locale).length;
+        const stale = worklist.filter(
+          (item) => item.contentType === type.id && item.locale === locale && item.reason === "stale"
+        ).length;
+        const missing = worklist.filter(
+          (item) => item.contentType === type.id && item.locale === locale && item.reason === "missing"
+        ).length;
+        const tags = [
+          stale ? `<span class="tag tag-warn">${stale}s</span>` : "",
+          missing ? `<span class="tag tag-err">${missing}m</span>` : ""
+        ].join("");
+        return `<td>${translated}${tags}</td>`;
       }).join("");
-      return `<div class="card"><h2>${type.config.label}</h2><ul>${localeRows}</ul></div>`;
+      return `<tr>
+        <td><a href="/type/${encodePathSegment(type.id)}">${escapeHtml(type.config.label)}</a></td>
+        <td class="dim">${escapeHtml(type.id)}</td>
+        <td>${enCount}</td>
+        ${localeCells}
+      </tr>`;
     });
-    return c.html(renderLayout("Browser", cards.join("")));
+    db.close();
+    const localeHeaders = config.locales.filter((l) => l !== config.defaultLocale).map((l) => `<th>${escapeHtml(l)}</th>`).join("");
+    const html = `<div class="toolbar">Overview</div>
+      <table class="data">
+        <thead><tr><th>Type</th><th>ID</th><th>EN</th>${localeHeaders}</tr></thead>
+        <tbody>${rows.join("")}</tbody>
+      </table>`;
+    return c.html(renderLayout("Overview", html, project));
   });
-  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("/type/:id", (c) => {
+    const typeId = c.req.param("id");
+    const type = project.getType(typeId);
+    if (!type) {
+      return c.html(renderLayout("Not found", `<div class="toolbar">Unknown type</div>`, project), 404);
+    }
+    const db = openStore(config, "readonly");
+    const locales = config.locales;
+    const headerCells = locales.map((locale) => `<th>${escapeHtml(locale)}</th>`).join("");
+    const rows = type.list().map((doc) => {
+      const title = docTitleFromFrontmatter(doc.frontmatter, doc.slug);
+      const statusCells = locales.map((locale) => {
+        const { status } = documentStatus(config, db, type, doc.slug, locale);
+        return `<td>${statusDot(status)}</td>`;
+      }).join("");
+      return `<tr>
+          <td class="mono"><a href="/type/${encodePathSegment(typeId)}/doc/${encodePathSegment(doc.slug)}">${escapeHtml(doc.slug)}</a></td>
+          <td>${escapeHtml(title)}</td>
+          ${statusCells}
+        </tr>`;
+    }).join("");
+    db.close();
+    const html = `<div class="toolbar">
+        <a href="/">Overview</a><span class="sep">\u203A</span>${escapeHtml(type.config.label)}
+      </div>
+      <table class="data">
+        <thead><tr><th>Slug</th><th>Title</th>${headerCells}</tr></thead>
+        <tbody>${rows || `<tr><td colspan="${2 + locales.length}" class="dim">No documents</td></tr>`}</tbody>
+      </table>`;
+    return c.html(renderLayout(type.config.label, html, project, { activeTypeId: typeId }));
   });
-  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>"));
+  app.get("/type/:id/doc/:enSlug", (c) => {
+    const typeId = c.req.param("id");
+    const enSlug = c.req.param("enSlug");
+    const locale = c.req.query("locale") ?? config.defaultLocale;
+    const showRaw = c.req.query("raw") === "1";
+    const type = project.getType(typeId);
+    if (!type) {
+      return c.html(renderLayout("Not found", `<div class="toolbar">Unknown type</div>`, project), 404);
+    }
     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>`;
+    const enDoc = readEnDocument(config, type.config, enSlug);
+    if (!enDoc) {
+      db.close();
+      return c.html(
+        renderLayout("Not found", `<div class="toolbar">Not found</div><p class="dim" style="padding:12px">${escapeHtml(enSlug)}</p>`, project, {
+          activeTypeId: typeId
+        }),
+        404
+      );
+    }
+    const localeTabs = config.locales.map((loc) => {
+      const { status } = documentStatus(config, db, type, enSlug, loc);
+      const active = loc === locale ? " active" : "";
+      const href = `/type/${encodePathSegment(typeId)}/doc/${encodePathSegment(enSlug)}?locale=${encodePathSegment(loc)}`;
+      return `<a class="tab${active}" href="${href}">${escapeHtml(loc)} ${statusDot(status)}</a>`;
+    }).join("");
+    let contentPanel = "";
+    let metaPanel = "";
+    let historyPanel = "";
+    if (locale === config.defaultLocale) {
+      contentPanel = `<div class="section">
+        <div class="section-head">Frontmatter</div>
+        <div class="section-body">${renderFrontmatterTable(enDoc.frontmatter, type.config.schema)}</div>
+        <div class="section-head">Body</div>
+        <pre class="code">${escapeHtml(enDoc.content)}</pre>
+      </div>`;
     } 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>`;
+      const translation = getTranslation(db, typeId, enSlug, locale);
+      const { status, currentEnHash, storedEnHash } = documentStatus(config, db, type, enSlug, locale);
+      if (translation) {
+        const rawFrontmatter = JSON.parse(translation.frontmatter_json);
+        const displayFrontmatter = showRaw ? rawFrontmatter : mergeStructuralOntoLocale(rawFrontmatter, enDoc.frontmatter, type.config.schema);
+        const rawToggle = showRaw ? `<span class="dim"> \xB7 <a href="?locale=${encodePathSegment(locale)}">merged</a></span>` : `<span class="dim"> \xB7 <a href="?locale=${encodePathSegment(locale)}&raw=1">raw</a></span>`;
+        contentPanel = `<div class="section">
+          <div class="section-head">Frontmatter${rawToggle}</div>
+          <div class="section-body">${renderFrontmatterTable(displayFrontmatter, type.config.schema)}</div>
+          <div class="section-head">Body</div>
+          <pre class="code">${escapeHtml(translation.body)}</pre>
+        </div>`;
+        metaPanel = `<dl class="meta">
+          <dt>status</dt><dd>${statusDot(status)}</dd>
+          <dt>model</dt><dd>${escapeHtml(translation.model)}</dd>
+          <dt>translated</dt><dd>${escapeHtml(translation.translated_at.slice(0, 19))}</dd>
+          <dt>slug</dt><dd>${escapeHtml(translation.slug)}</dd>
+          <dt>en_hash</dt><dd>${escapeHtml(currentEnHash?.slice(0, 12) ?? "\u2014")} / ${escapeHtml(storedEnHash?.slice(0, 12) ?? "\u2014")}</dd>
+        </dl>`;
+        const revisions = listRevisions(db, typeId, enSlug, locale);
+        historyPanel = `<div class="section">
+          <div class="section-head">History</div>
+          <div class="section-body">${renderRevisionTimeline(revisions)}</div>
+        </div>`;
+      } else {
+        contentPanel = `<p class="dim" style="padding:12px">No translation for ${escapeHtml(locale)}.</p>`;
+        metaPanel = `<dl class="meta"><dt>status</dt><dd>${statusDot(status)}</dd></dl>`;
+      }
     }
     db.close();
-    return c.html(renderLayout("History", body));
+    const title = docTitleFromFrontmatter(enDoc.frontmatter, enSlug);
+    const html = `<div class="toolbar">
+        <a href="/">Overview</a><span class="sep">\u203A</span>
+        <a href="/type/${encodePathSegment(typeId)}">${escapeHtml(type.config.label)}</a><span class="sep">\u203A</span>
+        <span>${escapeHtml(enSlug)}</span>
+      </div>
+      <div class="tabs">${localeTabs}</div>
+      ${metaPanel}
+      ${contentPanel}
+      ${historyPanel}`;
+    return c.html(renderLayout(title, html, project, { activeTypeId: typeId }));
+  });
+  app.get("/staleness", (c) => {
+    const worklist = buildWorklist(config);
+    const rows = worklist.slice(0, 500).map((item) => {
+      const href = `/type/${encodePathSegment(item.contentType)}/doc/${encodePathSegment(item.enSlug)}?locale=${encodePathSegment(item.locale)}`;
+      return `<tr>
+          <td>${escapeHtml(item.contentType)}</td>
+          <td class="mono"><a href="${href}">${escapeHtml(item.enSlug)}</a></td>
+          <td>${escapeHtml(item.locale)}</td>
+          <td>${statusDot(item.reason === "stale" ? "stale" : "missing")}</td>
+        </tr>`;
+    }).join("");
+    const html = `<div class="toolbar">Staleness <span class="dim">\xB7 ${worklist.length} entries</span></div>
+      <table class="data">
+        <thead><tr><th>Type</th><th>Slug</th><th>Locale</th><th>Status</th></tr></thead>
+        <tbody>${rows || `<tr><td colspan="4" class="dim">All up to date</td></tr>`}</tbody>
+      </table>`;
+    return c.html(renderLayout("Staleness", html, project));
   });
   app.get("/api/staleness-matrix", (c) => {
+    const worklist = buildWorklist(config);
     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;
+        matrix[type.id][locale] = worklist.filter(
+          (item) => item.contentType === type.id && item.locale === locale
+        ).length;
       }
     }
     return c.json(matrix);
@@ -2138,6 +2908,276 @@ async function startStudio(project, options = {}) {
   });
 }
 
+// cli/prompt-translate.ts
+init_cjs_shims();
+
+// ../../node_modules/@inquirer/core/dist/lib/errors.js
+init_cjs_shims();
+var CancelPromptError = class extends Error {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "name", "CancelPromptError");
+    __publicField(this, "message", "Prompt was canceled");
+  }
+};
+function isInteractive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function nonDefaultLocales(config) {
+  return config.locales.filter((locale) => locale !== config.defaultLocale);
+}
+async function runPrompt(prompt) {
+  try {
+    return await prompt;
+  } catch (error) {
+    if (error instanceof CancelPromptError) process.exit(0);
+    throw error;
+  }
+}
+async function promptContentType(config) {
+  return runPrompt(
+    prompts.select({
+      message: "Content type to translate",
+      choices: [
+        { name: "All content types", value: void 0 },
+        ...config.types.map((type) => ({ name: type.id, value: type.id }))
+      ]
+    })
+  );
+}
+async function promptLocalePreset(config) {
+  const presets = Object.entries(config.localePresets ?? {}).filter(
+    (entry) => Array.isArray(entry[1])
+  );
+  if (presets.length === 0) {
+    const locales = nonDefaultLocales(config);
+    if (locales.length <= 1) return {};
+    const picked = await runPrompt(
+      prompts.checkbox({
+        message: "Locales to translate",
+        choices: locales.map((locale) => ({ name: locale, value: locale, checked: true })),
+        validate: (values) => values.length > 0 || "Pick at least one locale"
+      })
+    );
+    return picked.length === locales.length ? {} : { locale: picked };
+  }
+  const choice = await runPrompt(
+    prompts.select({
+      message: "Locale preset",
+      choices: [
+        { name: "All locales", value: void 0 },
+        ...presets.map(([name, locales]) => ({
+          name: `${name} (${locales.join(", ")})`,
+          value: name
+        }))
+      ]
+    })
+  );
+  return choice ? { preset: choice } : {};
+}
+async function promptStrategy() {
+  return runPrompt(
+    prompts.select({
+      message: "Translation strategy",
+      choices: [
+        { name: "Stale and missing", value: "all" },
+        { name: "Missing only (skip stale)", value: "missing-only" }
+      ],
+      default: "all"
+    })
+  );
+}
+async function promptTranslateSelection(config, flags) {
+  const selection = {
+    contentType: flags.type,
+    preset: flags.preset,
+    locale: flags.locale,
+    strategy: flags.strategy
+  };
+  if (!isInteractive()) return selection;
+  if (!selection.contentType) {
+    selection.contentType = await promptContentType(config);
+  }
+  if (!selection.preset && !selection.locale?.length) {
+    Object.assign(selection, await promptLocalePreset(config));
+  }
+  if (!selection.strategy) {
+    selection.strategy = await promptStrategy();
+  }
+  return selection;
+}
+
+// cli/translate-progress.ts
+init_cjs_shims();
+var dim = (text) => `\x1B[2m${text}\x1B[0m`;
+var green = (text) => `\x1B[32m${text}\x1B[0m`;
+var yellow = (text) => `\x1B[33m${text}\x1B[0m`;
+var red = (text) => `\x1B[31m${text}\x1B[0m`;
+var cyan = (text) => `\x1B[36m${text}\x1B[0m`;
+function isInteractive2() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function progressBar(ratio, width = 28) {
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const filled = Math.round(clamped * width);
+  return `${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}`;
+}
+function labelForResult(result) {
+  return `${result.contentType}/${result.enSlug}@${result.locale}`;
+}
+function statusForResult(result, dryRun) {
+  if (result.failed) return red("failed");
+  if (result.skipped) return dim("skipped");
+  if (dryRun) return yellow("would translate");
+  return green("translated");
+}
+function detailForResult(result) {
+  const parts = [];
+  if (result.durationMs !== void 0) parts.push(`${(result.durationMs / 1e3).toFixed(1)}s`);
+  if (result.usage) {
+    parts.push(`${formatTokenCount(result.usage.inputTokens)} in`);
+    parts.push(`${formatTokenCount(result.usage.outputTokens)} out`);
+  }
+  if (result.estimatedCostUsd !== void 0) parts.push(formatUsd(result.estimatedCostUsd));
+  if (result.error) parts.push(red(result.error));
+  return parts.length > 0 ? dim(parts.join(" \xB7 ")) : "";
+}
+function formatSummaryLine(totals, dryRun) {
+  const action = dryRun ? "Would translate" : "Translated";
+  const parts = [
+    `${action} ${totals.translated}`,
+    `skipped ${totals.skipped}`
+  ];
+  if (totals.failed > 0) parts.push(red(`failed ${totals.failed}`));
+  parts.push(`${formatTokenCount(totals.inputTokens)} in / ${formatTokenCount(totals.outputTokens)} out`);
+  parts.push(`${formatUsd(totals.estimatedCostUsd)} est.`);
+  parts.push(`${(totals.durationMs / 1e3).toFixed(1)}s`);
+  return parts.join(" \xB7 ");
+}
+function createTranslateProgressReporter(options = {}) {
+  const enabled = options.enabled ?? isInteractive2();
+  const dryRun = Boolean(options.dryRun);
+  const recentLimit = options.recentLimit ?? 6;
+  if (!enabled) {
+    return {
+      onEvent(event) {
+        if (event.type === "item-done") {
+          const label = labelForResult(event.result);
+          const status = statusForResult(event.result, dryRun);
+          const detail = detailForResult(event.result);
+          console.log(`${label}: ${status}${detail ? ` (${detail.replace(/\x1b\[[0-9;]*m/g, "")})` : ""}`);
+          if (event.result.failed && event.result.error) {
+            console.error(event.result.error);
+          }
+          return;
+        }
+        if (event.type === "done") {
+          console.log(formatSummaryLine(event.totals, dryRun));
+        }
+      },
+      finish() {
+      }
+    };
+  }
+  let total = 0;
+  let concurrency = 1;
+  let model;
+  let done = 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let estimatedCostUsd = 0;
+  let active = [];
+  const recent = [];
+  let renderedLines = 0;
+  let cursorHidden = false;
+  function hideCursor() {
+    if (!cursorHidden) {
+      process.stdout.write("\x1B[?25l");
+      cursorHidden = true;
+    }
+  }
+  function showCursor() {
+    if (cursorHidden) {
+      process.stdout.write("\x1B[?25h");
+      cursorHidden = false;
+    }
+  }
+  function render() {
+    hideCursor();
+    if (renderedLines > 0) {
+      process.stdout.write(`\x1B[${renderedLines}A`);
+    }
+    const lines = [];
+    const title = dryRun ? "Dry run" : "Translating";
+    lines.push(cyan(`${title} ${done}/${total}`) + dim(` \xB7 ${concurrency} parallel`) + (model ? dim(` \xB7 ${model}`) : ""));
+    lines.push(progressBar(total === 0 ? 0 : done / total) + dim(`  ${Math.round(total === 0 ? 0 : done / total * 100)}%`));
+    lines.push(
+      dim("Tokens ") + `${formatTokenCount(inputTokens)} in \xB7 ${formatTokenCount(outputTokens)} out` + dim(" \xB7 Cost ") + formatUsd(estimatedCostUsd) + dim(" est.")
+    );
+    if (active.length > 0) {
+      lines.push(dim("Active ") + active.slice(0, 3).join(", ") + (active.length > 3 ? dim(` +${active.length - 3}`) : ""));
+    } else if (done < total) {
+      lines.push(dim("Active ") + "starting\u2026");
+    } else {
+      lines.push("");
+    }
+    lines.push("");
+    if (recent.length === 0) {
+      lines.push(dim("Waiting for first page\u2026"));
+    } else {
+      for (const result of recent) {
+        const detail = detailForResult(result);
+        lines.push(`${statusForResult(result, dryRun)} ${labelForResult(result)}${detail ? ` ${detail}` : ""}`);
+      }
+    }
+    for (const line of lines) {
+      process.stdout.write("\x1B[2K" + line + "\n");
+    }
+    renderedLines = lines.length;
+  }
+  return {
+    onEvent(event) {
+      switch (event.type) {
+        case "start":
+          total = event.total;
+          concurrency = event.concurrency;
+          model = event.model;
+          render();
+          break;
+        case "item-start":
+          active = event.active;
+          render();
+          break;
+        case "item-done": {
+          done += 1;
+          active = active.filter((label) => label !== labelForResult(event.result));
+          inputTokens += event.result.usage?.inputTokens ?? 0;
+          outputTokens += event.result.usage?.outputTokens ?? 0;
+          estimatedCostUsd += event.result.estimatedCostUsd ?? 0;
+          recent.unshift(event.result);
+          recent.splice(recentLimit);
+          render();
+          break;
+        }
+        case "done":
+          showCursor();
+          if (renderedLines > 0) {
+            process.stdout.write(`\x1B[${renderedLines}A`);
+          }
+          process.stdout.write("\x1B[2K" + green("Done") + " \xB7 " + formatSummaryLine(event.totals, dryRun) + "\n");
+          renderedLines = 0;
+          for (const result of event.results.filter((entry) => entry.failed)) {
+            process.stdout.write("\x1B[2K" + red(`${labelForResult(result)}: ${result.error ?? "failed"}`) + "\n");
+          }
+          break;
+      }
+    },
+    finish() {
+      showCursor();
+    }
+  };
+}
+
 // cli/index.ts
 function parseArgs(argv) {
   const options = { cwd: process.cwd() };
@@ -2194,6 +3234,35 @@ function parseArgs(argv) {
       i++;
       continue;
     }
+    if (arg === "--concurrency") {
+      options.concurrency = Number(argv[++i]);
+      i++;
+      continue;
+    }
+    if (arg === "--no-progress") {
+      options.noProgress = true;
+      i++;
+      continue;
+    }
+    if (arg === "--strategy") {
+      const value = argv[++i];
+      if (value !== "all" && value !== "missing-only") {
+        throw new Error(`Unknown strategy: ${value} (expected all or missing-only)`);
+      }
+      options.strategy = value;
+      i++;
+      continue;
+    }
+    if (arg === "--out") {
+      options.out = argv[++i];
+      i++;
+      continue;
+    }
+    if (arg === "--extension") {
+      options.extension = argv[++i];
+      i++;
+      continue;
+    }
     if (arg.startsWith("--")) {
       throw new Error(`Unknown flag: ${arg}`);
     }
@@ -2219,9 +3288,28 @@ async function main() {
 Commands:
   status                 Show EN docs + translation counts
   validate               Validate EN files and sqlite consistency
+  export-static          Write raw MDX files for static hosting
   translate              Translate stale/missing locale pages
   history <type> <slug>  Show revision timeline
   studio                 Start read-only local studio
+
+Export-static flags:
+  --out <dir>            Output directory (default: public)
+  --extension <ext>      File extension (default: mdx)
+  --type <id>            Comma-separated content types (default: all routable)
+  --locale <code>...     Locales to export (default: all configured)
+
+Translate flags:
+  --type <id>            Content type (interactive picker in a TTY when omitted)
+  --preset <name>        Locale preset from config (interactive picker in a TTY)
+  --locale <code>...     Target locale(s); overrides --preset
+  --slug <en-slug>       Single English document
+  --model <id>           Gemini model override
+  --concurrency <n>      Parallel translations (default: 3)
+  --dry-run              List work without writing
+  --force                Re-translate even when hashes match
+  --strategy <mode>      all (default) or missing-only
+  --no-progress          Plain line logging instead of live progress
 `);
     return;
   }
@@ -2251,24 +3339,49 @@ Commands:
       if (!result.ok) process.exitCode = 1;
       break;
     }
+    case "export-static": {
+      const types = options.type?.split(",").map((t) => t.trim()).filter(Boolean);
+      const { written } = writeStaticRawExports(project, {
+        outDir: options.out,
+        extension: options.extension ? `.${options.extension.replace(/^\./, "")}` : void 0,
+        types,
+        locales: options.locale
+      });
+      console.log(`Wrote ${written} static raw exports to ${options.out ?? "public"}`);
+      break;
+    }
     case "translate": {
-      const locales = resolveLocalesFromPreset(config, options.preset, options.locale);
+      const selection = await promptTranslateSelection(config, {
+        type: options.type,
+        preset: options.preset,
+        locale: options.locale,
+        strategy: options.strategy
+      });
+      const locales = resolveLocalesFromPreset(config, selection.preset, selection.locale);
       const worklist = buildWorklist(config, {
-        contentType: options.type,
+        contentType: selection.contentType,
         locales,
-        enSlug: options.slug
+        enSlug: options.slug,
+        strategy: selection.strategy ?? "all"
+      });
+      if (worklist.length === 0) {
+        console.log("Nothing to translate.");
+        break;
+      }
+      const reporter = createTranslateProgressReporter({
+        enabled: !options.noProgress,
+        dryRun: options.dryRun
       });
-      console.log(`Translating ${worklist.length} page(s)...`);
       const results = await translateWorklist(config, worklist, {
         model: options.model,
         dryRun: options.dryRun,
-        force: options.force
+        force: options.force,
+        concurrency: options.concurrency,
+        onProgress: reporter.onEvent
       });
-      for (const result of results) {
-        console.log(
-          `${result.contentType}/${result.enSlug}@${result.locale}: ${result.skipped ? "skipped" : "translated"}${result.model ? ` (${result.model})` : ""}`
-        );
-      }
+      reporter.finish();
+      const failed = results.filter((result) => result.failed);
+      if (failed.length > 0) process.exitCode = 1;
       break;
     }
     case "history": {