glotto 3.0.0 → 3.1.0

package/esm/src/contants.js

@@ -1,4 +1,4 @@
-export const DEFAULT_PROVIDER = 'gemini';
+export const DEFAULT_PROVIDER = 'openai';
 export const DEFAULT_MODELS = {
     gemini: 'gemini-2.5-flash',
     openai: 'gpt-4.1-mini',
@@ -8,6 +8,10 @@ export const DEFAULT_MAX_BATCH_BYTES = 12_000;
 export const MAX_RETRIES = 3;
 export const BASE_RETRY_DELAY_MS = 2_000;
 export const INTER_BATCH_DELAY_MS = 1_500;
+export const INTER_LEAF_DELAY_MS = 200;
+export const PER_LEAF_FALLBACK_RATIO = 0.5;
+export const GITHUB_REPO_URL = 'https://github.com/ibodev1/glotto';
+export const CONFIG_FILE_NAME = 'glotto.config.json';
 export const HELP_TEXT = `
 Glotto AI Translator
 -------------------
@@ -23,10 +27,13 @@ Options:
   -p, --provider      AI translation provider to use (default: ${DEFAULT_PROVIDER})
   -m, --model         Model name for the selected provider (optional)
   -i, --input         Path to source JSON file (required)
-  -o, --output        Path to target JSON file (required)
+  -o, --output        Target JSON file path. Comma-separated for multi-target (required)
   -f, --from          Source language (required)
-  -t, --to            Target language (required)
+  -t, --to            Target language. Comma-separated for multi-target (required)
   --url               Custom base URL for OpenAI/Anthropic (optional)
+  --config            Path to a glotto.config.json (default: ./glotto.config.json if present)
+  --stats             Print AI usage stats (input/output tokens, calls) at the end
+  --incremental       Translate only missing/empty keys when the target file already exists
   --no-limit          Disable rate limit delay between batches
   --no-timeout        Disable request timeout (wait indefinitely for AI response)
   --max-batch-size    Maximum source size per batch, in KB (default: ${DEFAULT_MAX_BATCH_BYTES / 1024} KB)
@@ -36,8 +43,10 @@ Options:
 Examples:
   glotto --key {{key}} --input=en.json --output=tr.json --from=english --to=turkish
   glotto --key {{key}} -i en.json -o tr.json -f english -t turkish -p gemini
-  glotto --key {{key}} -i en.json -o tr.json -f english -t turkish -p openai
-  glotto --key {{key}} -i en.json -o tr.json -f english -t turkish -p anthropic
+  glotto --key {{key}} -i en.json -f english -t "turkish,french" -o "tr.json,fr.json"
+  glotto --key {{key}} -i en.json -o tr.json -f english -t turkish --incremental
+  glotto --key {{key}} -i en.json -o tr.json -f english -t turkish --stats
+  glotto --key {{key}} --config ./glotto.config.json
   glotto --key {{key}} -i en.json -o tr.json -f english -t turkish --no-limit --no-timeout
   glotto --key {{key}} -i en.json -o tr.json -f english -t turkish --max-batch-size 8
 `;

package/esm/src/diff.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue, Leaf } from './types.js';
+export declare function findMissingLeaves(sourceLeaves: Leaf[], existingTarget: JsonValue): Leaf[];
+export declare function mergeTranslations(existingTarget: JsonValue, sourceLeaves: Leaf[], translations: Map<number, string>): JsonValue;
+//# sourceMappingURL=diff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/src/diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAQ,MAAM,YAAY,CAAC;AAyBxD,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,IAAI,EAAE,EAAE,cAAc,EAAE,SAAS,GAAG,IAAI,EAAE,CAYzF;AASD,wBAAgB,iBAAiB,CAC/B,cAAc,EAAE,SAAS,EACzB,YAAY,EAAE,IAAI,EAAE,EACpB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,SAAS,CAYX"}

package/esm/src/diff.js

@@ -0,0 +1,53 @@
+import { setPath } from './translator.js';
+function getPath(root, path) {
+    let node = root;
+    for (const key of path) {
+        if (node === null || typeof node !== 'object') {
+            return undefined;
+        }
+        const container = node;
+        if (!(key in container)) {
+            return undefined;
+        }
+        node = container[key];
+    }
+    return node;
+}
+function isPresentTranslation(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    return value.trim().length > 0;
+}
+export function findMissingLeaves(sourceLeaves, existingTarget) {
+    const missing = [];
+    for (const leaf of sourceLeaves) {
+        if (!leaf.translatable) {
+            continue;
+        }
+        const existingValue = getPath(existingTarget, leaf.path);
+        if (!isPresentTranslation(existingValue)) {
+            missing.push(leaf);
+        }
+    }
+    return missing;
+}
+function deepClone(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+export function mergeTranslations(existingTarget, sourceLeaves, translations) {
+    const clone = deepClone(existingTarget);
+    for (const leaf of sourceLeaves) {
+        if (!translations.has(leaf.id)) {
+            continue;
+        }
+        if (leaf.path.length === 0) {
+            return translations.get(leaf.id);
+        }
+        setPath(clone, leaf.path, translations.get(leaf.id));
+    }
+    return clone;
+}

package/esm/src/file.d.ts

@@ -1,5 +1,6 @@
 import type { JsonValue } from './types.js';
-export declare const resolvePath: (...paths: string[]) => string;
-export declare const getImportJson: <T = JsonValue>(input: string) => Promise<T>;
-export declare const writeOutput: (outputPath: string, content: string) => Promise<void>;
+export declare function resolvePath(...paths: string[]): string;
+export declare function getImportJson<T = JsonValue>(input: string): Promise<T>;
+export declare function writeOutput(outputPath: string, content: string): Promise<void>;
+export declare function readJsonIfExists<T = JsonValue>(path: string): Promise<T | null>;
 //# sourceMappingURL=file.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/src/file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,MAAM,EAAE,KAAG,MAA4C,CAAC;AAE9F,eAAO,MAAM,aAAa,GAAU,CAAC,GAAG,SAAS,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,CAAC,CAO3E,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,YAAY,MAAM,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAEnF,CAAC"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/src/file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,wBAAgB,WAAW,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAEtD;AAED,wBAAsB,aAAa,CAAC,CAAC,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAO5E;AAED,wBAAsB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpF;AAED,wBAAsB,gBAAgB,CAAC,CAAC,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAcrF"}

package/esm/src/file.js

@@ -1,14 +1,32 @@
 import * as dntShim from "../_dnt.shims.js";
 import { join } from '../deps/jsr.io/@std/path/1.1.4/mod.js';
-export const resolvePath = (...paths) => join(dntShim.Deno.cwd(), ...paths);
-export const getImportJson = async (input) => {
+export function resolvePath(...paths) {
+    return join(dntShim.Deno.cwd(), ...paths);
+}
+export async function getImportJson(input) {
     const filePath = resolvePath(input);
     const fileContent = await dntShim.Deno.readTextFile(filePath);
     if (typeof fileContent !== 'string' || fileContent.trim() === '') {
         throw new Error('No Content!');
     }
     return JSON.parse(fileContent);
-};
-export const writeOutput = async (outputPath, content) => {
+}
+export async function writeOutput(outputPath, content) {
     await dntShim.Deno.writeTextFile(outputPath, content, { create: true });
-};
+}
+export async function readJsonIfExists(path) {
+    let raw;
+    try {
+        raw = await dntShim.Deno.readTextFile(path);
+    }
+    catch (error) {
+        if (error instanceof dntShim.Deno.errors.NotFound) {
+            return null;
+        }
+        throw error;
+    }
+    if (raw.trim() === '') {
+        return null;
+    }
+    return JSON.parse(raw);
+}

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

@@ -1,9 +1,9 @@
-import type { TextTranslator, TranslateOptions } from '../types.js';
+import type { TextTranslator, TranslateOptions, TranslateResult } from '../types.js';
 declare class AnthropicModel implements TextTranslator {
     private client;
     private model;
     constructor(key: string, baseUrl?: string, modelName?: string, options?: TranslateOptions);
-    translate(prompt: string): Promise<string>;
+    translate(prompt: string): Promise<TranslateResult>;
 }
 export default AnthropicModel;
 //# sourceMappingURL=anthropic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/src/providers/anthropic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpE,cAAM,cAAe,YAAW,cAAc;IAC5C,OAAO,CAAC,MAAM,CAAY;IAC1B,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,MAAM,CAAC;CAYjD;AAED,eAAe,cAAc,CAAC"}
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/src/providers/anthropic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAkB,MAAM,aAAa,CAAC;AAGrG,cAAM,cAAe,YAAW,cAAc;IAC5C,OAAO,CAAC,MAAM,CAAY;IAC1B,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;CAoB1D;AAED,eAAe,cAAc,CAAC"}

package/esm/src/providers/anthropic.js

@@ -28,10 +28,18 @@ class AnthropicModel {
             temperature: 0.2,
             messages: [{ role: 'user', content: prompt }],
         });
-        return message.content
+        const text = message.content
             .filter((part) => part.type === 'text')
             .map((part) => part.text)
             .join('');
+        let usage;
+        if (message.usage) {
+            usage = {
+                inputTokens: message.usage.input_tokens ?? 0,
+                outputTokens: message.usage.output_tokens ?? 0,
+            };
+        }
+        return { text, usage };
     }
 }
 export default AnthropicModel;

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

@@ -1,9 +1,9 @@
-import type { TextTranslator, TranslateOptions } from '../types.js';
+import type { TextTranslator, TranslateOptions, TranslateResult } from '../types.js';
 declare class Gemini implements TextTranslator {
     private genAI;
     private model;
     constructor(key: string, modelName?: string, options?: TranslateOptions);
-    translate(prompt: string): Promise<string>;
+    translate(prompt: string): Promise<TranslateResult>;
 }
 export default Gemini;
 //# sourceMappingURL=gemini.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../../src/src/providers/gemini.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpE,cAAM,MAAO,YAAW,cAAc;IACpC,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,KAAK,CAAS;gBAGpB,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,GAAE,gBAAuD;IAS5D,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAWjD;AAED,eAAe,MAAM,CAAC"}
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../../src/src/providers/gemini.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAkB,MAAM,aAAa,CAAC;AAGrG,cAAM,MAAO,YAAW,cAAc;IACpC,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,KAAK,CAAS;gBAGpB,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,GAAE,gBAAuD;IAS5D,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAmB1D;AAED,eAAe,MAAM,CAAC"}

package/esm/src/providers/gemini.js

@@ -21,7 +21,7 @@ class Gemini {
         });
     }
     async translate(prompt) {
-        const { text } = await this.genAI.models.generateContent({
+        const response = await this.genAI.models.generateContent({
             model: this.model,
             contents: prompt,
             config: {
@@ -29,7 +29,15 @@ class Gemini {
                 temperature: 0.2,
             },
         });
-        return text ?? '';
+        const text = response.text ?? '';
+        let usage;
+        if (response.usageMetadata) {
+            usage = {
+                inputTokens: response.usageMetadata.promptTokenCount ?? 0,
+                outputTokens: response.usageMetadata.candidatesTokenCount ?? 0,
+            };
+        }
+        return { text, usage };
     }
 }
 export default Gemini;

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

@@ -1,9 +1,9 @@
-import type { TextTranslator, TranslateOptions } from '../types.js';
+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<string>;
+    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":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpE,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,MAAM,CAAC;CAQjD;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

@@ -27,7 +27,15 @@ class OpenAIModel {
             messages: [{ role: 'user', content: prompt }],
             temperature: 0.2,
         });
-        return completion.choices[0]?.message?.content ?? '';
+        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,
+            };
+        }
+        return { text, usage };
     }
 }
 export default OpenAIModel;

package/esm/src/translator.d.ts

@@ -1,8 +1,15 @@
-import type { Batch, JsonValue, Leaf, TextTranslator, TranslateOptions } from './types.js';
-export declare const extractLeaves: (data: JsonValue) => Leaf[];
-export declare const groupIntoBatches: (leaves: Leaf[], maxBytes: number) => Batch[];
-export declare const buildBatchPrompt: (from: string, to: string, leaves: Leaf[]) => string;
-export declare const decodeResponse: (text: string) => Map<number, string>;
-export declare const reconstruct: (allLeaves: Leaf[], translations: Map<number, string>) => JsonValue;
-export declare const runBatches: (batches: Batch[], translator: TextTranslator, from: string, to: string, options: TranslateOptions) => Promise<Map<number, string>>;
+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

@@ -1 +1 @@
-{"version":3,"file":"translator.d.ts","sourceRoot":"","sources":["../../src/src/translator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAQ,cAAc,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAQjG,eAAO,MAAM,aAAa,GAAI,MAAM,SAAS,KAAG,IAAI,EAiCnD,CAAC;AAQF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,IAAI,EAAE,EAAE,UAAU,MAAM,KAAG,KAAK,EA0BxE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,EAAE,IAAI,MAAM,EAAE,QAAQ,IAAI,EAAE,KAAG,MAkB3E,CAAC;AAQF,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAS/D,CAAC;AAgBF,eAAO,MAAM,WAAW,GAAI,WAAW,IAAI,EAAE,EAAE,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,SAalF,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,SAAS,KAAK,EAAE,EAChB,YAAY,cAAc,EAC1B,MAAM,MAAM,EACZ,IAAI,MAAM,EACV,SAAS,gBAAgB,KACxB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAgF7B,CAAC"}
+{"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

@@ -1,12 +1,14 @@
 import { logger } from './logger.js';
 import { delay, formatBytes } from './utilites.js';
-import { BASE_RETRY_DELAY_MS, INTER_BATCH_DELAY_MS, MAX_RETRIES } from './contants.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();
-const byteSize = (s) => encoder.encode(s).byteLength;
-export const extractLeaves = (data) => {
+function byteSize(s) {
+    return encoder.encode(s).byteLength;
+}
+export function extractLeaves(data) {
     const out = [];
     let nextId = 0;
-    const walk = (node, path) => {
+    function walk(node, path) {
         if (node === null || typeof node !== 'object') {
             const isString = typeof node === 'string';
             out.push({
@@ -30,17 +32,24 @@ export const extractLeaves = (data) => {
             out.push({ id: ++nextId, path, value: node, translatable: false });
             return;
         }
-        for (const [k, v] of entries)
+        for (const [k, v] of entries) {
             walk(v, [...path, k]);
-    };
+        }
+    }
     walk(data, []);
     return out;
-};
-const TAG_OPEN = (id) => `≪${id}≫`;
-const TAG_CLOSE = (id) => `≪/${id}≫`;
+}
+function tagOpen(id) {
+    return `≪${id}≫`;
+}
+function tagClose(id) {
+    return `≪/${id}≫`;
+}
 const TAG_OVERHEAD_CHARS = 8;
-const wrapEntry = (leaf) => `${TAG_OPEN(leaf.id)}${String(leaf.value)}${TAG_CLOSE(leaf.id)}`;
-export const groupIntoBatches = (leaves, maxBytes) => {
+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 = [];
@@ -62,8 +71,8 @@ export const groupIntoBatches = (leaves, maxBytes) => {
         batches.push({ index: batches.length, leaves: current, byteSize: currentSize });
     }
     return batches;
-};
-export const buildBatchPrompt = (from, to, leaves) => {
+}
+export function buildBatchPrompt(from, to, leaves) {
     const entries = leaves.map(wrapEntry).join('\n');
     return `Translate each tagged entry below from ${from} to ${to}.
 
@@ -81,24 +90,32 @@ What to write back:
 
 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 const decodeResponse = (text) => {
+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))
+            if (!map.has(id)) {
                 map.set(id, match[2].trim());
+            }
         }
     }
     return map;
-};
-const setPath = (root, path, value) => {
+}
+export function setPath(root, path, value) {
     let node = root;
     for (let i = 0; i < path.length - 1; i++) {
         const key = path[i];
@@ -110,10 +127,11 @@ const setPath = (root, path, value) => {
         node = container[key];
     }
     node[path[path.length - 1]] = value;
-};
-export const reconstruct = (allLeaves, translations) => {
-    if (allLeaves.length === 0)
+}
+export function reconstruct(allLeaves, translations) {
+    if (allLeaves.length === 0) {
         return {};
+    }
     const firstStep = allLeaves[0].path[0];
     if (firstStep === undefined) {
         const only = allLeaves[0];
@@ -125,10 +143,115 @@ export const reconstruct = (allLeaves, translations) => {
         setPath(root, leaf.path, value);
     }
     return root;
-};
-export const runBatches = async (batches, translator, from, to, options) => {
+}
+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}]`;
@@ -136,58 +259,19 @@ export const runBatches = async (batches, translator, from, to, options) => {
             logger.info(`Waiting ${INTER_BATCH_DELAY_MS}ms before next batch (rate limit protection)...`);
             await delay(INTER_BATCH_DELAY_MS);
         }
-        let remaining = [...batch.leaves];
-        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);
-                const response = await translator.translate(prompt);
-                if (!response || response.trim().length === 0) {
-                    if (attempt === MAX_RETRIES) {
-                        logger.error(`${label} Failed after ${MAX_RETRIES + 1} attempts: empty response`);
-                        for (const leaf of remaining)
-                            failedIds.push(leaf.id);
-                        break;
-                    }
-                    logger.warn(`${label} Attempt ${attempt + 1} returned empty response`);
-                    continue;
-                }
-                const decoded = decodeResponse(response);
-                const stillMissing = [];
-                for (const leaf of remaining) {
-                    const value = decoded.get(leaf.id);
-                    if (!value || value.trim().length === 0) {
-                        stillMissing.push(leaf);
-                        continue;
-                    }
-                    translations.set(leaf.id, value);
-                }
-                if (stillMissing.length === 0) {
-                    logger.info(`${label} Translated successfully (${formatBytes(batch.byteSize)}, ${batch.leaves.length} entries)`);
-                    break;
-                }
-                if (attempt === MAX_RETRIES) {
-                    logger.error(`${label} Failed after ${MAX_RETRIES + 1} attempts: ${stillMissing.length} entries missing`);
-                    for (const leaf of stillMissing)
-                        failedIds.push(leaf.id);
-                    break;
-                }
-                logger.warn(`${label} ${stillMissing.length}/${remaining.length} entries missing, will retry`);
-                remaining = stillMissing;
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                if (attempt === MAX_RETRIES) {
-                    logger.error(`${label} Failed after ${MAX_RETRIES + 1} attempts: ${message}`);
-                    for (const leaf of remaining)
-                        failedIds.push(leaf.id);
-                    break;
-                }
-                logger.warn(`${label} Attempt ${attempt + 1} failed: ${message}`);
+        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);
             }
         }
     }
@@ -196,5 +280,5 @@ export const runBatches = async (batches, translator, from, to, options) => {
         const more = failedIds.length > 20 ? `, …(+${failedIds.length - 20})` : '';
         throw new Error(`Translation failed for ${failedIds.length} entry/entries (ids: ${preview}${more})`);
     }
-    return translations;
-};
+    return { translations, usage, calls: callCounter.count };
+}