scribe-cms 0.0.1 → 0.0.4

package/dist/index.cjs

@@ -109,6 +109,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) {
@@ -123,14 +139,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(path10, typeId) {
+  if (!path10.startsWith("/")) {
+    throw new Error(`Content type "${typeId}": path must start with / (got "${path10}")`);
   }
-  const count = (path9.match(/\{slug\}/g) ?? []).length;
+  const count = (path10.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 "${path10}")`
     );
   }
 }
@@ -254,10 +270,10 @@ function introspectSchema(schema, prefix = []) {
 }
 function extractByPaths(data, paths) {
   const out = {};
-  for (const path9 of paths) {
-    const value = getAtPath(data, path9);
+  for (const path10 of paths) {
+    const value = getAtPath(data, path10);
     if (value !== void 0) {
-      setAtPath(out, path9.filter((p) => p !== "*"), value);
+      setAtPath(out, path10.filter((p) => p !== "*"), value);
     }
   }
   return out;
@@ -275,13 +291,13 @@ function mergeStructuralOntoLocale(localeData, enData, schema) {
   const translatable = pickTranslatable(localeData, schema);
   return deepMerge(structural, translatable);
 }
-function getAtPath(obj, path9) {
+function getAtPath(obj, path10) {
   let current = obj;
-  for (const segment of path9) {
+  for (const segment of path10) {
     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, path10.slice(path10.indexOf("*") + 1)) : void 0
       );
     }
     if (typeof current !== "object" || current === null || Array.isArray(current)) return void 0;
@@ -289,13 +305,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, path10, value) {
+  if (path10.length === 0) return;
+  if (path10.length === 1) {
+    obj[path10[0]] = value;
     return;
   }
-  const [head, ...rest] = path9;
+  const [head, ...rest] = path10;
   if (!(head in obj) || typeof obj[head] !== "object" || obj[head] === null) {
     obj[head] = {};
   }
@@ -491,7 +507,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,
@@ -548,17 +564,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`
@@ -609,8 +635,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,
@@ -620,7 +647,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);
 }
@@ -1553,8 +1582,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 path10 = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${origin}${path10}`;
 }
 
 // src/sitemap/generate-sitemap.ts
@@ -1721,7 +1750,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;
@@ -1905,7 +1936,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);
@@ -2030,6 +2062,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) {
@@ -2039,7 +2075,30 @@ function resolveLocalesFromPreset(config, preset, explicitLocales) {
   }
   return config.locales.filter((l) => l !== config.defaultLocale);
 }
-var DEFAULT_MODEL = "gemini-2.5-pro";
+
+// 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();
@@ -2053,13 +2112,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 ?? "";
@@ -2067,7 +2130,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
@@ -2103,6 +2197,7 @@ function buildPageTranslationPrompt(input) {
     prompt,
     "",
     ...input.resolved.context ? ["## Context", input.resolved.context, ""] : [],
+    ...input.contextLabel ? [`Document: ${input.contextLabel}`, ""] : [],
     "## Rules",
     ...input.resolved.rules.map((rule) => `- ${rule}`),
     "",
@@ -2110,10 +2205,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),
     "",
@@ -2122,6 +2213,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 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
 function slugStrategyRules(slugStrategy, preserveTerms) {
@@ -2162,107 +2318,329 @@ 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: result.model,
+      usage: result.usage,
+      estimatedCostUsd,
+      durationMs: Date.now() - startedAt
+    };
+  } catch (error) {
+    return {
+      ...base,
       skipped: false,
-      model: options.model
+      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__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;
+}
+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 };
 }
 
 exports.buildAllContentRedirects = buildAllContentRedirects;
+exports.buildStaticRawExports = buildStaticRawExports;
 exports.buildWorklist = buildWorklist;
 exports.createProject = createProject;
 exports.createScribe = createScribe;
 exports.defineConfig = defineConfig;
 exports.defineContentType = defineContentType;
+exports.exportDirSegment = exportDirSegment;
 exports.field = field;
 exports.findConfigPath = findConfigPath;
 exports.generateSitemap = generateSitemap;
 exports.getFieldKind = getFieldKind;
 exports.getRedirectSourceSlugs = getRedirectSourceSlugs;
 exports.getRelationTarget = getRelationTarget;
+exports.getStaticExportRoots = getStaticExportRoots;
 exports.isResolvedConfig = isResolvedConfig;
 exports.loadConfigSync = loadConfigSync;
 exports.resolveConfig = resolveConfig;
 exports.resolveLocalesFromPreset = resolveLocalesFromPreset;
+exports.serializeMdx = serializeMdx;
 exports.translatePage = translatePage;
 exports.translateWorklist = translateWorklist;
 exports.unwrapSchema = unwrapSchema;
 exports.validateProject = validateProject;
+exports.writeStaticRawExports = writeStaticRawExports;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map