glotfile 0.4.2 → 0.4.4

package/dist/server/server.js

@@ -29,7 +29,7 @@ var init_dictionary_en = __esm({
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
 import { fileURLToPath } from "url";
-import { dirname as dirname3, join as join9, resolve as resolve9, extname as extname3, sep as sep2 } from "path";
+import { dirname as dirname4, join as join9, 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";
@@ -92,6 +92,17 @@ var RULE_IDS = [
   "whitespace",
   "spelling"
 ];
+var DEFAULT_SEVERITY = {
+  "empty-source": "error",
+  "empty-translation": "error",
+  "placeholder-mismatch": "error",
+  "icu-mismatch": "error",
+  "glossary-violation": "error",
+  "max-length": "warn",
+  "identical-to-source": "warn",
+  "whitespace": "warn",
+  "spelling": "warn"
+};
 
 // src/server/schema.ts
 var CURRENT_VERSION = 1;
@@ -783,8 +794,10 @@ function findMissing(state) {
   const targets = state.config.locales.filter((l) => l !== state.config.sourceLocale).sort();
   const out = [];
   for (const key of Object.keys(state.keys).sort()) {
+    const entry = state.keys[key];
+    if (entry.skipTranslate) continue;
     for (const locale of targets) {
-      const v = state.keys[key].values[locale]?.value;
+      const v = entry.plural ? entry.values[locale]?.forms?.other?.trim() : entry.values[locale]?.value;
       if (!v) out.push({ key, locale });
     }
   }
@@ -1384,6 +1397,10 @@ function toI18next(value) {
   if (isIcuPluralOrSelect(value)) return value;
   return value.replace(/(?<!\{)\{(\w+)\}(?!\})/g, "{{$1}}");
 }
+function toRuby(value) {
+  if (isIcuPluralOrSelect(value)) return value;
+  return value.replace(/(?<!%)\{(\w+)\}/g, "%{$1}");
+}
 function placeholdersMatch(source, translation) {
   const a = extractPlaceholders(source).sort();
   const b = extractPlaceholders(translation).sort();
@@ -1771,16 +1788,310 @@ function runChecks(state, opts = {}) {
   return { issues, 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;
+}
+var spellingRule = {
+  id: "spelling",
+  run(state, ctx) {
+    const out = [];
+    for (const key of Object.keys(state.keys)) {
+      const entry = state.keys[key];
+      for (const locale of ctx.targetLocales) {
+        const speller = ctx.spellers.get(locale);
+        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;
+          if (!speller.correct(word)) {
+            out.push({ ruleId: "spelling", key, locale, message: `possible misspelling: "${word}"` });
+          }
+        }
+      }
+    }
+    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;
+  }
+};
+
+// src/server/lint/rules.ts
+var emptySourceRule = {
+  id: "empty-source",
+  run(state, ctx) {
+    const out = [];
+    for (const key of Object.keys(state.keys)) {
+      const entry = state.keys[key];
+      const v = entry.plural ? entry.values[ctx.sourceLocale]?.forms?.other : entry.values[ctx.sourceLocale]?.value;
+      if (!v || !v.trim()) out.push({ ruleId: "empty-source", key, locale: "", message: "source value is empty" });
+    }
+    return out;
+  }
+};
+var emptyTranslationRule = {
+  id: "empty-translation",
+  run(state, ctx) {
+    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;
+  }
+};
+var identicalToSourceRule = {
+  id: "identical-to-source",
+  run(state, ctx) {
+    const out = [];
+    for (const key of Object.keys(state.keys)) {
+      const entry = state.keys[key];
+      if (entry.skipTranslate) continue;
+      const src = entry.values[ctx.sourceLocale]?.value;
+      if (!src) continue;
+      for (const locale of ctx.targetLocales) {
+        const v = entry.values[locale]?.value;
+        if (v && v === src) out.push({ ruleId: "identical-to-source", key, locale, message: "translation is identical to the source" });
+      }
+    }
+    return out;
+  }
+};
+var whitespaceRule = {
+  id: "whitespace",
+  run(state, ctx) {
+    const out = [];
+    for (const key of Object.keys(state.keys)) {
+      const entry = state.keys[key];
+      const src = entry.values[ctx.sourceLocale]?.value ?? "";
+      const srcEdge = src !== src.trim();
+      for (const locale of ctx.targetLocales) {
+        const v = entry.values[locale]?.value;
+        if (!v) continue;
+        if (v !== v.trim() !== srcEdge) {
+          out.push({ ruleId: "whitespace", key, locale, message: "leading/trailing whitespace differs from the source" });
+        }
+      }
+    }
+    return out;
+  }
+};
+var placeholderMismatchRule = {
+  id: "placeholder-mismatch",
+  run(state, ctx) {
+    const out = [];
+    for (const key of Object.keys(state.keys)) {
+      const entry = state.keys[key];
+      if (entry.plural) {
+        const srcForm = entry.values[ctx.sourceLocale]?.forms?.other;
+        if (!srcForm) continue;
+        for (const locale of ctx.targetLocales) {
+          const forms = entry.values[locale]?.forms;
+          if (!forms) continue;
+          const bad = Object.entries(forms).some(
+            ([cat, form]) => form && !pluralFormPlaceholdersMatch(cat, srcForm, form)
+          );
+          if (bad) {
+            out.push({ ruleId: "placeholder-mismatch", key, locale, message: "placeholders differ from the source" });
+          }
+        }
+        continue;
+      }
+      const src = entry.values[ctx.sourceLocale]?.value;
+      if (!src) continue;
+      for (const locale of ctx.targetLocales) {
+        const v = entry.values[locale]?.value;
+        if (!v) continue;
+        if (!placeholdersMatch(src, v)) {
+          out.push({ ruleId: "placeholder-mismatch", key, locale, message: "placeholders differ from the source" });
+        }
+      }
+    }
+    return out;
+  }
+};
+var icuMismatchRule = {
+  id: "icu-mismatch",
+  run(state, ctx) {
+    const out = [];
+    for (const key of Object.keys(state.keys)) {
+      const entry = state.keys[key];
+      const src = entry.values[ctx.sourceLocale]?.value;
+      if (!src) continue;
+      const srcIcu = isIcuPluralOrSelect(src);
+      for (const locale of ctx.targetLocales) {
+        const v = entry.values[locale]?.value;
+        if (!v) continue;
+        if (isIcuPluralOrSelect(v) !== srcIcu) {
+          out.push({
+            ruleId: "icu-mismatch",
+            key,
+            locale,
+            message: srcIcu ? "source is an ICU plural/select but the translation is not" : "translation is an ICU plural/select but the source is not"
+          });
+        }
+      }
+    }
+    return out;
+  }
+};
+var maxLengthRule = {
+  id: "max-length",
+  run(state, ctx) {
+    const out = [];
+    for (const key of Object.keys(state.keys)) {
+      const entry = state.keys[key];
+      const max = entry.maxLength;
+      if (max == null) continue;
+      for (const locale of ctx.targetLocales) {
+        const v = entry.values[locale]?.value;
+        if (v && v.length > max) {
+          out.push({ ruleId: "max-length", key, locale, message: `length ${v.length} exceeds maxLength ${max}` });
+        }
+      }
+    }
+    return out;
+  }
+};
+var glossaryViolationRule = {
+  id: "glossary-violation",
+  run(state, ctx) {
+    const out = [];
+    for (const key of Object.keys(state.keys)) {
+      const entry = state.keys[key];
+      const src = entry.values[ctx.sourceLocale]?.value;
+      if (!src) continue;
+      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}"` });
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+var ALL_RULES = [
+  emptySourceRule,
+  emptyTranslationRule,
+  placeholderMismatchRule,
+  icuMismatchRule,
+  glossaryViolationRule,
+  maxLengthRule,
+  identicalToSourceRule,
+  whitespaceRule,
+  spellingRule
+];
+
+// src/server/lint/run.ts
+function resolveSeverity(id, config) {
+  return config.rules?.[id] ?? DEFAULT_SEVERITY[id];
+}
+function sortFindings(findings) {
+  return [...findings].sort(
+    (a, b) => a.key.localeCompare(b.key) || a.locale.localeCompare(b.locale) || a.ruleId.localeCompare(b.ruleId)
+  );
+}
+function countSeverities(findings) {
+  let error = 0, warn = 0;
+  for (const f of findings) f.severity === "error" ? error++ : warn++;
+  return { error, warn };
+}
+async function loadSpellers(locales, config, load, warn) {
+  const map = /* @__PURE__ */ new Map();
+  for (const locale of locales) {
+    const dictId = config.spelling?.locales?.[locale] ?? locale;
+    const speller = await load(dictId);
+    if (speller) map.set(locale, speller);
+    else warn(`no dictionary for "${locale}", skipping spelling`);
+  }
+  return map;
+}
+async function runLint(state, options = {}) {
+  const config = state.config.lint ?? {};
+  const rules = options.rules ?? ALL_RULES;
+  const warn = options.warn ?? ((m) => console.warn(m));
+  const load = options.loadSpeller ?? defaultLoader;
+  const targetLocales = state.config.locales.filter((l) => l !== state.config.sourceLocale);
+  const isActive = (rule) => {
+    if (options.ruleIds && !options.ruleIds.includes(rule.id)) return false;
+    return resolveSeverity(rule.id, config) !== "off";
+  };
+  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 ctx = {
+    config,
+    sourceLocale: state.config.sourceLocale,
+    targetLocales,
+    glossary: state.glossary,
+    spellers,
+    allowWords
+  };
+  const ignoreRes = (config.ignore ?? []).map(globToRegExp2);
+  const localeFilter = options.locales ? new Set(options.locales) : null;
+  const findings = [];
+  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;
+      findings.push({ ...raw, severity });
+    }
+  }
+  const sorted = sortFindings(findings);
+  const counts = countSeverities(sorted);
+  return { findings: sorted, counts, ok: counts.error === 0 };
+}
+
+// src/server/lint/outputs.ts
+import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { resolve as resolve5 } from "path";
+
 // src/server/adapters/options.ts
 function applyCase(canonical, style) {
-  const sep3 = style === "lower-underscore" || style === "bcp47-underscore" ? "_" : "-";
+  const sep4 = style === "lower-underscore" || style === "bcp47-underscore" ? "_" : "-";
   const lower = style === "lower-hyphen" || style === "lower-underscore";
   return canonical.split(/[-_]/).map((p, i) => {
     if (lower || i === 0) return p.toLowerCase();
     if (/^[a-z]{4}$/i.test(p)) return p[0].toUpperCase() + p.slice(1).toLowerCase();
     if (/^[a-z]{2}$/i.test(p)) return p.toUpperCase();
     return p;
-  }).join(sep3);
+  }).join(sep4);
 }
 function resolveLocaleToken(output, canonical, adapterDefault) {
   const mapped = output.localeMap?.[canonical];
@@ -2301,6 +2612,182 @@ var vueI18nJson = {
   }
 };
 
+// src/server/adapters/angular-xliff.ts
+function xmlEscape2(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderInterpolations(text, ids) {
+  let out = "";
+  let last = 0;
+  for (const m of text.matchAll(/\{(\w+)\}/g)) {
+    const name = m[1];
+    let id = ids.get(name);
+    if (id === void 0) {
+      id = ids.size === 0 ? "INTERPOLATION" : `INTERPOLATION_${ids.size}`;
+      ids.set(name, id);
+    }
+    out += xmlEscape2(text.slice(last, m.index)) + `<x id="${id}" equiv-text="{{${name}}}"/>`;
+    last = m.index + m[0].length;
+  }
+  return out + xmlEscape2(text.slice(last));
+}
+function renderPluralIcu(forms, ids) {
+  const cats = [
+    ...Object.keys(forms).filter((c) => c.startsWith("=")),
+    ...PLURAL_CATEGORIES.filter((c) => forms[c] !== void 0)
+  ];
+  const branches = cats.map((cat) => `${cat} {${renderInterpolations(forms[cat] ?? "", ids)}}`);
+  return `{VAR_PLURAL, plural, ${branches.join(" ")}}`;
+}
+function renderEmbeddedIcu(value) {
+  const renamed = value.replace(
+    /\{\s*\w+\s*,\s*(plural|select|selectordinal)\s*,/g,
+    (_, type) => `{${type === "plural" ? "VAR_PLURAL" : "VAR_SELECT"}, ${type},`
+  );
+  return xmlEscape2(renamed);
+}
+function renderScalar(value, ids) {
+  return isIcuPluralOrSelect(value) ? renderEmbeddedIcu(value) : renderInterpolations(value, ids);
+}
+var DEFAULT_LOCALE_CASE7 = "bcp47-hyphen";
+var angularXliff = {
+  name: "angular-xliff",
+  capabilities: {
+    plural: "native",
+    select: "native",
+    nesting: "flat",
+    metadata: true,
+    placeholderStyle: "icu",
+    fileGrouping: "per-locale"
+  },
+  defaultLocaleCase: DEFAULT_LOCALE_CASE7,
+  export(state, output) {
+    const files = [];
+    const warnings = [];
+    warnings.push(...localeCollisionWarnings(output, state.config.locales, DEFAULT_LOCALE_CASE7));
+    const sourceLocale = state.config.sourceLocale;
+    const sourceToken = resolveLocaleToken(output, sourceLocale, DEFAULT_LOCALE_CASE7);
+    const emptyAs = resolveEmptyAs(output, "source");
+    const keys = Object.keys(state.keys).sort();
+    for (const locale of state.config.locales) {
+      const token = resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE7);
+      const units = [];
+      for (const key of keys) {
+        const entry = state.keys[key];
+        let source;
+        let target;
+        const ids = /* @__PURE__ */ new Map();
+        if (entry.plural) {
+          const targetForms = resolveForms(entry, locale, sourceLocale, emptyAs);
+          if (targetForms === null) continue;
+          source = renderPluralIcu(entry.values[sourceLocale]?.forms ?? {}, ids);
+          target = renderPluralIcu(targetForms, ids);
+        } else {
+          const targetValue = resolveScalar(entry, locale, sourceLocale, emptyAs);
+          if (targetValue === null) continue;
+          source = renderScalar(entry.values[sourceLocale]?.value ?? "", ids);
+          target = renderScalar(targetValue, ids);
+        }
+        units.push(`      <trans-unit id="${xmlEscape2(key)}" datatype="html">`);
+        units.push(`        <source>${source}</source>`);
+        units.push(`        <target>${target}</target>`);
+        if (entry.description) {
+          units.push(`        <note priority="1" from="description">${xmlEscape2(entry.description)}</note>`);
+        }
+        units.push(`      </trans-unit>`);
+      }
+      const contents = `<?xml version="1.0" encoding="UTF-8" ?>
+<xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2">
+  <file source-language="${xmlEscape2(sourceToken)}" target-language="${xmlEscape2(token)}" datatype="plaintext" original="ng2.template">
+    <body>
+` + (units.length ? units.join("\n") + "\n" : "") + `    </body>
+  </file>
+</xliff>
+`;
+      files.push({ path: resolvePath(output.path, token), contents });
+    }
+    return { files, warnings };
+  }
+};
+
+// src/server/adapters/rails-yaml.ts
+var RESERVED_KEYS = /* @__PURE__ */ new Set(["true", "false", "yes", "no", "on", "off", "null", "y", "n"]);
+function yamlString(s) {
+  return '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t") + '"';
+}
+function yamlKey(k) {
+  if (RESERVED_KEYS.has(k.toLowerCase())) return yamlString(k);
+  return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(k) ? k : yamlString(k);
+}
+function yamlMap(node, indent, level) {
+  const pad = " ".repeat(indent * level);
+  const lines = [];
+  for (const key of Object.keys(node).sort()) {
+    const v = node[key];
+    if (v && typeof v === "object") {
+      lines.push(`${pad}${yamlKey(key)}:`);
+      lines.push(...yamlMap(v, indent, level + 1));
+    } else {
+      lines.push(`${pad}${yamlKey(key)}: ${yamlString(String(v))}`);
+    }
+  }
+  return lines;
+}
+var DEFAULT_LOCALE_CASE8 = "bcp47-hyphen";
+var railsYaml = {
+  name: "rails-yaml",
+  capabilities: {
+    plural: "native",
+    select: "lossy",
+    nesting: "nested",
+    metadata: false,
+    placeholderStyle: "named",
+    fileGrouping: "per-locale"
+  },
+  defaultLocaleCase: DEFAULT_LOCALE_CASE8,
+  export(state, output) {
+    const warnings = [];
+    warnings.push(...localeCollisionWarnings(output, state.config.locales, DEFAULT_LOCALE_CASE8));
+    const { indent, finalNewline } = resolveFormat(state, output);
+    const emptyAs = resolveEmptyAs(output, "omit");
+    const files = [];
+    for (const locale of state.config.locales) {
+      const flat = {};
+      for (const [key, entry] of Object.entries(state.keys)) {
+        if (entry.plural) {
+          const forms = resolveForms(entry, locale, state.config.sourceLocale, emptyAs);
+          if (!forms) continue;
+          for (const cat of PLURAL_CATEGORIES) {
+            const body2 = forms[cat];
+            if (body2 !== void 0) flat[`${key}.${cat}`] = toRuby(body2);
+          }
+        } else {
+          const raw = resolveScalar(entry, locale, state.config.sourceLocale, emptyAs);
+          if (raw === null) continue;
+          if (raw && isIcuPluralOrSelect(raw)) {
+            warnings.push({
+              code: "lossy-plural",
+              key,
+              locale,
+              message: "rails-yaml cannot represent ICU plural/select; written unconverted"
+            });
+          }
+          flat[key] = toRuby(raw);
+        }
+      }
+      const { tree: nested, collisions } = nestKeys(flat);
+      for (const c of collisions) {
+        warnings.push({ code: "key-collision", key: c, locale, message: "key is both a leaf and a parent; dropped from nested output" });
+      }
+      const token = resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE8);
+      const body = [`${yamlKey(token)}:`, ...yamlMap(nested, indent, 1)].join("\n");
+      files.push({ path: resolvePath(output.path, token), contents: finalNewline ? body + "\n" : body });
+    }
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    return { files, warnings };
+  }
+};
+
 // src/server/adapters/index.ts
 function resolvePath(template, locale, namespace = "") {
   return template.replaceAll("{locale}", locale).replaceAll("{namespace}", namespace);
@@ -2333,7 +2820,9 @@ function getRegistry() {
     [i18nextJson.name]: i18nextJson,
     [gettextPo.name]: gettextPo,
     [appleStringsdict.name]: appleStringsdict,
-    [vueI18nJson.name]: vueI18nJson
+    [vueI18nJson.name]: vueI18nJson,
+    [angularXliff.name]: angularXliff,
+    [railsYaml.name]: railsYaml
   };
 }
 function getAdapter(name) {
@@ -2342,9 +2831,27 @@ function getAdapter(name) {
   return a;
 }
 
+// src/server/lint/outputs.ts
+function checkOutputs(state, root) {
+  const out = [];
+  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;
+      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) {
+        out.push({ ruleId: "output-stale", key: file.path, locale: "", severity: "error", message: "output file is out of date; run `glotfile export`" });
+      }
+    }
+  }
+  return out;
+}
+
 // src/server/api.ts
-import { readFileSync as readFileSync13, existsSync as existsSync9, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "fs";
-import { dirname as dirname2, resolve as resolve8, basename, relative as relative3, sep } from "path";
+import { readFileSync as readFileSync14, existsSync as existsSync11, readdirSync as readdirSync8, statSync as statSync5, rmSync as rmSync4 } from "fs";
+import { dirname as dirname3, resolve as resolve9, basename, relative as relative3, sep as sep2 } from "path";
 
 // src/server/ai/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
@@ -2841,7 +3348,7 @@ function stripFences(s) {
   return s.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
 }
 function defaultSpawn(prompt, systemPrompt, model) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     const args = [
       "--print",
       "--output-format",
@@ -2873,7 +3380,7 @@ function defaultSpawn(prompt, systemPrompt, model) {
           reject(new Error(`claude error: ${envelope.result ?? "unknown error"}`));
           return;
         }
-        resolve10(envelope.result ?? "");
+        resolve11(envelope.result ?? "");
       } catch {
         reject(new Error(`Failed to parse claude JSON output: ${stdout.slice(0, 200)}`));
       }
@@ -2946,11 +3453,107 @@ function makeProvider(ai) {
   }
 }
 
+// src/server/ai/pricing.ts
+var PRICE_TABLE = [
+  ["claude-fable-5", 10, 50],
+  ["claude-mythos-5", 10, 50],
+  // Deprecated Opus 4.1 / 4.0 cost 3x the 4.5+ generation — they must outrank
+  // the shorter "claude-opus-4" prefix (4-2025 covers the dated Opus 4 full IDs).
+  ["claude-opus-4-1", 15, 75],
+  ["claude-opus-4-0", 15, 75],
+  ["claude-opus-4-2025", 15, 75],
+  ["claude-opus-4", 5, 25],
+  ["claude-sonnet-4", 3, 15],
+  ["claude-haiku-4", 1, 5],
+  ["claude-3-5-haiku", 0.8, 4],
+  ["gpt-5.5-pro", 30, 180],
+  ["gpt-5.5", 5, 30],
+  ["gpt-5.4-pro", 30, 180],
+  ["gpt-5.4-mini", 0.75, 4.5],
+  ["gpt-5.4-nano", 0.2, 1.25],
+  ["gpt-5.4", 2.5, 15],
+  ["gpt-5.3-codex", 1.75, 14]
+];
+var FREE_PROVIDERS = /* @__PURE__ */ new Set(["ollama", "claude-code"]);
+function bareModelId(model) {
+  let id = model.trim().toLowerCase();
+  const slash = id.lastIndexOf("/");
+  if (slash !== -1) id = id.slice(slash + 1);
+  const anth = id.lastIndexOf("anthropic.");
+  if (anth !== -1) id = id.slice(anth + "anthropic.".length);
+  return id;
+}
+function resolvePricing(ai) {
+  if (ai.inputPricePerMTok !== void 0 && ai.outputPricePerMTok !== void 0) {
+    return { source: "profile", inputPerMTok: ai.inputPricePerMTok, outputPerMTok: ai.outputPricePerMTok };
+  }
+  if (FREE_PROVIDERS.has(ai.provider)) return { source: "builtin", inputPerMTok: 0, outputPerMTok: 0 };
+  const id = bareModelId(ai.model);
+  let best;
+  for (const row of PRICE_TABLE) {
+    if (id.startsWith(row[0]) && (!best || row[0].length > best[0].length)) best = row;
+  }
+  return best ? { source: "builtin", inputPerMTok: best[1], outputPerMTok: best[2] } : null;
+}
+
+// src/server/ai/estimate.ts
+var CJK_RE = /[　-鿿가-힯豈-﫿]/g;
+function estimateTokens(text) {
+  const cjk = text.match(CJK_RE)?.length ?? 0;
+  return Math.ceil((text.length - cjk) / 4 + cjk / 2);
+}
+var EXPANSION = 1.2;
+var ITEM_REPLY_OVERHEAD = 16;
+var FORM_REPLY_OVERHEAD = 8;
+function estimateOutputTokens(req) {
+  const translated = Math.ceil(estimateTokens(req.source) * EXPANSION);
+  if (req.plural) {
+    return ITEM_REPLY_OVERHEAD + req.plural.categories.length * (translated + FORM_REPLY_OVERHEAD);
+  }
+  return ITEM_REPLY_OVERHEAD + translated;
+}
+function estimateTranslation(state, ai, opts) {
+  const reqs = selectRequests(state, opts);
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const r of reqs) {
+    let group = byLocale.get(r.targetLocale);
+    if (!group) {
+      group = [];
+      byLocale.set(r.targetLocale, group);
+    }
+    group.push(r);
+  }
+  const perLocale = [];
+  for (const [locale, group] of byLocale) {
+    let inputTokens2 = 0;
+    let outputTokens2 = 0;
+    const batches = chunk(group, Math.max(1, ai.batchSize));
+    for (const batch of batches) {
+      const system = buildSystemPrompt(batch.some((r) => r.plural !== void 0));
+      inputTokens2 += estimateTokens(system) + estimateTokens(buildBatchPrompt(batch));
+      for (const r of batch) outputTokens2 += estimateOutputTokens(r);
+    }
+    perLocale.push({ locale, requests: group.length, batches: batches.length, inputTokens: inputTokens2, outputTokens: outputTokens2 });
+  }
+  const inputTokens = perLocale.reduce((n, l) => n + l.inputTokens, 0);
+  const outputTokens = perLocale.reduce((n, l) => n + l.outputTokens, 0);
+  const pricing = resolvePricing(ai);
+  return {
+    requests: reqs.length,
+    batches: perLocale.reduce((n, l) => n + l.batches, 0),
+    perLocale,
+    inputTokens,
+    outputTokens,
+    pricing,
+    estimatedCost: pricing ? (inputTokens * pricing.inputPerMTok + outputTokens * pricing.outputPerMTok) / 1e6 : null
+  };
+}
+
 // src/server/log.ts
-import { appendFileSync, readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
-import { resolve as resolve5 } from "path";
+import { appendFileSync, readFileSync as readFileSync8, existsSync as existsSync8 } from "fs";
+import { resolve as resolve6 } from "path";
 function logPath(projectRoot) {
-  return resolve5(projectRoot, ".glotfile", "log.jsonl");
+  return resolve6(projectRoot, ".glotfile", "log.jsonl");
 }
 function appendLog(projectRoot, entry) {
   ensureGlotfileDir(projectRoot);
@@ -2958,14 +3561,14 @@ function appendLog(projectRoot, entry) {
 }
 function readLog(projectRoot, limit = 100) {
   const path = logPath(projectRoot);
-  if (!existsSync7(path)) return [];
-  const lines = readFileSync7(path, "utf8").split("\n").filter((l) => l.trim() !== "");
+  if (!existsSync8(path)) return [];
+  const lines = readFileSync8(path, "utf8").split("\n").filter((l) => l.trim() !== "");
   const entries = lines.map((l) => JSON.parse(l));
   return entries.reverse().slice(0, limit);
 }
 
 // src/server/import/detect.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
 import { join as join4 } from "path";
 var LOCALE_RE = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
 var VUE_DIR_CANDIDATES = ["src/locale", "src/locales", "src/i18n/locales", "locales", "lang"];
@@ -2998,12 +3601,13 @@ function detectLaravel(root) {
   const sourceLocale = pickSource(locales, (loc) => fileCount(join4(localeRoot, loc)));
   return { format: "laravel-php", localeRoot, locales, sourceLocale };
 }
-function detectVue(root) {
+function detectVue(root, forced = false) {
   for (const rel of VUE_DIR_CANDIDATES) {
     const localeRoot = join4(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = readdirSync3(localeRoot).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)).filter((l) => LOCALE_RE.test(l));
-    if (locales.length >= 2) {
+    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 statSync2(join4(localeRoot, `${loc}.json`)).size;
@@ -3030,11 +3634,11 @@ function detectArb(root) {
 var DETECTORS = [detectLaravel, detectVue, detectArb];
 var BY_FORMAT = {
   "laravel-php": detectLaravel,
-  "vue-i18n-json": detectVue,
+  "vue-i18n-json": (root) => detectVue(root, true),
   "flutter-arb": detectArb
 };
 function detect(root, formatOverride) {
-  if (!existsSync8(root)) return null;
+  if (!existsSync9(root)) return null;
   if (formatOverride) {
     const fn = BY_FORMAT[formatOverride];
     if (!fn) throw new Error(`Unknown format: ${formatOverride}`);
@@ -3048,7 +3652,7 @@ function detect(root, formatOverride) {
 }
 
 // src/server/import/parsers/vue-i18n-json.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
 import { join as join5 } from "path";
 
 // src/server/import/flatten.ts
@@ -3088,7 +3692,7 @@ var vueI18nJson2 = {
       if (opts?.locales && !opts.locales.includes(locale)) continue;
       let data;
       try {
-        data = JSON.parse(readFileSync8(join5(localeRoot, file), "utf8"));
+        data = JSON.parse(readFileSync9(join5(localeRoot, file), "utf8"));
       } catch (e) {
         warnings.push(`vue-i18n-json: failed to parse ${file}: ${e.message}`);
         continue;
@@ -3180,7 +3784,7 @@ var laravelPhp2 = {
 };
 
 // src/server/import/parsers/flutter-arb.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync10 } from "fs";
 import { join as join7 } from "path";
 var LOCALE_RE3 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
 function localeFromArbName(file) {
@@ -3217,7 +3821,7 @@ var flutterArb2 = {
       if (opts?.locales && !opts.locales.includes(locale)) continue;
       let data;
       try {
-        data = JSON.parse(readFileSync9(join7(localeRoot, file), "utf8"));
+        data = JSON.parse(readFileSync10(join7(localeRoot, file), "utf8"));
       } catch (e) {
         warnings.push(`flutter-arb: failed to parse ${file}: ${e.message}`);
         continue;
@@ -3371,8 +3975,8 @@ function runImport(opts) {
 }
 
 // src/server/export-run.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { resolve as resolve6 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync11, readdirSync as readdirSync7, rmdirSync, statSync as statSync4, unlinkSync } from "fs";
+import { dirname as dirname2, resolve as resolve7, sep } from "path";
 function effectiveLocales(config) {
   const limit = config.exportLocales;
   if (!limit || limit.length === 0) return config.locales;
@@ -3383,18 +3987,86 @@ function narrowForExport(state) {
   if (locales.length === state.config.locales.length) return state;
   return { ...state, config: { ...state.config, locales } };
 }
+var LOCALE_TOKEN = /^[a-z]{2,3}([_-][a-z0-9]+)*$/i;
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function segmentRegExp(segment) {
+  const pattern = escapeRegExp(segment).replaceAll("\\{locale\\}", "(?<locale>[A-Za-z0-9_-]+)").replaceAll("\\{namespace\\}", "[^/]*");
+  return new RegExp(`^${pattern}$`);
+}
+function removeEmptyDirs(dir, stopAt) {
+  let current = dir;
+  while (current !== stopAt && current.startsWith(stopAt + sep)) {
+    try {
+      rmdirSync(current);
+    } catch {
+      return;
+    }
+    current = dirname2(current);
+  }
+}
+function pruneStaleLocaleFiles(output, validTokens, projectRoot) {
+  const segments = output.path.split("/").filter(Boolean);
+  if (!segments.some((s) => s.includes("{locale}"))) return 0;
+  const root = resolve7(projectRoot);
+  let deleted = 0;
+  const stale = (token) => token !== void 0 && !validTokens.has(token) && LOCALE_TOKEN.test(token);
+  const visit = (dir, index, locale) => {
+    const segment = segments[index];
+    const isLast = index === segments.length - 1;
+    if (!segment.includes("{locale}") && !segment.includes("{namespace}")) {
+      const next = resolve7(dir, segment);
+      if (isLast) {
+        if (stale(locale) && existsSync10(next) && statSync4(next).isFile()) {
+          unlinkSync(next);
+          deleted++;
+          removeEmptyDirs(dir, root);
+        }
+        return;
+      }
+      visit(next, index + 1, locale);
+      return;
+    }
+    const re = segmentRegExp(segment);
+    let entries;
+    try {
+      entries = readdirSync7(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const m = entry.name.match(re);
+      if (!m) continue;
+      const token = m.groups?.locale ?? locale;
+      if (isLast) {
+        if (!entry.isFile() || !stale(token)) continue;
+        unlinkSync(resolve7(dir, entry.name));
+        deleted++;
+        removeEmptyDirs(dir, root);
+      } else if (entry.isDirectory()) {
+        visit(resolve7(dir, entry.name), index + 1, token);
+      }
+    }
+  };
+  visit(root, 0, void 0);
+  return deleted;
+}
 function exportToDisk(state, projectRoot, opts) {
+  const allLocales = state.config.locales;
   state = narrowForExport(state);
   const outputs = opts?.adapter ? state.config.outputs.filter((o) => o.adapter === opts.adapter) : state.config.outputs;
   const warnings = [];
   let written = 0;
   let skipped = 0;
+  let deleted = 0;
   for (const output of outputs) {
-    const result = getAdapter(output.adapter).export(state, output);
+    const adapter = getAdapter(output.adapter);
+    const result = adapter.export(state, output);
     warnings.push(...result.warnings);
     const writtenPaths = /* @__PURE__ */ new Set();
     for (const f of result.files) {
-      const abs = resolve6(projectRoot, f.path);
+      const abs = resolve7(projectRoot, f.path);
       if (writtenPaths.has(abs)) {
         skipped++;
         continue;
@@ -3402,7 +4074,7 @@ function exportToDisk(state, projectRoot, opts) {
       writtenPaths.add(abs);
       let current = null;
       try {
-        current = readFileSync10(abs, "utf8");
+        current = readFileSync11(abs, "utf8");
       } catch {
       }
       if (current === f.contents) {
@@ -3412,12 +4084,14 @@ function exportToDisk(state, projectRoot, opts) {
       writeFileAtomic(abs, f.contents);
       written++;
     }
+    const validTokens = new Set(allLocales.map((l) => resolveLocaleToken(output, l, adapter.defaultLocaleCase)));
+    deleted += pruneStaleLocaleFiles(output, validTokens, projectRoot);
   }
-  return { written, skipped, warnings };
+  return { written, skipped, deleted, warnings };
 }
 
 // src/server/ui-prefs.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { homedir } from "os";
 import { join as join8 } from "path";
 var THEMES = ["system", "light", "dark"];
@@ -3426,7 +4100,7 @@ var defaultUiPrefsPath = () => join8(homedir(), ".glotfile", "ui.json");
 var DEFAULTS = { theme: "system" };
 function readJson(path) {
   try {
-    const parsed = JSON.parse(readFileSync11(path, "utf8"));
+    const parsed = JSON.parse(readFileSync12(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -3442,8 +4116,8 @@ function saveUiPrefs(path, prefs) {
 }
 
 // src/server/local-settings.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { resolve as resolve7 } from "path";
+import { readFileSync as readFileSync13 } from "fs";
+import { resolve as resolve8 } from "path";
 var EDITOR_IDS = ["vscode", "zed", "phpstorm"];
 var isEditorId = (v) => EDITOR_IDS.includes(v);
 var DEFAULT_AI = {
@@ -3454,10 +4128,10 @@ var DEFAULT_AI = {
   batchSize: 25
 };
 var DEFAULT_EDITOR = "vscode";
-var settingsPath = (projectRoot) => resolve7(projectRoot, ".glotfile", "settings.json");
+var settingsPath = (projectRoot) => resolve8(projectRoot, ".glotfile", "settings.json");
 function readJson2(path) {
   try {
-    const parsed = JSON.parse(readFileSync12(path, "utf8"));
+    const parsed = JSON.parse(readFileSync13(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -3475,7 +4149,9 @@ function coerceAi(raw) {
     contextBatchSize: typeof a.contextBatchSize === "number" && a.contextBatchSize > 0 ? a.contextBatchSize : void 0,
     contextConcurrency: typeof a.contextConcurrency === "number" && a.contextConcurrency > 0 ? a.contextConcurrency : void 0,
     vision: typeof a.vision === "boolean" ? a.vision : void 0,
-    promptStyle: PROMPT_STYLES.includes(a.promptStyle) ? a.promptStyle : void 0
+    promptStyle: PROMPT_STYLES.includes(a.promptStyle) ? a.promptStyle : void 0,
+    inputPricePerMTok: typeof a.inputPricePerMTok === "number" && a.inputPricePerMTok >= 0 ? a.inputPricePerMTok : void 0,
+    outputPricePerMTok: typeof a.outputPricePerMTok === "number" && a.outputPricePerMTok >= 0 ? a.outputPricePerMTok : void 0
   };
 }
 function coerceProfiles(raw) {
@@ -3514,6 +4190,10 @@ function aiConfigError(ai) {
   if (!(a.endpoint === null || a.endpoint === void 0 || typeof a.endpoint === "string")) return "ai.endpoint must be a string or null";
   if (!(a.region === void 0 || a.region === null || typeof a.region === "string")) return "ai.region must be a string or null";
   if (typeof a.batchSize !== "number") return "ai.batchSize must be a number";
+  for (const f of ["inputPricePerMTok", "outputPricePerMTok"]) {
+    const v = a[f];
+    if (!(v === void 0 || v === null || typeof v === "number" && v >= 0)) return `ai.${f} must be a non-negative number`;
+  }
   return null;
 }
 
@@ -3521,10 +4201,10 @@ function aiConfigError(ai) {
 var sanitize = (s) => s.replace(/[^\w.\-]+/g, "_");
 var screenshotDirName = (statePath) => basename(statePath).replace(/\.[^.]+$/, "") + "-screenshots";
 function projectName(root) {
-  const nameFile = resolve8(root, ".idea", ".name");
-  if (existsSync9(nameFile)) {
+  const nameFile = resolve9(root, ".idea", ".name");
+  if (existsSync11(nameFile)) {
     try {
-      const name = readFileSync13(nameFile, "utf8").trim();
+      const name = readFileSync14(nameFile, "utf8").trim();
       if (name) return name;
     } catch {
     }
@@ -3534,7 +4214,7 @@ function projectName(root) {
 function createApi(deps) {
   const app = new Hono();
   const load = () => loadState(deps.statePath);
-  const projectRoot = dirname2(resolve8(deps.statePath));
+  const projectRoot = dirname3(resolve9(deps.statePath));
   let translateQueue = Promise.resolve();
   const withTranslateLock = (fn) => {
     const next = translateQueue.then(fn, fn);
@@ -3632,27 +4312,27 @@ function createApi(deps) {
     found.set(deps.statePath, {
       name: basename(deps.statePath),
       path: deps.statePath,
-      relDir: activeRel !== basename(activeRel) ? dirname2(activeRel) : void 0
+      relDir: activeRel !== basename(activeRel) ? dirname3(activeRel) : void 0
     });
     function walk(dir, depth) {
       if (depth > 4) return;
       let entries = [];
       try {
-        entries = readdirSync7(dir);
+        entries = readdirSync8(dir);
       } catch {
         return;
       }
       for (const name of entries) {
         if (name.startsWith(".") || name === "node_modules") continue;
-        const abs = resolve8(dir, name);
+        const abs = resolve9(dir, name);
         let filePath = null;
-        if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync9(resolve8(abs, "config.json"))) {
-          filePath = resolve8(dir, `${name}.json`);
+        if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync11(resolve9(abs, "config.json"))) {
+          filePath = resolve9(dir, `${name}.json`);
         } else if (name === "glotfile.json" || name.endsWith(".glotfile.json")) {
           filePath = abs;
         } else {
           try {
-            if (statSync4(abs).isDirectory()) walk(abs, depth + 1);
+            if (statSync5(abs).isDirectory()) walk(abs, depth + 1);
           } catch {
           }
           continue;
@@ -3661,7 +4341,7 @@ function createApi(deps) {
         try {
           loadState(filePath);
           const rel = relative3(projectRoot, filePath);
-          found.set(filePath, { name: basename(filePath), path: filePath, relDir: rel !== basename(filePath) ? dirname2(rel) : void 0 });
+          found.set(filePath, { name: basename(filePath), path: filePath, relDir: rel !== basename(filePath) ? dirname3(rel) : void 0 });
         } catch {
         }
       }
@@ -3677,10 +4357,10 @@ function createApi(deps) {
   app.post("/file", async (c) => {
     const { path } = await c.req.json();
     if (typeof path !== "string") return c.json({ error: "path must be a string" }, 400);
-    const resolved = resolve8(projectRoot, path);
-    const inside = resolved === projectRoot || resolved.startsWith(projectRoot + sep);
+    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 (!existsSync9(resolved)) return c.json({ error: "file not found" }, 400);
+    if (!existsSync11(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) });
@@ -3737,11 +4417,11 @@ function createApi(deps) {
   function removeOrphanScreenshot(s, screenshot) {
     if (!screenshot) return;
     for (const e of Object.values(s.keys)) if (e.screenshot === screenshot) return;
-    const root = dirname2(resolve8(deps.statePath));
-    const abs = resolve8(root, screenshot);
+    const root = dirname3(resolve9(deps.statePath));
+    const abs = resolve9(root, screenshot);
     const rel = relative3(root, abs);
-    const seg0 = rel.split(sep)[0] ?? "";
-    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync9(abs)) {
+    const seg0 = rel.split(sep2)[0] ?? "";
+    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync11(abs)) {
       try {
         rmSync4(abs);
       } catch {
@@ -3993,11 +4673,11 @@ function createApi(deps) {
     const body = await c.req.parseBody();
     const file = body["file"];
     if (!file || typeof file === "string") return c.json({ error: "no file uploaded" }, 400);
-    const root = dirname2(resolve8(deps.statePath));
+    const root = dirname3(resolve9(deps.statePath));
     const dirName = screenshotDirName(deps.statePath);
-    const dir = resolve8(root, dirName);
+    const dir = resolve9(root, dirName);
     const filename = `${sanitize(key)}__${sanitize(file.name)}`;
-    writeFileAtomic(resolve8(dir, filename), Buffer.from(await file.arrayBuffer()));
+    writeFileAtomic(resolve9(dir, filename), Buffer.from(await file.arrayBuffer()));
     const path = `${dirName}/${filename}`;
     const s = load();
     const prev = s.keys[key]?.screenshot;
@@ -4029,6 +4709,23 @@ function createApi(deps) {
     return c.json({ files, warnings });
   });
   app.get("/scan/missing", (c) => c.json(findMissing(load())));
+  const spellerCache = /* @__PURE__ */ new Map();
+  const cachedLoader = (dictId) => {
+    let p = spellerCache.get(dictId);
+    if (!p) {
+      p = defaultLoader(dictId);
+      spellerCache.set(dictId, p);
+    }
+    return p;
+  };
+  app.get("/lint", async (c) => {
+    const state = load();
+    const lint = await runLint(state, { loadSpeller: cachedLoader, warn: () => {
+    } });
+    const findings = sortFindings([...lint.findings, ...checkOutputs(state, projectRoot)]);
+    const counts = countSeverities(findings);
+    return c.json({ findings, counts, ok: counts.error === 0 });
+  });
   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;
@@ -4064,22 +4761,12 @@ function createApi(deps) {
     return c.json({ keyCount: result.keyCount, localeCount: result.localeCount, warnings: result.warnings });
   });
   app.post("/export", (c) => {
-    const s = narrowForExport(load());
-    const root = dirname2(resolve8(deps.statePath));
-    const warnings = [];
-    let count = 0;
-    for (const output of s.config.outputs) {
-      const adapter = getAdapter(output.adapter);
-      const result = adapter.export(s, output);
-      warnings.push(...result.warnings);
-      for (const f of result.files) {
-        const abs = resolve8(root, f.path);
-        writeFileAtomic(abs, f.contents);
-        count++;
-      }
-    }
-    console.log(`[export] ${count} file(s)${warnings.length ? `, ${warnings.length} warning(s)` : ""}`);
-    return c.json({ files: count, warnings });
+    const root = dirname3(resolve9(deps.statePath));
+    const { written, skipped, deleted, warnings } = exportToDisk(load(), root);
+    console.log(
+      `[export] ${written + skipped} file(s)${deleted ? `, ${deleted} removed` : ""}${warnings.length ? `, ${warnings.length} warning(s)` : ""}`
+    );
+    return c.json({ files: written + skipped, warnings });
   });
   app.post("/translate/stream", async (c) => {
     const signal = c.req.raw.signal;
@@ -4101,7 +4788,7 @@ function createApi(deps) {
         await stream.writeSSE({ event: "error", data: JSON.stringify({ error: e.message }) });
         return;
       }
-      const { skipped } = attachScreenshotsForProvider(reqs, s, dirname2(resolve8(deps.statePath)), provider.supportsVision());
+      const { skipped } = attachScreenshotsForProvider(reqs, s, dirname3(resolve9(deps.statePath)), provider.supportsVision());
       if (skipped) console.warn(`Model "${aiCfg.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
       console.log(`[translate] ${reqs.length} string(s) \u2192 ${aiCfg.model}`);
       let totalWritten = 0;
@@ -4179,7 +4866,7 @@ function createApi(deps) {
       } catch (e) {
         return c.json({ error: e.message }, 400);
       }
-      const { skipped } = attachScreenshotsForProvider(toTranslate, s, dirname2(resolve8(deps.statePath)), provider.supportsVision());
+      const { skipped } = attachScreenshotsForProvider(toTranslate, s, dirname3(resolve9(deps.statePath)), provider.supportsVision());
       if (skipped) console.warn(`Model "${aiCfg.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
       const results = await runLocaleParallel(toTranslate, provider, {}, aiCfg.concurrency);
       const latest = load();
@@ -4207,6 +4894,13 @@ function createApi(deps) {
     }
     return c.json({ requested: reqs.length, written, errors });
   }));
+  app.post("/translate/estimate", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const keys = Array.isArray(body.keys) && body.keys.length ? body.keys.filter(Boolean) : void 0;
+    const locales = Array.isArray(body.locales) && body.locales.length ? body.locales.filter(Boolean) : void 0;
+    const ai = loadLocalSettings(projectRoot).ai;
+    return c.json(estimateTranslation(load(), ai, { onlyMissing: body.onlyMissing ?? true, keys, locales }));
+  });
   app.get("/log", (c) => c.json(readLog(projectRoot, 100)));
   app.post("/scan", async (c) => {
     const s = load();
@@ -4231,7 +4925,7 @@ function createApi(deps) {
     const refs = [];
     const prefixRefs = [];
     for (const [file, entry] of Object.entries(cache2.files)) {
-      const abs = resolve8(projectRoot, file);
+      const abs = resolve9(projectRoot, file);
       for (const r of entry.refs) {
         if (r.key === key) refs.push({ file, abs, line: r.line, col: r.col, scanner: r.scanner });
       }
@@ -4358,7 +5052,7 @@ function createApi(deps) {
 }
 
 // src/server/server.ts
-var here = dirname3(fileURLToPath(import.meta.url));
+var here = dirname4(fileURLToPath(import.meta.url));
 var DEFAULT_UI_DIR = join9(here, "..", "ui");
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -4392,11 +5086,11 @@ function buildApp(opts) {
   app.get("/:dir/*", async (c, next) => {
     const dirSeg = c.req.param("dir");
     if (!dirSeg.endsWith("-screenshots")) return next();
-    const shotsRoot = resolve9(dirname3(resolve9(apiDeps.statePath)), dirSeg);
+    const shotsRoot = resolve10(dirname4(resolve10(apiDeps.statePath)), dirSeg);
     const pathname = decodeURIComponent(new URL(c.req.url).pathname);
     const rest = pathname.slice(`/${dirSeg}`.length);
-    const target = resolve9(shotsRoot, "." + rest);
-    const inside = target === shotsRoot || target.startsWith(shotsRoot + sep2);
+    const target = resolve10(shotsRoot, "." + rest);
+    const inside = target === shotsRoot || target.startsWith(shotsRoot + sep3);
     if (inside) {
       const file = await readFileResponse(target);
       if (file) return file;
@@ -4404,11 +5098,11 @@ function buildApp(opts) {
     return c.notFound();
   });
   if (!opts.dev) {
-    const root = resolve9(opts.uiDir ?? DEFAULT_UI_DIR);
+    const root = resolve10(opts.uiDir ?? DEFAULT_UI_DIR);
     app.get("/*", async (c) => {
       const pathname = decodeURIComponent(new URL(c.req.url).pathname);
-      const target = resolve9(root, "." + pathname);
-      const inside = target === root || target.startsWith(root + sep2);
+      const target = resolve10(root, "." + pathname);
+      const inside = target === root || target.startsWith(root + sep3);
       if (inside && pathname !== "/") {
         const file = await readFileResponse(target);
         if (file) return file;
@@ -4461,7 +5155,7 @@ async function startServer(opts) {
   });
 }
 function backgroundScan(statePath) {
-  const projectRoot = dirname3(resolve9(statePath));
+  const projectRoot = dirname4(resolve10(statePath));
   Promise.resolve().then(() => {
     const state = loadState(statePath);
     const existing = loadUsageCache(projectRoot);