glotfile 0.4.2 → 0.4.4

package/dist/server/cli.js

@@ -788,14 +788,14 @@ var init_state = __esm({
 
 // 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];
@@ -901,6 +901,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();
@@ -1457,6 +1461,203 @@ var init_vue_i18n_json = __esm({
   }
 });
 
+// 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, angularXliff;
+var init_angular_xliff = __esm({
+  "src/server/adapters/angular-xliff.ts"() {
+    "use strict";
+    init_adapters();
+    init_options();
+    init_placeholders();
+    init_schema();
+    DEFAULT_LOCALE_CASE7 = "bcp47-hyphen";
+    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
+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 RESERVED_KEYS, DEFAULT_LOCALE_CASE8, railsYaml;
+var init_rails_yaml = __esm({
+  "src/server/adapters/rails-yaml.ts"() {
+    "use strict";
+    init_adapters();
+    init_shared();
+    init_options();
+    init_placeholders();
+    init_schema();
+    RESERVED_KEYS = /* @__PURE__ */ new Set(["true", "false", "yes", "no", "on", "off", "null", "y", "n"]);
+    DEFAULT_LOCALE_CASE8 = "bcp47-hyphen";
+    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);
@@ -1488,7 +1689,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) {
@@ -1507,12 +1710,14 @@ var init_adapters = __esm({
     init_gettext_po();
     init_apple_stringsdict();
     init_vue_i18n_json();
+    init_angular_xliff();
+    init_rails_yaml();
   }
 });
 
 // src/server/export-run.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, rmdirSync, statSync, unlinkSync } from "fs";
+import { dirname as dirname2, resolve, sep } from "path";
 function effectiveLocales(config) {
   const limit = config.exportLocales;
   if (!limit || limit.length === 0) return config.locales;
@@ -1523,14 +1728,81 @@ function narrowForExport(state) {
   if (locales.length === state.config.locales.length) return state;
   return { ...state, config: { ...state.config, locales } };
 }
+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 = resolve(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 = resolve(dir, segment);
+      if (isLast) {
+        if (stale(locale) && existsSync3(next) && statSync(next).isFile()) {
+          unlinkSync(next);
+          deleted++;
+          removeEmptyDirs(dir, root);
+        }
+        return;
+      }
+      visit(next, index + 1, locale);
+      return;
+    }
+    const re = segmentRegExp(segment);
+    let entries;
+    try {
+      entries = readdirSync2(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(resolve(dir, entry.name));
+        deleted++;
+        removeEmptyDirs(dir, root);
+      } else if (entry.isDirectory()) {
+        visit(resolve(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) {
@@ -1552,14 +1824,19 @@ 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 };
 }
+var LOCALE_TOKEN;
 var init_export_run = __esm({
   "src/server/export-run.ts"() {
     "use strict";
     init_adapters();
+    init_options();
     init_atomic_write();
+    LOCALE_TOKEN = /^[a-z]{2,3}([_-][a-z0-9]+)*$/i;
   }
 });
 
@@ -2232,13 +2509,13 @@ var init_ai = __esm({
 });
 
 // src/server/glotfile-dir.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 function ensureGlotfileDir(projectRoot) {
   const dir = resolve2(projectRoot, ".glotfile");
   mkdirSync3(dir, { recursive: true });
   const ignore = resolve2(dir, ".gitignore");
-  if (!existsSync3(ignore)) {
+  if (!existsSync4(ignore)) {
     try {
       writeFileSync2(ignore, "*\n");
     } catch {
@@ -2275,7 +2552,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) {
@@ -2314,6 +2593,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;
 }
 var EDITOR_IDS, isEditorId, DEFAULT_AI, DEFAULT_EDITOR, settingsPath;
@@ -2349,7 +2632,7 @@ var init_glob = __esm({
 });
 
 // src/server/ai/run.ts
-import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
 import { resolve as resolve4, extname } from "path";
 function selectRequests(state, opts) {
   const targets = (opts.locales ?? state.config.locales).filter((l) => l !== state.config.sourceLocale);
@@ -2432,7 +2715,7 @@ function attachScreenshots(reqs, state, projectRoot) {
     if (!mediaType) continue;
     if (!cache2.has(screenshot)) {
       const abs = resolve4(projectRoot, screenshot);
-      if (!existsSync4(abs)) {
+      if (!existsSync5(abs)) {
         cache2.set(screenshot, null);
       } else {
         const buf = readFileSync5(abs);
@@ -2529,8 +2812,120 @@ var init_run = __esm({
   }
 });
 
+// src/server/ai/pricing.ts
+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;
+}
+var PRICE_TABLE, FREE_PROVIDERS;
+var init_pricing = __esm({
+  "src/server/ai/pricing.ts"() {
+    "use strict";
+    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]
+    ];
+    FREE_PROVIDERS = /* @__PURE__ */ new Set(["ollama", "claude-code"]);
+  }
+});
+
+// src/server/ai/estimate.ts
+function estimateTokens(text) {
+  const cjk = text.match(CJK_RE)?.length ?? 0;
+  return Math.ceil((text.length - cjk) / 4 + cjk / 2);
+}
+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
+  };
+}
+var CJK_RE, EXPANSION, ITEM_REPLY_OVERHEAD, FORM_REPLY_OVERHEAD;
+var init_estimate = __esm({
+  "src/server/ai/estimate.ts"() {
+    "use strict";
+    init_run();
+    init_provider();
+    init_batch();
+    init_pricing();
+    CJK_RE = /[　-鿿가-힯豈-﫿]/g;
+    EXPANSION = 1.2;
+    ITEM_REPLY_OVERHEAD = 16;
+    FORM_REPLY_OVERHEAD = 8;
+  }
+});
+
 // src/server/log.ts
-import { appendFileSync, readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
+import { appendFileSync, readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
 import { resolve as resolve5 } from "path";
 function logPath(projectRoot) {
   return resolve5(projectRoot, ".glotfile", "log.jsonl");
@@ -2541,7 +2936,7 @@ function appendLog(projectRoot, entry) {
 }
 function readLog(projectRoot, limit = 100) {
   const path = logPath(projectRoot);
-  if (!existsSync5(path)) return [];
+  if (!existsSync6(path)) return [];
   const lines = readFileSync6(path, "utf8").split("\n").filter((l) => l.trim() !== "");
   const entries = lines.map((l) => JSON.parse(l));
   return entries.reverse().slice(0, limit);
@@ -2554,11 +2949,11 @@ var init_log = __esm({
 });
 
 // src/server/scan.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import { resolve as resolve6 } from "path";
 function loadUsageCache(projectRoot) {
   const path = resolve6(projectRoot, ".glotfile", "usage.json");
-  if (!existsSync6(path)) return null;
+  if (!existsSync7(path)) return null;
   try {
     return JSON.parse(readFileSync7(path, "utf8"));
   } catch {
@@ -2574,8 +2969,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 });
     }
   }
@@ -2601,7 +2998,7 @@ var init_scan = __esm({
 });
 
 // src/server/scanner.ts
-import { readdirSync as readdirSync2, statSync, readFileSync as readFileSync8 } from "fs";
+import { readdirSync as readdirSync3, statSync as statSync2, readFileSync as readFileSync8 } from "fs";
 import { join as join3, extname as extname2, relative } from "path";
 function scannerForExt(ext) {
   return EXT_SCANNER[ext] ?? null;
@@ -2722,7 +3119,7 @@ function isIncluded(relPath, includePatterns) {
 function* walkFiles(dir, root, exclude) {
   let entries;
   try {
-    entries = readdirSync2(dir);
+    entries = readdirSync3(dir);
   } catch {
     return;
   }
@@ -2732,7 +3129,7 @@ function* walkFiles(dir, root, exclude) {
     const rel = relative(root, abs);
     let st;
     try {
-      st = statSync(abs);
+      st = statSync2(abs);
     } catch {
       continue;
     }
@@ -2761,7 +3158,7 @@ function runScan(projectRoot, opts, existing) {
     const abs = join3(projectRoot, relPath);
     let st;
     try {
-      st = statSync(abs);
+      st = statSync2(abs);
     } catch {
       continue;
     }
@@ -2879,7 +3276,7 @@ var init_scanner = __esm({
 });
 
 // src/server/ai/context.ts
-import { existsSync as existsSync7, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
 import { resolve as resolve7 } from "path";
 function globToRegExp2(glob) {
   const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
@@ -2894,7 +3291,7 @@ function extractSnippets(refs, projectRoot, fileCache) {
   for (const ref of selected) {
     const absPath = resolve7(projectRoot, ref.file);
     if (!fileCache.has(ref.file)) {
-      if (!existsSync7(absPath)) continue;
+      if (!existsSync8(absPath)) continue;
       const content = readFileSync9(absPath, "utf8");
       fileCache.set(ref.file, content.split("\n"));
     }
@@ -3039,103 +3436,446 @@ var init_context = __esm({
   }
 });
 
-// src/server/import/detect.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join4 } from "path";
-function safeIsDir(p) {
-  try {
-    return statSync2(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function listDirs(dir) {
-  return readdirSync3(dir).filter((e) => safeIsDir(join4(dir, e)));
-}
-function fileCount(dir) {
-  try {
-    return readdirSync3(dir).length;
-  } catch {
-    return 0;
-  }
-}
-function pickSource(locales, sizeOf) {
-  if (locales.includes("en")) return "en";
-  return [...locales].sort((a, b) => sizeOf(b) - sizeOf(a) || a.localeCompare(b))[0] ?? "en";
-}
-function detectLaravel(root) {
-  const localeRoot = [join4(root, "resources", "lang"), join4(root, "lang")].find(safeIsDir);
-  if (!localeRoot) return null;
-  const locales = listDirs(localeRoot).filter((d) => LOCALE_RE.test(d));
-  if (locales.length === 0) return null;
-  const sourceLocale = pickSource(locales, (loc) => fileCount(join4(localeRoot, loc)));
-  return { format: "laravel-php", localeRoot, locales, sourceLocale };
-}
-function detectVue(root) {
-  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 sourceLocale = pickSource(locales, (loc) => {
-        try {
-          return statSync2(join4(localeRoot, `${loc}.json`)).size;
-        } catch {
-          return 0;
-        }
-      });
-      return { format: "vue-i18n-json", localeRoot, locales, sourceLocale };
-    }
-  }
-  return null;
-}
-function detectArb(root) {
-  for (const rel of ["lib/l10n", "l10n", "lib/src/l10n"]) {
-    const localeRoot = join4(root, rel);
-    if (!safeIsDir(localeRoot)) continue;
-    const locales = readdirSync3(localeRoot).map((f) => f.match(/^(?:app_)?(.+)\.arb$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l));
-    if (locales.length >= 1) {
-      return { format: "flutter-arb", localeRoot, locales, sourceLocale: pickSource(locales, () => 0) };
-    }
-  }
-  return null;
+// src/server/lint/spelling.ts
+function tokenize(text) {
+  return text.match(new RegExp("\\p{L}[\\p{L}'']*", "gu")) ?? [];
 }
-function detect(root, formatOverride) {
-  if (!existsSync9(root)) return null;
-  if (formatOverride) {
-    const fn = BY_FORMAT[formatOverride];
-    if (!fn) throw new Error(`Unknown format: ${formatOverride}`);
-    return fn(root);
-  }
-  for (const fn of DETECTORS) {
-    const d = fn(root);
-    if (d) return d;
-  }
-  return null;
+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 LOCALE_RE, VUE_DIR_CANDIDATES, DETECTORS, BY_FORMAT;
-var init_detect = __esm({
-  "src/server/import/detect.ts"() {
+var spellingRule, defaultLoader;
+var init_spelling = __esm({
+  "src/server/lint/spelling.ts"() {
     "use strict";
-    LOCALE_RE = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
-    VUE_DIR_CANDIDATES = ["src/locale", "src/locales", "src/i18n/locales", "locales", "lang"];
-    DETECTORS = [detectLaravel, detectVue, detectArb];
-    BY_FORMAT = {
-      "laravel-php": detectLaravel,
-      "vue-i18n-json": detectVue,
-      "flutter-arb": detectArb
+    init_placeholders();
+    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;
+      }
+    };
+    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/import/flatten.ts
-function flattenObject(value, prefix, warnings) {
-  const out = {};
-  const walk = (node, path) => {
-    if (typeof node === "string") {
-      out[path] = node;
-    } else if (typeof node === "number" || typeof node === "boolean") {
-      out[path] = String(node);
+// src/server/lint/rules.ts
+var emptySourceRule, emptyTranslationRule, identicalToSourceRule, whitespaceRule, placeholderMismatchRule, icuMismatchRule, maxLengthRule, glossaryViolationRule, ALL_RULES;
+var init_rules = __esm({
+  "src/server/lint/rules.ts"() {
+    "use strict";
+    init_scan();
+    init_placeholders();
+    init_run();
+    init_spelling();
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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(globToRegExp);
+  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 };
+}
+var init_run2 = __esm({
+  "src/server/lint/run.ts"() {
+    "use strict";
+    init_glob();
+    init_registry();
+    init_rules();
+    init_spelling();
+  }
+});
+
+// src/server/lint/outputs.ts
+import { readFileSync as readFileSync10, existsSync as existsSync9 } from "fs";
+import { resolve as resolve8 } from "path";
+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 = resolve8(root, file.path);
+      const current = existsSync9(abs) ? readFileSync10(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;
+}
+var init_outputs = __esm({
+  "src/server/lint/outputs.ts"() {
+    "use strict";
+    init_adapters();
+  }
+});
+
+// src/server/import/detect.ts
+import { existsSync as existsSync10, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { join as join4 } from "path";
+function safeIsDir(p) {
+  try {
+    return statSync3(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function listDirs(dir) {
+  return readdirSync4(dir).filter((e) => safeIsDir(join4(dir, e)));
+}
+function fileCount(dir) {
+  try {
+    return readdirSync4(dir).length;
+  } catch {
+    return 0;
+  }
+}
+function pickSource(locales, sizeOf) {
+  if (locales.includes("en")) return "en";
+  return [...locales].sort((a, b) => sizeOf(b) - sizeOf(a) || a.localeCompare(b))[0] ?? "en";
+}
+function detectLaravel(root) {
+  const localeRoot = [join4(root, "resources", "lang"), join4(root, "lang")].find(safeIsDir);
+  if (!localeRoot) return null;
+  const locales = listDirs(localeRoot).filter((d) => LOCALE_RE.test(d));
+  if (locales.length === 0) return null;
+  const sourceLocale = pickSource(locales, (loc) => fileCount(join4(localeRoot, loc)));
+  return { format: "laravel-php", localeRoot, locales, sourceLocale };
+}
+function detectVue(root, forced = false) {
+  for (const rel of VUE_DIR_CANDIDATES) {
+    const localeRoot = join4(root, rel);
+    if (!safeIsDir(localeRoot)) continue;
+    const locales = readdirSync4(localeRoot).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)).filter((l) => LOCALE_RE.test(l));
+    const enough = locales.length >= 2 || locales.length === 1 && (forced || locales[0] === "en" || locales[0].startsWith("en-") || locales[0].startsWith("en_"));
+    if (enough) {
+      const sourceLocale = pickSource(locales, (loc) => {
+        try {
+          return statSync3(join4(localeRoot, `${loc}.json`)).size;
+        } catch {
+          return 0;
+        }
+      });
+      return { format: "vue-i18n-json", localeRoot, locales, sourceLocale };
+    }
+  }
+  return null;
+}
+function detectArb(root) {
+  for (const rel of ["lib/l10n", "l10n", "lib/src/l10n"]) {
+    const localeRoot = join4(root, rel);
+    if (!safeIsDir(localeRoot)) continue;
+    const locales = readdirSync4(localeRoot).map((f) => f.match(/^(?:app_)?(.+)\.arb$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l));
+    if (locales.length >= 1) {
+      return { format: "flutter-arb", localeRoot, locales, sourceLocale: pickSource(locales, () => 0) };
+    }
+  }
+  return null;
+}
+function detect(root, formatOverride) {
+  if (!existsSync10(root)) return null;
+  if (formatOverride) {
+    const fn = BY_FORMAT[formatOverride];
+    if (!fn) throw new Error(`Unknown format: ${formatOverride}`);
+    return fn(root);
+  }
+  for (const fn of DETECTORS) {
+    const d = fn(root);
+    if (d) return d;
+  }
+  return null;
+}
+var LOCALE_RE, VUE_DIR_CANDIDATES, DETECTORS, BY_FORMAT;
+var init_detect = __esm({
+  "src/server/import/detect.ts"() {
+    "use strict";
+    LOCALE_RE = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+    VUE_DIR_CANDIDATES = ["src/locale", "src/locales", "src/i18n/locales", "locales", "lang"];
+    DETECTORS = [detectLaravel, detectVue, detectArb];
+    BY_FORMAT = {
+      "laravel-php": detectLaravel,
+      "vue-i18n-json": (root) => detectVue(root, true),
+      "flutter-arb": detectArb
+    };
+  }
+});
+
+// src/server/import/flatten.ts
+function flattenObject(value, prefix, warnings) {
+  const out = {};
+  const walk = (node, path) => {
+    if (typeof node === "string") {
+      out[path] = node;
+    } else if (typeof node === "number" || typeof node === "boolean") {
+      out[path] = String(node);
     } else if (Array.isArray(node)) {
       node.forEach((el, i) => walk(el, path ? `${path}.${i}` : String(i)));
     } else if (node && typeof node === "object") {
@@ -3156,7 +3896,7 @@ var init_flatten = __esm({
 });
 
 // src/server/import/parsers/vue-i18n-json.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync11 } from "fs";
 import { join as join5 } from "path";
 var LOCALE_RE2, vueI18nJson2;
 var init_vue_i18n_json2 = __esm({
@@ -3170,7 +3910,7 @@ var init_vue_i18n_json2 = __esm({
         const warnings = [];
         const keys = {};
         const locales = [];
-        for (const file of readdirSync4(localeRoot).sort()) {
+        for (const file of readdirSync5(localeRoot).sort()) {
           if (!file.endsWith(".json")) continue;
           const locale = file.slice(0, -".json".length);
           if (!LOCALE_RE2.test(locale)) continue;
@@ -3204,18 +3944,18 @@ var init_placeholders2 = __esm({
 });
 
 // src/server/import/parsers/laravel-php.ts
-import { readdirSync as readdirSync5, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync6, statSync as statSync4 } from "fs";
 import { join as join6, relative as relative2 } from "path";
 import { execFileSync } from "child_process";
 function listDirs2(dir) {
-  return readdirSync5(dir).filter((e) => statSync3(join6(dir, e)).isDirectory());
+  return readdirSync6(dir).filter((e) => statSync4(join6(dir, e)).isDirectory());
 }
 function listPhpFiles(dir) {
   const out = [];
   const walk = (d) => {
-    for (const e of readdirSync5(d)) {
+    for (const e of readdirSync6(d)) {
       const full = join6(d, e);
-      if (statSync3(full).isDirectory()) walk(full);
+      if (statSync4(full).isDirectory()) walk(full);
       else if (e.endsWith(".php")) out.push(full);
     }
   };
@@ -3282,7 +4022,7 @@ var init_laravel_php2 = __esm({
 });
 
 // src/server/import/parsers/flutter-arb.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync12 } from "fs";
+import { readdirSync as readdirSync7, readFileSync as readFileSync12 } from "fs";
 import { join as join7 } from "path";
 function localeFromArbName(file) {
   const m = file.match(/^(.+)\.arb$/);
@@ -3316,7 +4056,7 @@ var init_flutter_arb2 = __esm({
         const warnings = [];
         const keys = {};
         const locales = [];
-        for (const file of readdirSync6(localeRoot).sort()) {
+        for (const file of readdirSync7(localeRoot).sort()) {
           if (!file.endsWith(".arb")) continue;
           const locale = localeFromArbName(file);
           if (!locale) continue;
@@ -3502,7 +4242,7 @@ function runImport(opts) {
     localeCount: state.config.locales.length
   };
 }
-var init_run2 = __esm({
+var init_run3 = __esm({
   "src/server/import/run.ts"() {
     "use strict";
     init_detect();
@@ -3888,11 +4628,11 @@ var init_ui_prefs = __esm({
 // src/server/api.ts
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { readFileSync as readFileSync14, existsSync as existsSync10, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "fs";
-import { dirname as dirname2, resolve as resolve9, 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";
 function projectName(root) {
   const nameFile = resolve9(root, ".idea", ".name");
-  if (existsSync10(nameFile)) {
+  if (existsSync11(nameFile)) {
     try {
       const name = readFileSync14(nameFile, "utf8").trim();
       if (name) return name;
@@ -3904,7 +4644,7 @@ function projectName(root) {
 function createApi(deps) {
   const app = new Hono();
   const load = () => loadState(deps.statePath);
-  const projectRoot = dirname2(resolve9(deps.statePath));
+  const projectRoot = dirname3(resolve9(deps.statePath));
   let translateQueue = Promise.resolve();
   const withTranslateLock = (fn) => {
     const next = translateQueue.then(fn, fn);
@@ -4002,13 +4742,13 @@ 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;
       }
@@ -4016,13 +4756,13 @@ function createApi(deps) {
         if (name.startsWith(".") || name === "node_modules") continue;
         const abs = resolve9(dir, name);
         let filePath = null;
-        if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync10(resolve9(abs, "config.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;
@@ -4031,7 +4771,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 {
         }
       }
@@ -4048,9 +4788,9 @@ function createApi(deps) {
     const { path } = await c.req.json();
     if (typeof path !== "string") return c.json({ error: "path must be a string" }, 400);
     const resolved = resolve9(projectRoot, path);
-    const inside = resolved === projectRoot || resolved.startsWith(projectRoot + sep);
+    const inside = resolved === projectRoot || resolved.startsWith(projectRoot + sep2);
     if (!inside) return c.json({ error: "file is outside the project" }, 400);
-    if (!existsSync10(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) });
@@ -4107,11 +4847,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(resolve9(deps.statePath));
+    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") && existsSync10(abs)) {
+    const seg0 = rel.split(sep2)[0] ?? "";
+    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync11(abs)) {
       try {
         rmSync4(abs);
       } catch {
@@ -4363,7 +5103,7 @@ 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(resolve9(deps.statePath));
+    const root = dirname3(resolve9(deps.statePath));
     const dirName = screenshotDirName(deps.statePath);
     const dir = resolve9(root, dirName);
     const filename = `${sanitize(key)}__${sanitize(file.name)}`;
@@ -4399,6 +5139,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;
@@ -4434,22 +5191,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(resolve9(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 = resolve9(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;
@@ -4471,7 +5218,7 @@ function createApi(deps) {
         await stream.writeSSE({ event: "error", data: JSON.stringify({ error: e.message }) });
         return;
       }
-      const { skipped } = attachScreenshotsForProvider(reqs, s, dirname2(resolve9(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;
@@ -4549,7 +5296,7 @@ function createApi(deps) {
       } catch (e) {
         return c.json({ error: e.message }, 400);
       }
-      const { skipped } = attachScreenshotsForProvider(toTranslate, s, dirname2(resolve9(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();
@@ -4577,6 +5324,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();
@@ -4736,13 +5490,17 @@ var init_api = __esm({
     init_context();
     init_stats();
     init_checks();
+    init_run2();
+    init_outputs();
+    init_spelling();
     init_adapters();
     init_ai();
     init_run();
     init_provider();
+    init_estimate();
     init_log();
     init_schema();
-    init_run2();
+    init_run3();
     init_export_run();
     init_ui_prefs();
     init_local_settings();
@@ -4761,7 +5519,7 @@ __export(server_exports, {
 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 resolve10, 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";
@@ -4783,11 +5541,11 @@ function buildApp(opts) {
   app.get("/:dir/*", async (c, next) => {
     const dirSeg = c.req.param("dir");
     if (!dirSeg.endsWith("-screenshots")) return next();
-    const shotsRoot = resolve10(dirname3(resolve10(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 = resolve10(shotsRoot, "." + rest);
-    const inside = target === shotsRoot || target.startsWith(shotsRoot + sep2);
+    const inside = target === shotsRoot || target.startsWith(shotsRoot + sep3);
     if (inside) {
       const file = await readFileResponse(target);
       if (file) return file;
@@ -4799,7 +5557,7 @@ function buildApp(opts) {
     app.get("/*", async (c) => {
       const pathname = decodeURIComponent(new URL(c.req.url).pathname);
       const target = resolve10(root, "." + pathname);
-      const inside = target === root || target.startsWith(root + sep2);
+      const inside = target === root || target.startsWith(root + sep3);
       if (inside && pathname !== "/") {
         const file = await readFileResponse(target);
         if (file) return file;
@@ -4841,7 +5599,7 @@ async function startServer(opts) {
   });
 }
 function backgroundScan(statePath) {
-  const projectRoot = dirname3(resolve10(statePath));
+  const projectRoot = dirname4(resolve10(statePath));
   Promise.resolve().then(() => {
     const state = loadState(statePath);
     const existing = loadUsageCache(projectRoot);
@@ -4861,7 +5619,7 @@ var init_server = __esm({
     init_state();
     init_scan();
     init_scanner();
-    here = dirname3(fileURLToPath(import.meta.url));
+    here = dirname4(fileURLToPath(import.meta.url));
     DEFAULT_UI_DIR = join9(here, "..", "ui");
     MIME = {
       ".html": "text/html; charset=utf-8",
@@ -4899,331 +5657,15 @@ init_ai();
 init_local_settings();
 init_run();
 init_provider();
+init_estimate();
 init_log();
 init_scan();
 init_scanner();
 init_context();
-import { resolve as resolve11, dirname as dirname4 } from "path";
-import { readFileSync as readFileSync15, existsSync as existsSync11 } from "fs";
-
-// src/server/lint/run.ts
-init_glob();
-init_registry();
-
-// src/server/lint/rules.ts
-init_scan();
-init_placeholders();
-init_run();
-
-// src/server/lint/spelling.ts
-init_placeholders();
-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 v = state.keys[key].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];
-      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(globToRegExp);
-  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
-init_adapters();
-import { readFileSync as readFileSync10, existsSync as existsSync8 } from "fs";
-import { resolve as resolve8 } from "path";
-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 = resolve8(root, file.path);
-      const current = existsSync8(abs) ? readFileSync10(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;
-}
+init_run2();
+init_outputs();
+import { resolve as resolve11, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync12 } from "fs";
 
 // src/server/lint/locate.ts
 function locate(rawText, key) {
@@ -5353,6 +5795,7 @@ function parseArgs(argv) {
     } else if (flag === "--empty-source") args.emptySource = true;
     else if (flag === "--unused") args.unused = true;
     else if (flag === "--write") args.write = true;
+    else if (flag === "--estimate") args.estimate = true;
   }
   return args;
 }
@@ -5366,7 +5809,7 @@ function watchTargetFor(statePath) {
   return detectFormat(statePath) === "split" ? { path: splitDirFor(statePath), recursive: true } : { path: statePath, recursive: false };
 }
 async function runExport(args) {
-  const root = dirname4(resolve11(args.statePath));
+  const root = dirname5(resolve11(args.statePath));
   const runOnce = () => {
     const state = loadState(args.statePath);
     const result = exportToDisk(state, root, args.adapter ? { adapter: args.adapter } : void 0);
@@ -5377,8 +5820,9 @@ async function runExport(args) {
     return result;
   };
   if (!args.watch) {
-    const { written, skipped } = runOnce();
-    console.log(`Exported ${written} file(s)${skipped ? ` (${skipped} unchanged)` : ""}.`);
+    const { written, skipped, deleted } = runOnce();
+    const extras = [skipped ? `${skipped} unchanged` : "", deleted ? `${deleted} stale removed` : ""].filter(Boolean);
+    console.log(`Exported ${written} file(s)${extras.length ? ` (${extras.join(", ")})` : ""}.`);
     return;
   }
   const { watch } = await import("fs");
@@ -5390,8 +5834,10 @@ async function runExport(args) {
     clearTimeout(timer);
     timer = setTimeout(() => {
       try {
-        const { written } = runOnce();
-        if (written) console.log(`Re-exported ${written} file(s).`);
+        const { written, deleted } = runOnce();
+        if (written || deleted) {
+          console.log(`Re-exported ${written} file(s)${deleted ? ` (${deleted} stale removed)` : ""}.`);
+        }
       } catch (e) {
         console.error(e.message);
       }
@@ -5402,7 +5848,32 @@ async function runExport(args) {
 }
 async function runTranslate(args) {
   const state = loadState(args.statePath);
-  const projectRoot = dirname4(resolve11(args.statePath));
+  const projectRoot = dirname5(resolve11(args.statePath));
+  if (args.estimate) {
+    const ai = loadLocalSettings(projectRoot).ai;
+    const est = estimateTranslation(state, ai, {
+      onlyMissing: args.all ? false : args.onlyMissing ?? true,
+      locales: args.locales,
+      keyGlob: args.keyGlob
+    });
+    if (!est.requests) {
+      console.log("Nothing to translate.");
+      return;
+    }
+    const fmt = (n) => n.toLocaleString("en-US");
+    console.log(`Estimate for ${fmt(est.requests)} request(s) in ${fmt(est.batches)} batch(es) \u2014 ${ai.provider} \xB7 ${ai.model}`);
+    for (const l of est.perLocale) {
+      console.log(`  ${l.locale.padEnd(8)} ${fmt(l.requests).padStart(7)} req  ${fmt(l.batches).padStart(5)} batch(es)  ~${fmt(l.inputTokens)} in / ~${fmt(l.outputTokens)} out tokens`);
+    }
+    console.log(`Totals: ~${fmt(est.inputTokens)} input / ~${fmt(est.outputTokens)} output tokens`);
+    if (est.pricing) {
+      const cost = est.estimatedCost;
+      console.log(`Estimated cost: ~$${cost >= 0.1 ? cost.toFixed(2) : cost.toFixed(4)} (\xB120%, ${est.pricing.source} pricing $${est.pricing.inputPerMTok}/$${est.pricing.outputPerMTok} per MTok)`);
+    } else {
+      console.log("No pricing known for this model \u2014 set inputPricePerMTok/outputPricePerMTok in your AI settings for a dollar estimate.");
+    }
+    return;
+  }
   const reqs = selectRequests(state, {
     // Default to translating only empty values; --all forces a full re-translate
     // (overwriting existing translations). --only missing stays as a no-op alias.
@@ -5472,7 +5943,7 @@ function printReport(report, format, rawText) {
 }
 async function runLintCmd(args) {
   const state = loadState(args.statePath);
-  const rawText = existsSync11(args.statePath) ? readFileSync15(args.statePath, "utf8") : "";
+  const rawText = existsSync12(args.statePath) ? readFileSync15(args.statePath, "utf8") : "";
   const report = await runLint(state, { locales: args.locales, ruleIds: args.ruleIds });
   printReport(report, args.format, rawText);
   const tooManyWarnings = args.maxWarnings != null && report.counts.warn > args.maxWarnings;
@@ -5492,8 +5963,8 @@ async function runCheck(args) {
     process.exitCode = 1;
     return;
   }
-  const rawText = existsSync11(args.statePath) ? readFileSync15(args.statePath, "utf8") : "";
-  const root = dirname4(resolve11(args.statePath));
+  const rawText = existsSync12(args.statePath) ? readFileSync15(args.statePath, "utf8") : "";
+  const root = dirname5(resolve11(args.statePath));
   const lint = await runLint(state, {});
   const findings = sortFindings([...lint.findings, ...checkOutputs(state, root)]);
   const counts = countSeverities(findings);
@@ -5502,10 +5973,10 @@ async function runCheck(args) {
   if (!report.ok) process.exitCode = 1;
 }
 async function runImportCmd(args) {
-  const { runImport: runImport2 } = await Promise.resolve().then(() => (init_run2(), run_exports));
-  const projectRoot = args.importSource ? resolve11(args.importSource) : dirname4(resolve11(args.statePath));
+  const { runImport: runImport2 } = await Promise.resolve().then(() => (init_run3(), run_exports));
+  const projectRoot = args.importSource ? resolve11(args.importSource) : dirname5(resolve11(args.statePath));
   const out = resolve11(projectRoot, "glotfile.json");
-  if (existsSync11(out) && !args.importForce) {
+  if (existsSync12(out) && !args.importForce) {
     console.error(`${out} already exists; pass --force to overwrite`);
     process.exitCode = 1;
     return;
@@ -5530,7 +6001,7 @@ async function runImportCmd(args) {
 }
 async function runBuildContext(args) {
   const state = loadState(args.statePath);
-  const projectRoot = dirname4(resolve11(args.statePath));
+  const projectRoot = dirname5(resolve11(args.statePath));
   const cache2 = loadUsageCache(projectRoot);
   if (!cache2) {
     console.error("No usage index found. Run 'glotfile scan' first.");
@@ -5601,7 +6072,7 @@ async function runBuildContext(args) {
 }
 async function runScanCmd(args) {
   const state = loadState(args.statePath);
-  const projectRoot = dirname4(resolve11(args.statePath));
+  const projectRoot = dirname5(resolve11(args.statePath));
   const existing = loadUsageCache(projectRoot);
   const result = runScan(projectRoot, state.config.scan ?? {}, existing);
   const fileCount2 = Object.keys(result.files).length;
@@ -5620,7 +6091,7 @@ async function runPrune(args) {
     for (const k of findEmptySourceKeys(state)) toRemove.add(k);
   }
   if (args.unused) {
-    const projectRoot = dirname4(resolve11(args.statePath));
+    const projectRoot = dirname5(resolve11(args.statePath));
     const cache2 = runScan(projectRoot, state.config.scan ?? {}, loadUsageCache(projectRoot));
     const used = new Set(computeUsedKeys(state, cache2));
     for (const k of Object.keys(state.keys)) {
@@ -5673,9 +6144,10 @@ var COMMAND_HELP = {
   },
   translate: {
     summary: "AI-translate missing strings into your target locales (writes back to the state file).",
-    usage: "glotfile translate [--all] [--locale <list>] [--key <glob>]",
+    usage: "glotfile translate [--all] [--estimate] [--locale <list>] [--key <glob>]",
     options: [
       ["--all", "Re-translate every string, not just empty values"],
+      ["--estimate", "Print batches, tokens and estimated cost without translating"],
       ["--locale <list>", "Comma-separated target locales (alias: --locales)"],
       ["--key <glob>", "Only keys matching this glob"]
     ]