docs-i18n 0.1.0

package/dist/translate-F3AQFN6X.js

@@ -0,0 +1,707 @@
+import "./chunk-QSVWLTGQ.js";
+import {
+  FRONTMATTER_TRANSLATABLE_FIELDS,
+  init_parser
+} from "./chunk-SUIDX6IZ.js";
+import {
+  TranslationCache
+} from "./chunk-XEOYZUHS.js";
+import {
+  flattenSources
+} from "./chunk-3YNFMSJH.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-AKLW2MUS.js";
+
+// src/core/frontmatter.ts
+var frontmatter_exports = {};
+__export(frontmatter_exports, {
+  extractTranslatableFields: () => extractTranslatableFields,
+  reconstructFrontmatter: () => reconstructFrontmatter
+});
+import { parseDocument } from "yaml";
+function getNestedValue(doc, path2) {
+  const parts = path2.split(".");
+  let current = doc;
+  for (const part of parts) {
+    if (current == null) return void 0;
+    if (typeof current.get === "function") {
+      current = current.get(part);
+    } else if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setNestedValue(doc, path2, value) {
+  const parts = path2.split(".");
+  if (parts.length === 1) {
+    if (doc.has(parts[0])) doc.set(parts[0], value);
+    return;
+  }
+  let current = doc;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (typeof current.get === "function") {
+      current = current.get(parts[i]);
+    } else {
+      return;
+    }
+  }
+  const lastKey = parts[parts.length - 1];
+  if (typeof current.set === "function") {
+    current.set(lastKey, value);
+  }
+}
+function extractTranslatableFields(frontmatterText) {
+  const yaml = frontmatterText.replace(/^---\n/, "").replace(/\n---$/, "");
+  const doc = parseDocument(yaml);
+  const fields = {};
+  for (const field of FRONTMATTER_TRANSLATABLE_FIELDS) {
+    const value = getNestedValue(doc, field);
+    if (typeof value === "string" && value.trim()) {
+      fields[field] = value;
+    }
+  }
+  return fields;
+}
+function reconstructFrontmatter(frontmatterText, translatedFields) {
+  const yaml = frontmatterText.replace(/^---\n/, "").replace(/\n---$/, "");
+  const doc = parseDocument(yaml);
+  for (const [field, value] of Object.entries(translatedFields)) {
+    setNestedValue(doc, field, value);
+  }
+  return `---
+${doc.toString().trimEnd()}
+---`;
+}
+var init_frontmatter = __esm({
+  "src/core/frontmatter.ts"() {
+    "use strict";
+    init_parser();
+  }
+});
+
+// src/commands/translate.ts
+import { resolve } from "path";
+
+// src/core/translator.ts
+import OpenAI from "openai";
+var DEFAULT_MAX_TOKENS = 16384;
+var MAX_RETRIES = 3;
+var INITIAL_BACKOFF_MS = 2e3;
+function stripThinkingBlock(text) {
+  return text.replace(/<think>[\s\S]*?<\/think>\s*/g, "").trim();
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function extractJson(response) {
+  let raw = stripThinkingBlock(response);
+  raw = raw.replace(/^```(?:json)?\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) {
+    return raw.trim();
+  }
+  return raw.substring(start, end + 1);
+}
+function repairJson(raw) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (escaped) {
+      result += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      result += ch;
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      result += ch;
+      continue;
+    }
+    if (inString && ch === "\n") {
+      result += "\\n";
+      continue;
+    }
+    if (inString && ch === "\r") {
+      continue;
+    }
+    if (inString && ch === "	") {
+      result += "\\t";
+      continue;
+    }
+    result += ch;
+  }
+  result = result.replace(/,\s*}/g, "}");
+  const trimmed = result.trim();
+  if (trimmed.startsWith("{") && !trimmed.endsWith("}")) {
+    const lastQuote = result.lastIndexOf('"');
+    if (lastQuote > 0) {
+      result = `${result.substring(0, lastQuote + 1)}}`;
+    }
+  }
+  return result;
+}
+var deadModels = /* @__PURE__ */ new Set();
+var rateLimitedModels = /* @__PURE__ */ new Set();
+function pickModel(opts) {
+  if (opts.modelRotate && opts.modelRotate.length > 0) {
+    const alive = opts.modelRotate.filter((m) => !deadModels.has(m));
+    if (alive.length === 0) {
+      deadModels.clear();
+      return opts.modelRotate[0];
+    }
+    const preferred = alive.filter((m) => !rateLimitedModels.has(m));
+    if (preferred.length > 0) return preferred[0];
+    rateLimitedModels.clear();
+    return alive[0];
+  }
+  return opts.model;
+}
+function isModelError(msg) {
+  return msg.includes("400") && msg.includes("not a valid") || msg.includes("404") || msg.includes("No endpoints found") || msg.includes("Empty response from API") || msg.includes("guardrail restrictions");
+}
+function resolveApiConfig(opts) {
+  const apiType = opts.apiType ?? "openrouter";
+  if (apiType === "openrouter") {
+    const apiKey2 = opts.apiKey ?? process.env.OPENROUTER_API_KEY ?? "";
+    if (!apiKey2) {
+      throw new Error(
+        "No API key found. Set OPENROUTER_API_KEY in .env or pass --api-key."
+      );
+    }
+    return {
+      baseURL: opts.apiBaseUrl ?? "https://openrouter.ai/api/v1",
+      apiKey: apiKey2,
+      model: pickModel(opts) ?? process.env.OPENROUTER_MODEL ?? "deepseek/deepseek-chat-v3-0324:free"
+    };
+  }
+  if (apiType === "openai") {
+    const apiKey2 = opts.apiKey ?? process.env.OPENAI_API_KEY ?? "";
+    if (!apiKey2) {
+      throw new Error(
+        "No API key found. Set OPENAI_API_KEY or pass --api-key."
+      );
+    }
+    return {
+      baseURL: opts.apiBaseUrl ?? "https://api.deepseek.com",
+      apiKey: apiKey2,
+      model: pickModel(opts) ?? "deepseek-chat"
+    };
+  }
+  const apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
+  if (!apiKey) {
+    throw new Error(
+      "No API key found. Set ANTHROPIC_API_KEY or pass --api-key."
+    );
+  }
+  return {
+    baseURL: opts.apiBaseUrl ?? "https://api.anthropic.com/v1",
+    apiKey,
+    model: pickModel(opts) ?? "claude-sonnet-4-20250514"
+  };
+}
+function buildJsonPrompt(opts) {
+  let prompt = `You are a professional technical translator specializing in software documentation.
+
+TASK: Translate the provided nodes to ${opts.langName} and return as JSON.
+
+INPUT: A JSON object with a "nodes" array. Each node has:
+- "key": unique identifier (use as key in your response)
+- "type": one of heading, paragraph, list, blockquote, html
+- "text": the content to translate
+
+OUTPUT: A single valid JSON object mapping each key to its translation. No other text.
+
+RULES:
+1. Return ONLY valid JSON. No markdown fences, no explanation.
+2. Escape newlines as \\n in JSON strings. Output must be parseable JSON.
+3. Translate EVERY node. Do not skip any key.
+4. Preserve Markdown: heading levels (##), links [text](url), inline \`code\`, **bold**, *italic*.
+5. Keep code blocks, file paths, URLs, variable names, component names unchanged.
+6. Keep HTML/JSX tags balanced: <AppOnly></AppOnly>, <PagesOnly></PagesOnly>.
+7. CRITICAL: Inline code wrapped in backticks (\`...\`) MUST keep the backticks. Example: \`<Link>\` must stay as \`<Link>\`, NOT become bare <Link>. Bare HTML tags will BREAK the document.
+
+TYPE-SPECIFIC RULES:
+- "heading": Keep ## or ### prefix exactly as original.
+- "list": Keep - or 1. markers and indentation.
+- "blockquote": Keep > prefix.
+- "html": Translate human text only. Keep all tags/attributes unchanged.
+
+EXAMPLE:
+Input: {"nodes":[{"key":"b2","type":"heading","text":"## Installation"},{"key":"c3","type":"paragraph","text":"Run the following command:"}]}
+Output: {"b2":"## \u5B89\u88C5","c3":"\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\uFF1A"}`;
+  if (opts.docsContext) {
+    prompt += `
+
+CONTEXT:
+${opts.docsContext}`;
+  }
+  if (opts.guide) {
+    prompt += `
+
+GUIDELINES:
+${opts.guide}`;
+  }
+  return prompt;
+}
+function buildJsonUserMessage(uncached, nodeTypes) {
+  const { extractTranslatableFields: extractTranslatableFields2 } = (init_frontmatter(), __toCommonJS(frontmatter_exports));
+  const nodes = [];
+  const frontmatterMap = /* @__PURE__ */ new Map();
+  for (const [md5, text] of Object.entries(uncached)) {
+    const type = nodeTypes[md5] ?? "paragraph";
+    if (type === "frontmatter") {
+      const fields = extractTranslatableFields2(text);
+      if (Object.keys(fields).length === 0) continue;
+      const fieldKeys = {};
+      for (const [field, value] of Object.entries(fields)) {
+        const virtualKey = `fm:${md5}:${field}`;
+        fieldKeys[field] = virtualKey;
+        nodes.push({ key: virtualKey, type: "paragraph", text: value });
+      }
+      frontmatterMap.set(md5, { source: text, fieldKeys });
+    } else {
+      nodes.push({ key: md5, type, text });
+    }
+  }
+  return { message: JSON.stringify({ nodes }), frontmatterMap };
+}
+async function translateJsonChunk(opts) {
+  const systemPrompt = buildJsonPrompt({
+    langName: opts.langName,
+    guide: opts.guide,
+    docsContext: opts.docsContext
+  });
+  const { message: userMessage, frontmatterMap } = buildJsonUserMessage(
+    opts.uncached,
+    opts.nodeTypes
+  );
+  const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const log = opts.logger ?? console.warn;
+  let lastError;
+  const requestedMd5s = (() => {
+    const keys = [];
+    for (const md5 of Object.keys(opts.uncached)) {
+      if (frontmatterMap.has(md5)) {
+        const info = frontmatterMap.get(md5);
+        keys.push(...Object.values(info.fieldKeys));
+      } else {
+        keys.push(md5);
+      }
+    }
+    return keys;
+  })();
+  log(
+    `\u{1F4E4} SYSTEM PROMPT (${systemPrompt.length} chars):
+${systemPrompt}
+--- END SYSTEM PROMPT ---`
+  );
+  log(
+    `\u{1F4E4} USER MESSAGE (${userMessage.length} chars):
+${userMessage}
+--- END USER MESSAGE ---`
+  );
+  const maxAttempts = opts.modelRotate && opts.modelRotate.length > 0 ? MAX_RETRIES + opts.modelRotate.length : MAX_RETRIES;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const { baseURL, apiKey, model } = resolveApiConfig(opts);
+    const client = new OpenAI({ baseURL, apiKey });
+    const modelCap = opts.modelMaxTokens?.get(model);
+    const effectiveMaxTokens = modelCap ? Math.min(maxTokens, modelCap) : maxTokens;
+    log(
+      `\u{1F527} attempt=${attempt}/${maxAttempts} model=${model} keys=${requestedMd5s.length} max_tokens=${effectiveMaxTokens}`
+    );
+    try {
+      const t0 = Date.now();
+      const params = {
+        model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userMessage }
+        ],
+        max_tokens: effectiveMaxTokens,
+        reasoning: { exclude: true }
+      };
+      if (!opts.noSchema) {
+        params.response_format = {
+          type: "json_schema",
+          json_schema: {
+            name: "translation_result",
+            strict: false,
+            schema: {
+              type: "object",
+              properties: Object.fromEntries(
+                requestedMd5s.map((k) => [k, { type: "string" }])
+              ),
+              required: requestedMd5s,
+              additionalProperties: false
+            }
+          }
+        };
+        params.provider = { require_parameters: true };
+      }
+      const response = await client.chat.completions.create(params);
+      const elapsed = Date.now() - t0;
+      const choice = response.choices?.[0];
+      const usage = response.usage;
+      log(
+        `\u{1F4E5} response in ${(elapsed / 1e3).toFixed(1)}s | finish=${choice?.finish_reason} | content=${choice?.message?.content?.length ?? 0} chars` + (usage ? ` | tokens: in=${usage.prompt_tokens} out=${usage.completion_tokens} total=${usage.total_tokens}` : "")
+      );
+      if (choice?.message?.content) {
+        log(
+          `\u{1F4E5} RESPONSE BODY:
+${choice.message.content}
+--- END RESPONSE BODY ---`
+        );
+      }
+      if (!choice?.message?.content) {
+        throw new Error("Empty response from API");
+      }
+      if (choice.finish_reason === "length") {
+        throw new Error(
+          `Output truncated (finish_reason=length). Model hit max_tokens=${maxTokens}.`
+        );
+      }
+      const raw = extractJson(choice.message.content);
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        try {
+          parsed = JSON.parse(repairJson(raw));
+        } catch {
+          throw new Error(`Failed to parse JSON: ${raw.substring(0, 200)}...`);
+        }
+      }
+      if (Object.keys(parsed).length === 1 && typeof Object.values(parsed)[0] === "object") {
+        const inner = Object.values(parsed)[0];
+        log("\u{1F504} Unwrapping nested JSON object");
+        parsed = inner;
+      }
+      const returnedMd5s = new Set(Object.keys(parsed));
+      const missing = requestedMd5s.filter((md5) => !returnedMd5s.has(md5));
+      const extra = [...returnedMd5s].filter(
+        (md5) => !requestedMd5s.includes(md5)
+      );
+      if (missing.length > 0) {
+        log(`\u26A0\uFE0F JSON missing ${missing.length}/${requestedMd5s.length} keys`);
+      }
+      if (extra.length > 0) {
+        log(`\u26A0\uFE0F JSON has ${extra.length} extra keys`);
+        if (missing.length > requestedMd5s.length * 0.5) {
+          log("   Extra key samples:");
+          for (const k of extra.slice(0, 3)) {
+            log(
+              `     ${k.substring(0, 16)}\u2026 = ${String(parsed[k]).substring(0, 60).replace(/\n/g, "\u21B5")}`
+            );
+          }
+          log("   Expected key samples:");
+          for (const k of requestedMd5s.slice(0, 3)) {
+            log(`     ${k.substring(0, 16)}\u2026`);
+          }
+        }
+      }
+      if (extra.length > 0 && missing.length > 0) {
+        for (const extraKey of extra) {
+          let bestMatch = null;
+          let bestDist = Number.POSITIVE_INFINITY;
+          for (const missKey of missing) {
+            let diff = Math.abs(extraKey.length - missKey.length);
+            const minLen = Math.min(extraKey.length, missKey.length);
+            for (let i = 0; i < minLen; i++) {
+              if (extraKey[i] !== missKey[i]) diff++;
+            }
+            if (diff < bestDist) {
+              bestDist = diff;
+              bestMatch = missKey;
+            }
+          }
+          if (bestMatch && bestDist <= 3) {
+            log(
+              `\u{1F527} Recovered key: ${extraKey} \u2192 ${bestMatch} (${bestDist} char diff)`
+            );
+            parsed[bestMatch] = parsed[extraKey];
+            missing.splice(missing.indexOf(bestMatch), 1);
+          }
+        }
+      }
+      const values = Object.values(parsed);
+      if (values.length > 3) {
+        const freq = /* @__PURE__ */ new Map();
+        for (const v of values) freq.set(v, (freq.get(v) ?? 0) + 1);
+        const maxFreq = Math.max(...freq.values());
+        if (maxFreq > values.length * 0.5) {
+          const dupVal = [...freq.entries()].find(
+            ([, c]) => c === maxFreq
+          )?.[0];
+          const msg = `Model returned identical value for ${maxFreq}/${values.length} keys: "${dupVal?.substring(0, 60)}..."`;
+          log(`\u{1F5D1}\uFE0F ${msg}`);
+          if (opts.modelRotate?.length) {
+            deadModels.add(model);
+            log(`\u{1F480} Model ${model} produces garbage, skipping`);
+            continue;
+          }
+          throw new Error(msg);
+        }
+      }
+      const translations = {};
+      for (const md5 of requestedMd5s) {
+        if (parsed[md5]) {
+          translations[md5] = parsed[md5];
+        }
+      }
+      if (frontmatterMap.size > 0) {
+        const { reconstructFrontmatter: reconstructFrontmatter2 } = (init_frontmatter(), __toCommonJS(frontmatter_exports));
+        for (const [fmMd5, info] of frontmatterMap) {
+          const fields = {};
+          let allFound = true;
+          for (const [field, vKey] of Object.entries(info.fieldKeys)) {
+            if (translations[vKey]) {
+              fields[field] = translations[vKey];
+              delete translations[vKey];
+            } else {
+              allFound = false;
+            }
+          }
+          if (Object.keys(fields).length > 0) {
+            translations[fmMd5] = reconstructFrontmatter2(info.source, fields);
+            log(
+              `\u2705 Frontmatter ${fmMd5.substring(0, 8)}: ${Object.keys(fields).join(", ")}`
+            );
+          }
+          if (!allFound) {
+            const vKeys = new Set(Object.values(info.fieldKeys));
+            const idx = missing.findIndex((m) => vKeys.has(m));
+            while (idx >= 0) {
+              missing.splice(idx, 1);
+            }
+          }
+        }
+      }
+      return { translations, missing, extra };
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      const msg = lastError.message;
+      if (isModelError(msg) && opts.modelRotate?.length) {
+        deadModels.add(model);
+        log(`\u{1F480} Model ${model} is dead (${msg.substring(0, 80)}), skipping`);
+        continue;
+      }
+      if (msg.includes("429") && opts.modelRotate?.length) {
+        rateLimitedModels.add(model);
+        const alive = opts.modelRotate.filter(
+          (m) => !deadModels.has(m) && !rateLimitedModels.has(m)
+        );
+        if (alive.length === 0) {
+          const waitSec = 30;
+          log(
+            `\u23F3 All models rate-limited. Waiting ${waitSec}s before retry...`
+          );
+          await sleep(waitSec * 1e3);
+          rateLimitedModels.clear();
+        } else {
+          log(`\u23F3 Model ${model} rate-limited, trying next model`);
+        }
+        continue;
+      }
+      const isRetryable = msg.includes("429") || msg.includes("503") || msg.includes("405") || msg.includes("timeout") || msg.includes("ECONNRESET") || msg.includes("truncated") || msg.includes("Empty response") || msg.includes("Failed to parse JSON");
+      if (!isRetryable || attempt === maxAttempts) {
+        throw lastError;
+      }
+      const backoff = INITIAL_BACKOFF_MS * 2 ** (attempt - 1);
+      log(
+        `\u26A0\uFE0F Attempt ${attempt}/${maxAttempts} failed: ${msg}. Retrying in ${backoff / 1e3}s...`
+      );
+      await sleep(backoff);
+    }
+  }
+  throw lastError ?? new Error("Translation failed after retries");
+}
+
+// src/core/ui.ts
+import fs from "fs";
+import path from "path";
+var FileLogger = class {
+  logDir;
+  streams = /* @__PURE__ */ new Map();
+  constructor(baseDir, lang) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
+    this.logDir = path.join(baseDir, `${ts}-translate-${lang}`);
+    fs.mkdirSync(this.logDir, { recursive: true });
+    this.log("_run", `Started at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    this.log("_run", `Language: ${lang}`);
+  }
+  getLogDir() {
+    return this.logDir;
+  }
+  log(file, message) {
+    const safeName = file.replace(/\//g, "__");
+    let stream = this.streams.get(safeName);
+    if (!stream) {
+      const logPath = path.join(this.logDir, `${safeName}.log`);
+      stream = fs.createWriteStream(logPath, { flags: "a" });
+      this.streams.set(safeName, stream);
+    }
+    const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+    stream.write(`[${ts}] ${message}
+`);
+  }
+  close() {
+    for (const stream of this.streams.values()) {
+      stream.end();
+    }
+    this.streams.clear();
+  }
+};
+
+// src/commands/translate.ts
+var OUTPUT_MULTIPLIER = {
+  ja: 2.5,
+  ko: 2.5,
+  hi: 2.5,
+  th: 2.5,
+  ru: 2,
+  ar: 2,
+  uk: 2,
+  he: 2,
+  "zh-hans": 1.5,
+  "zh-hant": 1.5,
+  de: 1.3,
+  fr: 1.3,
+  pt: 1.3,
+  es: 1.2,
+  vi: 1.2
+};
+async function translate(config, opts) {
+  const lang = opts.lang;
+  const cacheDir = resolve(config.cacheDir ?? ".cache");
+  const cache = new TranslationCache(cacheDir);
+  cache.load(lang);
+  const sources = flattenSources(config);
+  const llm = config.llm ?? {};
+  const maxTokens = opts.maxTokens ?? llm.maxTokens ?? 16384;
+  const contextLength = opts.contextLength ?? llm.contextLength ?? 32768;
+  const model = opts.model ?? llm.model ?? "";
+  const apiType = llm.provider ?? "openrouter";
+  const docsContext = config.context ?? "";
+  for (const source of sources) {
+    if (opts.project && source.project !== opts.project) continue;
+    if (opts.version && source.version !== opts.version) continue;
+    console.log(`
+\u{1F4E6} Translating ${source.versionKey} \u2192 ${lang}`);
+    console.log(`   Model: ${model || "default"}`);
+    const fileFilter = opts.files?.length ? opts.files : void 0;
+    if (fileFilter) {
+      console.log(`   Files: ${fileFilter.length} selected`);
+    }
+    const untranslated = cache.untranslatedKeys(lang, source.versionKey, 0, fileFilter);
+    console.log(`   ${untranslated.length} untranslated keys`);
+    if (untranslated.length === 0) {
+      console.log("   \u2705 All translated.");
+      continue;
+    }
+    const outputMultiplier = OUTPUT_MULTIPLIER[lang] ?? 2;
+    const SYSTEM_PROMPT_TOKENS = 700;
+    const JSON_OVERHEAD = 200;
+    const maxCompletionTokens = Math.min(maxTokens, contextLength - 4096);
+    const inputBudget = Math.floor(
+      (contextLength - maxCompletionTokens - SYSTEM_PROMPT_TOKENS - JSON_OVERHEAD) * 0.85
+    );
+    const outputBudget = Math.floor(maxCompletionTokens * 0.75);
+    const chunks = [[]];
+    let curIn = SYSTEM_PROMPT_TOKENS;
+    let curOut = JSON_OVERHEAD;
+    for (const k of untranslated) {
+      const inTok = Math.ceil(k.text.length / 4 + 80);
+      const outTok = Math.ceil(k.text.length * outputMultiplier / 4 + 80);
+      if ((curIn + inTok > inputBudget || curOut + outTok > outputBudget) && chunks[chunks.length - 1].length > 0) {
+        chunks.push([]);
+        curIn = SYSTEM_PROMPT_TOKENS;
+        curOut = JSON_OVERHEAD;
+      }
+      chunks[chunks.length - 1].push(k);
+      curIn += inTok;
+      curOut += outTok;
+    }
+    const maxChunks = Math.min(chunks.length, opts.max ?? 999);
+    const totalKeys = chunks.slice(0, maxChunks).reduce((s, c) => s + c.length, 0);
+    console.log(`   ${chunks.length} chunks, ${maxChunks} to process (${totalKeys} keys)`);
+    if (opts.dryRun) {
+      console.log("   \u23ED\uFE0F  Dry run \u2014 skipping API calls");
+      continue;
+    }
+    const logDir = resolve(".logs");
+    const fileLogger = new FileLogger(logDir, lang);
+    const concurrency = opts.concurrency ?? 3;
+    const startTime = Date.now();
+    let totalCached = 0;
+    let totalMissing = 0;
+    let chunkErrors = 0;
+    async function processChunk(i) {
+      const chunk = chunks[i];
+      const uncached = {};
+      const nodeTypes = {};
+      for (const k of chunk) {
+        uncached[k.key] = k.text;
+        nodeTypes[k.key] = k.type;
+      }
+      const chunkLog = `_md5-chunk-${String(i + 1).padStart(3, "0")}`;
+      const clog = (msg) => fileLogger.log(chunkLog, msg);
+      const label = `chunk ${i + 1}/${maxChunks} (${chunk.length} keys)`;
+      console.log(`\u23F3 ${label}...`);
+      try {
+        const result = await translateJsonChunk({
+          assembledContent: "",
+          uncached,
+          nodeTypes,
+          langName: lang,
+          guide: "",
+          apiType,
+          model: model || void 0,
+          maxTokens,
+          filePath: chunkLog,
+          logger: clog,
+          docsContext
+        });
+        let cached = 0;
+        for (const [key, translation] of Object.entries(result.translations)) {
+          if (typeof translation !== "string" || !translation.trim()) continue;
+          cache.set(lang, key, translation);
+          cached++;
+        }
+        totalCached += cached;
+        totalMissing += result.missing.length;
+        console.log(`\u2705 ${label} \u2014 +${cached} cached, ${result.missing.length} missing`);
+      } catch (err) {
+        chunkErrors++;
+        console.error(`\u274C ${label} \u2014 ${err instanceof Error ? err.message.substring(0, 100) : err}`);
+      }
+    }
+    const running = /* @__PURE__ */ new Set();
+    for (let i = 0; i < maxChunks; i++) {
+      const p = processChunk(i).finally(() => running.delete(p));
+      running.add(p);
+      if (running.size >= concurrency) await Promise.race(running);
+    }
+    await Promise.all(running);
+    const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+    console.log(`
+\u2705 ${source.versionKey}/${lang}: +${totalCached} cached, ${totalMissing} missing, ${chunkErrors} errors (${elapsed}s)`);
+    fileLogger.close();
+  }
+  cache.db.close();
+}
+export {
+  translate
+};