glotfile 0.6.4 → 0.7.1

package/dist/server/cli.js

@@ -1969,6 +1969,9 @@ var init_export_run = __esm({
 });
 
 // src/server/ai/provider.ts
+function supportsBatchTranslate(p) {
+  return typeof p.submitTranslationBatch === "function";
+}
 function buildSystemPrompt(hasPluralItems) {
   const lines = [
     "You are a professional software localization engine for a UI string catalog.",
@@ -2277,6 +2280,53 @@ var init_anthropic = __esm({
           return {};
         }
       }
+      batchesClient() {
+        const b = this.client.messages.batches;
+        if (!b) throw new Error("Anthropic client has no batches support.");
+        return b;
+      }
+      // Each job becomes one batch entry whose params mirror callBatch exactly —
+      // same prompts, schema, and vision blocks — so batch and sync replies are
+      // interchangeable downstream.
+      async submitTranslationBatch(jobs) {
+        const requests = jobs.map((job) => ({
+          custom_id: job.customId,
+          params: {
+            model: this.config.model,
+            max_tokens: 8192,
+            // Batch entries don't share a live cache window, so cache_control is omitted here.
+            system: [{ type: "text", text: buildSystemPrompt(job.requests.some((r) => r.plural !== void 0)) }],
+            output_config: { format: { type: "json_schema", schema: BATCH_SCHEMA } },
+            messages: [{ role: "user", content: this.buildUserContent(job.requests) }]
+          }
+        }));
+        const res = await this.batchesClient().create({ requests });
+        return res.id;
+      }
+      async translationBatchStatus(batchId) {
+        const r = await this.batchesClient().retrieve(batchId);
+        return { status: r.processing_status, counts: r.request_counts };
+      }
+      async translationBatchResults(batchId) {
+        const out = /* @__PURE__ */ new Map();
+        for await (const entry of await this.batchesClient().results(batchId)) {
+          if (entry.result.type !== "succeeded") {
+            out.set(entry.custom_id, { type: "failed", error: entry.result.error?.message ?? entry.result.type });
+            continue;
+          }
+          const text = entry.result.message?.content.find((b) => b.type === "text")?.text ?? "";
+          try {
+            out.set(entry.custom_id, { type: "items", items: parseReplyItems(text) });
+          } catch (err) {
+            if (!(err instanceof MalformedReplyError)) throw err;
+            out.set(entry.custom_id, { type: "malformed", raw: err.raw });
+          }
+        }
+        return out;
+      }
+      async cancelTranslationBatch(batchId) {
+        await this.batchesClient().cancel(batchId);
+      }
       async callBatch(batch, signal) {
         const content = this.buildUserContent(batch);
         const res = await this.client.messages.create({
@@ -3050,6 +3100,143 @@ var init_run = __esm({
   }
 });
 
+// src/server/ai/pending-batch.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3, rmSync as rmSync4 } from "fs";
+import { join as join3 } from "path";
+function pendingBatchPath(projectRoot) {
+  return join3(projectRoot, ".glotfile", "batch.json");
+}
+function loadPendingBatch(projectRoot) {
+  const path = pendingBatchPath(projectRoot);
+  if (!existsSync6(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    if (parsed?.version !== 1) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function savePendingBatch(projectRoot, pending) {
+  const dir = join3(projectRoot, ".glotfile");
+  mkdirSync4(dir, { recursive: true });
+  const gitignore = join3(dir, ".gitignore");
+  if (!existsSync6(gitignore)) writeFileSync3(gitignore, "*\n");
+  writeFileSync3(pendingBatchPath(projectRoot), JSON.stringify(pending, null, 2) + "\n");
+}
+function clearPendingBatch(projectRoot) {
+  rmSync4(pendingBatchPath(projectRoot), { force: true });
+}
+var init_pending_batch = __esm({
+  "src/server/ai/pending-batch.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/ai/batch-run.ts
+function buildBatchJobs(reqs, batchSize) {
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const req of reqs) {
+    let group = byLocale.get(req.targetLocale);
+    if (!group) {
+      group = [];
+      byLocale.set(req.targetLocale, group);
+    }
+    group.push(req);
+  }
+  const jobs = [];
+  for (const [locale, group] of byLocale) {
+    chunk(group, Math.max(1, batchSize)).forEach((batch, i) => {
+      const safeLocale = locale.replace(/[^a-zA-Z0-9-]/g, "-").slice(0, 56);
+      jobs.push({ customId: `${safeLocale}_${i}`, locale, requests: batch });
+    });
+  }
+  return jobs;
+}
+async function submitBatchTranslation(state, provider, reqs, batchSize, model, projectRoot) {
+  if (loadPendingBatch(projectRoot)) {
+    throw new Error("A translation batch is already pending. Apply or cancel it first (`glotfile batch`).");
+  }
+  const jobs = buildBatchJobs(reqs, batchSize);
+  const batchId = await provider.submitTranslationBatch(jobs);
+  const pending = {
+    version: 1,
+    // Only Anthropic implements batch translation today.
+    provider: "anthropic",
+    model,
+    batchId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    total: reqs.length,
+    jobs: jobs.map((j) => ({
+      customId: j.customId,
+      locale: j.locale,
+      requests: j.requests.map((r) => {
+        const { image: _image, ...rest } = r;
+        return { ...rest, sourceHash: sourceHash(state.keys[r.key], state.config.sourceLocale) };
+      })
+    }))
+  };
+  savePendingBatch(projectRoot, pending);
+  return pending;
+}
+async function applyBatchResults(load, persist, provider, pending, projectRoot, ai) {
+  const outcomes = await provider.translationBatchResults(pending.batchId);
+  const fresh = load();
+  const isStale = (r) => {
+    const entry = fresh.keys[r.key];
+    return !entry || sourceHash(entry, fresh.config.sourceLocale) !== r.sourceHash;
+  };
+  const applied = [];
+  const results = [];
+  const retryReqs = [];
+  let staleSkipped = 0;
+  for (const job of pending.jobs) {
+    const outcome = outcomes.get(job.customId);
+    const itemsById = outcome?.type === "items" ? new Map(outcome.items.map((i) => [i.id, i])) : null;
+    for (const stored of job.requests) {
+      if (isStale(stored)) {
+        staleSkipped++;
+        continue;
+      }
+      const { sourceHash: _hash, ...req } = stored;
+      if (!itemsById) {
+        retryReqs.push(req);
+        continue;
+      }
+      applied.push(req);
+      results.push(validateReply(req, itemsById.get(req.id)));
+    }
+  }
+  let screenshotsSkipped = 0;
+  if (retryReqs.length) {
+    const { skipped } = attachScreenshotsForProvider(retryReqs, fresh, projectRoot, provider.supportsVision());
+    screenshotsSkipped = skipped;
+    const retryResults = await runLocaleParallel(
+      retryReqs,
+      provider,
+      {},
+      ai.concurrency,
+      void 0,
+      ai.batchSize
+    );
+    applied.push(...retryReqs);
+    results.push(...retryResults);
+  }
+  const { written, errors } = applyResults(fresh, applied, results);
+  persist(fresh);
+  clearPendingBatch(projectRoot);
+  return { written, errors, staleSkipped, retried: retryReqs.length, screenshotsSkipped };
+}
+var init_batch_run = __esm({
+  "src/server/ai/batch-run.ts"() {
+    "use strict";
+    init_suppress();
+    init_batch();
+    init_run();
+    init_pending_batch();
+  }
+});
+
 // src/server/ai/pricing.ts
 function bareModelId(model) {
   let id = model.trim().toLowerCase();
@@ -3163,7 +3350,7 @@ var init_estimate = __esm({
 });
 
 // src/server/log.ts
-import { appendFileSync, readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
+import { appendFileSync, readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
 import { resolve as resolve5 } from "path";
 function logPath(projectRoot) {
   return resolve5(projectRoot, ".glotfile", "log.jsonl");
@@ -3174,8 +3361,8 @@ function appendLog(projectRoot, entry) {
 }
 function readLog(projectRoot, limit = 100) {
   const path = logPath(projectRoot);
-  if (!existsSync6(path)) return [];
-  const lines = readFileSync6(path, "utf8").split("\n").filter((l) => l.trim() !== "");
+  if (!existsSync7(path)) return [];
+  const lines = readFileSync7(path, "utf8").split("\n").filter((l) => l.trim() !== "");
   const entries = lines.map((l) => JSON.parse(l));
   return entries.reverse().slice(0, limit);
 }
@@ -3187,13 +3374,13 @@ var init_log = __esm({
 });
 
 // src/server/scan.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
 import { resolve as resolve6 } from "path";
 function loadUsageCache(projectRoot) {
   const path = resolve6(projectRoot, ".glotfile", "usage.json");
-  if (!existsSync7(path)) return null;
+  if (!existsSync8(path)) return null;
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     return null;
   }
@@ -3258,8 +3445,8 @@ var init_scan = __esm({
 });
 
 // src/server/scanner.ts
-import { readdirSync as readdirSync3, statSync as statSync2, readFileSync as readFileSync8 } from "fs";
-import { join as join3, extname as extname2, relative } from "path";
+import { readdirSync as readdirSync3, statSync as statSync2, readFileSync as readFileSync9 } from "fs";
+import { join as join4, extname as extname2, relative } from "path";
 function scannerForExt(ext) {
   return EXT_SCANNER[ext] ?? null;
 }
@@ -3411,7 +3598,7 @@ function* walkFiles(dir, root, exclude) {
   }
   for (const name of entries) {
     if (ALWAYS_EXCLUDE.has(name)) continue;
-    const abs = join3(dir, name);
+    const abs = join4(dir, name);
     const rel = relative(root, abs);
     let st;
     try {
@@ -3441,7 +3628,7 @@ function runScan(projectRoot, opts, existing) {
     const ext = extname2(relPath);
     const scanner = scannerForExt(ext);
     if (!scanner) continue;
-    const abs = join3(projectRoot, relPath);
+    const abs = join4(projectRoot, relPath);
     let st;
     try {
       st = statSync2(abs);
@@ -3457,7 +3644,7 @@ function runScan(projectRoot, opts, existing) {
     }
     let content;
     try {
-      content = readFileSync8(abs, "utf8");
+      content = readFileSync9(abs, "utf8");
     } catch {
       continue;
     }
@@ -3573,7 +3760,7 @@ var init_scanner = __esm({
 });
 
 // src/server/ai/context.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
 import { resolve as resolve7 } from "path";
 function globToRegExp2(glob) {
   const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
@@ -3588,8 +3775,8 @@ function extractSnippets(refs, projectRoot, fileCache) {
   for (const ref of selected) {
     const absPath = resolve7(projectRoot, ref.file);
     if (!fileCache.has(ref.file)) {
-      if (!existsSync8(absPath)) continue;
-      const content = readFileSync9(absPath, "utf8");
+      if (!existsSync9(absPath)) continue;
+      const content = readFileSync10(absPath, "utf8");
       fileCache.set(ref.file, content.split("\n"));
     }
     const lines = fileCache.get(ref.file);
@@ -4105,7 +4292,7 @@ var init_run2 = __esm({
 });
 
 // src/server/lint/outputs.ts
-import { readFileSync as readFileSync10, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync11, existsSync as existsSync10 } from "fs";
 import { resolve as resolve8 } from "path";
 function checkOutputs(state, root) {
   const out = [];
@@ -4113,7 +4300,7 @@ function checkOutputs(state, root) {
     const result = getAdapter(output.adapter).export(state, output);
     for (const file of result.files) {
       const abs = resolve8(root, file.path);
-      const current = existsSync9(abs) ? readFileSync10(abs, "utf8") : null;
+      const current = existsSync10(abs) ? readFileSync11(abs, "utf8") : null;
       if (current === null) {
         out.push({ ruleId: "output-stale", key: file.path, locale: "", severity: "error", message: "output file is missing; run `glotfile export`" });
       } else if (current !== file.contents) {
@@ -4158,8 +4345,8 @@ var init_accept = __esm({
 });
 
 // src/server/import/detect.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
+import { join as join5 } from "path";
 function safeIsDir(p) {
   try {
     return statSync3(p).isDirectory();
@@ -4168,7 +4355,7 @@ function safeIsDir(p) {
   }
 }
 function listDirs(dir) {
-  return readdirSync4(dir).filter((e) => safeIsDir(join4(dir, e)));
+  return readdirSync4(dir).filter((e) => safeIsDir(join5(dir, e)));
 }
 function fileCount(dir) {
   try {
@@ -4182,23 +4369,23 @@ function pickSource(locales, sizeOf) {
   return [...locales].sort((a, b) => sizeOf(b) - sizeOf(a) || a.localeCompare(b))[0] ?? "en";
 }
 function detectLaravel(root) {
-  const localeRoot = [join4(root, "resources", "lang"), join4(root, "lang")].find(safeIsDir);
+  const localeRoot = [join5(root, "resources", "lang"), join5(root, "lang")].find(safeIsDir);
   if (!localeRoot) return null;
   const locales = listDirs(localeRoot).filter((d) => LOCALE_RE.test(d));
   if (locales.length === 0) return null;
-  const sourceLocale = pickSource(locales, (loc) => fileCount(join4(localeRoot, loc)));
+  const sourceLocale = pickSource(locales, (loc) => fileCount(join5(localeRoot, loc)));
   return { format: "laravel-php", localeRoot, locales, sourceLocale };
 }
 function detectVue(root, forced = false) {
   for (const rel of VUE_DIR_CANDIDATES) {
-    const localeRoot = join4(root, rel);
+    const localeRoot = join5(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = readdirSync4(localeRoot).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)).filter((l) => LOCALE_RE.test(l));
     const enough = locales.length >= 2 || locales.length === 1 && (forced || locales[0] === "en" || locales[0].startsWith("en-") || locales[0].startsWith("en_"));
     if (enough) {
       const sourceLocale = pickSource(locales, (loc) => {
         try {
-          return statSync3(join4(localeRoot, `${loc}.json`)).size;
+          return statSync3(join5(localeRoot, `${loc}.json`)).size;
         } catch {
           return 0;
         }
@@ -4210,7 +4397,7 @@ function detectVue(root, forced = false) {
 }
 function detectArb(root) {
   for (const rel of ["lib/l10n", "l10n", "lib/src/l10n"]) {
-    const localeRoot = join4(root, rel);
+    const localeRoot = join5(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = readdirSync4(localeRoot).map((f) => f.match(/^(?:app_)?(.+)\.arb$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l));
     if (locales.length >= 1) {
@@ -4220,10 +4407,10 @@ function detectArb(root) {
   return null;
 }
 function lprojLocales(dir) {
-  return listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync10(join4(dir, `${l}.lproj`, "Localizable.strings")));
+  return listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync11(join5(dir, `${l}.lproj`, "Localizable.strings")));
 }
 function detectApple(root) {
-  const candidates = [root, ...listDirs(root).map((d) => join4(root, d))];
+  const candidates = [root, ...listDirs(root).map((d) => join5(root, d))];
   let best = null;
   for (const dir of candidates) {
     const locales = lprojLocales(dir);
@@ -4235,7 +4422,7 @@ function detectApple(root) {
         locales,
         sourceLocale: pickSource(locales, (loc) => {
           try {
-            return statSync3(join4(dir, `${loc}.lproj`, "Localizable.strings")).size;
+            return statSync3(join5(dir, `${loc}.lproj`, "Localizable.strings")).size;
           } catch {
             return 0;
           }
@@ -4247,7 +4434,7 @@ function detectApple(root) {
 }
 function detectAngularXliff(root) {
   for (const rel of ANGULAR_DIR_CANDIDATES) {
-    const localeRoot = rel === "." ? root : join4(root, rel);
+    const localeRoot = rel === "." ? root : join5(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const files = readdirSync4(localeRoot).filter((f) => /^messages(\..+)?\.xlf$/.test(f)).sort();
     if (files.length === 0) continue;
@@ -4255,7 +4442,7 @@ function detectAngularXliff(root) {
     const attrFile = files.includes("messages.xlf") ? "messages.xlf" : files[0];
     let sourceLocale;
     try {
-      sourceLocale = readFileSync11(join4(localeRoot, attrFile), "utf8").match(/source-language="([^"]+)"/)?.[1];
+      sourceLocale = readFileSync12(join5(localeRoot, attrFile), "utf8").match(/source-language="([^"]+)"/)?.[1];
     } catch {
     }
     if (!sourceLocale && locales.length === 0) continue;
@@ -4266,14 +4453,14 @@ function detectAngularXliff(root) {
   return null;
 }
 function detectRails(root) {
-  const localeRoot = join4(root, "config", "locales");
+  const localeRoot = join5(root, "config", "locales");
   if (!safeIsDir(localeRoot)) return null;
   const locales = [];
   for (const file of readdirSync4(localeRoot).sort()) {
     if (!/\.ya?ml$/.test(file)) continue;
     let text;
     try {
-      text = readFileSync11(join4(localeRoot, file), "utf8");
+      text = readFileSync12(join5(localeRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -4287,15 +4474,15 @@ function detectRails(root) {
 }
 function detectI18next(root) {
   for (const rel of I18NEXT_DIR_CANDIDATES) {
-    const localeRoot = join4(root, rel);
+    const localeRoot = join5(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = listDirs(localeRoot).filter(
-      (d) => LOCALE_RE.test(d) && readdirSync4(join4(localeRoot, d)).some((f) => f.endsWith(".json"))
+      (d) => LOCALE_RE.test(d) && readdirSync4(join5(localeRoot, d)).some((f) => f.endsWith(".json"))
     );
     if (locales.length === 0) continue;
     const sourceLocale = pickSource(locales, (loc) => {
       try {
-        return readdirSync4(join4(localeRoot, loc)).filter((f) => f.endsWith(".json")).reduce((sum, f) => sum + statSync3(join4(localeRoot, loc, f)).size, 0);
+        return readdirSync4(join5(localeRoot, loc)).filter((f) => f.endsWith(".json")).reduce((sum, f) => sum + statSync3(join5(localeRoot, loc, f)).size, 0);
       } catch {
         return 0;
       }
@@ -4312,8 +4499,8 @@ function gettextLocales(dir) {
       if (!locales.includes(flat)) locales.push(flat);
       continue;
     }
-    if (!LOCALE_RE.test(entry) || !safeIsDir(join4(dir, entry))) continue;
-    const sub = join4(dir, entry);
+    if (!LOCALE_RE.test(entry) || !safeIsDir(join5(dir, entry))) continue;
+    const sub = join5(dir, entry);
     const hasPo = (d) => {
       try {
         return readdirSync4(d).some((f) => f.endsWith(".po"));
@@ -4321,7 +4508,7 @@ function gettextLocales(dir) {
         return false;
       }
     };
-    if (hasPo(join4(sub, "LC_MESSAGES")) || hasPo(sub)) {
+    if (hasPo(join5(sub, "LC_MESSAGES")) || hasPo(sub)) {
       if (!locales.includes(entry)) locales.push(entry);
     }
   }
@@ -4329,7 +4516,7 @@ function gettextLocales(dir) {
 }
 function detectGettext(root) {
   for (const rel of GETTEXT_DIR_CANDIDATES) {
-    const localeRoot = join4(root, rel);
+    const localeRoot = join5(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = gettextLocales(localeRoot);
     if (locales.length === 0) continue;
@@ -4338,10 +4525,10 @@ function detectGettext(root) {
   return null;
 }
 function detectAppleStringsdict(root) {
-  const candidates = [root, ...listDirs(root).map((d) => join4(root, d))];
+  const candidates = [root, ...listDirs(root).map((d) => join5(root, d))];
   let best = null;
   for (const dir of candidates) {
-    const locales = listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync10(join4(dir, `${l}.lproj`, "Localizable.stringsdict")));
+    const locales = listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync11(join5(dir, `${l}.lproj`, "Localizable.stringsdict")));
     if (locales.length === 0) continue;
     if (!best || locales.length > best.locales.length) {
       best = { format: "apple-stringsdict", localeRoot: dir, locales, sourceLocale: pickSource(locales, () => 0) };
@@ -4350,7 +4537,7 @@ function detectAppleStringsdict(root) {
   return best;
 }
 function detect(root, formatOverride) {
-  if (!existsSync10(root)) return null;
+  if (!existsSync11(root)) return null;
   if (formatOverride) {
     const fn = BY_FORMAT[formatOverride];
     if (!fn) throw new Error(`Unknown format: ${formatOverride}`);
@@ -4424,8 +4611,8 @@ var init_flatten = __esm({
 });
 
 // src/server/import/parsers/vue-i18n-json.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
-import { join as join5 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync13 } from "fs";
+import { join as join6 } from "path";
 var LOCALE_RE2, vueI18nJson2;
 var init_vue_i18n_json2 = __esm({
   "src/server/import/parsers/vue-i18n-json.ts"() {
@@ -4445,7 +4632,7 @@ var init_vue_i18n_json2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync12(join5(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync13(join6(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`vue-i18n-json: failed to parse ${file}: ${e.message}`);
             continue;
@@ -4473,16 +4660,16 @@ var init_placeholders2 = __esm({
 
 // src/server/import/parsers/laravel-php.ts
 import { readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { join as join6, relative as relative2 } from "path";
+import { join as join7, relative as relative2 } from "path";
 import { execFileSync } from "child_process";
 function listDirs2(dir) {
-  return readdirSync6(dir).filter((e) => statSync4(join6(dir, e)).isDirectory());
+  return readdirSync6(dir).filter((e) => statSync4(join7(dir, e)).isDirectory());
 }
 function listPhpFiles(dir) {
   const out = [];
   const walk = (d) => {
     for (const e of readdirSync6(d)) {
-      const full = join6(d, e);
+      const full = join7(d, e);
       if (statSync4(full).isDirectory()) walk(full);
       else if (e.endsWith(".php")) out.push(full);
     }
@@ -4525,7 +4712,7 @@ var init_laravel_php2 = __esm({
         for (const locale of listDirs2(localeRoot).sort()) {
           if (locale === "vendor") continue;
           if (opts?.locales && !opts.locales.includes(locale)) continue;
-          const localeDir = join6(localeRoot, locale);
+          const localeDir = join7(localeRoot, locale);
           locales.push(locale);
           for (const file of listPhpFiles(localeDir)) {
             const group = relative2(localeDir, file).replace(/\\/g, "/").replace(/\.php$/, "");
@@ -4550,8 +4737,8 @@ var init_laravel_php2 = __esm({
 });
 
 // src/server/import/parsers/flutter-arb.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync13 } from "fs";
-import { join as join7 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync14 } from "fs";
+import { join as join8 } from "path";
 function localeFromArbName(file) {
   const m = file.match(/^(.+)\.arb$/);
   if (!m) return null;
@@ -4591,7 +4778,7 @@ var init_flutter_arb2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync13(join7(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync14(join8(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`flutter-arb: failed to parse ${file}: ${e.message}`);
             continue;
@@ -4618,8 +4805,8 @@ var init_flutter_arb2 = __esm({
 });
 
 // src/server/import/parsers/apple-strings.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync14, statSync as statSync5 } from "fs";
-import { join as join8 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync15, statSync as statSync5 } from "fs";
+import { join as join9 } from "path";
 function localeFromLproj(dir) {
   const m = dir.match(/^(.+)\.lproj$/);
   if (!m) return null;
@@ -4727,16 +4914,16 @@ var init_apple_strings2 = __esm({
           const locale = localeFromLproj(dir);
           if (!locale) continue;
           if (opts?.locales && !opts.locales.includes(locale)) continue;
-          const file = join8(localeRoot, dir, TABLE);
+          const file = join9(localeRoot, dir, TABLE);
           let text;
           try {
             if (!statSync5(file).isFile()) continue;
-            text = readFileSync14(file, "utf8");
+            text = readFileSync15(file, "utf8");
           } catch {
             continue;
           }
           locales.push(locale);
-          const others = readdirSync8(join8(localeRoot, dir)).filter((f) => f.endsWith(".strings") && f !== TABLE);
+          const others = readdirSync8(join9(localeRoot, dir)).filter((f) => f.endsWith(".strings") && f !== TABLE);
           if (others.length) {
             warnings.push(`apple-strings: ${dir} has other .strings tables (${others.join(", ")}); only ${TABLE} is imported`);
           }
@@ -4751,8 +4938,8 @@ var init_apple_strings2 = __esm({
 });
 
 // src/server/import/parsers/angular-xliff.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync15 } from "fs";
-import { join as join9 } from "path";
+import { readdirSync as readdirSync9, readFileSync as readFileSync16 } from "fs";
+import { join as join10 } from "path";
 function decodeEntities(s) {
   return s.replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d))).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 }
@@ -4804,7 +4991,7 @@ var init_angular_xliff2 = __esm({
           if (fnameLocale !== void 0 && !LOCALE_RE5.test(fnameLocale)) continue;
           let xml;
           try {
-            xml = readFileSync15(join9(localeRoot, file), "utf8");
+            xml = readFileSync16(join10(localeRoot, file), "utf8");
           } catch (e) {
             warnings.push(`angular-xliff: failed to read ${file}: ${e.message}`);
             continue;
@@ -4847,8 +5034,8 @@ var init_angular_xliff2 = __esm({
 });
 
 // src/server/import/parsers/gettext-po.ts
-import { readdirSync as readdirSync10, readFileSync as readFileSync16 } from "fs";
-import { join as join10 } from "path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync17 } from "fs";
+import { join as join11 } from "path";
 function unescapePo(s) {
   return s.replace(
     /\\([\\"ntr])/g,
@@ -4919,17 +5106,17 @@ function discoverPoFiles(root) {
   for (const e of entries) {
     if (e.isFile() && e.name.endsWith(".po")) {
       const base = e.name.slice(0, -3);
-      found.push({ path: join10(root, e.name), rel: e.name, locale: LOCALE_RE6.test(base) ? base : null });
+      found.push({ path: join11(root, e.name), rel: e.name, locale: LOCALE_RE6.test(base) ? base : null });
     } else if (e.isDirectory() && LOCALE_RE6.test(e.name)) {
-      for (const sub of [join10(e.name, "LC_MESSAGES"), e.name]) {
+      for (const sub of [join11(e.name, "LC_MESSAGES"), e.name]) {
         let names;
         try {
-          names = readdirSync10(join10(root, sub)).sort();
+          names = readdirSync10(join11(root, sub)).sort();
         } catch {
           continue;
         }
         for (const f of names) {
-          if (f.endsWith(".po")) found.push({ path: join10(root, sub, f), rel: join10(sub, f), locale: e.name });
+          if (f.endsWith(".po")) found.push({ path: join11(root, sub, f), rel: join11(sub, f), locale: e.name });
         }
       }
     }
@@ -4953,7 +5140,7 @@ var init_gettext_po2 = __esm({
         for (const file of discoverPoFiles(localeRoot)) {
           let entries;
           try {
-            entries = parseEntries(readFileSync16(file.path, "utf8"));
+            entries = parseEntries(readFileSync17(file.path, "utf8"));
           } catch (e) {
             warnings.push(`gettext-po: failed to parse ${file.rel}: ${e.message}`);
             continue;
@@ -5000,8 +5187,8 @@ var init_gettext_po2 = __esm({
 });
 
 // src/server/import/parsers/i18next-json.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync17, statSync as statSync6 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync11, readFileSync as readFileSync18, statSync as statSync6 } from "fs";
+import { join as join12 } from "path";
 function safeIsDir2(p) {
   try {
     return statSync6(p).isDirectory();
@@ -5016,7 +5203,7 @@ function fromI18next(value) {
 function ingestFile(path, label, prefix, locale, keys, warnings) {
   let data;
   try {
-    data = JSON.parse(readFileSync17(path, "utf8"));
+    data = JSON.parse(readFileSync18(path, "utf8"));
   } catch (e) {
     warnings.push(`i18next-json: failed to parse ${label}: ${e.message}`);
     return false;
@@ -5069,7 +5256,7 @@ var init_i18next_json2 = __esm({
         const keys = {};
         const locales = [];
         for (const entry of readdirSync11(localeRoot).sort()) {
-          const full = join11(localeRoot, entry);
+          const full = join12(localeRoot, entry);
           if (safeIsDir2(full)) {
             if (!LOCALE_RE7.test(entry)) continue;
             if (opts?.locales && !opts.locales.includes(entry)) continue;
@@ -5078,7 +5265,7 @@ var init_i18next_json2 = __esm({
               if (!file.endsWith(".json")) continue;
               const ns = file.slice(0, -".json".length);
               const prefix = ns === DEFAULT_NAMESPACE ? "" : `${ns}.`;
-              if (ingestFile(join11(full, file), `${entry}/${file}`, prefix, entry, keys, warnings)) any = true;
+              if (ingestFile(join12(full, file), `${entry}/${file}`, prefix, entry, keys, warnings)) any = true;
             }
             if (any && !locales.includes(entry)) locales.push(entry);
           } else if (entry.endsWith(".json")) {
@@ -5097,8 +5284,8 @@ var init_i18next_json2 = __esm({
 });
 
 // src/server/import/parsers/rails-yaml.ts
-import { readdirSync as readdirSync12, readFileSync as readFileSync18 } from "fs";
-import { join as join12 } from "path";
+import { readdirSync as readdirSync12, readFileSync as readFileSync19 } from "fs";
+import { join as join13 } from "path";
 function fromRuby(value) {
   return value.replace(/%\{(\w+)\}/g, "{$1}");
 }
@@ -5315,7 +5502,7 @@ var init_rails_yaml2 = __esm({
           if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
           let text;
           try {
-            text = readFileSync18(join12(localeRoot, file), "utf8");
+            text = readFileSync19(join13(localeRoot, file), "utf8");
           } catch (e) {
             warnings.push(`rails-yaml: failed to read ${file}: ${e.message}`);
             continue;
@@ -5338,8 +5525,8 @@ var init_rails_yaml2 = __esm({
 });
 
 // src/server/import/parsers/apple-stringsdict.ts
-import { readdirSync as readdirSync13, readFileSync as readFileSync19, statSync as statSync7 } from "fs";
-import { join as join13 } from "path";
+import { readdirSync as readdirSync13, readFileSync as readFileSync20, statSync as statSync7 } from "fs";
+import { join as join14 } from "path";
 function localeFromLproj2(dir) {
   const m = dir.match(/^(.+)\.lproj$/);
   if (!m) return null;
@@ -5481,16 +5668,16 @@ var init_apple_stringsdict2 = __esm({
           const locale = localeFromLproj2(dir);
           if (!locale) continue;
           if (opts?.locales && !opts.locales.includes(locale)) continue;
-          const file = join13(localeRoot, dir, TABLE2);
+          const file = join14(localeRoot, dir, TABLE2);
           let text;
           try {
             if (!statSync7(file).isFile()) continue;
-            text = readFileSync19(file, "utf8");
+            text = readFileSync20(file, "utf8");
           } catch {
             continue;
           }
           locales.push(locale);
-          const others = readdirSync13(join13(localeRoot, dir)).filter(
+          const others = readdirSync13(join14(localeRoot, dir)).filter(
             (f) => f.endsWith(".stringsdict") && f !== TABLE2
           );
           if (others.length) {
@@ -5949,12 +6136,12 @@ var init_checks = __esm({
 });
 
 // src/server/ui-prefs.ts
-import { readFileSync as readFileSync20 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 import { homedir } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function readJson2(path) {
   try {
-    const parsed = JSON.parse(readFileSync20(path, "utf8"));
+    const parsed = JSON.parse(readFileSync21(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -5979,7 +6166,7 @@ var init_ui_prefs = __esm({
     THEMES = ["system", "light", "dark"];
     isThemeMode = (v) => THEMES.includes(v);
     isPanelWidth = (v) => typeof v === "number" && Number.isFinite(v) && v >= 120 && v <= 1200;
-    defaultUiPrefsPath = () => join14(homedir(), ".glotfile", "ui.json");
+    defaultUiPrefsPath = () => join15(homedir(), ".glotfile", "ui.json");
     DEFAULTS = { theme: "system" };
   }
 });
@@ -5987,13 +6174,13 @@ var init_ui_prefs = __esm({
 // src/server/api.ts
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { readFileSync as readFileSync21, existsSync as existsSync11, readdirSync as readdirSync14, statSync as statSync8, rmSync as rmSync4 } from "fs";
+import { readFileSync as readFileSync22, existsSync as existsSync12, readdirSync as readdirSync14, statSync as statSync8, rmSync as rmSync5 } from "fs";
 import { dirname as dirname3, resolve as resolve9, basename, relative as relative4, sep as sep2 } from "path";
 function projectName(root) {
   const nameFile = resolve9(root, ".idea", ".name");
-  if (existsSync11(nameFile)) {
+  if (existsSync12(nameFile)) {
     try {
-      const name = readFileSync21(nameFile, "utf8").trim();
+      const name = readFileSync22(nameFile, "utf8").trim();
       if (name) return name;
     } catch {
     }
@@ -6126,7 +6313,7 @@ function createApi(deps) {
         if (name.startsWith(".") || name === "node_modules") continue;
         const abs = resolve9(dir, name);
         let filePath = null;
-        if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync11(resolve9(abs, "config.json"))) {
+        if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync12(resolve9(abs, "config.json"))) {
           filePath = resolve9(dir, `${name}.json`);
         } else if (name === "glotfile.json" || name.endsWith(".glotfile.json")) {
           filePath = abs;
@@ -6160,7 +6347,7 @@ function createApi(deps) {
     const resolved = resolve9(projectRoot, path);
     const inside = resolved === projectRoot || resolved.startsWith(projectRoot + sep2);
     if (!inside) return c.json({ error: "file is outside the project" }, 400);
-    if (!existsSync11(resolved)) return c.json({ error: "file not found" }, 400);
+    if (!existsSync12(resolved)) return c.json({ error: "file not found" }, 400);
     loadState(resolved);
     deps.statePath = resolved;
     return c.json({ ok: true, path: resolved, name: basename(resolved), dir: projectRoot, project: basename(projectRoot) });
@@ -6221,9 +6408,9 @@ function createApi(deps) {
     const abs = resolve9(root, screenshot);
     const rel = relative4(root, abs);
     const seg0 = rel.split(sep2)[0] ?? "";
-    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync11(abs)) {
+    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync12(abs)) {
       try {
-        rmSync4(abs);
+        rmSync5(abs);
       } catch {
       }
     }
@@ -6761,6 +6948,104 @@ function createApi(deps) {
     const ai = loadLocalSettings(projectRoot).ai;
     return c.json(estimateTranslation(load(), ai, { onlyMissing: body.onlyMissing ?? true, keys, locales }));
   });
+  app.get("/batch/status", async (c) => {
+    const aiCfg = loadLocalSettings(projectRoot).ai;
+    let supported = false;
+    let provider;
+    try {
+      provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
+      supported = supportsBatchTranslate(provider);
+    } catch {
+    }
+    const pending = loadPendingBatch(projectRoot);
+    if (!pending) return c.json({ supported, pending: null });
+    const base = { batchId: pending.batchId, createdAt: pending.createdAt, model: pending.model, total: pending.total };
+    if (!provider || !supportsBatchTranslate(provider)) {
+      return c.json({ supported, pending: { ...base, status: "unknown", counts: null } });
+    }
+    try {
+      const status = await provider.translationBatchStatus(pending.batchId);
+      return c.json({ supported, pending: { ...base, status: status.status, counts: status.counts } });
+    } catch (e) {
+      return c.json({ supported, pending: { ...base, status: "unknown", counts: null, error: e.message } });
+    }
+  });
+  app.post("/batch/translate", (c) => withTranslateLock(async () => {
+    const body = await c.req.json().catch(() => ({}));
+    const s = load();
+    const reqs = selectRequests(s, {
+      onlyMissing: body.onlyMissing ?? true,
+      keys: Array.isArray(body.keys) && body.keys.length ? body.keys.filter(Boolean) : void 0,
+      locales: Array.isArray(body.locales) && body.locales.length ? body.locales.filter(Boolean) : void 0
+    });
+    if (!reqs.length) return c.json({ error: "Nothing to translate." }, 400);
+    const aiCfg = loadLocalSettings(projectRoot).ai;
+    let provider;
+    try {
+      provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+    if (!supportsBatchTranslate(provider)) {
+      return c.json({ error: `Provider "${aiCfg.provider}" does not support batch mode.` }, 400);
+    }
+    attachScreenshotsForProvider(reqs, s, dirname3(resolve9(deps.statePath)), provider.supportsVision());
+    let pending;
+    try {
+      pending = await submitBatchTranslation(s, provider, reqs, aiCfg.batchSize, aiCfg.model, projectRoot);
+    } catch (e) {
+      return c.json({ error: e.message }, 409);
+    }
+    appendLog(projectRoot, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "translate",
+      summary: `Submitted batch ${pending.batchId} (${pending.total} items)`,
+      model: aiCfg.model,
+      system: buildSystemPrompt(reqs.some((r) => r.plural !== void 0)),
+      items: reqs.map((r) => ({ id: r.id, key: r.key, source: r.source, targetLocale: r.targetLocale, context: r.context, glossary: r.glossary, screenshot: s.keys[r.key]?.screenshot }))
+    });
+    console.log(`[batch] submitted ${pending.batchId} \u2014 ${pending.total} string(s)`);
+    return c.json({ batchId: pending.batchId, total: pending.total });
+  }));
+  app.post("/batch/apply", (c) => withTranslateLock(async () => {
+    const pending = loadPendingBatch(projectRoot);
+    if (!pending) return c.json({ error: "No pending batch." }, 404);
+    const aiCfg = loadLocalSettings(projectRoot).ai;
+    let provider;
+    try {
+      provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+    if (!supportsBatchTranslate(provider)) {
+      return c.json({ error: `Provider "${aiCfg.provider}" does not support batch mode.` }, 400);
+    }
+    const outcome = await applyBatchResults(load, persist, provider, pending, projectRoot, {
+      batchSize: aiCfg.batchSize,
+      concurrency: aiCfg.concurrency
+    });
+    appendLog(projectRoot, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "translate",
+      summary: `Applied batch ${pending.batchId}: wrote ${outcome.written}, ${outcome.retried} retried, ${outcome.staleSkipped} stale`,
+      model: aiCfg.model,
+      results: []
+    });
+    console.log(`[batch] applied ${pending.batchId} \u2014 wrote ${outcome.written}, ${outcome.errors.length} error(s)`);
+    return c.json(outcome);
+  }));
+  app.post("/batch/cancel", async (c) => {
+    const pending = loadPendingBatch(projectRoot);
+    if (!pending) return c.json({ error: "No pending batch." }, 404);
+    const aiCfg = loadLocalSettings(projectRoot).ai;
+    try {
+      const provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
+      if (supportsBatchTranslate(provider)) await provider.cancelTranslationBatch(pending.batchId);
+    } catch {
+    }
+    clearPendingBatch(projectRoot);
+    return c.json({ canceled: pending.batchId });
+  });
   app.get("/log", (c) => c.json(readLog(projectRoot, 100)));
   app.post("/scan", async (c) => {
     const s = load();
@@ -6941,6 +7226,8 @@ var init_api = __esm({
     init_ai();
     init_run();
     init_provider();
+    init_batch_run();
+    init_pending_batch();
     init_estimate();
     init_log();
     init_schema();
@@ -6963,7 +7250,7 @@ __export(server_exports, {
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
 import { fileURLToPath } from "url";
-import { dirname as dirname4, join as join15, resolve as resolve10, extname as extname3, sep as sep3 } from "path";
+import { dirname as dirname4, join as join16, resolve as resolve10, extname as extname3, sep as sep3 } from "path";
 import { readFile, stat } from "fs/promises";
 import { createServer } from "net";
 import open from "open";
@@ -7006,7 +7293,7 @@ function buildApp(opts) {
         const file = await readFileResponse(target);
         if (file) return file;
       }
-      const index = await readFileResponse(join15(root, "index.html"));
+      const index = await readFileResponse(join16(root, "index.html"));
       if (index) return index;
       return c.notFound();
     });
@@ -7064,7 +7351,7 @@ var init_server = __esm({
     init_scan();
     init_scanner();
     here = dirname4(fileURLToPath(import.meta.url));
-    DEFAULT_UI_DIR = join15(here, "..", "ui");
+    DEFAULT_UI_DIR = join16(here, "..", "ui");
     MIME = {
       ".html": "text/html; charset=utf-8",
       ".js": "text/javascript; charset=utf-8",
@@ -7101,6 +7388,8 @@ init_ai();
 init_local_settings();
 init_run();
 init_provider();
+init_batch_run();
+init_pending_batch();
 init_estimate();
 init_log();
 init_scan();
@@ -7108,8 +7397,8 @@ init_scanner();
 init_context();
 init_run2();
 init_outputs();
-import { resolve as resolve11, dirname as dirname5, join as join16 } from "path";
-import { readFileSync as readFileSync22, existsSync as existsSync12, mkdirSync as mkdirSync4, cpSync } from "fs";
+import { resolve as resolve11, dirname as dirname5, join as join17 } from "path";
+import { readFileSync as readFileSync23, existsSync as existsSync13, mkdirSync as mkdirSync5, cpSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/server/lint/locate.ts
@@ -7176,7 +7465,7 @@ function formatSarif(report, rawText) {
 }
 
 // src/server/cli.ts
-var COMMANDS = ["serve", "export", "translate", "lint", "check", "import", "build-context", "scan", "prune", "split", "skill"];
+var COMMANDS = ["serve", "export", "translate", "lint", "check", "import", "build-context", "scan", "prune", "split", "skill", "batch"];
 var isCommand = (s) => s != null && COMMANDS.includes(s);
 function parseArgs(argv) {
   const statePath = resolve11(process.cwd(), "glotfile.json");
@@ -7246,7 +7535,12 @@ function parseArgs(argv) {
     else if (flag === "--unused") args.unused = true;
     else if (flag === "--write") args.write = true;
     else if (flag === "--estimate") args.estimate = true;
+    else if (flag === "--batch") args.batch = true;
+    else if (flag === "--wait") args.wait = true;
     else if (flag === "--print") args.print = true;
+    else if (args.command === "batch" && (flag === "status" || flag === "apply" || flag === "cancel")) {
+      args.batchAction = flag;
+    }
   }
   return args;
 }
@@ -7297,6 +7591,15 @@ async function runExport(args) {
   await new Promise(() => {
   });
 }
+function makeProviderOrExit(ai) {
+  try {
+    return makeProvider(ai);
+  } catch (e) {
+    console.error(e.message);
+    process.exitCode = 1;
+    return null;
+  }
+}
 async function runTranslate(args) {
   const state = loadState(args.statePath);
   const projectRoot = dirname5(resolve11(args.statePath));
@@ -7333,18 +7636,51 @@ async function runTranslate(args) {
     keyGlob: args.keyGlob
   });
   const toTranslate = [...reqs];
-  let written = 0;
-  let errors = [];
-  if (toTranslate.length) {
+  if (args.batch) {
+    if (!toTranslate.length) {
+      console.log("Nothing to translate.");
+      return;
+    }
     const ai = loadLocalSettings(projectRoot).ai;
-    let provider;
+    const provider = makeProviderOrExit(ai);
+    if (!provider) return;
+    if (!supportsBatchTranslate(provider)) {
+      console.error(`Provider "${ai.provider}" does not support batch mode. Currently anthropic only.`);
+      process.exitCode = 1;
+      return;
+    }
+    const { skipped } = attachScreenshotsForProvider(toTranslate, state, projectRoot, provider.supportsVision());
+    if (skipped) console.warn(`Model "${ai.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
+    let pending;
     try {
-      provider = makeProvider(ai);
+      pending = await submitBatchTranslation(state, provider, toTranslate, ai.batchSize, ai.model, projectRoot);
     } catch (e) {
       console.error(e.message);
       process.exitCode = 1;
       return;
     }
+    appendLog(projectRoot, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "translate",
+      summary: `Submitted batch ${pending.batchId} (${pending.total} items)`,
+      model: ai.model,
+      system: buildSystemPrompt(toTranslate.some((r) => r.plural !== void 0)),
+      items: toTranslate.map((r) => ({ id: r.id, key: r.key, source: r.source, targetLocale: r.targetLocale, context: r.context, glossary: r.glossary, screenshot: state.keys[r.key]?.screenshot }))
+    });
+    console.log(`Submitted batch ${pending.batchId} \u2014 ${pending.total} string(s) at 50% batch pricing.`);
+    if (!args.wait) {
+      console.log("Check progress with `glotfile batch`; it applies results automatically when finished.");
+      return;
+    }
+    await waitAndApply(args, provider, pending, ai);
+    return;
+  }
+  let written = 0;
+  let errors = [];
+  if (toTranslate.length) {
+    const ai = loadLocalSettings(projectRoot).ai;
+    const provider = makeProviderOrExit(ai);
+    if (!provider) return;
     const { skipped } = attachScreenshotsForProvider(toTranslate, state, projectRoot, provider.supportsVision());
     if (skipped) console.warn(`Model "${ai.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
     console.log(`Translating ${toTranslate.length} string(s)\u2026`);
@@ -7401,6 +7737,80 @@ async function runTranslate(args) {
   console.log(`Wrote ${written} machine translation(s).`);
   for (const e of errors) console.warn(`skip ${e.key} @ ${e.locale}: ${e.error}`);
 }
+function reportApply(outcome) {
+  console.log(`Wrote ${outcome.written} machine translation(s).`);
+  if (outcome.retried) console.log(`${outcome.retried} item(s) re-run synchronously (batch entries failed or were malformed).`);
+  if (outcome.staleSkipped) console.log(`${outcome.staleSkipped} result(s) skipped \u2014 source changed since submission.`);
+  if (outcome.screenshotsSkipped) console.log(`${outcome.screenshotsSkipped} screenshot(s) ignored on retry (model has no vision support).`);
+  for (const e of outcome.errors) console.warn(`skip ${e.key} @ ${e.locale}: ${e.error}`);
+}
+async function applyPending(args, provider, pending, ai) {
+  const projectRoot = dirname5(resolve11(args.statePath));
+  const outcome = await applyBatchResults(
+    () => loadState(args.statePath),
+    (s) => saveState(args.statePath, s),
+    provider,
+    pending,
+    projectRoot,
+    { batchSize: ai.batchSize, concurrency: ai.concurrency }
+  );
+  reportApply(outcome);
+}
+async function waitAndApply(args, provider, pending, ai) {
+  for (; ; ) {
+    const status = await provider.translationBatchStatus(pending.batchId);
+    const c = status.counts;
+    process.stdout.write(`\r  ${c.succeeded + c.errored + c.expired + c.canceled}/${pending.jobs.length} entries done (${c.processing} processing)`);
+    if (status.status === "ended") break;
+    await new Promise((r) => setTimeout(r, 6e4));
+  }
+  process.stdout.write("\n");
+  await applyPending(args, provider, pending, ai);
+}
+async function runBatch(args) {
+  const projectRoot = dirname5(resolve11(args.statePath));
+  const pending = loadPendingBatch(projectRoot);
+  if (!pending) {
+    console.log("No pending batch. Start one with `glotfile translate --batch`.");
+    return;
+  }
+  const action = args.batchAction ?? "status";
+  if (action === "cancel") {
+    let remoteFailed = false;
+    try {
+      const ai2 = loadLocalSettings(projectRoot).ai;
+      const provider2 = makeProvider(ai2);
+      if (supportsBatchTranslate(provider2)) {
+        await provider2.cancelTranslationBatch(pending.batchId);
+      } else {
+        remoteFailed = true;
+      }
+    } catch {
+      remoteFailed = true;
+    }
+    clearPendingBatch(projectRoot);
+    const suffix = remoteFailed ? " (remote cancel failed \u2014 it will expire server-side)" : "";
+    console.log(`Canceled batch ${pending.batchId}.${suffix}`);
+    return;
+  }
+  const ai = loadLocalSettings(projectRoot).ai;
+  const provider = makeProviderOrExit(ai);
+  if (!provider) return;
+  if (!supportsBatchTranslate(provider)) {
+    console.error(`Pending batch was submitted via anthropic, but the configured provider "${ai.provider}" has no batch support.`);
+    process.exitCode = 1;
+    return;
+  }
+  const status = await provider.translationBatchStatus(pending.batchId);
+  const c = status.counts;
+  console.log(`Batch ${pending.batchId} (${pending.total} string(s), submitted ${pending.createdAt})`);
+  console.log(`  ${status.status} \u2014 ${c.succeeded} succeeded, ${c.processing} processing, ${c.errored} errored, ${c.expired} expired, ${c.canceled} canceled`);
+  if (status.status !== "ended") {
+    if (action === "apply") console.log("Not finished yet \u2014 try again later.");
+    return;
+  }
+  await applyPending(args, provider, pending, ai);
+}
 function printReport(report, format, rawText) {
   if (format === "json") console.log(formatJson(report).trimEnd());
   else if (format === "sarif") console.log(formatSarif(report, rawText).trimEnd());
@@ -7420,7 +7830,7 @@ async function runLintCmd(args) {
     }
     return;
   }
-  const rawText = existsSync12(args.statePath) ? readFileSync22(args.statePath, "utf8") : "";
+  const rawText = existsSync13(args.statePath) ? readFileSync23(args.statePath, "utf8") : "";
   const report = await runLint(state, {
     locales: args.locales,
     ruleIds: args.ruleIds,
@@ -7444,7 +7854,7 @@ async function runCheck(args) {
     process.exitCode = 1;
     return;
   }
-  const rawText = existsSync12(args.statePath) ? readFileSync22(args.statePath, "utf8") : "";
+  const rawText = existsSync13(args.statePath) ? readFileSync23(args.statePath, "utf8") : "";
   const root = dirname5(resolve11(args.statePath));
   const lint = await runLint(state, {});
   const findings = sortFindings([...lint.findings, ...checkOutputs(state, root)]);
@@ -7457,7 +7867,7 @@ async function runImportCmd(args) {
   const { runImport: runImport2 } = await Promise.resolve().then(() => (init_run3(), run_exports));
   const projectRoot = args.importSource ? resolve11(args.importSource) : dirname5(resolve11(args.statePath));
   const out = resolve11(projectRoot, "glotfile.json");
-  if (existsSync12(out) && !args.importForce) {
+  if (existsSync13(out) && !args.importForce) {
     console.error(`${out} already exists; pass --force to overwrite`);
     process.exitCode = 1;
     return;
@@ -7605,19 +8015,19 @@ function runSplit(args) {
     `Split catalog into ${splitDirFor(args.statePath)}/ (config.json, keys.json, locales/ \u2014 up to ${state.config.locales.length} locale files). Removed ${args.statePath}.`
   );
 }
-var SKILL_SRC = join16(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "skill");
+var SKILL_SRC = join17(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "skill");
 function runSkill(args) {
   if (args.print) {
-    console.log(readFileSync22(join16(SKILL_SRC, "SKILL.md"), "utf8").trimEnd());
+    console.log(readFileSync23(join17(SKILL_SRC, "SKILL.md"), "utf8").trimEnd());
     return;
   }
   const dest = resolve11(process.cwd(), ".claude", "skills", "glotfile");
-  if (existsSync12(dest) && !args.importForce) {
+  if (existsSync13(dest) && !args.importForce) {
     console.error(`${dest} already exists; pass --force to overwrite`);
     process.exitCode = 1;
     return;
   }
-  mkdirSync4(dirname5(dest), { recursive: true });
+  mkdirSync5(dirname5(dest), { recursive: true });
   cpSync(SKILL_SRC, dest, { recursive: true });
   console.log(`Installed the glotfile skill to ${dest}. Restart Claude Code to pick it up.`);
 }
@@ -7646,7 +8056,9 @@ var COMMAND_HELP = {
       ["--all", "Re-translate every string, not just empty values"],
       ["--estimate", "Print batches, tokens and estimated cost without translating"],
       ["--locale <list>", "Comma-separated target locales (alias: --locales)"],
-      ["--key <glob>", "Only keys matching this glob"]
+      ["--key <glob>", "Only keys matching this glob"],
+      ["--batch", "Submit via the provider's batch API (50% cost, async; anthropic only)"],
+      ["--wait", "With --batch: stay attached, poll until finished, then apply"]
     ]
   },
   lint: {
@@ -7714,6 +8126,15 @@ var COMMAND_HELP = {
       ["--print", "Write SKILL.md to stdout instead of installing"],
       ["--force", "Overwrite an existing installed skill"]
     ]
+  },
+  batch: {
+    summary: "Check, apply, or cancel a pending batch translation.",
+    usage: "glotfile batch [status|apply|cancel]",
+    options: [
+      ["status", "Show the pending batch's progress (default)"],
+      ["apply", "Fetch results and write translations (auto-runs when finished)"],
+      ["cancel", "Cancel the pending batch and discard the handle"]
+    ]
   }
 };
 function formatOpts(opts) {
@@ -7746,8 +8167,8 @@ ${formatOpts([...options, ...GLOBAL_OPTS])}`);
   );
 }
 function printVersion() {
-  const pkgPath = join16(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
-  console.log(JSON.parse(readFileSync22(pkgPath, "utf8")).version);
+  const pkgPath = join17(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
+  console.log(JSON.parse(readFileSync23(pkgPath, "utf8")).version);
 }
 async function main(argv) {
   const args = parseArgs(argv);
@@ -7770,6 +8191,7 @@ async function main(argv) {
   if (args.command === "prune") return runPrune(args);
   if (args.command === "split") return runSplit(args);
   if (args.command === "skill") return runSkill(args);
+  if (args.command === "batch") return runBatch(args);
   const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const { url } = await startServer2({ statePath: args.statePath, dev: args.dev });
   if (args.dev) console.log(`Glotfile dev API on ${url} \u2014 open the UI at the Vite "Local:" URL above`);