glotfile 0.5.3 → 0.5.4

package/dist/server/server.js

@@ -1,30 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// node_modules/dictionary-en/index.js
-var dictionary_en_exports = {};
-__export(dictionary_en_exports, {
-  default: () => dictionary_en_default
-});
-import fs from "fs/promises";
-var aff, dic, dictionary, dictionary_en_default;
-var init_dictionary_en = __esm({
-  async "node_modules/dictionary-en/index.js"() {
-    "use strict";
-    aff = await fs.readFile(new URL("index.aff", import.meta.url));
-    dic = await fs.readFile(new URL("index.dic", import.meta.url));
-    dictionary = { aff, dic };
-    dictionary_en_default = dictionary;
-  }
-});
-
 // src/server/server.ts
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
@@ -865,7 +838,7 @@ function findMissing(state) {
     const entry = state.keys[key];
     if (entry.skipTranslate) continue;
     for (const locale of targets) {
-      const v = entry.plural ? entry.values[locale]?.forms?.other?.trim() : entry.values[locale]?.value;
+      const v = entry.plural ? entry.values[locale]?.forms?.other?.trim() : entry.values[locale]?.value?.trim();
       if (!v) out.push({ key, locale });
     }
   }
@@ -1487,162 +1460,14 @@ function pluralFormPlaceholdersMatch(category, source, form) {
   return COUNT_OPTIONAL.has(category) ? placeholdersSubset(source, form) : placeholdersMatch(source, form);
 }
 
-// src/server/ai/run.ts
-import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
-import { resolve as resolve4, extname as extname2 } from "path";
-
-// src/server/glob.ts
-function globToRegExp2(glob) {
-  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
-}
-
-// src/server/ai/batch.ts
-var MalformedReplyError = class extends Error {
-  constructor(raw) {
-    super("Model reply was not valid translation JSON.");
-    this.raw = raw;
-    this.name = "MalformedReplyError";
-  }
-  raw;
-};
-function parseReplyItems(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    throw new MalformedReplyError(text);
-  }
-  if (!Array.isArray(parsed.items)) throw new MalformedReplyError(text);
-  return parsed.items;
-}
-function chunk(items, size) {
-  const out = [];
-  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
-  return out;
-}
-function validateTranslation(req, translation) {
-  if (translation === void 0) return { id: req.id, error: "No translation returned." };
-  if (!placeholdersMatch(req.source, translation)) {
-    return { id: req.id, error: "Placeholder mismatch between source and translation." };
-  }
-  if (req.maxLength !== void 0 && translation.length > req.maxLength) {
-    return { id: req.id, translation, error: `Exceeds maxLength (${translation.length} > ${req.maxLength}).` };
-  }
-  return { id: req.id, translation };
-}
-function validatePlural(req, forms) {
-  if (!forms) return { id: req.id, error: "No translation returned." };
-  const plural = req.plural;
-  if (!plural) return { id: req.id, error: "validatePlural called on a non-plural request." };
-  const cats = plural.categories;
-  const missing = cats.filter((c) => typeof forms[c] !== "string");
-  if (missing.length) return { id: req.id, error: `Missing plural categories: ${missing.join(", ")}.` };
-  const badPh = cats.find((c) => !pluralFormPlaceholdersMatch(c, req.source, forms[c]));
-  if (badPh) return { id: req.id, error: `Placeholder mismatch in plural form "${badPh}".` };
-  if (req.maxLength !== void 0) {
-    const over = cats.find((c) => forms[c].length > req.maxLength);
-    if (over) return { id: req.id, error: `Plural form "${over}" exceeds maxLength (${forms[over].length} > ${req.maxLength}).` };
-  }
-  const out = {};
-  for (const c of cats) out[c] = forms[c];
-  return { id: req.id, forms: out };
-}
-function validateReply(req, item) {
-  return req.plural ? validatePlural(req, item?.forms) : validateTranslation(req, item?.translation);
-}
-async function runBatched(reqs, batchSize, callBatch, onBatchComplete, signal, onMalformedReply) {
-  const failBatch = (batch) => batch.map((req) => ({ id: req.id, error: "Model returned malformed JSON for this string." }));
-  async function resolveBatch(batch, isRetry = false) {
-    let reply;
-    try {
-      reply = await callBatch(batch, signal);
-    } catch (err) {
-      if (!(err instanceof MalformedReplyError)) throw err;
-      onMalformedReply?.(err.raw, batch.length);
-      if (signal?.aborted) return failBatch(batch);
-      if (batch.length === 1) return isRetry ? failBatch(batch) : resolveBatch(batch, true);
-      const mid = Math.ceil(batch.length / 2);
-      return [...await resolveBatch(batch.slice(0, mid)), ...await resolveBatch(batch.slice(mid))];
-    }
-    const byId = new Map(reply.map((r) => [r.id, r]));
-    return batch.map((req) => validateReply(req, byId.get(req.id)));
-  }
-  const results = [];
-  const total = reqs.length;
-  for (const batch of chunk(reqs, Math.max(1, batchSize))) {
-    if (signal?.aborted) break;
-    const batchResults = await resolveBatch(batch);
-    results.push(...batchResults);
-    onBatchComplete?.(results.length, total, batchResults);
-  }
-  return results;
-}
-
-// src/server/ai/run.ts
-function selectRequests(state, opts) {
-  const targets = (opts.locales ?? state.config.locales).filter((l) => l !== state.config.sourceLocale);
-  const keyRe = opts.keyGlob ? globToRegExp2(opts.keyGlob) : null;
-  const keySet = opts.keys ? new Set(opts.keys) : null;
-  const reqs = [];
-  let id = 0;
-  for (const key of Object.keys(state.keys).sort()) {
-    const entry = state.keys[key];
-    if (entry.skipTranslate) continue;
-    if (keyRe && !keyRe.test(key)) continue;
-    if (keySet && !keySet.has(key)) continue;
-    const sourceLv = entry.values[state.config.sourceLocale];
-    if (entry.plural) {
-      const sourceForms = sourceLv?.forms;
-      const other = sourceForms?.other;
-      if (!sourceForms || !other) continue;
-      for (const locale of targets) {
-        const have = entry.values[locale]?.forms ?? {};
-        const complete = categoriesFor(locale).every((c) => (have[c] ?? "") !== "");
-        if (opts.onlyMissing && complete) continue;
-        const glossary = relevantGlossary(other, locale, state.glossary);
-        reqs.push({
-          id: String(id++),
-          key,
-          source: other,
-          sourceLocale: state.config.sourceLocale,
-          context: entry.context,
-          targetLocale: locale,
-          maxLength: entry.maxLength,
-          placeholders: extractPlaceholders(other),
-          ...glossary.length ? { glossary } : {},
-          plural: { arg: entry.plural.arg, categories: categoriesFor(locale), sourceForms }
-        });
-      }
-      continue;
-    }
-    const source = sourceLv?.value;
-    if (!source) continue;
-    for (const locale of targets) {
-      const existing = entry.values[locale]?.value;
-      if (opts.onlyMissing && existing) continue;
-      const glossary = relevantGlossary(source, locale, state.glossary);
-      reqs.push({
-        id: String(id++),
-        key,
-        source,
-        sourceLocale: state.config.sourceLocale,
-        context: entry.context,
-        targetLocale: locale,
-        maxLength: entry.maxLength,
-        placeholders: extractPlaceholders(source),
-        ...glossary.length ? { glossary } : {}
-      });
-    }
-  }
-  return reqs;
+// src/server/glossary.ts
+function contains(haystack, needle, caseSensitive) {
+  return caseSensitive ? haystack.includes(needle) : haystack.toLowerCase().includes(needle.toLowerCase());
 }
 function relevantGlossary(source, targetLocale, glossary) {
   const hints = [];
   for (const entry of glossary) {
-    const haystack = entry.caseSensitive ? source : source.toLowerCase();
-    const needle = entry.caseSensitive ? entry.term : entry.term.toLowerCase();
-    if (!haystack.includes(needle)) continue;
+    if (!contains(source, entry.term, entry.caseSensitive)) continue;
     hints.push({
       term: entry.term,
       doNotTranslate: entry.doNotTranslate,
@@ -1652,170 +1477,84 @@ function relevantGlossary(source, targetLocale, glossary) {
   }
   return hints;
 }
-var MEDIA_TYPES = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".webp": "image/webp",
-  ".gif": "image/gif"
-};
-var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
-function attachScreenshots(reqs, state, projectRoot) {
-  const cache2 = /* @__PURE__ */ new Map();
-  for (const req of reqs) {
-    const screenshot = state.keys[req.key]?.screenshot;
-    if (!screenshot) continue;
-    const mediaType = MEDIA_TYPES[extname2(screenshot).toLowerCase()];
-    if (!mediaType) continue;
-    if (!cache2.has(screenshot)) {
-      const abs = resolve4(projectRoot, screenshot);
-      if (!existsSync6(abs)) {
-        cache2.set(screenshot, null);
-      } else {
-        const buf = readFileSync6(abs);
-        cache2.set(screenshot, buf.length > MAX_IMAGE_BYTES ? null : { mediaType, base64: buf.toString("base64") });
+function glossaryViolations(source, value, targetLocale, glossary) {
+  const out = [];
+  for (const entry of glossary) {
+    if (!contains(source, entry.term, entry.caseSensitive)) continue;
+    if (entry.doNotTranslate) {
+      if (!contains(value, entry.term, entry.caseSensitive)) {
+        out.push({ term: entry.term, expected: entry.term, kind: "do-not-translate" });
       }
+      continue;
+    }
+    const forced = entry.translations?.[targetLocale];
+    if (forced && !contains(value, forced, entry.caseSensitive)) {
+      out.push({ term: entry.term, expected: forced, kind: "forced" });
     }
-    const image = cache2.get(screenshot);
-    if (image) req.image = image;
   }
+  return out;
 }
-function attachScreenshotsForProvider(reqs, state, projectRoot, supportsVision) {
-  if (supportsVision) {
-    attachScreenshots(reqs, state, projectRoot);
-    return { skipped: 0 };
+
+// src/server/spell.ts
+var instances = /* @__PURE__ */ new Map();
+var loading = /* @__PURE__ */ new Set();
+var unavailable = /* @__PURE__ */ new Set();
+var cache = /* @__PURE__ */ new Map();
+var norm = (dictId) => dictId.toLowerCase();
+var ICU_BLOCK = /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g;
+var MASK = /\{[^}]*\}|<[^>]*>|:\w+|%[sd]/g;
+var WORD = new RegExp("\\p{L}[\\p{L}''\u2019-]*", "gu");
+function spellTokens(value) {
+  return value.replace(ICU_BLOCK, " ").replace(MASK, " ").match(WORD) ?? [];
+}
+function ignoreWordsFor(glossary, customWords = []) {
+  const set = /* @__PURE__ */ new Set();
+  const add = (text) => {
+    for (const w of text.match(WORD) ?? []) set.add(w.toLowerCase());
+  };
+  for (const e of glossary) {
+    add(e.term);
+    for (const t of Object.values(e.translations ?? {})) add(t);
   }
-  const keys = new Set(reqs.filter((r) => state.keys[r.key]?.screenshot).map((r) => r.key));
-  return { skipped: keys.size };
+  for (const w of customWords) add(w);
+  return set;
 }
-var DEFAULT_LOCALE_CONCURRENCY = 3;
-async function runLocaleParallel(reqs, provider, hooks = {}, concurrency = DEFAULT_LOCALE_CONCURRENCY, signal, batchSize = Infinity) {
-  if (!reqs.length) return [];
-  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);
+async function getSpeller(dictId) {
+  const key = norm(dictId);
+  const existing = instances.get(key);
+  if (existing) return existing;
+  if (unavailable.has(key)) return null;
+  try {
+    const nspellMod = await import("nspell");
+    const nspell = nspellMod.default ?? nspellMod;
+    const dictMod = await import(`dictionary-${key}`);
+    const dictExport = dictMod.default ?? dictMod;
+    const dict = typeof dictExport === "function" ? await dictExport() : dictExport;
+    const speller = nspell(dict);
+    instances.set(key, speller);
+    return speller;
+  } catch {
+    unavailable.add(key);
+    return null;
+  } finally {
+    loading.delete(key);
   }
-  const localeBatches = [...byLocale.entries()].map(([locale, group]) => ({
-    locale,
-    batches: chunk(group, Math.max(1, batchSize))
-  }));
-  const jobs = [];
-  const maxBatches = Math.max(...localeBatches.map((g) => g.batches.length));
-  for (let i = 0; i < maxBatches; i++) {
-    for (const g of localeBatches) {
-      if (i < g.batches.length) jobs.push({ locale: g.locale, batch: g.batches[i] });
+}
+function spellValue(dictId, value, ignore) {
+  const key = norm(dictId);
+  if (unavailable.has(key)) return [];
+  const spell = instances.get(key);
+  if (!spell) {
+    if (!loading.has(key)) {
+      loading.add(key);
+      void getSpeller(key);
     }
-  }
-  const remaining = new Map(localeBatches.map((g) => [g.locale, g.batches.length]));
-  const started = /* @__PURE__ */ new Set();
-  const total = reqs.length;
-  let done = 0;
-  const allResults = [];
-  let next = 0;
-  async function worker() {
-    while (next < jobs.length) {
-      if (signal?.aborted) break;
-      const { locale, batch } = jobs[next++];
-      if (!started.has(locale)) {
-        started.add(locale);
-        hooks.onLocaleStart?.(locale);
-      }
-      const batchResults = await provider.translate(batch, (_localeDone, _localeTotal, results) => {
-        done += results.length;
-        hooks.onBatchComplete?.(done, total, results, locale);
-      }, signal, (raw, size) => hooks.onMalformedReply?.(raw, size, locale));
-      allResults.push(...batchResults);
-      const left = remaining.get(locale) - 1;
-      remaining.set(locale, left);
-      if (left === 0 && !signal?.aborted) hooks.onLocaleDone?.(locale);
-    }
-  }
-  const workers = Array.from({ length: Math.min(concurrency, jobs.length) }, worker);
-  await Promise.all(workers);
-  return allResults;
-}
-function applyResults(state, reqs, results, clock = systemClock, force = false) {
-  const byId = new Map(reqs.map((r) => [r.id, r]));
-  let written = 0;
-  const errors = [];
-  for (const res of results) {
-    const req = byId.get(res.id);
-    if (!req) continue;
-    if (req.plural) {
-      if (res.error || res.forms === void 0) {
-        errors.push({ key: req.key, locale: req.targetLocale, error: res.error ?? "no translation" });
-        continue;
-      }
-      if (applyMachineTranslationForms(state, req.key, req.targetLocale, res.forms, clock, force)) written++;
-      continue;
-    }
-    if (res.translation === void 0) {
-      errors.push({ key: req.key, locale: req.targetLocale, error: res.error ?? "no translation" });
-      continue;
-    }
-    if (res.error) errors.push({ key: req.key, locale: req.targetLocale, error: res.error });
-    if (applyMachineTranslation(state, req.key, req.targetLocale, res.translation, clock, force)) written++;
-  }
-  return { written, errors };
-}
-
-// src/server/spell.ts
-import nspell from "nspell";
-var LOADERS = {
-  en: () => init_dictionary_en().then(() => dictionary_en_exports),
-  es: () => import("dictionary-es"),
-  fr: () => import("dictionary-fr")
-};
-var instances = /* @__PURE__ */ new Map();
-var loading = /* @__PURE__ */ new Set();
-var unavailable = /* @__PURE__ */ new Set();
-var cache = /* @__PURE__ */ new Map();
-var norm = (locale) => locale.toLowerCase();
-var ICU_BLOCK = /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g;
-var MASK = /\{[^}]*\}|<[^>]*>|:\w+|%[sd]/g;
-var WORD = new RegExp("\\p{L}[\\p{L}''\u2019-]*", "gu");
-async function loadDictionary(locale) {
-  const key = norm(locale);
-  if (instances.has(key) || unavailable.has(key)) return;
-  const loader = LOADERS[key];
-  if (!loader) {
-    unavailable.add(key);
-    return;
-  }
-  try {
-    const { default: dict } = await loader();
-    instances.set(key, nspell(dict));
-  } catch {
-    unavailable.add(key);
-  } finally {
-    loading.delete(key);
-  }
-}
-function spellValue(locale, value, ignore) {
-  const key = norm(locale);
-  if (unavailable.has(key)) return [];
-  const spell = instances.get(key);
-  if (!spell) {
-    if (!LOADERS[key]) {
-      unavailable.add(key);
-      return [];
-    }
-    if (!loading.has(key)) {
-      loading.add(key);
-      void loadDictionary(key);
-    }
-    return null;
+    return null;
   }
   const cacheKey = key + " " + value;
   let allBad = cache.get(cacheKey);
   if (!allBad) {
-    const words = value.replace(ICU_BLOCK, " ").replace(MASK, " ").match(WORD) ?? [];
-    allBad = words.filter((w) => !spell.correct(w));
+    allBad = spellTokens(value).filter((w) => !spell.correct(w));
     cache.set(cacheKey, allBad);
   }
   return allBad.filter((w) => !ignore.has(w.toLowerCase()));
@@ -1830,39 +1569,21 @@ var CHECK_RULE = {
   length: "max-length",
   glossary: "glossary-violation"
 };
-function contains(haystack, needle, caseSensitive) {
-  return caseSensitive ? haystack.includes(needle) : haystack.toLowerCase().includes(needle.toLowerCase());
-}
 function runChecks(state, opts = {}) {
   const ruleOff = (id) => state.config.lint?.rules?.[CHECK_RULE[id]] === "off";
   const on = (id) => (!opts.only || opts.only.includes(id)) && !ruleOff(id);
   const issues = [];
   let spellPending = false;
   const { sourceLocale } = state.config;
-  const byTerm = new Map(state.glossary.map((e) => [e.term, e]));
-  const ignore = /* @__PURE__ */ new Set();
-  for (const e of state.glossary) {
-    for (const w of e.term.toLowerCase().split(/\s+/)) if (w) ignore.add(w);
-    for (const t of Object.values(e.translations ?? {})) {
-      for (const w of t.toLowerCase().split(/\s+/)) if (w) ignore.add(w);
+  const ignore = ignoreWordsFor(state.glossary, state.config.spelling?.customWords);
+  if (on("untranslated")) {
+    for (const m of findMissing(state)) {
+      issues.push({ key: m.key, locale: m.locale, check: "untranslated", message: "Not translated yet" });
     }
   }
-  for (const word of state.config.spelling?.customWords ?? []) {
-    const w = word.trim().toLowerCase();
-    if (w) ignore.add(w);
-  }
-  const targetLocales = state.config.locales.filter((l) => l !== sourceLocale);
   for (const key of Object.keys(state.keys).sort()) {
     const entry = state.keys[key];
     const source = entry.values[sourceLocale]?.value ?? "";
-    if (on("untranslated") && !entry.skipTranslate) {
-      for (const locale of targetLocales) {
-        const translated = entry.plural ? (entry.values[locale]?.forms?.other ?? "").trim() !== "" : (entry.values[locale]?.value ?? "").trim() !== "";
-        if (!translated) {
-          issues.push({ key, locale, check: "untranslated", message: "Not translated yet" });
-        }
-      }
-    }
     if (entry.plural) {
       if (on("placeholder")) {
         const sourceForm = entry.values[sourceLocale]?.forms?.other ?? "";
@@ -1906,7 +1627,8 @@ function runChecks(state, opts = {}) {
         });
       }
       if (on("spelling") && !blank) {
-        const bad = spellValue(locale, value, ignore);
+        const dictId = state.config.lint?.spelling?.locales?.[locale] ?? locale;
+        const bad = spellValue(dictId, value, ignore);
         if (bad === null) spellPending = true;
         else if (bad.length) {
           issues.push({
@@ -1936,29 +1658,14 @@ function runChecks(state, opts = {}) {
         });
       }
       if (on("glossary") && source) {
-        for (const hint of relevantGlossary(source, locale, state.glossary)) {
-          const cs = byTerm.get(hint.term)?.caseSensitive;
-          if (hint.doNotTranslate) {
-            if (!contains(value, hint.term, cs)) {
-              issues.push({
-                key,
-                locale,
-                check: "glossary",
-                message: `Do-not-translate term "${hint.term}" is missing from the translation`,
-                detail: [hint.term]
-              });
-            }
-          } else if (hint.forced) {
-            if (!contains(value, hint.forced, cs)) {
-              issues.push({
-                key,
-                locale,
-                check: "glossary",
-                message: `Should use "${hint.forced}" for "${hint.term}"`,
-                detail: [hint.forced]
-              });
-            }
-          }
+        for (const viol of glossaryViolations(source, value, locale, state.glossary)) {
+          issues.push({
+            key,
+            locale,
+            check: "glossary",
+            message: viol.kind === "do-not-translate" ? `Do-not-translate term "${viol.term}" is missing from the translation` : `Should use "${viol.expected}" for "${viol.term}"`,
+            detail: [viol.expected]
+          });
         }
       }
     }
@@ -1970,19 +1677,13 @@ function runChecks(state, opts = {}) {
   return { issues: visible, spellPending };
 }
 
-// src/server/lint/spelling.ts
-function tokenize(text) {
-  return text.match(new RegExp("\\p{L}[\\p{L}'']*", "gu")) ?? [];
-}
-function buildAllowWords(glossary, dictionary2 = []) {
-  const set = /* @__PURE__ */ new Set();
-  const add = (s) => {
-    for (const w of tokenize(s)) set.add(w.toLowerCase());
-  };
-  for (const g of glossary) add(g.term);
-  for (const w of dictionary2) add(w);
-  return set;
+// src/server/glob.ts
+function globToRegExp2(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
 }
+
+// src/server/lint/spelling.ts
 var spellingRule = {
   id: "spelling",
   run(state, ctx) {
@@ -1994,10 +1695,8 @@ var spellingRule = {
         if (!speller) continue;
         const value = entry.values[locale]?.value;
         if (!value) continue;
-        const placeholders = new Set(extractPlaceholders(value).map((p) => p.toLowerCase()));
-        for (const word of tokenize(value)) {
-          const lower = word.toLowerCase();
-          if (placeholders.has(lower) || ctx.allowWords.has(lower)) continue;
+        for (const word of spellTokens(value)) {
+          if (ctx.allowWords.has(word.toLowerCase())) continue;
           if (!speller.correct(word)) {
             out.push({ ruleId: "spelling", key, locale, message: `possible misspelling: "${word}"` });
           }
@@ -2007,18 +1706,7 @@ var spellingRule = {
     return out;
   }
 };
-var defaultLoader = async (dictId) => {
-  try {
-    const nspellMod = await import("nspell");
-    const nspell2 = nspellMod.default ?? nspellMod;
-    const dictMod = await import(`dictionary-${dictId.toLowerCase()}`);
-    const dictExport = dictMod.default ?? dictMod;
-    const dict = typeof dictExport === "function" ? await dictExport() : dictExport;
-    return nspell2(dict);
-  } catch {
-    return null;
-  }
-};
+var defaultLoader = (dictId) => getSpeller(dictId);
 
 // src/server/lint/rules.ts
 var emptySourceRule = {
@@ -2035,17 +1723,14 @@ var emptySourceRule = {
 };
 var emptyTranslationRule = {
   id: "empty-translation",
-  run(state, ctx) {
+  // findMissing is the shared "untranslated" walk (also behind the editor's
+  // untranslated check and /scan/missing); a whitespace-only value counts as
+  // missing there, so no separate whitespace pass is needed.
+  run(state) {
     const out = [];
     for (const m of findMissing(state)) {
       out.push({ ruleId: "empty-translation", key: m.key, locale: m.locale, message: "translation is empty or missing" });
     }
-    for (const key of Object.keys(state.keys)) {
-      for (const locale of ctx.targetLocales) {
-        const v = state.keys[key].values[locale]?.value;
-        if (v && !v.trim()) out.push({ ruleId: "empty-translation", key, locale, message: "translation is whitespace-only" });
-      }
-    }
     return out;
   }
 };
@@ -2173,13 +1858,13 @@ var glossaryViolationRule = {
       for (const locale of ctx.targetLocales) {
         const v = entry.values[locale]?.value;
         if (!v) continue;
-        for (const hint of relevantGlossary(src, locale, ctx.glossary)) {
-          if (hint.doNotTranslate && !v.includes(hint.term)) {
-            out.push({ ruleId: "glossary-violation", key, locale, message: `do-not-translate term "${hint.term}" is missing or altered` });
-          }
-          if (hint.forced && !v.includes(hint.forced)) {
-            out.push({ ruleId: "glossary-violation", key, locale, message: `expected glossary translation "${hint.forced}" for "${hint.term}"` });
-          }
+        for (const viol of glossaryViolations(src, v, locale, ctx.glossary)) {
+          out.push({
+            ruleId: "glossary-violation",
+            key,
+            locale,
+            message: viol.kind === "do-not-translate" ? `do-not-translate term "${viol.term}" is missing or altered` : `expected glossary translation "${viol.expected}" for "${viol.term}"`
+          });
         }
       }
     }
@@ -2238,7 +1923,7 @@ async function runLint(state, options = {}) {
   const active = rules.filter(isActive);
   const spellingOn = active.some((r) => r.id === "spelling");
   const spellers = spellingOn ? await loadSpellers(targetLocales, config, load, warn) : /* @__PURE__ */ new Map();
-  const allowWords = spellingOn ? buildAllowWords(state.glossary, state.config.spelling?.customWords) : /* @__PURE__ */ new Set();
+  const allowWords = spellingOn ? ignoreWordsFor(state.glossary, state.config.spelling?.customWords) : /* @__PURE__ */ new Set();
   const ctx = {
     config,
     sourceLocale: state.config.sourceLocale,
@@ -2271,8 +1956,8 @@ async function runLint(state, options = {}) {
 }
 
 // src/server/lint/outputs.ts
-import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
-import { resolve as resolve5 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
+import { resolve as resolve4 } from "path";
 
 // src/server/adapters/options.ts
 function applyCase(canonical, style) {
@@ -3072,8 +2757,8 @@ function checkOutputs(state, root) {
   for (const output of state.config.outputs) {
     const result = getAdapter(output.adapter).export(state, output);
     for (const file of result.files) {
-      const abs = resolve5(root, file.path);
-      const current = existsSync7(abs) ? readFileSync7(abs, "utf8") : null;
+      const abs = resolve4(root, file.path);
+      const current = existsSync6(abs) ? readFileSync6(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) {
@@ -3187,6 +2872,88 @@ var BATCH_SCHEMA = {
   additionalProperties: false
 };
 
+// src/server/ai/batch.ts
+var MalformedReplyError = class extends Error {
+  constructor(raw) {
+    super("Model reply was not valid translation JSON.");
+    this.raw = raw;
+    this.name = "MalformedReplyError";
+  }
+  raw;
+};
+function parseReplyItems(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new MalformedReplyError(text);
+  }
+  if (!Array.isArray(parsed.items)) throw new MalformedReplyError(text);
+  return parsed.items;
+}
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+function validateTranslation(req, translation) {
+  if (translation === void 0) return { id: req.id, error: "No translation returned." };
+  if (!placeholdersMatch(req.source, translation)) {
+    return { id: req.id, error: "Placeholder mismatch between source and translation." };
+  }
+  if (req.maxLength !== void 0 && translation.length > req.maxLength) {
+    return { id: req.id, translation, error: `Exceeds maxLength (${translation.length} > ${req.maxLength}).` };
+  }
+  return { id: req.id, translation };
+}
+function validatePlural(req, forms) {
+  if (!forms) return { id: req.id, error: "No translation returned." };
+  const plural = req.plural;
+  if (!plural) return { id: req.id, error: "validatePlural called on a non-plural request." };
+  const cats = plural.categories;
+  const missing = cats.filter((c) => typeof forms[c] !== "string");
+  if (missing.length) return { id: req.id, error: `Missing plural categories: ${missing.join(", ")}.` };
+  const badPh = cats.find((c) => !pluralFormPlaceholdersMatch(c, req.source, forms[c]));
+  if (badPh) return { id: req.id, error: `Placeholder mismatch in plural form "${badPh}".` };
+  if (req.maxLength !== void 0) {
+    const over = cats.find((c) => forms[c].length > req.maxLength);
+    if (over) return { id: req.id, error: `Plural form "${over}" exceeds maxLength (${forms[over].length} > ${req.maxLength}).` };
+  }
+  const out = {};
+  for (const c of cats) out[c] = forms[c];
+  return { id: req.id, forms: out };
+}
+function validateReply(req, item) {
+  return req.plural ? validatePlural(req, item?.forms) : validateTranslation(req, item?.translation);
+}
+async function runBatched(reqs, batchSize, callBatch, onBatchComplete, signal, onMalformedReply) {
+  const failBatch = (batch) => batch.map((req) => ({ id: req.id, error: "Model returned malformed JSON for this string." }));
+  async function resolveBatch(batch, isRetry = false) {
+    let reply;
+    try {
+      reply = await callBatch(batch, signal);
+    } catch (err) {
+      if (!(err instanceof MalformedReplyError)) throw err;
+      onMalformedReply?.(err.raw, batch.length);
+      if (signal?.aborted) return failBatch(batch);
+      if (batch.length === 1) return isRetry ? failBatch(batch) : resolveBatch(batch, true);
+      const mid = Math.ceil(batch.length / 2);
+      return [...await resolveBatch(batch.slice(0, mid)), ...await resolveBatch(batch.slice(mid))];
+    }
+    const byId = new Map(reply.map((r) => [r.id, r]));
+    return batch.map((req) => validateReply(req, byId.get(req.id)));
+  }
+  const results = [];
+  const total = reqs.length;
+  for (const batch of chunk(reqs, Math.max(1, batchSize))) {
+    if (signal?.aborted) break;
+    const batchResults = await resolveBatch(batch);
+    results.push(...batchResults);
+    onBatchComplete?.(results.length, total, batchResults);
+  }
+  return results;
+}
+
 // src/server/ai/anthropic.ts
 var AnthropicProvider = class {
   constructor(config, client) {
@@ -3618,6 +3385,178 @@ function makeProvider(ai) {
   }
 }
 
+// src/server/ai/run.ts
+import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { resolve as resolve5, extname as extname2 } from "path";
+function selectRequests(state, opts) {
+  const targets = (opts.locales ?? state.config.locales).filter((l) => l !== state.config.sourceLocale);
+  const keyRe = opts.keyGlob ? globToRegExp2(opts.keyGlob) : null;
+  const keySet = opts.keys ? new Set(opts.keys) : null;
+  const reqs = [];
+  let id = 0;
+  for (const key of Object.keys(state.keys).sort()) {
+    const entry = state.keys[key];
+    if (entry.skipTranslate) continue;
+    if (keyRe && !keyRe.test(key)) continue;
+    if (keySet && !keySet.has(key)) continue;
+    const sourceLv = entry.values[state.config.sourceLocale];
+    if (entry.plural) {
+      const sourceForms = sourceLv?.forms;
+      const other = sourceForms?.other;
+      if (!sourceForms || !other) continue;
+      for (const locale of targets) {
+        const have = entry.values[locale]?.forms ?? {};
+        const complete = categoriesFor(locale).every((c) => (have[c] ?? "") !== "");
+        if (opts.onlyMissing && complete) continue;
+        const glossary = relevantGlossary(other, locale, state.glossary);
+        reqs.push({
+          id: String(id++),
+          key,
+          source: other,
+          sourceLocale: state.config.sourceLocale,
+          context: entry.context,
+          targetLocale: locale,
+          maxLength: entry.maxLength,
+          placeholders: extractPlaceholders(other),
+          ...glossary.length ? { glossary } : {},
+          plural: { arg: entry.plural.arg, categories: categoriesFor(locale), sourceForms }
+        });
+      }
+      continue;
+    }
+    const source = sourceLv?.value;
+    if (!source) continue;
+    for (const locale of targets) {
+      const existing = entry.values[locale]?.value;
+      if (opts.onlyMissing && existing) continue;
+      const glossary = relevantGlossary(source, locale, state.glossary);
+      reqs.push({
+        id: String(id++),
+        key,
+        source,
+        sourceLocale: state.config.sourceLocale,
+        context: entry.context,
+        targetLocale: locale,
+        maxLength: entry.maxLength,
+        placeholders: extractPlaceholders(source),
+        ...glossary.length ? { glossary } : {}
+      });
+    }
+  }
+  return reqs;
+}
+var MEDIA_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif"
+};
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+function attachScreenshots(reqs, state, projectRoot) {
+  const cache2 = /* @__PURE__ */ new Map();
+  for (const req of reqs) {
+    const screenshot = state.keys[req.key]?.screenshot;
+    if (!screenshot) continue;
+    const mediaType = MEDIA_TYPES[extname2(screenshot).toLowerCase()];
+    if (!mediaType) continue;
+    if (!cache2.has(screenshot)) {
+      const abs = resolve5(projectRoot, screenshot);
+      if (!existsSync7(abs)) {
+        cache2.set(screenshot, null);
+      } else {
+        const buf = readFileSync7(abs);
+        cache2.set(screenshot, buf.length > MAX_IMAGE_BYTES ? null : { mediaType, base64: buf.toString("base64") });
+      }
+    }
+    const image = cache2.get(screenshot);
+    if (image) req.image = image;
+  }
+}
+function attachScreenshotsForProvider(reqs, state, projectRoot, supportsVision) {
+  if (supportsVision) {
+    attachScreenshots(reqs, state, projectRoot);
+    return { skipped: 0 };
+  }
+  const keys = new Set(reqs.filter((r) => state.keys[r.key]?.screenshot).map((r) => r.key));
+  return { skipped: keys.size };
+}
+var DEFAULT_LOCALE_CONCURRENCY = 3;
+async function runLocaleParallel(reqs, provider, hooks = {}, concurrency = DEFAULT_LOCALE_CONCURRENCY, signal, batchSize = Infinity) {
+  if (!reqs.length) return [];
+  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 localeBatches = [...byLocale.entries()].map(([locale, group]) => ({
+    locale,
+    batches: chunk(group, Math.max(1, batchSize))
+  }));
+  const jobs = [];
+  const maxBatches = Math.max(...localeBatches.map((g) => g.batches.length));
+  for (let i = 0; i < maxBatches; i++) {
+    for (const g of localeBatches) {
+      if (i < g.batches.length) jobs.push({ locale: g.locale, batch: g.batches[i] });
+    }
+  }
+  const remaining = new Map(localeBatches.map((g) => [g.locale, g.batches.length]));
+  const started = /* @__PURE__ */ new Set();
+  const total = reqs.length;
+  let done = 0;
+  const allResults = [];
+  let next = 0;
+  async function worker() {
+    while (next < jobs.length) {
+      if (signal?.aborted) break;
+      const { locale, batch } = jobs[next++];
+      if (!started.has(locale)) {
+        started.add(locale);
+        hooks.onLocaleStart?.(locale);
+      }
+      const batchResults = await provider.translate(batch, (_localeDone, _localeTotal, results) => {
+        done += results.length;
+        hooks.onBatchComplete?.(done, total, results, locale);
+      }, signal, (raw, size) => hooks.onMalformedReply?.(raw, size, locale));
+      allResults.push(...batchResults);
+      const left = remaining.get(locale) - 1;
+      remaining.set(locale, left);
+      if (left === 0 && !signal?.aborted) hooks.onLocaleDone?.(locale);
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, jobs.length) }, worker);
+  await Promise.all(workers);
+  return allResults;
+}
+function applyResults(state, reqs, results, clock = systemClock, force = false) {
+  const byId = new Map(reqs.map((r) => [r.id, r]));
+  let written = 0;
+  const errors = [];
+  for (const res of results) {
+    const req = byId.get(res.id);
+    if (!req) continue;
+    if (req.plural) {
+      if (res.error || res.forms === void 0) {
+        errors.push({ key: req.key, locale: req.targetLocale, error: res.error ?? "no translation" });
+        continue;
+      }
+      if (applyMachineTranslationForms(state, req.key, req.targetLocale, res.forms, clock, force)) written++;
+      continue;
+    }
+    if (res.translation === void 0) {
+      errors.push({ key: req.key, locale: req.targetLocale, error: res.error ?? "no translation" });
+      continue;
+    }
+    if (res.error) errors.push({ key: req.key, locale: req.targetLocale, error: res.error });
+    if (applyMachineTranslation(state, req.key, req.targetLocale, res.translation, clock, force)) written++;
+  }
+  return { written, errors };
+}
+
 // src/server/ai/pricing.ts
 var PRICE_TABLE = [
   ["claude-fable-5", 10, 50],