glotfile 0.4.6 → 0.5.1

package/dist/server/server.js

@@ -202,9 +202,6 @@ function validate(raw) {
     if (lint.ignore !== void 0 && (!Array.isArray(lint.ignore) || !lint.ignore.every((g) => typeof g === "string"))) {
       fail("config.lint.ignore must be an array of strings");
     }
-    if (lint.dictionary !== void 0 && (!Array.isArray(lint.dictionary) || !lint.dictionary.every((w) => typeof w === "string"))) {
-      fail("config.lint.dictionary must be an array of strings");
-    }
     if (lint.spelling !== void 0) {
       if (!isObject(lint.spelling)) fail("config.lint.spelling must be an object");
       if (lint.spelling.locales !== void 0 && (!isObject(lint.spelling.locales) || !Object.values(lint.spelling.locales).every((v) => typeof v === "string"))) {
@@ -269,6 +266,20 @@ function validate(raw) {
         lv.value = lv.value.trim();
       }
     }
+    if (entry.suppressions !== void 0) {
+      if (!Array.isArray(entry.suppressions)) fail(`key "${key}" suppressions must be an array`);
+      for (const s of entry.suppressions) {
+        if (!isObject(s) || typeof s.locale !== "string" || typeof s.source !== "string") {
+          fail(`key "${key}" has an invalid suppression (needs string rule, locale, source)`);
+        }
+        if (!RULE_IDS.includes(s.rule)) {
+          fail(`key "${key}" suppression has unknown rule id "${String(s.rule)}"`);
+        }
+        if (s.at !== void 0 && typeof s.at !== "string") {
+          fail(`key "${key}" suppression "at" must be a string`);
+        }
+      }
+    }
     if (entry.notes !== void 0) {
       if (!Array.isArray(entry.notes)) fail(`key "${key}" notes must be an array`);
       for (const n of entry.notes) {
@@ -512,6 +523,30 @@ function normalizeSource(value) {
   return value.trim().replace(/\s+/g, " ").toLowerCase();
 }
 
+// src/server/lint/suppress.ts
+import { createHash } from "crypto";
+function sourceSignature(entry, sourceLocale) {
+  const lv = entry.values[sourceLocale];
+  if (entry.plural) {
+    return Object.entries(lv?.forms ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([cat, body]) => `${cat}:${normalizeSource(body ?? "")}`).join("|");
+  }
+  return normalizeSource(lv?.value ?? "");
+}
+function sourceHash(entry, sourceLocale) {
+  return createHash("sha256").update(sourceSignature(entry, sourceLocale)).digest("hex").slice(0, 12);
+}
+function findSuppression(entry, sourceLocale, ruleId, locale) {
+  if (!entry.suppressions?.length) return void 0;
+  const current = sourceHash(entry, sourceLocale);
+  return entry.suppressions.find((s) => s.rule === ruleId && s.locale === locale && s.source === current);
+}
+function pruneStaleSuppressions(entry, sourceLocale) {
+  if (!entry.suppressions?.length) return;
+  const current = sourceHash(entry, sourceLocale);
+  entry.suppressions = entry.suppressions.filter((s) => s.source === current);
+  if (!entry.suppressions.length) delete entry.suppressions;
+}
+
 // src/server/state.ts
 var systemClock = () => (/* @__PURE__ */ new Date()).toISOString();
 function canonLocale(locale) {
@@ -532,6 +567,7 @@ function normalizeState(state) {
     const remapped = {};
     for (const [loc, lv] of Object.entries(entry.values)) remapped[canonLocale(loc)] = lv;
     entry.values = remapped;
+    for (const s of entry.suppressions ?? []) s.locale = canonLocale(s.locale);
   }
   for (const output of state.config.outputs) {
     if (!output.localeMap) continue;
@@ -623,6 +659,7 @@ function setSourceValue(state, key, value) {
         lv.state = "needs-review";
       }
     }
+    pruneStaleSuppressions(entry, state.config.sourceLocale);
   }
 }
 function setTargetValue(state, key, locale, value, clock = systemClock) {
@@ -646,6 +683,7 @@ function setSourcePluralForms(state, key, forms) {
         lv.state = "needs-review";
       }
     }
+    pruneStaleSuppressions(entry, state.config.sourceLocale);
   }
 }
 function setPluralForms(state, key, locale, forms, clock = systemClock) {
@@ -719,6 +757,19 @@ function deleteNote(state, key, id) {
   if (!entry.notes) return;
   entry.notes = entry.notes.filter((n) => n.id !== id);
 }
+function addSuppression(state, key, rule, locale, clock = systemClock) {
+  const entry = requireKey(state, key);
+  if (!RULE_IDS.includes(rule)) throw new GlotfileError(`Unknown lint rule: ${rule}`);
+  const list = (entry.suppressions ?? []).filter((s) => !(s.rule === rule && s.locale === locale));
+  list.push({ rule, locale, source: sourceHash(entry, state.config.sourceLocale), at: clock() });
+  entry.suppressions = list;
+}
+function removeSuppression(state, key, rule, locale) {
+  const entry = requireKey(state, key);
+  if (!entry.suppressions) return;
+  entry.suppressions = entry.suppressions.filter((s) => !(s.rule === rule && s.locale === locale));
+  if (!entry.suppressions.length) delete entry.suppressions;
+}
 function upsertGlossaryEntry(state, entry) {
   const i = state.glossary.findIndex((e) => e.term === entry.term);
   if (i === -1) state.glossary.push(entry);
@@ -755,6 +806,23 @@ function applyMachineTranslationForms(state, key, locale, forms, clock = systemC
   return true;
 }
 
+// src/server/lint/accept.ts
+function acceptFindings(state, findings, opts = {}, clock = systemClock) {
+  const byRule = {};
+  let accepted = 0;
+  for (const f of findings) {
+    if (f.locale === "" || f.suppressed) continue;
+    if (f.severity === "error" && !opts.includeErrors) continue;
+    if (opts.rules && !opts.rules.includes(f.ruleId)) continue;
+    if (opts.locales && !opts.locales.includes(f.locale)) continue;
+    if (!state.keys[f.key]) continue;
+    addSuppression(state, f.key, f.ruleId, f.locale, clock);
+    byRule[f.ruleId] = (byRule[f.ruleId] ?? 0) + 1;
+    accepted++;
+  }
+  return { accepted, byRule };
+}
+
 // src/server/scan.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve2 } from "path";
@@ -1425,6 +1493,88 @@ function globToRegExp2(glob) {
   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);
@@ -1535,7 +1685,7 @@ function attachScreenshotsForProvider(reqs, state, projectRoot, supportsVision)
   return { skipped: keys.size };
 }
 var DEFAULT_LOCALE_CONCURRENCY = 3;
-async function runLocaleParallel(reqs, provider, hooks = {}, concurrency = DEFAULT_LOCALE_CONCURRENCY, signal) {
+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) {
@@ -1546,26 +1696,42 @@ async function runLocaleParallel(reqs, provider, hooks = {}, concurrency = DEFAU
     }
     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 = [];
-  const groups = [...byLocale.values()];
   let next = 0;
   async function worker() {
-    while (next < groups.length) {
+    while (next < jobs.length) {
       if (signal?.aborted) break;
-      const group = groups[next++];
-      const locale = group[0].targetLocale;
-      hooks.onLocaleStart?.(locale);
-      const localeResults = await provider.translate(group, (_localeDone, _localeTotal, batchResults) => {
-        done += batchResults.length;
-        hooks.onBatchComplete?.(done, total, batchResults, locale);
-      }, signal, (raw, batchSize) => hooks.onMalformedReply?.(raw, batchSize, locale));
-      allResults.push(...localeResults);
-      if (!signal?.aborted) hooks.onLocaleDone?.(locale);
-    }
-  }
-  const workers = Array.from({ length: Math.min(concurrency, groups.length) }, worker);
+      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;
 }
@@ -1653,11 +1819,19 @@ function spellValue(locale, value, ignore) {
 
 // src/server/checks.ts
 var CHECK_IDS = ["untranslated", "placeholder", "spelling", "length", "glossary"];
+var CHECK_RULE = {
+  untranslated: "empty-translation",
+  placeholder: "placeholder-mismatch",
+  spelling: "spelling",
+  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 on = (id) => !opts.only || opts.only.includes(id);
+  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;
@@ -1785,7 +1959,11 @@ function runChecks(state, opts = {}) {
       }
     }
   }
-  return { issues, spellPending };
+  const visible = issues.filter((i) => {
+    const entry = state.keys[i.key];
+    return !entry || !findSuppression(entry, sourceLocale, CHECK_RULE[i.check], i.locale);
+  });
+  return { issues: visible, spellPending };
 }
 
 // src/server/lint/spelling.ts
@@ -2027,7 +2205,10 @@ function sortFindings(findings) {
 }
 function countSeverities(findings) {
   let error = 0, warn = 0;
-  for (const f of findings) f.severity === "error" ? error++ : warn++;
+  for (const f of findings) {
+    if (f.suppressed) continue;
+    f.severity === "error" ? error++ : warn++;
+  }
   return { error, warn };
 }
 async function loadSpellers(locales, config, load, warn) {
@@ -2053,7 +2234,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, config.dictionary) : /* @__PURE__ */ new Set();
+  const allowWords = spellingOn ? buildAllowWords(state.glossary, state.config.spelling?.customWords) : /* @__PURE__ */ new Set();
   const ctx = {
     config,
     sourceLocale: state.config.sourceLocale,
@@ -2065,16 +2246,23 @@ async function runLint(state, options = {}) {
   const ignoreRes = (config.ignore ?? []).map(globToRegExp2);
   const localeFilter = options.locales ? new Set(options.locales) : null;
   const findings = [];
+  let suppressed = 0;
   for (const rule of active) {
     const severity = resolveSeverity(rule.id, config);
     for (const raw of rule.run(state, ctx)) {
       if (ignoreRes.some((re) => re.test(raw.key))) continue;
       if (localeFilter && raw.locale !== "" && !localeFilter.has(raw.locale)) continue;
+      const entry = state.keys[raw.key];
+      if (raw.locale !== "" && entry && findSuppression(entry, state.config.sourceLocale, rule.id, raw.locale)) {
+        suppressed++;
+        if (options.includeSuppressed) findings.push({ ...raw, severity, suppressed: true });
+        continue;
+      }
       findings.push({ ...raw, severity });
     }
   }
   const sorted = sortFindings(findings);
-  const counts = countSeverities(sorted);
+  const counts = { ...countSeverities(sorted), suppressed };
   return { findings: sorted, counts, ok: counts.error === 0 };
 }
 
@@ -2952,88 +3140,6 @@ 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) {
@@ -4108,6 +4214,7 @@ import { homedir } from "os";
 import { join as join8 } from "path";
 var THEMES = ["system", "light", "dark"];
 var isThemeMode = (v) => THEMES.includes(v);
+var isPanelWidth = (v) => typeof v === "number" && Number.isFinite(v) && v >= 120 && v <= 1200;
 var defaultUiPrefsPath = () => join8(homedir(), ".glotfile", "ui.json");
 var DEFAULTS = { theme: "system" };
 function readJson(path) {
@@ -4120,7 +4227,10 @@ function readJson(path) {
 }
 function loadUiPrefs(path) {
   const raw = readJson(path);
-  return { theme: isThemeMode(raw.theme) ? raw.theme : DEFAULTS.theme };
+  const prefs = { theme: isThemeMode(raw.theme) ? raw.theme : DEFAULTS.theme };
+  if (isPanelWidth(raw.keyColumnWidth)) prefs.keyColumnWidth = Math.round(raw.keyColumnWidth);
+  if (isPanelWidth(raw.detailPanelWidth)) prefs.detailPanelWidth = Math.round(raw.detailPanelWidth);
+  return prefs;
 }
 function saveUiPrefs(path, prefs) {
   const merged = { ...readJson(path), ...prefs };
@@ -4256,9 +4366,20 @@ function createApi(deps) {
   app.get("/state", (c) => c.json(load()));
   app.get("/ui-prefs", (c) => c.json(loadUiPrefs(uiPrefsPath)));
   app.put("/ui-prefs", async (c) => {
-    const { theme } = await c.req.json();
-    if (!isThemeMode(theme)) return c.json({ error: "theme must be system, light, or dark" }, 400);
-    saveUiPrefs(uiPrefsPath, { theme });
+    const body = await c.req.json();
+    const patch = {};
+    if ("theme" in body) {
+      if (!isThemeMode(body.theme)) return c.json({ error: "theme must be system, light, or dark" }, 400);
+      patch.theme = body.theme;
+    }
+    for (const field of ["keyColumnWidth", "detailPanelWidth"]) {
+      if (field in body) {
+        if (!isPanelWidth(body[field])) return c.json({ error: `${field} must be a number between 120 and 1200` }, 400);
+        patch[field] = Math.round(body[field]);
+      }
+    }
+    if (Object.keys(patch).length === 0) return c.json({ error: "no recognized preferences in body" }, 400);
+    saveUiPrefs(uiPrefsPath, patch);
     return c.json({ ok: true });
   });
   app.get("/local-settings", (c) => c.json(loadLocalSettings(projectRoot)));
@@ -4732,12 +4853,47 @@ function createApi(deps) {
   };
   app.get("/lint", async (c) => {
     const state = load();
+    const includeSuppressed = c.req.query("includeSuppressed") === "1";
     const lint = await runLint(state, { loadSpeller: cachedLoader, warn: () => {
-    } });
+    }, includeSuppressed });
     const findings = sortFindings([...lint.findings, ...checkOutputs(state, projectRoot)]);
-    const counts = countSeverities(findings);
+    const counts = { ...countSeverities(findings), suppressed: lint.counts.suppressed };
     return c.json({ findings, counts, ok: counts.error === 0 });
   });
+  app.post("/keys/:key/suppressions", async (c) => {
+    const key = c.req.param("key");
+    const { rule, locale } = await c.req.json();
+    if (typeof rule !== "string" || !rule) return c.json({ error: "rule is required" }, 400);
+    if (typeof locale !== "string" || !locale) return c.json({ error: "locale is required" }, 400);
+    const s = load();
+    addSuppression(s, key, rule, locale);
+    persist(s);
+    logChange({ kind: "suppression", summary: `Suppressed ${rule} for ${key} [${locale}]`, key, locale, after: rule });
+    return c.json({ ok: true });
+  });
+  app.delete("/keys/:key/suppressions", (c) => {
+    const key = c.req.param("key");
+    const rule = c.req.query("rule") ?? "";
+    const locale = c.req.query("locale") ?? "";
+    if (!rule || !locale) return c.json({ error: "rule and locale are required" }, 400);
+    const s = load();
+    removeSuppression(s, key, rule, locale);
+    persist(s);
+    logChange({ kind: "suppression", summary: `Unsuppressed ${rule} for ${key} [${locale}]`, key, locale, before: rule });
+    return c.json({ ok: true });
+  });
+  app.post("/lint/accept", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const s = load();
+    const lint = await runLint(s, { loadSpeller: cachedLoader, warn: () => {
+    } });
+    const result = acceptFindings(s, lint.findings, { rules: body.rules, locales: body.locales });
+    if (result.accepted > 0) {
+      persist(s);
+      logChange({ kind: "suppression", summary: `Suppressed ${result.accepted} finding(s)`, after: result.byRule });
+    }
+    return c.json({ ok: true, ...result });
+  });
   app.get("/checks", (c) => {
     const param = c.req.query("checks");
     const only = param ? param.split(",").map((s) => s.trim()).filter((s) => CHECK_IDS.includes(s)) : void 0;
@@ -4862,7 +5018,7 @@ function createApi(deps) {
             raw
           });
         }
-      }, aiCfg.concurrency, signal);
+      }, aiCfg.concurrency, signal, aiCfg.batchSize);
       if (!signal?.aborted) {
         console.log(`[translate] done \u2014 wrote ${totalWritten}, ${allErrors.length} error(s)`);
         await stream.writeSSE({ event: "done", data: JSON.stringify({ written: totalWritten, errors: allErrors }) });
@@ -4905,7 +5061,7 @@ function createApi(deps) {
             raw
           });
         }
-      }, aiCfg.concurrency);
+      }, aiCfg.concurrency, void 0, aiCfg.batchSize);
       const latest = load();
       ({ written, errors } = applyResults(latest, toTranslate, results, void 0, force));
       const entry = {