scribe-cms 0.0.2 → 0.0.5

package/dist/index.js

@@ -98,6 +98,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
 function defineConfig(config) {
@@ -112,14 +128,14 @@ var SLUG_PLACEHOLDER = "{slug}";
 function isRoutableType(type) {
   return typeof type.path === "string" && type.path.length > 0;
 }
-function assertValidPathTemplate(path9, typeId) {
-  if (!path9.startsWith("/")) {
-    throw new Error(`Content type "${typeId}": path must start with / (got "${path9}")`);
+function assertValidPathTemplate(path11, typeId) {
+  if (!path11.startsWith("/")) {
+    throw new Error(`Content type "${typeId}": path must start with / (got "${path11}")`);
   }
-  const count = (path9.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 "${path9}")`
+      `Content type "${typeId}": path must contain exactly one {slug} (got "${path11}")`
     );
   }
 }
@@ -171,6 +187,7 @@ function resolveConfig(input, baseDir) {
   const projectRoot = path3.resolve(baseDir ?? process.cwd(), raw.rootDir);
   const contentRoot = path3.resolve(projectRoot, raw.contentDir ?? "content");
   const storePath = path3.resolve(projectRoot, raw.store ?? ".scribe/store.sqlite");
+  const assetsPath = raw.assetsDir ? path3.resolve(projectRoot, raw.assetsDir) : void 0;
   const seenIds = /* @__PURE__ */ new Set();
   const types = raw.types.map((type) => {
     if (seenIds.has(type.id)) {
@@ -191,6 +208,7 @@ function resolveConfig(input, baseDir) {
   const config = {
     rootDir: contentRoot,
     storePath,
+    assetsPath,
     locales: [...raw.locales],
     defaultLocale,
     localePresets: raw.localePresets,
@@ -243,10 +261,10 @@ function introspectSchema(schema, prefix = []) {
 }
 function extractByPaths(data, paths) {
   const out = {};
-  for (const path9 of paths) {
-    const value = getAtPath(data, path9);
+  for (const path11 of paths) {
+    const value = getAtPath(data, path11);
     if (value !== void 0) {
-      setAtPath(out, path9.filter((p) => p !== "*"), value);
+      setAtPath(out, path11.filter((p) => p !== "*"), value);
     }
   }
   return out;
@@ -264,13 +282,13 @@ function mergeStructuralOntoLocale(localeData, enData, schema) {
   const translatable = pickTranslatable(localeData, schema);
   return deepMerge(structural, translatable);
 }
-function getAtPath(obj, path9) {
+function getAtPath(obj, path11) {
   let current = obj;
-  for (const segment of path9) {
+  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, path9.slice(path9.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;
@@ -278,13 +296,13 @@ function getAtPath(obj, path9) {
   }
   return current;
 }
-function setAtPath(obj, path9, value) {
-  if (path9.length === 0) return;
-  if (path9.length === 1) {
-    obj[path9[0]] = value;
+function setAtPath(obj, path11, value) {
+  if (path11.length === 0) return;
+  if (path11.length === 1) {
+    obj[path11[0]] = value;
     return;
   }
-  const [head, ...rest] = path9;
+  const [head, ...rest] = path11;
   if (!(head in obj) || typeof obj[head] !== "object" || obj[head] === null) {
     obj[head] = {};
   }
@@ -480,7 +498,7 @@ function seoFieldsFromEn(enDoc) {
     redirectTo: enDoc.redirectTo
   };
 }
-var SCHEMA_VERSION = 2;
+var SCHEMA_VERSION = 3;
 var MIGRATIONS = [
   `CREATE TABLE IF NOT EXISTS meta (
     key TEXT PRIMARY KEY,
@@ -537,17 +555,27 @@ function resolveStorePath(config) {
 }
 function openStore(config, mode = "readwrite") {
   const storePath = resolveStorePath(config);
-  fs2.mkdirSync(path3.dirname(storePath), { recursive: true });
+  if (mode === "readwrite") {
+    fs2.mkdirSync(path3.dirname(storePath), { recursive: true });
+  }
   const db = new Database(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`
@@ -598,8 +626,9 @@ function bulkLoadTranslations(db) {
 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,
@@ -609,7 +638,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);
 }
@@ -1542,8 +1573,8 @@ function getRedirectSourceSlugs(project) {
 // src/sitemap/join-base-url.ts
 function joinBaseUrl(baseUrl, pathname) {
   const origin = baseUrl.replace(/\/$/, "");
-  const path9 = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  return `${origin}${path9}`;
+  const path11 = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${origin}${path11}`;
 }
 
 // src/sitemap/generate-sitemap.ts
@@ -1687,34 +1718,6 @@ function loadConfigSync(options = {}) {
   }
   return resolveConfig(config, path3.dirname(configPath));
 }
-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
-function recordRevision(config, input) {
-  const db = openStore(config, "readwrite");
-  const id = appendRevision(db, {
-    contentType: input.contentType,
-    enSlug: input.enSlug,
-    locale: input.locale,
-    revisionKind: input.revisionKind,
-    enHash: input.enHash,
-    bodyHash: computeBodyHash(input.body),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    model: input.model,
-    bodyPreview: input.body.slice(0, 200)
-  });
-  db.close();
-  return id;
-}
 function getAtPath2(obj, fieldPath) {
   let current = obj;
   for (const segment of fieldPath) {
@@ -1794,6 +1797,72 @@ function validateRelations(project) {
   }
   return issues;
 }
+var IMAGE_EXT = String.raw`(?:png|jpe?g|webp|gif|svg)`;
+var IMAGE_WEB_PATH = String.raw`\/[\w\-./]+\.${IMAGE_EXT}`;
+var MARKDOWN_IMAGE_RE = new RegExp(
+  String.raw`!\[[^\]]*\]\((${IMAGE_WEB_PATH})\)`,
+  "gi"
+);
+var HTML_SRC_RE = new RegExp(String.raw`src=["'](${IMAGE_WEB_PATH})["']`, "gi");
+function isImageWebPath(value) {
+  return new RegExp(String.raw`^${IMAGE_WEB_PATH}$`, "i").test(value);
+}
+function isSiteAssetPath(webPath) {
+  const segment = webPath.split("/")[1];
+  return Boolean(segment && !segment.includes("."));
+}
+function addImagePath(webPath, out) {
+  if (isSiteAssetPath(webPath)) out.add(webPath);
+}
+function collectBodyImagePaths(body, out) {
+  for (const re of [MARKDOWN_IMAGE_RE, HTML_SRC_RE]) {
+    for (const match of body.matchAll(re)) {
+      addImagePath(match[1], out);
+    }
+  }
+}
+function collectFrontmatterImagePaths(value, out) {
+  if (typeof value === "string") {
+    if (isImageWebPath(value)) addImagePath(value, out);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectFrontmatterImagePaths(item, out);
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const nested of Object.values(value)) {
+      collectFrontmatterImagePaths(nested, out);
+    }
+  }
+}
+function collectImagePaths(frontmatter, body) {
+  const paths = /* @__PURE__ */ new Set();
+  collectFrontmatterImagePaths(frontmatter, paths);
+  collectBodyImagePaths(body, paths);
+  return [...paths].sort();
+}
+function assetFilePath(assetsPath, webPath) {
+  return path3.join(assetsPath, webPath.replace(/^\//, ""));
+}
+function validateDocumentAssets(config, input) {
+  const assetsPath = config.assetsPath;
+  if (!assetsPath) return [];
+  const issues = [];
+  for (const webPath of collectImagePaths(input.frontmatter, input.body)) {
+    const filePath = assetFilePath(assetsPath, webPath);
+    if (fs2.existsSync(filePath)) continue;
+    issues.push({
+      level: "warning",
+      contentType: input.contentType,
+      enSlug: input.enSlug,
+      locale: input.locale,
+      field: "asset",
+      message: `Missing image asset ${webPath} (expected ${filePath})`
+    });
+  }
+  return issues;
+}
 
 // src/validate/validate-slug-suffix.ts
 function validateTranslationSlugSuffixes(config, db) {
@@ -1856,8 +1925,6 @@ function validateProject(config) {
         });
         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,
@@ -1875,28 +1942,18 @@ function validateProject(config) {
           message: issue.message
         });
       }
+      for (const issue of validateDocumentAssets(config, {
+        contentType: type.id,
+        enSlug,
+        frontmatter: enDoc.frontmatter,
+        body: enDoc.content
+      })) {
+        issues.push(issue);
+      }
       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({
@@ -1908,6 +1965,15 @@ function validateProject(config) {
             message: issue.message
           });
         }
+        for (const issue of validateDocumentAssets(config, {
+          contentType: type.id,
+          enSlug,
+          locale,
+          frontmatter: localeFm,
+          body: row.body
+        })) {
+          issues.push(issue);
+        }
       }
     }
     try {
@@ -1975,6 +2041,18 @@ function validateProject(config) {
   }
   return { ok: issues.every((i) => i.level !== "error"), issues };
 }
+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/translate/worklist.ts
 function listEnSlugs3(rootDir, contentDir) {
   const dir = path3.join(rootDir, contentDir);
   if (!fs2.existsSync(dir)) return [];
@@ -2019,6 +2097,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) {
@@ -2028,7 +2110,50 @@ function resolveLocalesFromPreset(config, preset, explicitLocales) {
   }
   return config.locales.filter((l) => l !== config.defaultLocale);
 }
-var DEFAULT_MODEL = "gemini-2.5-pro";
+
+// src/history/record-revision.ts
+function recordRevision(config, input) {
+  const db = openStore(config, "readwrite");
+  const id = appendRevision(db, {
+    contentType: input.contentType,
+    enSlug: input.enSlug,
+    locale: input.locale,
+    revisionKind: input.revisionKind,
+    enHash: input.enHash,
+    bodyHash: computeBodyHash(input.body),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    model: input.model,
+    bodyPreview: input.body.slice(0, 200),
+    frontmatterJson: input.frontmatter ? JSON.stringify(input.frontmatter) : null,
+    body: input.body
+  });
+  db.close();
+  return id;
+}
+
+// src/translate/gemini-models.ts
+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();
@@ -2042,13 +2167,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 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 ?? "";
@@ -2056,7 +2185,38 @@ 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
+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;
 }
 
 // src/translate/prompts/translation-prompt.ts
@@ -2092,6 +2252,7 @@ function buildPageTranslationPrompt(input) {
     prompt,
     "",
     ...input.resolved.context ? ["## Context", input.resolved.context, ""] : [],
+    ...input.contextLabel ? [`Document: ${input.contextLabel}`, ""] : [],
     "## Rules",
     ...input.resolved.rules.map((rule) => `- ${rule}`),
     "",
@@ -2099,10 +2260,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),
     "",
@@ -2111,6 +2268,71 @@ function buildPageTranslationPrompt(input) {
   ];
   return lines.join("\n");
 }
+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 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 z.object(out);
+}
+function buildGeminiResponseSchema(schema, slugStrategy) {
+  try {
+    const translatable = buildTranslatableSubschema(schema);
+    if (!translatable) return null;
+    const responseShape = {
+      frontmatter: translatable,
+      body: z.string()
+    };
+    if (slugStrategy === "localized") {
+      responseShape.slug = z.string();
+    }
+    const jsonSchema = z.toJSONSchema(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
 function slugStrategyRules(slugStrategy, preserveTerms) {
@@ -2151,88 +2373,305 @@ function resolveTranslateConfig(config, type) {
   return mergeTranslateConfig(config.translate, type.translate, type.slugStrategy);
 }
 
+// src/translate/validate-translation.ts
+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));
+function serializeMdx(frontmatter, content) {
+  return matter.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;
+}
+function rmDirIfExists(dir) {
+  if (fs2.existsSync(dir)) {
+    fs2.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function writeStaticRawExports(project, options = {}) {
+  const outDir = path3.resolve(options.outDir ?? "public");
+  const typeFilter = options.types;
+  for (const root of getStaticExportRoots(project, {
+    types: typeFilter,
+    locales: options.locales
+  })) {
+    rmDirIfExists(path3.join(outDir, root));
+  }
+  const exports = buildStaticRawExports(project, options);
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of exports) {
+    const filePath = path3.join(outDir, item.relativePath);
+    fs2.mkdirSync(path3.dirname(filePath), { recursive: true });
+    fs2.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 };
 }
 
-export { buildAllContentRedirects, buildWorklist, createProject, createScribe, defineConfig, defineContentType, field, findConfigPath, generateSitemap, getFieldKind, getRedirectSourceSlugs, getRelationTarget, isResolvedConfig, loadConfigSync, resolveConfig, resolveLocalesFromPreset, translatePage, translateWorklist, unwrapSchema, validateProject };
+export { buildAllContentRedirects, buildStaticRawExports, buildWorklist, createProject, createScribe, defineConfig, defineContentType, exportDirSegment, field, findConfigPath, generateSitemap, getFieldKind, getRedirectSourceSlugs, getRelationTarget, getStaticExportRoots, isResolvedConfig, loadConfigSync, resolveConfig, resolveLocalesFromPreset, serializeMdx, translatePage, translateWorklist, unwrapSchema, validateProject, writeStaticRawExports };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map