glotto 2.9.0 → 3.1.0

package/esm/src/providers/gemini.js

@@ -1,29 +1,7 @@
 import { GoogleGenAI } from '@google/genai';
-import { encodeBase64 } from '../../deps/jsr.io/@std/encoding/1.0.10/mod.js';
-import { delay, formatBytes, generatePrompts, isValidJson, stripJsonMarkdown } from '../utilites.js';
-import { logger } from '../logger.js';
-import { mergeInputs, writeTemp } from '../file.js';
-import { BASE_RETRY_DELAY_MS, DEFAULT_MODELS, INTER_CHUNK_DELAY_MS, MAX_RETRIES } from '../contants.js';
+import { DEFAULT_MODELS } from '../contants.js';
 class Gemini {
-    constructor(key, chunks, from, to, modelName) {
-        Object.defineProperty(this, "chunks", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "from", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "to", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+    constructor(key, modelName, options = { noLimit: false, noTimeout: false }) {
         Object.defineProperty(this, "genAI", {
             enumerable: true,
             configurable: true,
@@ -36,101 +14,30 @@ class Gemini {
             writable: true,
             value: void 0
         });
-        this.chunks = chunks;
-        this.from = from;
-        this.to = to;
         this.model = modelName ?? DEFAULT_MODELS.gemini;
         this.genAI = new GoogleGenAI({
             apiKey: key,
+            httpOptions: options.noTimeout ? { timeout: 2_147_483_647 } : undefined,
         });
     }
-    async translateChunk(chunk, systemPrompt, userPrompt) {
-        const chunkLabel = `[Chunk ${chunk.index + 1}/${this.chunks.length}]`;
-        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-            try {
-                if (attempt > 0) {
-                    const backoffMs = BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
-                    logger.warn(`${chunkLabel} Retry ${attempt}/${MAX_RETRIES} after ${backoffMs}ms backoff...`);
-                    await delay(backoffMs);
-                }
-                const fileBase64 = encodeBase64(chunk.data);
-                const part = {
-                    inlineData: {
-                        data: fileBase64,
-                        mimeType: 'text/plain',
-                    },
-                };
-                const { text } = await this.genAI.models.generateContent({
-                    model: this.model,
-                    contents: [systemPrompt, userPrompt, part],
-                    config: {
-                        systemInstruction: systemPrompt,
-                        candidateCount: 1,
-                        responseMimeType: 'application/json',
-                        responseLogprobs: false,
-                        temperature: 0.3,
-                        topP: 0.7,
-                        topK: 20,
-                        maxOutputTokens: Number.POSITIVE_INFINITY,
-                    },
-                });
-                if (!text) {
-                    logger.error(`${chunkLabel} Empty response from Gemini AI`);
-                    continue;
-                }
-                const cleanedText = stripJsonMarkdown(text);
-                const tempJsonFileName = `chunk_${chunk.index + 1}.json`;
-                await writeTemp(this.to, tempJsonFileName, cleanedText);
-                if (!isValidJson(cleanedText)) {
-                    if (attempt === MAX_RETRIES) {
-                        logger.error(`${chunkLabel} Failed after ${MAX_RETRIES + 1} attempts: Invalid JSON response`);
-                        return null;
-                    }
-                    logger.error(`${chunkLabel} Invalid JSON response, saved to ${tempJsonFileName}`);
-                    continue;
-                }
-                logger.info(`${chunkLabel} Translated successfully (${formatBytes(chunk.byteSize)}, ${chunk.keyCount} keys)`);
-                return cleanedText;
-            }
-            catch (error) {
-                const isLastAttempt = attempt === MAX_RETRIES;
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                if (isLastAttempt) {
-                    logger.error(`${chunkLabel} Failed after ${MAX_RETRIES + 1} attempts: ${errorMessage}`);
-                    return null;
-                }
-                logger.warn(`${chunkLabel} Attempt ${attempt + 1} failed: ${errorMessage}`);
-            }
-        }
-        return null;
-    }
-    async translate() {
-        const { systemPrompt, userPrompt } = generatePrompts(this.from, this.to);
-        const totalChunks = this.chunks.length;
-        logger.info(`Starting translation: ${totalChunks} chunk(s) to process`);
-        const results = [];
-        const failedChunks = [];
-        for (let i = 0; i < totalChunks; i++) {
-            const chunk = this.chunks[i];
-            if (i > 0) {
-                logger.info(`Waiting ${INTER_CHUNK_DELAY_MS}ms before next chunk (rate limit protection)...`);
-                await delay(INTER_CHUNK_DELAY_MS);
-            }
-            const result = await this.translateChunk(chunk, systemPrompt, userPrompt);
-            if (result) {
-                results.push(result);
-            }
-            else {
-                failedChunks.push(chunk.index + 1);
-            }
-        }
-        if (failedChunks.length > 0) {
-            throw new Error(`Translation failed for chunk(s): ${failedChunks.join(', ')}. Check temp files for partial results.`);
+    async translate(prompt) {
+        const response = await this.genAI.models.generateContent({
+            model: this.model,
+            contents: prompt,
+            config: {
+                candidateCount: 1,
+                temperature: 0.2,
+            },
+        });
+        const text = response.text ?? '';
+        let usage;
+        if (response.usageMetadata) {
+            usage = {
+                inputTokens: response.usageMetadata.promptTokenCount ?? 0,
+                outputTokens: response.usageMetadata.candidatesTokenCount ?? 0,
+            };
         }
-        logger.info(`All ${totalChunks} chunk(s) translated successfully, merging results...`);
-        const jsonInputs = results.map((r) => JSON.parse(r));
-        const mergedContent = mergeInputs(jsonInputs);
-        return JSON.stringify(mergedContent, null, 2);
+        return { text, usage };
     }
 }
 export default Gemini;

package/esm/src/providers/openai.d.ts

@@ -1,14 +1,9 @@
-import OpenAI from 'openai';
-import type { ChunkInfo, Translatable } from '../types.js';
-declare class OpenAIModel implements Translatable {
-    chunks: ChunkInfo[];
-    from: string;
-    to: string;
-    client: OpenAI;
-    model: string;
-    constructor(key: string, chunks: ChunkInfo[], from: string, to: string, baseUrl?: string, modelName?: string);
-    private translateChunk;
-    translate(): Promise<string>;
+import type { TextTranslator, TranslateOptions, TranslateResult } from '../types.js';
+declare class OpenAIModel implements TextTranslator {
+    private client;
+    private model;
+    constructor(key: string, baseUrl?: string, modelName?: string, options?: TranslateOptions);
+    translate(prompt: string): Promise<TranslateResult>;
 }
 export default OpenAIModel;
 //# sourceMappingURL=openai.d.ts.map

package/esm/src/providers/openai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/src/providers/openai.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAc,YAAY,EAAE,MAAM,aAAa,CAAC;AAQvE,cAAM,WAAY,YAAW,YAAY;IACvC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;gBAEF,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;YAW9F,cAAc;IAkEtB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;CAqCnC;AAED,eAAe,WAAW,CAAC"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/src/providers/openai.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAkB,MAAM,aAAa,CAAC;AAGrG,cAAM,WAAY,YAAW,cAAc;IACzC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAS;gBAGpB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,GAAE,gBAAuD;IAU5D,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAgB1D;AAED,eAAe,WAAW,CAAC"}

package/esm/src/providers/openai.js

@@ -1,29 +1,7 @@
 import OpenAI from 'openai';
-import { delay, formatBytes, generatePrompts, isValidJson, stripJsonMarkdown } from '../utilites.js';
-import { logger } from '../logger.js';
-import { mergeInputs, writeTemp } from '../file.js';
-import { BASE_RETRY_DELAY_MS, DEFAULT_MODELS, INTER_CHUNK_DELAY_MS, MAX_RETRIES } from '../contants.js';
-const decoder = new TextDecoder();
+import { DEFAULT_MODELS } from '../contants.js';
 class OpenAIModel {
-    constructor(key, chunks, from, to, baseUrl, modelName) {
-        Object.defineProperty(this, "chunks", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "from", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "to", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+    constructor(key, baseUrl, modelName, options = { noLimit: false, noTimeout: false }) {
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
@@ -36,97 +14,28 @@ class OpenAIModel {
             writable: true,
             value: void 0
         });
-        this.chunks = chunks;
-        this.from = from;
-        this.to = to;
         this.model = modelName ?? DEFAULT_MODELS.openai;
         this.client = new OpenAI({
             apiKey: key,
             baseURL: baseUrl,
+            timeout: options.noTimeout ? 2_147_483_647 : undefined,
         });
     }
-    async translateChunk(chunk, systemPrompt, userPrompt) {
-        const chunkLabel = `[Chunk ${chunk.index + 1}/${this.chunks.length}]`;
-        const sourceJson = decoder.decode(chunk.data);
-        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-            try {
-                if (attempt > 0) {
-                    const backoffMs = BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
-                    logger.warn(`${chunkLabel} Retry ${attempt}/${MAX_RETRIES} after ${backoffMs}ms backoff...`);
-                    await delay(backoffMs);
-                }
-                const response = await this.client.responses.create({
-                    model: this.model,
-                    input: [
-                        {
-                            role: 'user',
-                            content: [
-                                {
-                                    type: 'input_text',
-                                    text: `${systemPrompt}\n\n${userPrompt}\n\nSOURCE_JSON:\n${sourceJson}`,
-                                },
-                            ],
-                        },
-                    ],
-                });
-                const text = response.output_text;
-                if (!text) {
-                    logger.error(`${chunkLabel} Empty response from OpenAI`);
-                    continue;
-                }
-                const cleanedText = stripJsonMarkdown(text);
-                const tempJsonFileName = `chunk_${chunk.index + 1}.json`;
-                await writeTemp(this.to, tempJsonFileName, cleanedText);
-                if (!isValidJson(cleanedText)) {
-                    if (attempt === MAX_RETRIES) {
-                        logger.error(`${chunkLabel} Failed after ${MAX_RETRIES + 1} attempts: Invalid JSON response`);
-                        return null;
-                    }
-                    logger.error(`${chunkLabel} Invalid JSON response, saved to ${tempJsonFileName}`);
-                    continue;
-                }
-                logger.info(`${chunkLabel} Translated successfully (${formatBytes(chunk.byteSize)}, ${chunk.keyCount} keys)`);
-                return cleanedText;
-            }
-            catch (error) {
-                const isLastAttempt = attempt === MAX_RETRIES;
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                if (isLastAttempt) {
-                    logger.error(`${chunkLabel} Failed after ${MAX_RETRIES + 1} attempts: ${errorMessage}`);
-                    return null;
-                }
-                logger.warn(`${chunkLabel} Attempt ${attempt + 1} failed: ${errorMessage}`);
-            }
-        }
-        return null;
-    }
-    async translate() {
-        const { systemPrompt, userPrompt } = generatePrompts(this.from, this.to);
-        const totalChunks = this.chunks.length;
-        logger.info(`Starting translation: ${totalChunks} chunk(s) to process`);
-        const results = [];
-        const failedChunks = [];
-        for (let i = 0; i < totalChunks; i++) {
-            const chunk = this.chunks[i];
-            if (i > 0) {
-                logger.info(`Waiting ${INTER_CHUNK_DELAY_MS}ms before next chunk (rate limit protection)...`);
-                await delay(INTER_CHUNK_DELAY_MS);
-            }
-            const result = await this.translateChunk(chunk, systemPrompt, userPrompt);
-            if (result) {
-                results.push(result);
-            }
-            else {
-                failedChunks.push(chunk.index + 1);
-            }
-        }
-        if (failedChunks.length > 0) {
-            throw new Error(`Translation failed for chunk(s): ${failedChunks.join(', ')}. Check temp files for partial results.`);
+    async translate(prompt) {
+        const completion = await this.client.chat.completions.create({
+            model: this.model,
+            messages: [{ role: 'user', content: prompt }],
+            temperature: 0.2,
+        });
+        const text = completion.choices[0]?.message?.content ?? '';
+        let usage;
+        if (completion.usage) {
+            usage = {
+                inputTokens: completion.usage.prompt_tokens ?? 0,
+                outputTokens: completion.usage.completion_tokens ?? 0,
+            };
         }
-        logger.info(`All ${totalChunks} chunk(s) translated successfully, merging results...`);
-        const jsonInputs = results.map((r) => JSON.parse(r));
-        const mergedContent = mergeInputs(jsonInputs);
-        return JSON.stringify(mergedContent, null, 2);
+        return { text, usage };
     }
 }
 export default OpenAIModel;

package/esm/src/translator.d.ts

@@ -0,0 +1,15 @@
+import type { Batch, JsonValue, Leaf, Path, TextTranslator, TranslateOptions, TranslateUsage } from './types.js';
+export declare function extractLeaves(data: JsonValue): Leaf[];
+export declare function groupIntoBatches(leaves: Leaf[], maxBytes: number): Batch[];
+export declare function buildBatchPrompt(from: string, to: string, leaves: Leaf[]): string;
+export declare function buildSinglePrompt(from: string, to: string, value: string): string;
+export declare function decodeResponse(text: string): Map<number, string>;
+export declare function setPath(root: JsonValue, path: Path, value: JsonValue): void;
+export declare function reconstruct(allLeaves: Leaf[], translations: Map<number, string>): JsonValue;
+export type RunBatchesResult = {
+    translations: Map<number, string>;
+    usage: TranslateUsage;
+    calls: number;
+};
+export declare function runBatches(batches: Batch[], translator: TextTranslator, from: string, to: string, options: TranslateOptions): Promise<RunBatchesResult>;
+//# sourceMappingURL=translator.d.ts.map

package/esm/src/translator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translator.d.ts","sourceRoot":"","sources":["../../src/src/translator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAWjH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,EAAE,CAmCrD;AAgBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,EAAE,CA0B1E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CAkBjF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAMjF;AAQD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAWhE;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAY3E;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,IAAI,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAe3F;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA6IF,wBAAsB,UAAU,CAC9B,OAAO,EAAE,KAAK,EAAE,EAChB,UAAU,EAAE,cAAc,EAC1B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,gBAAgB,CAAC,CAwC3B"}

package/esm/src/translator.js

@@ -0,0 +1,284 @@
+import { logger } from './logger.js';
+import { delay, formatBytes } from './utilites.js';
+import { BASE_RETRY_DELAY_MS, INTER_BATCH_DELAY_MS, INTER_LEAF_DELAY_MS, MAX_RETRIES, PER_LEAF_FALLBACK_RATIO } from './contants.js';
+const encoder = new TextEncoder();
+function byteSize(s) {
+    return encoder.encode(s).byteLength;
+}
+export function extractLeaves(data) {
+    const out = [];
+    let nextId = 0;
+    function walk(node, path) {
+        if (node === null || typeof node !== 'object') {
+            const isString = typeof node === 'string';
+            out.push({
+                id: ++nextId,
+                path,
+                value: node,
+                translatable: isString && node.trim().length > 0,
+            });
+            return;
+        }
+        if (Array.isArray(node)) {
+            if (node.length === 0) {
+                out.push({ id: ++nextId, path, value: node, translatable: false });
+                return;
+            }
+            node.forEach((item, i) => walk(item, [...path, i]));
+            return;
+        }
+        const entries = Object.entries(node);
+        if (entries.length === 0) {
+            out.push({ id: ++nextId, path, value: node, translatable: false });
+            return;
+        }
+        for (const [k, v] of entries) {
+            walk(v, [...path, k]);
+        }
+    }
+    walk(data, []);
+    return out;
+}
+function tagOpen(id) {
+    return `≪${id}≫`;
+}
+function tagClose(id) {
+    return `≪/${id}≫`;
+}
+const TAG_OVERHEAD_CHARS = 8;
+function wrapEntry(leaf) {
+    return `${tagOpen(leaf.id)}${String(leaf.value)}${tagClose(leaf.id)}`;
+}
+export function groupIntoBatches(leaves, maxBytes) {
+    const translatable = leaves.filter((l) => l.translatable);
+    const batches = [];
+    let current = [];
+    let currentSize = 0;
+    for (const leaf of translatable) {
+        const valueBytes = byteSize(String(leaf.value));
+        const idChars = String(leaf.id).length;
+        const overhead = TAG_OVERHEAD_CHARS + idChars * 2 + 1;
+        const itemSize = valueBytes + overhead;
+        if (current.length > 0 && currentSize + itemSize > maxBytes) {
+            batches.push({ index: batches.length, leaves: current, byteSize: currentSize });
+            current = [];
+            currentSize = 0;
+        }
+        current.push(leaf);
+        currentSize += itemSize;
+    }
+    if (current.length > 0) {
+        batches.push({ index: batches.length, leaves: current, byteSize: currentSize });
+    }
+    return batches;
+}
+export function buildBatchPrompt(from, to, leaves) {
+    const entries = leaves.map(wrapEntry).join('\n');
+    return `Translate each tagged entry below from ${from} to ${to}.
+
+Tag format:
+- Every entry is wrapped exactly as ≪N≫value≪/N≫, where N is the entry id (a positive integer).
+- The opening marker is the character ≪ (U+226A), then the id, then ≫ (U+226B). The closing marker is ≪, /, the same id, then ≫.
+- Copy these markers verbatim. Do not put spaces inside them. Do not change them to <<>>, «», <tag>, [n], or any other notation.
+- The id must match the input id of the same entry — never renumber, merge, split, or reorder entries.
+
+What to write back:
+- One ≪N≫translated_value≪/N≫ block per input entry, in the same order, separated by single newlines.
+- Translate only the text that sits between ≪N≫ and ≪/N≫.
+- Preserve every variable ({{name}}, {name}, __VAR__, $t(...), %s, %d), HTML tag, markdown token, escape sequence, and special character inside the value.
+- Output nothing else: no headings, no prose, no commentary, no code fences, no language labels.
+
+Now translate the following entries:
+${entries}`;
+}
+export function buildSinglePrompt(from, to, value) {
+    return `You are a professional ${from} to ${to} translator. Your goal is to accurately convey the meaning and nuances of the original ${from} text while adhering to ${to} grammar, vocabulary, and cultural sensitivities. Preserve every variable ({{name}}, {name}, __VAR__, $t(...), %s, %d), HTML tag, markdown token, escape sequence, and special character exactly as given.
+Produce only the ${to} translation, without any additional explanations, quotes, labels, or commentary. Please translate the following ${from} text into ${to}:
+
+
+${value}`;
+}
+const TAG_PATTERNS = [
+    /≪\s*(\d+)\s*≫([\s\S]*?)≪\s*\/\s*\1\s*≫/g,
+    /<<\s*(\d+)\s*>>([\s\S]*?)<<\s*\/\s*\1\s*>>/g,
+    /«\s*(\d+)\s*»([\s\S]*?)«\s*\/\s*\1\s*»/g,
+];
+export function decodeResponse(text) {
+    const map = new Map();
+    for (const pattern of TAG_PATTERNS) {
+        for (const match of text.matchAll(pattern)) {
+            const id = parseInt(match[1], 10);
+            if (!map.has(id)) {
+                map.set(id, match[2].trim());
+            }
+        }
+    }
+    return map;
+}
+export function setPath(root, path, value) {
+    let node = root;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        const nextKey = path[i + 1];
+        const container = node;
+        if (container[key] === undefined) {
+            container[key] = typeof nextKey === 'number' ? [] : {};
+        }
+        node = container[key];
+    }
+    node[path[path.length - 1]] = value;
+}
+export function reconstruct(allLeaves, translations) {
+    if (allLeaves.length === 0) {
+        return {};
+    }
+    const firstStep = allLeaves[0].path[0];
+    if (firstStep === undefined) {
+        const only = allLeaves[0];
+        return only.translatable ? translations.get(only.id) ?? only.value : only.value;
+    }
+    const root = typeof firstStep === 'number' ? [] : {};
+    for (const leaf of allLeaves) {
+        const value = leaf.translatable && translations.has(leaf.id) ? translations.get(leaf.id) : leaf.value;
+        setPath(root, leaf.path, value);
+    }
+    return root;
+}
+function accumulateUsage(target, source) {
+    if (!source) {
+        return;
+    }
+    target.inputTokens += source.inputTokens;
+    target.outputTokens += source.outputTokens;
+}
+async function translateOne(translator, from, to, value, usage, callCounter) {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        if (attempt > 0) {
+            await delay(BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1));
+        }
+        try {
+            callCounter.count += 1;
+            const response = await translator.translate(buildSinglePrompt(from, to, value));
+            accumulateUsage(usage, response.usage);
+            const trimmed = response.text.trim();
+            if (trimmed.length > 0) {
+                return trimmed;
+            }
+        }
+        catch {
+            if (attempt === MAX_RETRIES) {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+async function runBatchAttempts(batchLeaves, translator, from, to, label, translations, usage, callCounter) {
+    let remaining = [...batchLeaves];
+    let firstAttempt = true;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        if (attempt > 0) {
+            const backoffMs = BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+            logger.warn(`${label} Retry ${attempt}/${MAX_RETRIES} after ${backoffMs}ms backoff (${remaining.length} entries)...`);
+            await delay(backoffMs);
+        }
+        try {
+            const prompt = buildBatchPrompt(from, to, remaining);
+            callCounter.count += 1;
+            const response = await translator.translate(prompt);
+            accumulateUsage(usage, response.usage);
+            const text = response.text;
+            if (!text || text.trim().length === 0) {
+                if (attempt === MAX_RETRIES) {
+                    return remaining;
+                }
+                logger.warn(`${label} Attempt ${attempt + 1} returned empty response`);
+                continue;
+            }
+            const decoded = decodeResponse(text);
+            const stillMissing = [];
+            for (const leaf of remaining) {
+                const value = decoded.get(leaf.id);
+                if (!value || value.trim().length === 0) {
+                    stillMissing.push(leaf);
+                }
+                else {
+                    translations.set(leaf.id, value);
+                }
+            }
+            if (stillMissing.length === 0) {
+                return [];
+            }
+            if (firstAttempt && stillMissing.length >= remaining.length * PER_LEAF_FALLBACK_RATIO) {
+                logger.warn(`${label} Batch mode unreliable for this model (${stillMissing.length}/${remaining.length} missing on first attempt), switching to per-entry mode`);
+                return stillMissing;
+            }
+            logger.warn(`${label} ${stillMissing.length}/${remaining.length} entries missing, will retry`);
+            firstAttempt = false;
+            remaining = stillMissing;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (attempt === MAX_RETRIES) {
+                logger.warn(`${label} Batch attempt failed after retries: ${message}`);
+                return remaining;
+            }
+            logger.warn(`${label} Attempt ${attempt + 1} failed: ${message}`);
+        }
+    }
+    return remaining;
+}
+async function runPerLeafFallback(leaves, translator, from, to, options, label, translations, usage, callCounter) {
+    logger.info(`${label} Per-entry fallback for ${leaves.length} entries`);
+    const failed = [];
+    for (let i = 0; i < leaves.length; i++) {
+        if (i > 0 && !options.noLimit) {
+            await delay(INTER_LEAF_DELAY_MS);
+        }
+        const leaf = leaves[i];
+        const result = await translateOne(translator, from, to, String(leaf.value), usage, callCounter);
+        if (result) {
+            translations.set(leaf.id, result);
+        }
+        else {
+            logger.warn(`${label} Per-entry failed for id=${leaf.id}`);
+            failed.push(leaf);
+        }
+    }
+    return failed;
+}
+export async function runBatches(batches, translator, from, to, options) {
+    const translations = new Map();
+    const failedIds = [];
+    const usage = { inputTokens: 0, outputTokens: 0 };
+    const callCounter = { count: 0 };
+    for (let i = 0; i < batches.length; i++) {
+        const batch = batches[i];
+        const label = `[Batch ${batch.index + 1}/${batches.length}]`;
+        if (i > 0 && !options.noLimit) {
+            logger.info(`Waiting ${INTER_BATCH_DELAY_MS}ms before next batch (rate limit protection)...`);
+            await delay(INTER_BATCH_DELAY_MS);
+        }
+        const missingAfterBatch = await runBatchAttempts(batch.leaves, translator, from, to, label, translations, usage, callCounter);
+        let stillFailed = [];
+        if (missingAfterBatch.length > 0) {
+            stillFailed = await runPerLeafFallback(missingAfterBatch, translator, from, to, options, label, translations, usage, callCounter);
+        }
+        const succeeded = batch.leaves.length - stillFailed.length;
+        if (stillFailed.length === 0) {
+            logger.info(`${label} Translated successfully (${formatBytes(batch.byteSize)}, ${succeeded} entries)`);
+        }
+        else {
+            logger.error(`${label} ${stillFailed.length}/${batch.leaves.length} entries failed permanently`);
+            for (const leaf of stillFailed) {
+                failedIds.push(leaf.id);
+            }
+        }
+    }
+    if (failedIds.length > 0) {
+        const preview = failedIds.slice(0, 20).join(', ');
+        const more = failedIds.length > 20 ? `, …(+${failedIds.length - 20})` : '';
+        throw new Error(`Translation failed for ${failedIds.length} entry/entries (ids: ${preview}${more})`);
+    }
+    return { translations, usage, calls: callCounter.count };
+}