glotfile 0.1.0

package/dist/server/server.js

@@ -0,0 +1,3936 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/dictionary-en/index.js
+var dictionary_en_exports = {};
+__export(dictionary_en_exports, {
+  default: () => dictionary_en_default
+});
+import fs from "fs/promises";
+var aff, dic, dictionary, dictionary_en_default;
+var init_dictionary_en = __esm({
+  async "node_modules/dictionary-en/index.js"() {
+    "use strict";
+    aff = await fs.readFile(new URL("index.aff", import.meta.url));
+    dic = await fs.readFile(new URL("index.dic", import.meta.url));
+    dictionary = { aff, dic };
+    dictionary_en_default = dictionary;
+  }
+});
+
+// src/server/server.ts
+import { Hono as Hono2 } from "hono";
+import { serve } from "@hono/node-server";
+import { fileURLToPath } from "url";
+import { dirname as dirname6, join as join7, resolve as resolve7, extname as extname3, sep as sep2 } from "path";
+import { readFile, stat } from "fs/promises";
+import open from "open";
+
+// src/server/api.ts
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+
+// src/server/state.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, rmSync as rmSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+import { randomUUID } from "crypto";
+
+// src/server/format.ts
+function sortDeep(value) {
+  if (Array.isArray(value)) return value.map(sortDeep);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const k of Object.keys(value).sort()) {
+      out[k] = sortDeep(value[k]);
+    }
+    return out;
+  }
+  return value;
+}
+function serializeJson(value, opts) {
+  const prepared = opts.sortKeys ? sortDeep(value) : value;
+  const body = JSON.stringify(prepared, null, opts.indent);
+  return opts.finalNewline ? body + "\n" : body;
+}
+
+// src/server/lint/registry.ts
+var RULE_IDS = [
+  "empty-source",
+  "empty-translation",
+  "placeholder-mismatch",
+  "icu-mismatch",
+  "glossary-violation",
+  "max-length",
+  "identical-to-source",
+  "whitespace",
+  "spelling"
+];
+
+// src/server/schema.ts
+var CURRENT_VERSION = 1;
+var STATES = ["source", "machine", "reviewed", "needs-review"];
+var PLURAL_CATEGORIES = ["zero", "one", "two", "few", "many", "other"];
+var EXACT_SELECTOR_RE = /^=\d+$/;
+function isPluralForm(key) {
+  return PLURAL_CATEGORIES.includes(key) || EXACT_SELECTOR_RE.test(key);
+}
+var LOCALE_CASES = ["lower-hyphen", "lower-underscore", "bcp47-hyphen", "bcp47-underscore"];
+var PROVIDERS = ["anthropic", "openai", "bedrock"];
+var GlotfileError = class extends Error {
+};
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function fail(msg) {
+  throw new GlotfileError(msg);
+}
+function validate(raw) {
+  if (!isObject(raw)) fail("glotfile.json must be a JSON object");
+  if (typeof raw.version !== "number") fail("version must be a number");
+  const config = raw.config;
+  if (!isObject(config)) fail("config must be an object");
+  if (typeof config.sourceLocale !== "string") fail("config.sourceLocale must be a string");
+  if (!Array.isArray(config.locales) || !config.locales.every((l) => typeof l === "string")) {
+    fail("config.locales must be an array of strings");
+  }
+  const locales = config.locales;
+  if (!locales.includes(config.sourceLocale)) {
+    fail(`config.sourceLocale "${config.sourceLocale}" is not in config.locales`);
+  }
+  if (!Array.isArray(config.outputs)) fail("config.outputs must be an array");
+  for (const o of config.outputs) {
+    if (!isObject(o) || typeof o.adapter !== "string" || typeof o.path !== "string") {
+      fail("each config.outputs entry needs string 'adapter' and 'path'");
+    }
+    if (o.style !== void 0 && typeof o.style !== "string") fail("config.outputs[].style must be a string");
+    if (o.emptyAs !== void 0 && !["source", "empty", "omit"].includes(o.emptyAs)) {
+      fail('config.outputs[].emptyAs must be "source", "empty", or "omit"');
+    }
+    if (o.indent !== void 0 && typeof o.indent !== "number") fail("config.outputs[].indent must be a number");
+    if (o.finalNewline !== void 0 && typeof o.finalNewline !== "boolean") fail("config.outputs[].finalNewline must be a boolean");
+    if (o.includeLocale !== void 0 && typeof o.includeLocale !== "boolean") fail("config.outputs[].includeLocale must be a boolean");
+    if (o.localeAliases !== void 0) {
+      if (!isObject(o.localeAliases)) fail("config.outputs[].localeAliases must be an object");
+      for (const [k, v] of Object.entries(o.localeAliases)) {
+        if (!Array.isArray(v) || !v.every((x) => typeof x === "string")) {
+          fail(`config.outputs[].localeAliases["${k}"] must be an array of strings`);
+        }
+      }
+    }
+    if (o.localeCase !== void 0 && !LOCALE_CASES.includes(o.localeCase)) {
+      fail('config.outputs[].localeCase must be one of "lower-hyphen", "lower-underscore", "bcp47-hyphen", "bcp47-underscore"');
+    }
+    if (o.localeMap !== void 0) {
+      if (!isObject(o.localeMap)) fail("config.outputs[].localeMap must be an object");
+      const canon = (s) => s.trim().toLowerCase().replace(/_/g, "-");
+      const localeSet = new Set(locales.map(canon));
+      for (const [k, v] of Object.entries(o.localeMap)) {
+        if (typeof v !== "string") fail(`config.outputs[].localeMap["${k}"] must be a string`);
+        if (!localeSet.has(canon(k))) fail(`config.outputs[].localeMap key "${k}" is not in config.locales`);
+      }
+    }
+  }
+  if (!isObject(config.ai)) fail("config.ai must be an object");
+  const ai = config.ai;
+  if (typeof ai.provider !== "string" || !PROVIDERS.includes(ai.provider)) {
+    fail(`config.ai.provider must be one of: ${PROVIDERS.join(", ")}`);
+  }
+  if (typeof ai.model !== "string") fail("config.ai.model must be a string");
+  if (!(ai.endpoint === null || typeof ai.endpoint === "string")) fail("config.ai.endpoint must be a string or null");
+  if (!(ai.region === void 0 || ai.region === null || typeof ai.region === "string")) {
+    fail("config.ai.region must be a string or null");
+  }
+  if (typeof ai.batchSize !== "number") fail("config.ai.batchSize must be a number");
+  if (!isObject(config.format)) fail("config.format must be an object");
+  const fmt = config.format;
+  if (typeof fmt.indent !== "number") fail("config.format.indent must be a number");
+  if (typeof fmt.sortKeys !== "boolean") fail("config.format.sortKeys must be a boolean");
+  if (typeof fmt.finalNewline !== "boolean") fail("config.format.finalNewline must be a boolean");
+  if (config.autoExport !== void 0 && typeof config.autoExport !== "boolean") fail("config.autoExport must be a boolean");
+  if (config.exportLocales !== void 0 && (!Array.isArray(config.exportLocales) || !config.exportLocales.every((l) => typeof l === "string"))) {
+    fail("config.exportLocales must be an array of strings");
+  }
+  if (config.storage !== void 0 && config.storage !== "single" && config.storage !== "split") {
+    fail('config.storage must be "single" or "split"');
+  }
+  if (config.spelling !== void 0) {
+    const sp = config.spelling;
+    if (!isObject(sp) || !Array.isArray(sp.customWords) || !sp.customWords.every((w) => typeof w === "string")) {
+      fail("config.spelling.customWords must be an array of strings");
+    }
+  }
+  if (config.lint !== void 0) {
+    const lint = config.lint;
+    if (!isObject(lint)) fail("config.lint must be an object");
+    if (lint.rules !== void 0) {
+      if (!isObject(lint.rules)) fail("config.lint.rules must be an object");
+      for (const [id, sev] of Object.entries(lint.rules)) {
+        if (!RULE_IDS.includes(id)) fail(`config.lint.rules has unknown rule id "${id}"`);
+        if (sev !== "error" && sev !== "warn" && sev !== "off") {
+          fail(`config.lint.rules.${id} must be "error", "warn", or "off"`);
+        }
+      }
+    }
+    if (lint.ignore !== void 0 && (!Array.isArray(lint.ignore) || !lint.ignore.every((g) => typeof g === "string"))) {
+      fail("config.lint.ignore must be an array of strings");
+    }
+    if (lint.dictionary !== void 0 && (!Array.isArray(lint.dictionary) || !lint.dictionary.every((w) => typeof w === "string"))) {
+      fail("config.lint.dictionary must be an array of strings");
+    }
+    if (lint.spelling !== void 0) {
+      if (!isObject(lint.spelling)) fail("config.lint.spelling must be an object");
+      if (lint.spelling.locales !== void 0 && (!isObject(lint.spelling.locales) || !Object.values(lint.spelling.locales).every((v) => typeof v === "string"))) {
+        fail("config.lint.spelling.locales must be a map of strings");
+      }
+    }
+  }
+  if (config.scan !== void 0) {
+    const scan = config.scan;
+    if (!isObject(scan)) fail("config.scan must be an object");
+    for (const f of ["include", "exclude", "accessors", "patterns"]) {
+      const v = scan[f];
+      if (v !== void 0 && (!Array.isArray(v) || !v.every((x) => typeof x === "string"))) {
+        fail(`config.scan.${f} must be an array of strings`);
+      }
+    }
+    for (const p of scan.patterns ?? []) {
+      try {
+        new RegExp(p);
+      } catch {
+        fail(`config.scan.patterns has an invalid regex: ${p}`);
+      }
+    }
+  }
+  if (!isObject(raw.keys)) fail("keys must be an object");
+  for (const [key, entry] of Object.entries(raw.keys)) {
+    if (!isObject(entry)) fail(`key "${key}" must be an object`);
+    if (!isObject(entry.values)) fail(`key "${key}" must have a values object`);
+    const plural = entry.plural;
+    if (plural !== void 0 && (!isObject(plural) || typeof plural.arg !== "string" || !plural.arg)) {
+      fail(`key "${key}" plural.arg must be a non-empty string`);
+    }
+    if (entry.placeholders !== void 0) {
+      if (!isObject(entry.placeholders)) fail(`key "${key}" placeholders must be an object`);
+      for (const [name, def] of Object.entries(entry.placeholders)) {
+        if (!isObject(def)) fail(`key "${key}" placeholder "${name}" must be an object`);
+        for (const f of ["type", "format", "example"]) {
+          if (def[f] !== void 0 && typeof def[f] !== "string") {
+            fail(`key "${key}" placeholder "${name}".${f} must be a string`);
+          }
+        }
+      }
+    }
+    for (const [loc, lv] of Object.entries(entry.values)) {
+      if (!isObject(lv)) fail(`key "${key}" locale "${loc}" must be an object`);
+      if (!STATES.includes(lv.state)) {
+        fail(`key "${key}" locale "${loc}" has invalid state "${String(lv.state)}"`);
+      }
+      if (plural) {
+        if (!isObject(lv.forms)) fail(`key "${key}" locale "${loc}" must have a forms object (plural key)`);
+        for (const [cat, body] of Object.entries(lv.forms)) {
+          if (!isPluralForm(cat)) {
+            fail(`key "${key}" locale "${loc}" has invalid plural category "${cat}"`);
+          }
+          if (typeof body !== "string") fail(`key "${key}" locale "${loc}" form "${cat}" must be a string`);
+        }
+        if (typeof lv.forms.other !== "string") {
+          fail(`key "${key}" locale "${loc}" plural must include the "other" form`);
+        }
+      } else {
+        if (typeof lv.value !== "string") fail(`key "${key}" locale "${loc}" value must be a string`);
+        lv.value = lv.value.trim();
+      }
+    }
+    if (entry.notes !== void 0) {
+      if (!Array.isArray(entry.notes)) fail(`key "${key}" notes must be an array`);
+      for (const n of entry.notes) {
+        if (!isObject(n) || typeof n.id !== "string" || typeof n.text !== "string" || typeof n.at !== "string") {
+          fail(`key "${key}" has an invalid note (needs string id, text, at)`);
+        }
+      }
+    }
+    if (entry.contextSource !== void 0 && entry.contextSource !== "ai") {
+      fail(`key "${key}" contextSource must be "ai" if present`);
+    }
+    if (entry.contextAt !== void 0 && typeof entry.contextAt !== "string") {
+      fail(`key "${key}" contextAt must be a string if present`);
+    }
+  }
+  if (raw.glossary !== void 0 && !Array.isArray(raw.glossary)) fail("glossary must be an array");
+  const state = { glossary: [], ...raw };
+  return state;
+}
+function defaultState() {
+  return {
+    $schema: "https://glotfile.dev/schema/v1.json",
+    version: CURRENT_VERSION,
+    config: {
+      sourceLocale: "en",
+      locales: ["en"],
+      outputs: [
+        { adapter: "flutter-arb", path: "lib/l10n/app_{locale}.arb" },
+        { adapter: "laravel-php", path: "lang/{locale}/{namespace}.php" }
+      ],
+      ai: { provider: "anthropic", model: "claude-haiku-4-5-20251001", endpoint: null, region: null, batchSize: 25 },
+      format: { indent: 2, sortKeys: true, finalNewline: true },
+      spelling: { customWords: [] },
+      autoExport: true
+    },
+    glossary: [],
+    keys: {}
+  };
+}
+
+// src/server/plurals.ts
+function bcp47(locale) {
+  return locale.replace(/_/g, "-");
+}
+function categoriesFor(locale) {
+  let reported;
+  try {
+    reported = new Intl.PluralRules(bcp47(locale), { type: "cardinal" }).resolvedOptions().pluralCategories;
+  } catch {
+    reported = ["other"];
+  }
+  const set = new Set(reported);
+  return PLURAL_CATEGORIES.filter((c) => set.has(c));
+}
+function parseIcuPlural(icu) {
+  const s = icu.trim();
+  if (!s.startsWith("{") || !s.endsWith("}")) return null;
+  const head = /^\{\s*(\w+)\s*,\s*plural\s*,/.exec(s);
+  if (!head) return null;
+  const arg = head[1];
+  const end = s.length - 1;
+  let i = head[0].length;
+  const forms = {};
+  while (i < end) {
+    while (i < end && /\s/.test(s[i])) i++;
+    if (i >= end) break;
+    const catStart = i;
+    while (i < end && !/\s/.test(s[i]) && s[i] !== "{") i++;
+    const cat = s.slice(catStart, i);
+    while (i < end && /\s/.test(s[i])) i++;
+    if (s[i] !== "{") return null;
+    let depth = 0;
+    const bodyStart = i + 1;
+    for (; i < s.length; i++) {
+      if (s[i] === "{") depth++;
+      else if (s[i] === "}") {
+        depth--;
+        if (depth === 0) break;
+      }
+    }
+    if (depth !== 0) return null;
+    const body = s.slice(bodyStart, i);
+    i++;
+    if (!isPluralForm(cat)) return null;
+    if (forms[cat] !== void 0) return null;
+    forms[cat] = body.replace(/#/g, `{${arg}}`);
+  }
+  if (typeof forms.other !== "string") return null;
+  return { arg, forms };
+}
+function formsToIcu(arg, forms) {
+  const parts = [];
+  const exact = Object.keys(forms).filter((k) => /^=\d+$/.test(k)).sort((a, b) => Number(a.slice(1)) - Number(b.slice(1)));
+  for (const sel of exact) parts.push(`${sel} {${forms[sel]}}`);
+  for (const cat of PLURAL_CATEGORIES) {
+    const body = forms[cat];
+    if (body !== void 0) parts.push(`${cat} {${body}}`);
+  }
+  return `{${arg}, plural, ${parts.join(" ")}}`;
+}
+function exactFormsToCldr(locale, forms) {
+  const exactKeys = Object.keys(forms).filter((k) => /^=\d+$/.test(k));
+  if (exactKeys.length === 0) return { ...forms };
+  let pr;
+  try {
+    pr = new Intl.PluralRules(bcp47(locale), { type: "cardinal" });
+  } catch {
+    return { other: forms.other ?? "" };
+  }
+  const exactByCat = /* @__PURE__ */ new Map();
+  for (const k of exactKeys.sort((a, b) => Number(a.slice(1)) - Number(b.slice(1)))) {
+    const cat = pr.select(Number(k.slice(1)));
+    if (cat !== "other" && !exactByCat.has(cat)) exactByCat.set(cat, forms[k]);
+  }
+  const out = {};
+  for (const c of categoriesFor(locale)) {
+    out[c] = exactByCat.get(c) ?? forms[c] ?? forms.other ?? "";
+  }
+  return out;
+}
+function gettextPluralForms(locale) {
+  const cats = categoriesFor(locale);
+  const nplurals = cats.length;
+  if (nplurals === 1) return { nplurals: 1, expr: "0", sampled: false };
+  let pr;
+  try {
+    pr = new Intl.PluralRules(bcp47(locale), { type: "cardinal" });
+  } catch {
+    return { nplurals: 1, expr: "0", sampled: false };
+  }
+  if (nplurals === 2 && cats[0] === "one" && cats[1] === "other" && pr.select(0) === "other" && pr.select(1) === "one") {
+    return { nplurals: 2, expr: "(n != 1)", sampled: false };
+  }
+  const index = new Map(cats.map((c, i) => [c, i]));
+  const idxOf = (n) => index.get(pr.select(n)) ?? 0;
+  const MAX = 200;
+  const runs = [];
+  for (let n = 0; n <= MAX; n++) {
+    const i = idxOf(n);
+    const last = runs[runs.length - 1];
+    if (last && last.idx === i && last.end === n - 1) last.end = n;
+    else runs.push({ start: n, end: n, idx: i });
+  }
+  let expr = String(runs[runs.length - 1].idx);
+  for (let r = runs.length - 2; r >= 0; r--) {
+    const { start, end, idx } = runs[r];
+    const cond = start === end ? `n == ${start}` : `n >= ${start} && n <= ${end}`;
+    expr = `(${cond}) ? ${idx} : ${expr}`;
+  }
+  return { nplurals, expr, sampled: true };
+}
+
+// src/server/storage.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync } from "fs";
+import { join, dirname } from "path";
+function splitDirFor(statePath) {
+  return statePath.replace(/\.json$/i, "");
+}
+function detectFormat(statePath) {
+  if (existsSync(join(splitDirFor(statePath), "config.json"))) return "split";
+  if (existsSync(statePath)) return "single";
+  return "none";
+}
+function disassemble(state) {
+  const { keys, ...manifest } = state;
+  const keyMeta = {};
+  const locales = {};
+  for (const [key, entry] of Object.entries(keys)) {
+    const { values, ...meta } = entry;
+    keyMeta[key] = meta;
+    for (const [locale, lv] of Object.entries(values)) {
+      (locales[locale] ??= {})[key] = lv;
+    }
+  }
+  return { manifest, keys: keyMeta, locales };
+}
+function assemble(parts) {
+  const keys = {};
+  for (const [key, meta] of Object.entries(parts.keys)) {
+    keys[key] = { ...meta, values: {} };
+  }
+  for (const [locale, entries] of Object.entries(parts.locales)) {
+    for (const [key, lv] of Object.entries(entries)) {
+      (keys[key] ??= { values: {} }).values[locale] = lv;
+    }
+  }
+  return { ...parts.manifest, keys };
+}
+function loadSplit(splitDir) {
+  const readJson = (p) => JSON.parse(readFileSync(p, "utf8"));
+  const manifest = readJson(join(splitDir, "config.json"));
+  const keysPath = join(splitDir, "keys.json");
+  const keys = existsSync(keysPath) ? readJson(keysPath) : {};
+  const localesDir = join(splitDir, "locales");
+  const locales = {};
+  if (existsSync(localesDir)) {
+    for (const name of readdirSync(localesDir)) {
+      if (name.endsWith(".json")) locales[name.slice(0, -5)] = readJson(join(localesDir, name));
+    }
+  }
+  return assemble({ manifest, keys, locales });
+}
+function writeIfChanged(path, contents) {
+  let current = null;
+  try {
+    current = readFileSync(path, "utf8");
+  } catch {
+  }
+  if (current === contents) return false;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, contents, "utf8");
+  return true;
+}
+function saveSplit(splitDir, state) {
+  const fmt = state.config.format;
+  const parts = disassemble(state);
+  const localesDir = join(splitDir, "locales");
+  mkdirSync(localesDir, { recursive: true });
+  let written = 0;
+  let skipped = 0;
+  let deleted = 0;
+  const track = (changed) => {
+    if (changed) written++;
+    else skipped++;
+  };
+  track(writeIfChanged(join(splitDir, "config.json"), serializeJson(parts.manifest, fmt)));
+  track(writeIfChanged(join(splitDir, "keys.json"), serializeJson(parts.keys, fmt)));
+  for (const [locale, entries] of Object.entries(parts.locales)) {
+    track(writeIfChanged(join(localesDir, `${locale}.json`), serializeJson(entries, fmt)));
+  }
+  const live = new Set(Object.keys(parts.locales).map((l) => `${l}.json`));
+  for (const name of readdirSync(localesDir)) {
+    if (name.endsWith(".json") && !live.has(name)) {
+      rmSync(join(localesDir, name));
+      deleted++;
+    }
+  }
+  return { written, skipped, deleted };
+}
+
+// src/server/normalize.ts
+function normalizeSource(value) {
+  return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+
+// src/server/state.ts
+var systemClock = () => (/* @__PURE__ */ new Date()).toISOString();
+function canonLocale(locale) {
+  return locale.trim().toLowerCase().replace(/_/g, "-");
+}
+function normalizeState(state) {
+  const src = canonLocale(state.config.sourceLocale);
+  state.config.sourceLocale = src;
+  state.version = CURRENT_VERSION;
+  const seen = /* @__PURE__ */ new Set([src]);
+  for (const l of state.config.locales) {
+    const c = canonLocale(l);
+    if (c) seen.add(c);
+  }
+  const rest = [...seen].filter((l) => l !== src).sort();
+  state.config.locales = [src, ...rest];
+  for (const entry of Object.values(state.keys)) {
+    const remapped = {};
+    for (const [loc, lv] of Object.entries(entry.values)) remapped[canonLocale(loc)] = lv;
+    entry.values = remapped;
+  }
+  for (const output of state.config.outputs) {
+    if (!output.localeMap) continue;
+    const remapped = {};
+    for (const [k, v] of Object.entries(output.localeMap)) remapped[canonLocale(k)] = v;
+    output.localeMap = remapped;
+  }
+}
+function loadState(path) {
+  const fmt = detectFormat(path);
+  if (fmt === "none") return defaultState();
+  let raw;
+  try {
+    raw = fmt === "split" ? loadSplit(splitDirFor(path)) : JSON.parse(readFileSync2(path, "utf8"));
+  } catch (e) {
+    throw new GlotfileError(`Could not load ${path}: ${e.message}`);
+  }
+  const state = validate(raw);
+  normalizeState(state);
+  return state;
+}
+function saveState(path, state) {
+  normalizeState(state);
+  if (state.config.storage === "split") {
+    saveSplit(splitDirFor(path), state);
+    if (existsSync2(path)) rmSync2(path);
+  } else {
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync2(path, serializeJson(state, state.config.format), "utf8");
+  }
+}
+function requireKey(state, key) {
+  const entry = state.keys[key];
+  if (!entry) throw new GlotfileError(`No such key: ${key}`);
+  return entry;
+}
+function requirePlural(state, key) {
+  const entry = requireKey(state, key);
+  if (!entry.plural) throw new GlotfileError(`Key is not a plural: ${key}`);
+  return entry;
+}
+function normalizeForms(forms) {
+  const out = {};
+  for (const [cat, body] of Object.entries(forms)) {
+    if (!isPluralForm(cat)) throw new GlotfileError(`Invalid plural category: ${cat}`);
+    if (typeof body !== "string") throw new GlotfileError(`Plural form "${cat}" must be a string`);
+    out[cat] = body.trim();
+  }
+  if (typeof out.other !== "string") throw new GlotfileError(`Plural forms must include the "other" form`);
+  return out;
+}
+function createKey(state, key, sourceValue, clock = systemClock, opts = {}) {
+  if (state.keys[key]) throw new GlotfileError(`Key already exists: ${key}`);
+  const sl = state.config.sourceLocale;
+  if (opts.plural) {
+    state.keys[key] = {
+      createdAt: clock(),
+      plural: { arg: opts.plural.arg },
+      // The source value seeds the required "other" form so nothing is empty.
+      values: { [sl]: { forms: { other: sourceValue.trim() }, state: "source" } }
+    };
+  } else {
+    state.keys[key] = {
+      createdAt: clock(),
+      values: { [sl]: { value: sourceValue.trim(), state: "source" } }
+    };
+  }
+}
+function renameKey(state, from, to) {
+  if (from === to) return;
+  const entry = requireKey(state, from);
+  if (state.keys[to]) throw new GlotfileError(`Key already exists: ${to}`);
+  delete state.keys[from];
+  state.keys[to] = entry;
+}
+function deleteKey(state, key) {
+  requireKey(state, key);
+  delete state.keys[key];
+}
+function setSourceValue(state, key, value) {
+  const entry = requireKey(state, key);
+  if (entry.plural) throw new GlotfileError(`Key is a plural; use the plural setters: ${key}`);
+  const oldNorm = normalizeSource(entry.values[state.config.sourceLocale]?.value ?? "");
+  const newNorm = normalizeSource(value);
+  entry.values[state.config.sourceLocale] = { value: value.trim(), state: "source" };
+  if (oldNorm !== newNorm) {
+    for (const [locale, lv] of Object.entries(entry.values)) {
+      if (locale === state.config.sourceLocale) continue;
+      if (lv.state === "reviewed" || lv.state === "machine") {
+        lv.state = "needs-review";
+      }
+    }
+  }
+}
+function setTargetValue(state, key, locale, value, clock = systemClock) {
+  const entry = requireKey(state, key);
+  if (entry.plural) throw new GlotfileError(`Key is a plural; use the plural setters: ${key}`);
+  entry.values[locale] = { value: value.trim(), state: "reviewed", updatedAt: clock() };
+}
+function formSignature(forms) {
+  return Object.entries(forms).sort(([a], [b]) => a.localeCompare(b)).map(([cat, val]) => `${cat}:${normalizeSource(val ?? "")}`).join("|");
+}
+function setSourcePluralForms(state, key, forms) {
+  const entry = requirePlural(state, key);
+  const normalized = normalizeForms(forms);
+  const oldSig = formSignature(entry.values[state.config.sourceLocale]?.forms ?? {});
+  const newSig = formSignature(normalized);
+  entry.values[state.config.sourceLocale] = { forms: normalized, state: "source" };
+  if (oldSig !== newSig) {
+    for (const [locale, lv] of Object.entries(entry.values)) {
+      if (locale === state.config.sourceLocale) continue;
+      if (lv.state === "reviewed" || lv.state === "machine") {
+        lv.state = "needs-review";
+      }
+    }
+  }
+}
+function setPluralForms(state, key, locale, forms, clock = systemClock) {
+  const entry = requirePlural(state, key);
+  if (locale === state.config.sourceLocale) throw new GlotfileError("Use setSourcePluralForms for the source locale");
+  entry.values[locale] = { forms: normalizeForms(forms), state: "reviewed", updatedAt: clock() };
+}
+function convertToPlural(state, key, arg) {
+  const entry = requireKey(state, key);
+  if (entry.plural) throw new GlotfileError(`Key is already a plural: ${key}`);
+  entry.plural = { arg };
+  for (const lv of Object.values(entry.values)) {
+    lv.forms = { other: lv.value ?? "" };
+    delete lv.value;
+  }
+}
+function setPluralArg(state, key, arg) {
+  const entry = requireKey(state, key);
+  if (!entry.plural) throw new GlotfileError(`Key is not a plural: ${key}`);
+  entry.plural = { arg };
+}
+function convertToScalar(state, key) {
+  const entry = requirePlural(state, key);
+  const arg = entry.plural.arg;
+  for (const lv of Object.values(entry.values)) {
+    const forms = lv.forms ?? {};
+    lv.value = Object.keys(forms).length <= 1 ? forms.other ?? "" : formsToIcu(arg, forms);
+    delete lv.forms;
+  }
+  delete entry.plural;
+}
+function clearValue(state, key, locale) {
+  const entry = requireKey(state, key);
+  if (locale === state.config.sourceLocale) throw new GlotfileError("Cannot clear the source value");
+  delete entry.values[locale];
+}
+function setKeyState(state, key, locale, next) {
+  const entry = requireKey(state, key);
+  const lv = entry.values[locale];
+  if (!lv) throw new GlotfileError(`No value for ${key} @ ${locale}`);
+  lv.state = next;
+}
+function setMetadata(state, key, partial) {
+  const entry = requireKey(state, key);
+  const safe = { ...partial };
+  delete safe.plural;
+  delete safe.values;
+  if ("context" in safe) {
+    delete entry.contextSource;
+    delete entry.contextAt;
+  }
+  Object.assign(entry, safe);
+}
+function addNote(state, key, text, clock = systemClock) {
+  const entry = requireKey(state, key);
+  const note = { id: "n_" + randomUUID(), text, at: clock() };
+  (entry.notes ??= []).push(note);
+  return note;
+}
+function editNote(state, key, id, text) {
+  const entry = requireKey(state, key);
+  const note = entry.notes?.find((n) => n.id === id);
+  if (!note) throw new GlotfileError(`No such note: ${id}`);
+  note.text = text;
+}
+function deleteNote(state, key, id) {
+  const entry = requireKey(state, key);
+  if (!entry.notes) return;
+  entry.notes = entry.notes.filter((n) => n.id !== id);
+}
+function upsertGlossaryEntry(state, entry) {
+  const i = state.glossary.findIndex((e) => e.term === entry.term);
+  if (i === -1) state.glossary.push(entry);
+  else state.glossary[i] = entry;
+}
+function deleteGlossaryEntry(state, term) {
+  state.glossary = state.glossary.filter((e) => e.term !== term);
+}
+function addCustomWord(state, word) {
+  const w = word.trim();
+  if (!w) return;
+  const spelling = state.config.spelling ??= { customWords: [] };
+  if (!spelling.customWords.includes(w)) {
+    spelling.customWords.push(w);
+    spelling.customWords.sort();
+  }
+}
+function removeCustomWord(state, word) {
+  const spelling = state.config.spelling;
+  if (!spelling) return;
+  spelling.customWords = spelling.customWords.filter((w) => w !== word);
+}
+function applyMachineTranslation(state, key, locale, value, clock = systemClock, force = false) {
+  const entry = requireKey(state, key);
+  if (entry.plural) throw new GlotfileError(`Key is a plural; use applyMachineTranslationForms: ${key}`);
+  if (!force && entry.values[locale]?.state === "reviewed") return false;
+  entry.values[locale] = { value: value.trim(), state: "machine", source: "ai", updatedAt: clock() };
+  return true;
+}
+function applyMachineTranslationForms(state, key, locale, forms, clock = systemClock, force = false) {
+  const entry = requirePlural(state, key);
+  if (!force && entry.values[locale]?.state === "reviewed") return false;
+  entry.values[locale] = { forms: normalizeForms(forms), state: "machine", source: "ai", updatedAt: clock() };
+  return true;
+}
+
+// src/server/scan.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { resolve, dirname as dirname3 } from "path";
+function loadUsageCache(projectRoot) {
+  const path = resolve(projectRoot, ".glotfile", "usage.json");
+  if (!existsSync3(path)) return null;
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function saveUsageCache(projectRoot, cache2) {
+  const path = resolve(projectRoot, ".glotfile", "usage.json");
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify(cache2, null, 2) + "\n", "utf8");
+}
+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()) {
+    for (const locale of targets) {
+      const v = state.keys[key].values[locale]?.value;
+      if (!v) out.push({ key, locale });
+    }
+  }
+  return out;
+}
+function computeUsedKeys(state, cache2) {
+  const exact = /* @__PURE__ */ new Set();
+  const prefixes = [];
+  for (const entry of Object.values(cache2.files)) {
+    for (const r of entry.refs) exact.add(r.key);
+    for (const p of entry.prefixes) {
+      if (p.prefix) prefixes.push(p.prefix);
+    }
+  }
+  return Object.keys(state.keys).filter((key) => exact.has(key) || prefixes.some((p) => key.startsWith(p))).sort();
+}
+
+// src/server/scanner.ts
+import { readdirSync as readdirSync2, statSync, readFileSync as readFileSync4 } from "fs";
+import { join as join2, extname, relative } from "path";
+var PATTERNS = {
+  laravel: [
+    /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*'([^']+)'/g,
+    /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*"([^"]+)"/g,
+    /@(?:lang|choice)\s*\(\s*'([^']+)'/g,
+    /@(?:lang|choice)\s*\(\s*"([^"]+)"/g
+  ],
+  "js-i18n": [
+    /\$t\s*\(\s*'([^']+)'/g,
+    /\$t\s*\(\s*"([^"]+)"/g,
+    /\$t\s*\(\s*`([^`$\n]+)`/g,
+    /\bi18n\.t\s*\(\s*'([^']+)'/g,
+    /\bi18n\.t\s*\(\s*"([^"]+)"/g,
+    /\bi18next\.t\s*\(\s*'([^']+)'/g,
+    /\bi18next\.t\s*\(\s*"([^"]+)"/g,
+    // t('key') — word boundary before t, not preceded by dot (excludes i18n.t which is above)
+    /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*'([^']+)'/g,
+    /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*"([^"]+)"/g,
+    /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*`([^`$\n]+)`/g
+  ],
+  gettext: [
+    /\b(?:gettext|ngettext)\s*\(\s*'([^']+)'/g,
+    /\b(?:gettext|ngettext)\s*\(\s*"([^"]+)"/g,
+    // _() — word boundary, not preceded by alphanumeric
+    /(?<![a-zA-Z0-9_$])_\s*\(\s*'([^']+)'/g,
+    /(?<![a-zA-Z0-9_$])_\s*\(\s*"([^"]+)"/g
+  ],
+  apple: [
+    /NSLocalizedString\s*\(\s*@?"([^"]+)"/g,
+    /String\s*\(\s*localized:\s*"([^"]+)"/g,
+    /localizedString\s*\(\s*forKey:\s*"([^"]+)"/g
+  ]
+};
+var PREFIX_PATTERNS = {
+  laravel: [
+    /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*'([^']*)'\s*\./g,
+    /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*"([^"]*)"\s*\./g,
+    /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*"([^"${]*)\{?\$/g
+  ],
+  "js-i18n": [
+    /(?:\$t|i18n\.t|i18next\.t)\s*\(\s*'([^']*)'\s*\+/g,
+    /(?:\$t|i18n\.t|i18next\.t)\s*\(\s*"([^"]*)"\s*\+/g,
+    /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*'([^']*)'\s*\+/g,
+    /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*"([^"]*)"\s*\+/g,
+    /(?:\$t|i18n\.t|i18next\.t)\s*\(\s*`([^`$]*)\$\{/g,
+    /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*`([^`$]*)\$\{/g
+  ]
+};
+var CACHE_VERSION = 4;
+var EXT_SCANNER = {
+  ".php": "laravel",
+  ".vue": "js-i18n",
+  ".js": "js-i18n",
+  ".ts": "js-i18n",
+  ".jsx": "js-i18n",
+  ".tsx": "js-i18n",
+  ".mjs": "js-i18n",
+  ".cjs": "js-i18n",
+  ".dart": "flutter",
+  ".py": "gettext",
+  ".c": "gettext",
+  ".cpp": "gettext",
+  ".h": "gettext",
+  ".swift": "apple",
+  ".m": "apple",
+  ".mm": "apple"
+};
+var ALWAYS_EXCLUDE = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".glotfile",
+  ".claude",
+  "dist",
+  "build",
+  "vendor",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  "__pycache__"
+]);
+function scannerForExt(ext) {
+  return EXT_SCANNER[ext] ?? null;
+}
+var FLUTTER_ACCESSOR_DEFAULTS = ["l10n", "loc", "localizations", "translations"];
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function detectFlutterAccessors(content) {
+  const names = /* @__PURE__ */ new Set();
+  const assigned = /\b([a-zA-Z_]\w*)\s*=\s*AppLocalizations\s*\.\s*of\s*\(/g;
+  const typed = /\bAppLocalizations[?!]?\s+([a-zA-Z_]\w*)\b(?!\s*\()/g;
+  let m;
+  while ((m = assigned.exec(content)) !== null) names.add(m[1]);
+  while ((m = typed.exec(content)) !== null) names.add(m[1]);
+  return [...names];
+}
+function flutterPatterns(content, opts) {
+  const names = [.../* @__PURE__ */ new Set([
+    ...FLUTTER_ACCESSOR_DEFAULTS,
+    ...detectFlutterAccessors(content),
+    ...opts?.accessors ?? []
+  ])].map(escapeRe);
+  return [
+    // AppLocalizations.of(context)!.key — tolerates the !/? null-assertion.
+    /AppLocalizations\.of\([^)]*\)[!?]?\.([a-zA-Z_][a-zA-Z0-9_]*)/g,
+    // <accessor>.key — accessor is conventional, auto-detected, or configured.
+    new RegExp(`\\b(?:${names.join("|")})[!?]?\\s*\\.([a-zA-Z_][a-zA-Z0-9_]*)`, "g")
+  ];
+}
+function customPatterns(opts) {
+  const out = [];
+  for (const p of opts?.patterns ?? []) {
+    try {
+      out.push(new RegExp(p, "g"));
+    } catch {
+    }
+  }
+  return out;
+}
+function lineStartOffsets(content) {
+  const starts = [0];
+  let idx = content.indexOf("\n");
+  while (idx !== -1) {
+    starts.push(idx + 1);
+    idx = content.indexOf("\n", idx + 1);
+  }
+  return starts;
+}
+function offsetToLineCol(starts, offset) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >>> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo + 1, col: offset - starts[lo] + 1 };
+}
+function extractRefs(content, scanner, opts) {
+  const base = scanner === "flutter" ? flutterPatterns(content, opts) : PATTERNS[scanner] ?? [];
+  const patterns = [...base, ...customPatterns(opts)];
+  if (patterns.length === 0) return [];
+  const starts = lineStartOffsets(content);
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.source, "g");
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      if (m.index === re.lastIndex) re.lastIndex++;
+      const key = m[1];
+      const { line, col } = offsetToLineCol(starts, m.index);
+      const dedup = `${line}:${col}:${key}`;
+      if (!seen.has(dedup)) {
+        seen.add(dedup);
+        result.push({ key, line, col, scanner });
+      }
+    }
+  }
+  result.sort((a, b) => a.line - b.line || a.col - b.col);
+  return result;
+}
+function extractPrefixes(content, scanner) {
+  const patterns = PREFIX_PATTERNS[scanner];
+  if (!patterns) return [];
+  const starts = lineStartOffsets(content);
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.source, "g");
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      if (m.index === re.lastIndex) re.lastIndex++;
+      const prefix = m[1];
+      if (!prefix) continue;
+      const { line, col } = offsetToLineCol(starts, m.index);
+      const dedup = `${line}:${col}:${prefix}`;
+      if (!seen.has(dedup)) {
+        seen.add(dedup);
+        result.push({ prefix, line, col, scanner });
+      }
+    }
+  }
+  result.sort((a, b) => a.line - b.line || a.col - b.col);
+  return result;
+}
+function matchesGlob(relPath, glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(//g, ".*");
+  return new RegExp(`^${escaped}$`).test(relPath);
+}
+function isExcluded(relPath, excludePatterns) {
+  return excludePatterns.some((p) => matchesGlob(relPath, p));
+}
+function isIncluded(relPath, includePatterns) {
+  if (includePatterns.length === 0) return true;
+  return includePatterns.some((p) => matchesGlob(relPath, p));
+}
+function* walkFiles(dir, root, exclude) {
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (ALWAYS_EXCLUDE.has(name)) continue;
+    const abs = join2(dir, name);
+    const rel = relative(root, abs);
+    let st;
+    try {
+      st = statSync(abs);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
+      yield* walkFiles(abs, root, exclude);
+    } else if (st.isFile()) {
+      yield rel;
+    }
+  }
+}
+function runScan(projectRoot, opts, existing) {
+  const exclude = opts.exclude ?? [];
+  const include = opts.include ?? [];
+  const cache2 = {
+    version: CACHE_VERSION,
+    scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: {}
+  };
+  const reusable = existing && existing.version === CACHE_VERSION ? existing : null;
+  for (const relPath of walkFiles(projectRoot, projectRoot, exclude)) {
+    if (isExcluded(relPath, exclude)) continue;
+    if (!isIncluded(relPath, include)) continue;
+    const ext = extname(relPath);
+    const scanner = scannerForExt(ext);
+    if (!scanner) continue;
+    const abs = join2(projectRoot, relPath);
+    let st;
+    try {
+      st = statSync(abs);
+    } catch {
+      continue;
+    }
+    const mtime = Math.floor(st.mtimeMs);
+    const size = st.size;
+    const prev = reusable?.files[relPath];
+    if (prev && prev.mtime === mtime && prev.size === size) {
+      cache2.files[relPath] = prev;
+      continue;
+    }
+    let content;
+    try {
+      content = readFileSync4(abs, "utf8");
+    } catch {
+      continue;
+    }
+    cache2.files[relPath] = {
+      mtime,
+      size,
+      refs: extractRefs(content, scanner, opts),
+      prefixes: extractPrefixes(content, scanner)
+    };
+  }
+  saveUsageCache(projectRoot, cache2);
+  return cache2;
+}
+
+// src/server/ai/context.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve2 } from "path";
+var MAX_CONTEXT_LENGTH = 500;
+var SNIPPET_WINDOW = 15;
+var MAX_SNIPPETS = 3;
+var EXCLUDED_DIRS = ["node_modules/", "vendor/", "dist/", ".git/", ".glotfile/"];
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function extractSnippets(refs, projectRoot, fileCache) {
+  const filtered = refs.filter((r) => !EXCLUDED_DIRS.some((d) => r.file.startsWith(d)));
+  const sorted = [...filtered].sort((a, b) => a.file.length - b.file.length);
+  const selected = sorted.slice(0, MAX_SNIPPETS);
+  const extraRefs = filtered.length > MAX_SNIPPETS ? filtered.length - MAX_SNIPPETS : 0;
+  const snippets = [];
+  for (const ref of selected) {
+    const absPath = resolve2(projectRoot, ref.file);
+    if (!fileCache.has(ref.file)) {
+      if (!existsSync4(absPath)) continue;
+      const content = readFileSync5(absPath, "utf8");
+      fileCache.set(ref.file, content.split("\n"));
+    }
+    const lines = fileCache.get(ref.file);
+    const start = Math.max(0, ref.line - 1 - SNIPPET_WINDOW);
+    const end = Math.min(lines.length, ref.line + SNIPPET_WINDOW);
+    snippets.push({
+      file: ref.file,
+      startLine: start + 1,
+      lines: lines.slice(start, end).join("\n"),
+      scanner: ref.scanner,
+      ...snippets.length === 0 && extraRefs > 0 ? { extraRefs } : {}
+    });
+  }
+  return snippets;
+}
+function buildUsageIndex(cache2) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [file, entry] of Object.entries(cache2.files)) {
+    for (const ref of entry.refs) {
+      const existing = index.get(ref.key) ?? [];
+      existing.push({ key: ref.key, file, line: ref.line, col: ref.col, scanner: ref.scanner });
+      index.set(ref.key, existing);
+    }
+  }
+  return index;
+}
+function selectContextTargets(state, opts, cache2, lastRunAt) {
+  const cutoff = opts.all ? void 0 : opts.since ?? lastRunAt;
+  const keyRe = opts.keyGlob ? globToRegExp(opts.keyGlob) : null;
+  const keySet = opts.keys ? new Set(opts.keys) : null;
+  const usageIndex = buildUsageIndex(cache2);
+  let candidates = [];
+  for (const key of Object.keys(state.keys).sort()) {
+    const entry = state.keys[key];
+    if (entry.context) continue;
+    if (keySet && !keySet.has(key)) continue;
+    if (keyRe && !keyRe.test(key)) continue;
+    if (cutoff) {
+      if (!entry.createdAt) continue;
+      if (entry.createdAt < cutoff) continue;
+    }
+    const source = entry.values[state.config.sourceLocale]?.value ?? "";
+    candidates.push({ id: String(candidates.length), key, source, usageSnippets: [] });
+  }
+  candidates.sort((a, b) => {
+    const ta = state.keys[a.key].createdAt ?? "";
+    const tb = state.keys[b.key].createdAt ?? "";
+    return tb.localeCompare(ta);
+  });
+  if (opts.limit !== void 0) candidates = candidates.slice(0, opts.limit);
+  candidates.forEach((c, i) => {
+    c.id = String(i);
+  });
+  return candidates;
+}
+function buildContextSystemPrompt() {
+  return [
+    "You are a localization context writer for a UI string catalog.",
+    "For each translation key you are given: its dot-path name, its source string, and one or more code snippets showing where the string is referenced in the codebase.",
+    "Your task: write a concise 1\u20132 sentence context note that describes WHERE in the UI this string appears and WHAT the user is doing at that point.",
+    "The context is read by human translators AND by an AI translation engine. It must answer: what screen is this on, what element is this (button, label, error, etc.), and what action does it relate to?",
+    "Rules:",
+    "- Use the code snippets as your primary signal. Look at the component name, surrounding labels, event handlers, and variable names.",
+    "- Do NOT restate the source string itself.",
+    "- Do NOT say 'This string is...' \u2014 write the context as a direct description.",
+    "- Keep it under 500 characters.",
+    "- If no code snippets are available, infer from the key path and source value."
+  ].join("\n");
+}
+function buildContextBatchPrompt(reqs) {
+  const items = reqs.map((r) => {
+    const snippetText = r.usageSnippets.length > 0 ? r.usageSnippets.map((s) => {
+      const extra = s.extraRefs ? ` (and ${s.extraRefs} more call site${s.extraRefs > 1 ? "s" : ""} not shown)` : "";
+      return `File: ${s.file} (lines ${s.startLine}+, scanner: ${s.scanner})${extra}
+\`\`\`
+${s.lines}
+\`\`\``;
+    }).join("\n\n") : "(no code references found \u2014 infer from key path and source value)";
+    return { id: r.id, key: r.key, source: r.source, codeSnippets: snippetText, hasScreenshot: r.image !== void 0 };
+  });
+  return 'Write a context note for each key. Return JSON {"items":[{"id","context"}]}.\n' + JSON.stringify(items, null, 2);
+}
+var CONTEXT_BATCH_SCHEMA = {
+  type: "object",
+  properties: {
+    items: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          context: { type: "string" },
+          error: { type: "string" }
+        },
+        required: ["id"],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ["items"],
+  additionalProperties: false
+};
+function applyContext(state, reqs, results, clock = systemClock) {
+  const byId = new Map(reqs.map((r) => [r.id, r]));
+  let written = 0;
+  const errors = [];
+  for (const res of results) {
+    const req = byId.get(res.id);
+    if (!req) continue;
+    if (res.error) {
+      errors.push({ key: req.key, error: res.error });
+      continue;
+    }
+    const context = res.context?.trim() ?? "";
+    if (!context) {
+      errors.push({ key: req.key, error: "AI returned empty context" });
+      continue;
+    }
+    if (context.length > MAX_CONTEXT_LENGTH) {
+      errors.push({ key: req.key, error: `Context too long (${context.length} chars, max ${MAX_CONTEXT_LENGTH})` });
+      continue;
+    }
+    const entry = state.keys[req.key];
+    if (!entry || entry.context) continue;
+    entry.context = context;
+    entry.contextSource = "ai";
+    entry.contextAt = clock();
+    written++;
+  }
+  return { written, errors };
+}
+
+// src/server/stats.ts
+function countWords(text) {
+  const t = text.trim();
+  return t === "" ? 0 : t.split(/\s+/).length;
+}
+function namespaceOf(key) {
+  const i = key.indexOf(".");
+  return i === -1 ? "(root)" : key.slice(0, i);
+}
+function pct(n, d) {
+  return d === 0 ? 0 : Math.round(n / d * 1e3) / 10;
+}
+function sourceText(entry, sourceLocale) {
+  const lv = entry.values[sourceLocale];
+  if (!lv) return "";
+  return entry.plural ? lv.forms?.other ?? "" : lv.value ?? "";
+}
+function isPresent(entry, locale) {
+  const lv = entry.values[locale];
+  if (!lv) return false;
+  return entry.plural ? (lv.forms?.other ?? "").trim() !== "" : (lv.value ?? "").trim() !== "";
+}
+function classify(entry, locale) {
+  if (!isPresent(entry, locale)) return "missing";
+  const st = entry.values[locale].state;
+  if (st === "reviewed") return "reviewed";
+  if (st === "needs-review") return "needsReview";
+  return "machine";
+}
+function groupCompletion(state, keys, targets, name) {
+  let translated = 0;
+  let reviewed = 0;
+  for (const k of keys) {
+    const entry = state.keys[k];
+    for (const locale of targets) {
+      const bucket = classify(entry, locale);
+      if (bucket !== "missing") translated++;
+      if (bucket === "reviewed") reviewed++;
+    }
+  }
+  const cells = keys.length * targets.length;
+  return { name, total: keys.length, translatedPct: pct(translated, cells), reviewedPct: pct(reviewed, cells) };
+}
+function worstFirst(a, b) {
+  return a.translatedPct - b.translatedPct || a.name.localeCompare(b.name);
+}
+function computeStats(state) {
+  const { sourceLocale, locales } = state.config;
+  const targets = locales.filter((l) => l !== sourceLocale);
+  const allKeys = Object.keys(state.keys);
+  const expected = allKeys.filter((k) => !state.keys[k].skipTranslate);
+  const locales_ = targets.map((locale) => {
+    const counts = { reviewed: 0, needsReview: 0, machine: 0, missing: 0 };
+    let sourceWords = 0;
+    let missingWords = 0;
+    for (const k of expected) {
+      const entry = state.keys[k];
+      const w = countWords(sourceText(entry, sourceLocale));
+      sourceWords += w;
+      const bucket = classify(entry, locale);
+      counts[bucket]++;
+      if (bucket === "missing") missingWords += w;
+    }
+    const total = expected.length;
+    const translated = counts.reviewed + counts.needsReview + counts.machine;
+    return {
+      locale,
+      total,
+      counts,
+      translated,
+      reviewed: counts.reviewed,
+      translatedPct: pct(translated, total),
+      reviewedPct: pct(counts.reviewed, total),
+      words: { source: sourceWords, missing: missingWords }
+    };
+  });
+  const cells = expected.length * targets.length;
+  let translatedCells = 0;
+  let reviewedCells = 0;
+  for (const ls of locales_) {
+    translatedCells += ls.translated;
+    reviewedCells += ls.reviewed;
+  }
+  const nsMap = /* @__PURE__ */ new Map();
+  for (const k of expected) {
+    const ns = namespaceOf(k);
+    (nsMap.get(ns) ?? nsMap.set(ns, []).get(ns)).push(k);
+  }
+  const byNamespace = [...nsMap.entries()].map(([name, keys]) => groupCompletion(state, keys, targets, name)).sort(worstFirst);
+  const tagMap = /* @__PURE__ */ new Map();
+  for (const k of expected) {
+    for (const tag of state.keys[k].tags ?? []) {
+      (tagMap.get(tag) ?? tagMap.set(tag, []).get(tag)).push(k);
+    }
+  }
+  const byTag = [...tagMap.entries()].map(([name, keys]) => groupCompletion(state, keys, targets, name)).sort(worstFirst);
+  return {
+    totals: {
+      keys: allKeys.length,
+      locales: targets.length,
+      translatedPct: pct(translatedCells, cells),
+      reviewedPct: pct(reviewedCells, cells),
+      sourceWords: expected.reduce((sum, k) => sum + countWords(sourceText(state.keys[k], sourceLocale)), 0)
+    },
+    locales: locales_,
+    byNamespace,
+    byTag
+  };
+}
+
+// src/server/placeholders.ts
+var ICU_PLURAL_SELECT = /\{\s*\w+\s*,\s*(?:plural|select|selectordinal)\s*,/;
+function withoutQuotedSpans(value) {
+  if (!value.includes("'")) return value;
+  let out = "";
+  for (let i = 0; i < value.length; ) {
+    if (value[i] === "'") {
+      const next = value[i + 1];
+      if (next === "'") {
+        out += " ";
+        i += 2;
+        continue;
+      }
+      if (next === "{" || next === "}" || next === "#" || next === "|") {
+        i += 2;
+        while (i < value.length && value[i] !== "'") i++;
+        i++;
+        continue;
+      }
+    }
+    out += value[i];
+    i++;
+  }
+  return out;
+}
+function extractPlaceholders(value) {
+  const scan = withoutQuotedSpans(value);
+  const names = /* @__PURE__ */ new Set();
+  for (const m of scan.matchAll(/\{\s*(\w+)\s*,\s*(?:plural|select|selectordinal)\s*,/g)) {
+    names.add(m[1]);
+  }
+  if (!isIcuPluralOrSelect(scan)) {
+    for (const m of scan.matchAll(/\{\s*(\w+)\s*\}/g)) names.add(m[1]);
+  }
+  return [...names];
+}
+function isIcuPluralOrSelect(value) {
+  return ICU_PLURAL_SELECT.test(value);
+}
+function toLaravel(value) {
+  if (isIcuPluralOrSelect(value)) return value;
+  return value.replace(/\{(\w+)\}/g, ":$1");
+}
+function toI18next(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();
+  return a.length === b.length && a.every((x, i) => x === b[i]);
+}
+function placeholdersSubset(source, translation) {
+  const allowed = new Set(extractPlaceholders(source));
+  return extractPlaceholders(translation).every((p) => allowed.has(p));
+}
+var COUNT_OPTIONAL = /* @__PURE__ */ new Set(["zero", "one", "two"]);
+function pluralFormPlaceholdersMatch(category, source, form) {
+  return COUNT_OPTIONAL.has(category) ? placeholdersSubset(source, form) : placeholdersMatch(source, form);
+}
+
+// src/server/ai/run.ts
+import { readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
+import { resolve as resolve3, extname as extname2 } from "path";
+
+// src/server/glob.ts
+function globToRegExp2(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+
+// src/server/ai/run.ts
+function selectRequests(state, opts) {
+  const targets = (opts.locales ?? state.config.locales).filter((l) => l !== state.config.sourceLocale);
+  const keyRe = opts.keyGlob ? globToRegExp2(opts.keyGlob) : null;
+  const keySet = opts.keys ? new Set(opts.keys) : null;
+  const reqs = [];
+  let id = 0;
+  for (const key of Object.keys(state.keys).sort()) {
+    const entry = state.keys[key];
+    if (entry.skipTranslate) continue;
+    if (keyRe && !keyRe.test(key)) continue;
+    if (keySet && !keySet.has(key)) continue;
+    const sourceLv = entry.values[state.config.sourceLocale];
+    if (entry.plural) {
+      const sourceForms = sourceLv?.forms;
+      const other = sourceForms?.other;
+      if (!sourceForms || !other) continue;
+      for (const locale of targets) {
+        const have = entry.values[locale]?.forms ?? {};
+        const complete = categoriesFor(locale).every((c) => (have[c] ?? "") !== "");
+        if (opts.onlyMissing && complete) continue;
+        const glossary = relevantGlossary(other, locale, state.glossary);
+        reqs.push({
+          id: String(id++),
+          key,
+          source: other,
+          context: entry.context,
+          targetLocale: locale,
+          maxLength: entry.maxLength,
+          placeholders: extractPlaceholders(other),
+          ...glossary.length ? { glossary } : {},
+          plural: { arg: entry.plural.arg, categories: categoriesFor(locale), sourceForms }
+        });
+      }
+      continue;
+    }
+    const source = sourceLv?.value;
+    if (!source) continue;
+    for (const locale of targets) {
+      const existing = entry.values[locale]?.value;
+      if (opts.onlyMissing && existing) continue;
+      const glossary = relevantGlossary(source, locale, state.glossary);
+      reqs.push({
+        id: String(id++),
+        key,
+        source,
+        context: entry.context,
+        targetLocale: locale,
+        maxLength: entry.maxLength,
+        placeholders: extractPlaceholders(source),
+        ...glossary.length ? { glossary } : {}
+      });
+    }
+  }
+  return reqs;
+}
+function relevantGlossary(source, targetLocale, glossary) {
+  const hints = [];
+  for (const entry of glossary) {
+    const haystack = entry.caseSensitive ? source : source.toLowerCase();
+    const needle = entry.caseSensitive ? entry.term : entry.term.toLowerCase();
+    if (!haystack.includes(needle)) continue;
+    hints.push({
+      term: entry.term,
+      doNotTranslate: entry.doNotTranslate,
+      forced: entry.translations?.[targetLocale],
+      notes: entry.notes
+    });
+  }
+  return hints;
+}
+var MEDIA_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif"
+};
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+function attachScreenshots(reqs, state, projectRoot) {
+  const cache2 = /* @__PURE__ */ new Map();
+  for (const req of reqs) {
+    const screenshot = state.keys[req.key]?.screenshot;
+    if (!screenshot) continue;
+    const mediaType = MEDIA_TYPES[extname2(screenshot).toLowerCase()];
+    if (!mediaType) continue;
+    if (!cache2.has(screenshot)) {
+      const abs = resolve3(projectRoot, screenshot);
+      if (!existsSync5(abs)) {
+        cache2.set(screenshot, null);
+      } else {
+        const buf = readFileSync6(abs);
+        cache2.set(screenshot, buf.length > MAX_IMAGE_BYTES ? null : { mediaType, base64: buf.toString("base64") });
+      }
+    }
+    const image = cache2.get(screenshot);
+    if (image) req.image = image;
+  }
+}
+function attachScreenshotsForProvider(reqs, state, projectRoot, supportsVision) {
+  if (supportsVision) {
+    attachScreenshots(reqs, state, projectRoot);
+    return { skipped: 0 };
+  }
+  const keys = new Set(reqs.filter((r) => state.keys[r.key]?.screenshot).map((r) => r.key));
+  return { skipped: keys.size };
+}
+var DEFAULT_LOCALE_CONCURRENCY = 3;
+async function runLocaleParallel(reqs, provider, onBatchComplete, concurrency = DEFAULT_LOCALE_CONCURRENCY, signal) {
+  if (!reqs.length) return [];
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const req of reqs) {
+    let group = byLocale.get(req.targetLocale);
+    if (!group) {
+      group = [];
+      byLocale.set(req.targetLocale, group);
+    }
+    group.push(req);
+  }
+  const total = reqs.length;
+  let done = 0;
+  const allResults = [];
+  const groups = [...byLocale.values()];
+  let next = 0;
+  async function worker() {
+    while (next < groups.length) {
+      if (signal?.aborted) break;
+      const group = groups[next++];
+      const localeResults = await provider.translate(group, (_localeDone, _localeTotal, batchResults) => {
+        done += batchResults.length;
+        onBatchComplete?.(done, total, batchResults);
+      }, signal);
+      allResults.push(...localeResults);
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, groups.length) }, worker);
+  await Promise.all(workers);
+  return allResults;
+}
+function applyResults(state, reqs, results, clock = systemClock, force = false) {
+  const byId = new Map(reqs.map((r) => [r.id, r]));
+  let written = 0;
+  const errors = [];
+  for (const res of results) {
+    const req = byId.get(res.id);
+    if (!req) continue;
+    if (req.plural) {
+      if (res.error || res.forms === void 0) {
+        errors.push({ key: req.key, locale: req.targetLocale, error: res.error ?? "no translation" });
+        continue;
+      }
+      if (applyMachineTranslationForms(state, req.key, req.targetLocale, res.forms, clock, force)) written++;
+      continue;
+    }
+    if (res.error || res.translation === void 0) {
+      errors.push({ key: req.key, locale: req.targetLocale, error: res.error ?? "no translation" });
+      continue;
+    }
+    if (applyMachineTranslation(state, req.key, req.targetLocale, res.translation, clock, force)) written++;
+  }
+  return { written, errors };
+}
+
+// src/server/spell.ts
+import nspell from "nspell";
+var LOADERS = {
+  en: () => init_dictionary_en().then(() => dictionary_en_exports),
+  es: () => import("dictionary-es"),
+  fr: () => import("dictionary-fr")
+};
+var instances = /* @__PURE__ */ new Map();
+var loading = /* @__PURE__ */ new Set();
+var unavailable = /* @__PURE__ */ new Set();
+var cache = /* @__PURE__ */ new Map();
+var norm = (locale) => locale.toLowerCase();
+var ICU_BLOCK = /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g;
+var MASK = /\{[^}]*\}|<[^>]*>|:\w+|%[sd]/g;
+var WORD = new RegExp("\\p{L}[\\p{L}''\u2019-]*", "gu");
+async function loadDictionary(locale) {
+  const key = norm(locale);
+  if (instances.has(key) || unavailable.has(key)) return;
+  const loader = LOADERS[key];
+  if (!loader) {
+    unavailable.add(key);
+    return;
+  }
+  try {
+    const { default: dict } = await loader();
+    instances.set(key, nspell(dict));
+  } catch {
+    unavailable.add(key);
+  } finally {
+    loading.delete(key);
+  }
+}
+function spellValue(locale, value, ignore) {
+  const key = norm(locale);
+  if (unavailable.has(key)) return [];
+  const spell = instances.get(key);
+  if (!spell) {
+    if (!LOADERS[key]) {
+      unavailable.add(key);
+      return [];
+    }
+    if (!loading.has(key)) {
+      loading.add(key);
+      void loadDictionary(key);
+    }
+    return null;
+  }
+  const cacheKey = key + " " + value;
+  let allBad = cache.get(cacheKey);
+  if (!allBad) {
+    const words = value.replace(ICU_BLOCK, " ").replace(MASK, " ").match(WORD) ?? [];
+    allBad = words.filter((w) => !spell.correct(w));
+    cache.set(cacheKey, allBad);
+  }
+  return allBad.filter((w) => !ignore.has(w.toLowerCase()));
+}
+
+// src/server/checks.ts
+var CHECK_IDS = ["untranslated", "placeholder", "spelling", "length", "glossary"];
+function contains(haystack, needle, caseSensitive) {
+  return caseSensitive ? haystack.includes(needle) : haystack.toLowerCase().includes(needle.toLowerCase());
+}
+function runChecks(state, opts = {}) {
+  const on = (id) => !opts.only || opts.only.includes(id);
+  const issues = [];
+  let spellPending = false;
+  const { sourceLocale } = state.config;
+  const byTerm = new Map(state.glossary.map((e) => [e.term, e]));
+  const ignore = /* @__PURE__ */ new Set();
+  for (const e of state.glossary) {
+    for (const w of e.term.toLowerCase().split(/\s+/)) if (w) ignore.add(w);
+    for (const t of Object.values(e.translations ?? {})) {
+      for (const w of t.toLowerCase().split(/\s+/)) if (w) ignore.add(w);
+    }
+  }
+  for (const word of state.config.spelling?.customWords ?? []) {
+    const w = word.trim().toLowerCase();
+    if (w) ignore.add(w);
+  }
+  const targetLocales = state.config.locales.filter((l) => l !== sourceLocale);
+  for (const key of Object.keys(state.keys).sort()) {
+    const entry = state.keys[key];
+    const source = entry.values[sourceLocale]?.value ?? "";
+    if (on("untranslated") && !entry.skipTranslate) {
+      for (const locale of targetLocales) {
+        const translated = entry.plural ? (entry.values[locale]?.forms?.other ?? "").trim() !== "" : (entry.values[locale]?.value ?? "").trim() !== "";
+        if (!translated) {
+          issues.push({ key, locale, check: "untranslated", message: "Not translated yet" });
+        }
+      }
+    }
+    if (entry.plural) {
+      if (on("placeholder")) {
+        const sourceForm = entry.values[sourceLocale]?.forms?.other ?? "";
+        if (sourceForm.trim() !== "") {
+          const sp = extractPlaceholders(sourceForm);
+          for (const [locale, lv] of Object.entries(entry.values)) {
+            if (locale === sourceLocale || !lv.forms) continue;
+            for (const [cat, form] of Object.entries(lv.forms)) {
+              const text = form ?? "";
+              if (text.trim() === "" || pluralFormPlaceholdersMatch(cat, sourceForm, text)) continue;
+              const tp = extractPlaceholders(text);
+              const missing = COUNT_OPTIONAL.has(cat) ? [] : sp.filter((p) => !tp.includes(p));
+              const extra = tp.filter((p) => !sp.includes(p));
+              const parts = [];
+              if (missing.length) parts.push(`missing ${missing.join(", ")}`);
+              if (extra.length) parts.push(`extra ${extra.join(", ")}`);
+              issues.push({
+                key,
+                locale,
+                check: "placeholder",
+                message: `Placeholder mismatch (${cat}): ${parts.join("; ")}`,
+                detail: [...missing.map((m) => `-${m}`), ...extra.map((e) => `+${e}`)]
+              });
+            }
+          }
+        }
+      }
+      continue;
+    }
+    for (const [locale, lv] of Object.entries(entry.values)) {
+      const value = lv.value ?? "";
+      const isSource = locale === sourceLocale;
+      const blank = value.trim() === "";
+      if (on("length") && entry.maxLength && value.length > entry.maxLength) {
+        issues.push({
+          key,
+          locale,
+          check: "length",
+          message: `Exceeds max length (${value.length}/${entry.maxLength})`,
+          detail: [`${value.length}/${entry.maxLength}`]
+        });
+      }
+      if (on("spelling") && !blank) {
+        const bad = spellValue(locale, value, ignore);
+        if (bad === null) spellPending = true;
+        else if (bad.length) {
+          issues.push({
+            key,
+            locale,
+            check: "spelling",
+            message: `Possible spelling: ${bad.join(", ")}`,
+            detail: bad
+          });
+        }
+      }
+      if (isSource || blank) continue;
+      if (on("placeholder") && !placeholdersMatch(source, value)) {
+        const sp = extractPlaceholders(source);
+        const tp = extractPlaceholders(value);
+        const missing = sp.filter((p) => !tp.includes(p));
+        const extra = tp.filter((p) => !sp.includes(p));
+        const parts = [];
+        if (missing.length) parts.push(`missing ${missing.join(", ")}`);
+        if (extra.length) parts.push(`extra ${extra.join(", ")}`);
+        issues.push({
+          key,
+          locale,
+          check: "placeholder",
+          message: `Placeholder mismatch: ${parts.join("; ")}`,
+          detail: [...missing.map((m) => `-${m}`), ...extra.map((e) => `+${e}`)]
+        });
+      }
+      if (on("glossary") && source) {
+        for (const hint of relevantGlossary(source, locale, state.glossary)) {
+          const cs = byTerm.get(hint.term)?.caseSensitive;
+          if (hint.doNotTranslate) {
+            if (!contains(value, hint.term, cs)) {
+              issues.push({
+                key,
+                locale,
+                check: "glossary",
+                message: `Do-not-translate term "${hint.term}" is missing from the translation`,
+                detail: [hint.term]
+              });
+            }
+          } else if (hint.forced) {
+            if (!contains(value, hint.forced, cs)) {
+              issues.push({
+                key,
+                locale,
+                check: "glossary",
+                message: `Should use "${hint.forced}" for "${hint.term}"`,
+                detail: [hint.forced]
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return { issues, spellPending };
+}
+
+// src/server/adapters/options.ts
+function applyCase(canonical, style) {
+  const sep3 = 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);
+}
+function resolveLocaleToken(output, canonical, adapterDefault) {
+  const mapped = output.localeMap?.[canonical];
+  if (mapped !== void 0) return mapped;
+  return applyCase(canonical, output.localeCase ?? adapterDefault);
+}
+function inferLocaleStyle(pairs, adapterDefault) {
+  const candidates = [adapterDefault, ...LOCALE_CASES.filter((c) => c !== adapterDefault)];
+  let best = adapterDefault;
+  let bestScore = -1;
+  for (const style of candidates) {
+    const score = pairs.filter(([c, obs]) => applyCase(c, style) === obs).length;
+    if (score > bestScore) {
+      bestScore = score;
+      best = style;
+    }
+  }
+  const localeMap = {};
+  for (const [c, obs] of pairs) {
+    if (applyCase(c, best) !== obs) localeMap[c] = obs;
+  }
+  const result = {};
+  if (best !== adapterDefault) result.localeCase = best;
+  if (Object.keys(localeMap).length) result.localeMap = localeMap;
+  return result;
+}
+function resolveFormat(state, output) {
+  const f = state.config.format;
+  return {
+    indent: output.indent ?? f.indent,
+    finalNewline: output.finalNewline ?? f.finalNewline
+  };
+}
+function resolveEmptyAs(output, fallback) {
+  return output.emptyAs ?? fallback;
+}
+function resolveScalar(entry, locale, sourceLocale, emptyAs) {
+  const raw = entry.values[locale]?.value ?? "";
+  if (raw) return raw;
+  if (locale === sourceLocale) return raw;
+  if (emptyAs === "omit") return null;
+  if (emptyAs === "empty") return "";
+  return entry.values[sourceLocale]?.value ?? "";
+}
+function resolveForms(entry, locale, sourceLocale, emptyAs) {
+  const forms = entry.values[locale]?.forms;
+  if (forms?.other) return forms;
+  if (locale === sourceLocale) return forms ?? { other: "" };
+  if (emptyAs === "omit") return null;
+  if (emptyAs === "empty") return { other: "" };
+  return entry.values[sourceLocale]?.forms ?? { other: "" };
+}
+
+// src/server/adapters/flutter-arb.ts
+var DEFAULT_LOCALE_CASE = "bcp47-underscore";
+var flutterArb = {
+  name: "flutter-arb",
+  capabilities: {
+    plural: "native",
+    select: "native",
+    nesting: "flat",
+    metadata: true,
+    placeholderStyle: "icu",
+    fileGrouping: "per-locale"
+  },
+  defaultLocaleCase: DEFAULT_LOCALE_CASE,
+  export(state, output) {
+    const files = [];
+    const warnings = [];
+    warnings.push(...localeCollisionWarnings(output, state.config.locales, DEFAULT_LOCALE_CASE));
+    const { indent, finalNewline } = resolveFormat(state, output);
+    const fmt = { indent, sortKeys: false, finalNewline };
+    const includeLocale = output.includeLocale ?? true;
+    const emptyAs = resolveEmptyAs(output, "omit");
+    const sortedKeys = Object.keys(state.keys).sort();
+    const built = {};
+    for (const locale of state.config.locales) {
+      const isSource = locale === state.config.sourceLocale;
+      const obj = {};
+      const token = resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE);
+      if (includeLocale) obj["@@locale"] = token;
+      for (const key of sortedKeys) {
+        const entry = state.keys[key];
+        let value;
+        let placeholderNames;
+        if (entry.plural) {
+          const forms = resolveForms(entry, locale, state.config.sourceLocale, emptyAs);
+          if (!forms) continue;
+          value = formsToIcu(entry.plural.arg, forms);
+          const srcForms = entry.values[state.config.sourceLocale]?.forms ?? {};
+          placeholderNames = [entry.plural.arg, ...Object.values(srcForms).flatMap((b) => extractPlaceholders(b ?? ""))];
+        } else {
+          const raw = resolveScalar(entry, locale, state.config.sourceLocale, emptyAs);
+          if (raw === null) continue;
+          value = raw;
+          placeholderNames = extractPlaceholders(raw);
+        }
+        obj[key] = value;
+        if (isSource) {
+          const placeholders = {};
+          for (const name of placeholderNames) {
+            if (!/^\w+$/.test(name)) continue;
+            placeholders[name] = {};
+          }
+          const meta = {};
+          if (entry.context) meta.description = entry.context;
+          if (Object.keys(placeholders).length) meta.placeholders = placeholders;
+          if (Object.keys(meta).length) obj["@" + key] = meta;
+        }
+      }
+      built[locale] = obj;
+      files.push({ path: resolvePath(output.path, token), contents: serializeJson(obj, fmt) });
+    }
+    for (const [canonical, aliasCodes] of Object.entries(output.localeAliases ?? {})) {
+      const obj = built[canonical];
+      if (!obj) continue;
+      for (const code of aliasCodes) {
+        const aliasToken = resolveLocaleToken(output, code, DEFAULT_LOCALE_CASE);
+        const aliasObj = includeLocale ? { ...obj, "@@locale": aliasToken } : obj;
+        files.push({ path: resolvePath(output.path, aliasToken), contents: serializeJson(aliasObj, fmt) });
+      }
+    }
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    return { files, warnings };
+  }
+};
+
+// src/server/adapters/shared.ts
+function nestKeys(flat) {
+  const tree = {};
+  const collisions = [];
+  for (const fullKey of Object.keys(flat)) {
+    const parts = fullKey.split(".");
+    let node = tree;
+    let collided = false;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const p = parts[i];
+      const existing = node[p];
+      if (existing === void 0) {
+        const next = {};
+        node[p] = next;
+        node = next;
+      } else if (typeof existing === "object" && existing !== null) {
+        node = existing;
+      } else {
+        collisions.push(fullKey);
+        collided = true;
+        break;
+      }
+    }
+    if (collided) continue;
+    const leaf = parts[parts.length - 1];
+    if (typeof node[leaf] === "object" && node[leaf] !== null) {
+      collisions.push(fullKey);
+      continue;
+    }
+    node[leaf] = flat[fullKey];
+  }
+  return { tree, collisions };
+}
+
+// src/server/adapters/laravel-php.ts
+function splitKey(key) {
+  const dot = key.indexOf(".");
+  if (dot === -1) return { namespace: "messages", inner: key };
+  return { namespace: key.slice(0, dot), inner: key.slice(dot + 1) };
+}
+function phpString(s) {
+  return "'" + s.replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
+}
+function phpArray(node, indent, level) {
+  const pad = " ".repeat(indent * (level + 1));
+  const closePad = " ".repeat(indent * level);
+  const lines = Object.keys(node).sort().map((key) => {
+    const v = node[key];
+    const rhs = v && typeof v === "object" ? phpArray(v, indent, level + 1) : phpString(String(v));
+    return `${pad}${phpString(key)} => ${rhs},`;
+  });
+  return `[
+${lines.join("\n")}
+${closePad}]`;
+}
+var DEFAULT_LOCALE_CASE2 = "lower-hyphen";
+var laravelPhp = {
+  name: "laravel-php",
+  capabilities: {
+    plural: "native",
+    select: "lossy",
+    nesting: "nested",
+    metadata: false,
+    placeholderStyle: "named",
+    fileGrouping: "per-locale-namespace"
+  },
+  defaultLocaleCase: DEFAULT_LOCALE_CASE2,
+  export(state, output) {
+    const warnings = [];
+    warnings.push(...localeCollisionWarnings(output, state.config.locales, DEFAULT_LOCALE_CASE2));
+    const { indent, finalNewline } = resolveFormat(state, output);
+    const emptyAs = resolveEmptyAs(output, "omit");
+    const tree = {};
+    for (const locale of state.config.locales) tree[locale] = {};
+    for (const [key, entry] of Object.entries(state.keys)) {
+      const { namespace, inner } = splitKey(key);
+      for (const locale of state.config.locales) {
+        if (entry.plural) {
+          const forms = resolveForms(entry, locale, state.config.sourceLocale, emptyAs);
+          if (!forms) continue;
+          const parts = PLURAL_CATEGORIES.map((c) => forms[c]).filter((v) => v !== void 0).map((body) => toLaravel(body)).filter(Boolean);
+          const value = parts.join("|");
+          if (!value && locale !== state.config.sourceLocale) continue;
+          (tree[locale][namespace] ??= {})[inner] = value;
+        } 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: "laravel-php cannot represent ICU plural/select; written unconverted"
+            });
+          }
+          (tree[locale][namespace] ??= {})[inner] = toLaravel(raw);
+        }
+      }
+    }
+    const files = [];
+    for (const [locale, namespaces] of Object.entries(tree)) {
+      for (const [namespace, flat] of Object.entries(namespaces)) {
+        const { tree: nested, collisions } = nestKeys(flat);
+        for (const c of collisions) {
+          warnings.push({ code: "key-collision", key: `${namespace}.${c}`, locale, message: "key is both a leaf and a parent; dropped from nested output" });
+        }
+        const body = `<?php
+
+return ${phpArray(nested, indent, 0)};`;
+        files.push({ path: resolvePath(output.path, resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE2), namespace), contents: finalNewline ? body + "\n" : body });
+      }
+    }
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    return { files, warnings };
+  }
+};
+
+// src/server/adapters/i18next-json.ts
+function setNested(root, path, value) {
+  let node = root;
+  let collided = false;
+  for (let i = 0; i < path.length - 1; i++) {
+    const seg = path[i];
+    if (typeof node[seg] !== "object" || node[seg] === null) {
+      if (node[seg] !== void 0) collided = true;
+      node[seg] = {};
+    }
+    node = node[seg];
+  }
+  const leaf = path[path.length - 1];
+  if (typeof node[leaf] === "object" && node[leaf] !== null) collided = true;
+  node[leaf] = value;
+  return collided;
+}
+var DEFAULT_LOCALE_CASE3 = "lower-hyphen";
+var i18nextJson = {
+  name: "i18next-json",
+  capabilities: {
+    plural: "native",
+    select: "lossy",
+    nesting: "nested",
+    metadata: false,
+    placeholderStyle: "named",
+    fileGrouping: "per-locale"
+  },
+  defaultLocaleCase: DEFAULT_LOCALE_CASE3,
+  export(state, output) {
+    const files = [];
+    const warnings = [];
+    const fmt = state.config.format;
+    const collided = /* @__PURE__ */ new Set();
+    warnings.push(...localeCollisionWarnings(output, state.config.locales, DEFAULT_LOCALE_CASE3));
+    for (const locale of state.config.locales) {
+      const obj = {};
+      for (const [key, entry] of Object.entries(state.keys)) {
+        const lv = entry.values[locale];
+        if (!lv) continue;
+        const segments = key.split(".");
+        const leaf = segments[segments.length - 1];
+        const parent = segments.slice(0, -1);
+        if (entry.plural) {
+          if (!lv.forms) continue;
+          for (const cat of PLURAL_CATEGORIES) {
+            const body = lv.forms[cat];
+            if (body === void 0) continue;
+            if (setNested(obj, [...parent, `${leaf}_${cat}`], toI18next(body))) collided.add(key);
+          }
+          continue;
+        }
+        if (lv.value === void 0) continue;
+        if (setNested(obj, segments, toI18next(lv.value))) collided.add(key);
+      }
+      files.push({ path: resolvePath(output.path, resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE3)), contents: serializeJson(obj, fmt) });
+    }
+    for (const key of [...collided].sort()) {
+      warnings.push({ code: "key-collision", key, message: "key collides with another key's nesting path; one value was overwritten" });
+    }
+    return { files, warnings };
+  }
+};
+
+// src/server/adapters/gettext-po.ts
+function poString(s) {
+  return '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r") + '"';
+}
+function toGettext(body, arg) {
+  return body.split(`{${arg}}`).join("%d");
+}
+var DEFAULT_LOCALE_CASE4 = "lower-hyphen";
+var gettextPo = {
+  name: "gettext-po",
+  capabilities: {
+    plural: "native",
+    select: "lossy",
+    nesting: "flat",
+    metadata: false,
+    placeholderStyle: "printf",
+    fileGrouping: "per-locale"
+  },
+  defaultLocaleCase: DEFAULT_LOCALE_CASE4,
+  export(state, output) {
+    const warnings = [];
+    warnings.push(...localeCollisionWarnings(output, state.config.locales, DEFAULT_LOCALE_CASE4));
+    const files = [];
+    const sourceLocale = state.config.sourceLocale;
+    const keys = Object.keys(state.keys).sort();
+    for (const locale of state.config.locales) {
+      const token = resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE4);
+      const { nplurals, expr, sampled } = gettextPluralForms(locale);
+      const cats = categoriesFor(locale);
+      const blocks = [
+        [
+          'msgid ""',
+          'msgstr ""',
+          poString("Content-Type: text/plain; charset=UTF-8\n"),
+          poString(`Language: ${token}
+`),
+          poString(`Plural-Forms: nplurals=${nplurals}; plural=${expr};
+`)
+        ].join("\n")
+      ];
+      let emittedPlural = false;
+      for (const key of keys) {
+        const entry = state.keys[key];
+        const lv = entry.values[locale];
+        const src = entry.values[sourceLocale];
+        if (entry.plural) {
+          emittedPlural = true;
+          const arg = entry.plural.arg;
+          const srcForms = src?.forms ?? {};
+          const lines = [
+            `msgctxt ${poString(key)}`,
+            // gettext keys a plural on the source singular/plural pair.
+            `msgid ${poString(toGettext(srcForms.one ?? srcForms.other ?? "", arg))}`,
+            `msgid_plural ${poString(toGettext(srcForms.other ?? "", arg))}`
+          ];
+          for (let i = 0; i < nplurals; i++) {
+            const cat = cats[i];
+            const body = lv?.forms?.[cat] ?? lv?.forms?.other ?? "";
+            lines.push(`msgstr[${i}] ${poString(toGettext(body, arg))}`);
+          }
+          blocks.push(lines.join("\n"));
+        } else {
+          blocks.push(
+            [
+              `msgctxt ${poString(key)}`,
+              `msgid ${poString(src?.value ?? "")}`,
+              `msgstr ${poString(lv?.value ?? "")}`
+            ].join("\n")
+          );
+        }
+      }
+      if (sampled && emittedPlural) {
+        warnings.push({
+          code: "unsupported-metadata",
+          key: "",
+          locale,
+          message: `Plural-Forms for "${locale}" is generated by sampling counts 0\u2013200; verify behaviour for larger numbers.`
+        });
+      }
+      files.push({ path: resolvePath(output.path, token), contents: blocks.join("\n\n") + "\n" });
+    }
+    return { files, warnings };
+  }
+};
+
+// src/server/adapters/apple-stringsdict.ts
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function toApple(body, arg) {
+  return body.split(`{${arg}}`).join("%d");
+}
+var DEFAULT_LOCALE_CASE5 = "lower-hyphen";
+var appleStringsdict = {
+  name: "apple-stringsdict",
+  capabilities: {
+    plural: "native",
+    select: "none",
+    nesting: "flat",
+    metadata: false,
+    placeholderStyle: "printf",
+    fileGrouping: "per-locale"
+  },
+  defaultLocaleCase: DEFAULT_LOCALE_CASE5,
+  export(state, output) {
+    const files = [];
+    const warnings = [];
+    warnings.push(...localeCollisionWarnings(output, state.config.locales, DEFAULT_LOCALE_CASE5));
+    const keys = Object.keys(state.keys).sort();
+    for (const locale of state.config.locales) {
+      const lines = [];
+      for (const key of keys) {
+        const entry = state.keys[key];
+        if (!entry.plural) continue;
+        const lv = entry.values[locale];
+        if (!lv?.forms || lv.forms.other === void 0) continue;
+        const arg = entry.plural.arg;
+        lines.push(`	<key>${xmlEscape(key)}</key>`);
+        lines.push(`	<dict>`);
+        lines.push(`		<key>NSStringLocalizedFormatKey</key>`);
+        lines.push(`		<string>%#@${xmlEscape(arg)}@</string>`);
+        lines.push(`		<key>${xmlEscape(arg)}</key>`);
+        lines.push(`		<dict>`);
+        lines.push(`			<key>NSStringFormatSpecTypeKey</key>`);
+        lines.push(`			<string>NSStringPluralRuleType</string>`);
+        lines.push(`			<key>NSStringFormatValueTypeKey</key>`);
+        lines.push(`			<string>d</string>`);
+        for (const cat of PLURAL_CATEGORIES) {
+          const body = lv.forms[cat];
+          if (body === void 0) continue;
+          lines.push(`			<key>${cat}</key>`);
+          lines.push(`			<string>${xmlEscape(toApple(body, arg))}</string>`);
+        }
+        lines.push(`		</dict>`);
+        lines.push(`	</dict>`);
+      }
+      const contents = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTD/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+` + (lines.length ? lines.join("\n") + "\n" : "") + `</dict>
+</plist>
+`;
+      files.push({ path: resolvePath(output.path, resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE5)), contents });
+    }
+    return { files, warnings };
+  }
+};
+
+// src/server/adapters/vue-i18n-json.ts
+var DEFAULT_LOCALE_CASE6 = "lower-hyphen";
+var vueI18nJson = {
+  name: "vue-i18n-json",
+  capabilities: {
+    plural: "native",
+    select: "lossy",
+    nesting: "both",
+    metadata: false,
+    placeholderStyle: "named",
+    fileGrouping: "per-locale"
+  },
+  defaultLocaleCase: DEFAULT_LOCALE_CASE6,
+  export(state, output) {
+    const files = [];
+    const warnings = [];
+    warnings.push(...localeCollisionWarnings(output, state.config.locales, DEFAULT_LOCALE_CASE6));
+    const { indent, finalNewline } = resolveFormat(state, output);
+    const fmt = { indent, sortKeys: true, finalNewline };
+    const emptyAs = resolveEmptyAs(output, "omit");
+    const flatOutput = output.style === "flat";
+    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;
+          const parts = PLURAL_CATEGORIES.map((c) => forms[c]).filter((v) => v !== void 0);
+          flat[key] = parts.join(" | ");
+        } 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: "vue-i18n-json does not yet convert ICU plural/select; written unconverted"
+            });
+          }
+          flat[key] = raw;
+        }
+      }
+      let payload = flat;
+      if (!flatOutput) {
+        const { tree, collisions } = nestKeys(flat);
+        for (const key of collisions) {
+          warnings.push({
+            code: "key-collision",
+            key,
+            locale,
+            message: "key is both a leaf and a parent; dropped from nested output"
+          });
+        }
+        payload = tree;
+      }
+      files.push({ path: resolvePath(output.path, resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE6)), contents: serializeJson(payload, fmt) });
+    }
+    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);
+}
+function localeCollisionWarnings(output, locales, adapterDefault) {
+  const byToken = /* @__PURE__ */ new Map();
+  for (const locale of locales) {
+    const token = resolveLocaleToken(output, locale, adapterDefault);
+    const group = byToken.get(token) ?? [];
+    group.push(locale);
+    byToken.set(token, group);
+  }
+  const warnings = [];
+  for (const [token, group] of byToken) {
+    if (group.length > 1) {
+      warnings.push({
+        code: "locale-collision",
+        key: "",
+        message: `locales ${group.join(", ")} all resolve to the export token "${token}"; only the first (in locale order) is written`
+      });
+    }
+  }
+  return warnings;
+}
+var registry;
+function getRegistry() {
+  return registry ??= {
+    [flutterArb.name]: flutterArb,
+    [laravelPhp.name]: laravelPhp,
+    [i18nextJson.name]: i18nextJson,
+    [gettextPo.name]: gettextPo,
+    [appleStringsdict.name]: appleStringsdict,
+    [vueI18nJson.name]: vueI18nJson
+  };
+}
+function getAdapter(name) {
+  const a = getRegistry()[name];
+  if (!a) throw new Error(`Unknown adapter: ${name}`);
+  return a;
+}
+
+// src/server/api.ts
+import { writeFileSync as writeFileSync5, readFileSync as readFileSync11, mkdirSync as mkdirSync6, existsSync as existsSync8, readdirSync as readdirSync7, rmSync as rmSync3 } from "fs";
+import { dirname as dirname5, resolve as resolve6, basename, relative as relative3, sep } from "path";
+
+// src/server/ai/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/server/ai/provider.ts
+function buildSystemPrompt() {
+  return [
+    "You are a professional software localization engine for a UI string catalog.",
+    "Your goal: translate each source UI string into its target locale accurately and idiomatically, as a native speaker would phrase it in a real app interface.",
+    "",
+    "You are given, per item: the key path, the source text, optional human context, the target locale, an optional max length, the list of interpolation placeholders, and any relevant glossary entries. Some items also include a screenshot image showing where the string appears in the UI \u2014 use it to disambiguate meaning, tone, and length.",
+    "",
+    "Hard rules:",
+    "- Preserve every interpolation placeholder EXACTLY as written: {name}, {{count}}, %s, %d, :name. Never translate, rename, reorder, or remove them.",
+    "- Preserve ICU plural/select structure verbatim (e.g. {count, plural, one {\u2026} other {\u2026}}); translate only the human-readable text inside each branch.",
+    "- Glossary: a term marked do-not-translate MUST appear unchanged in the translation. A term with a forced translation for the target locale MUST use that exact translation.",
+    "- Respect the max length (characters) when given; prefer a shorter natural phrasing over exceeding it.",
+    "- Match the register and capitalization conventions of the target language and of UI microcopy.",
+    "- Return ONLY the translated string for each item \u2014 no quotes, notes, or explanations.",
+    "",
+    'Plural items: an item with a `plural` field gives you the source plural FORMS (keyed by CLDR category) and the `categories` REQUIRED for the target language. Return a `forms` object with one idiomatic translation per REQUIRED category \u2014 including categories the source language does not have (infer them from meaning). Keep the count token shown in the source forms (e.g. {count}) in every form that states a quantity; the `zero`, `one`, and `two` forms MAY omit it when that is natural in the target language \u2014 e.g. "No files", "One file", or a dual form that encodes the count grammatically (Arabic \u0645\u0644\u0641\u0627\u0646). Never introduce a placeholder the source did not have. For these items return `forms` instead of `translation`.'
+  ].join("\n");
+}
+function buildBatchPrompt(reqs) {
+  const targetLocale = reqs[0]?.targetLocale ?? "";
+  const items = reqs.map((r) => {
+    const base = {
+      id: r.id,
+      key: r.key,
+      context: r.context ?? null,
+      maxLength: r.maxLength ?? null,
+      placeholders: r.placeholders,
+      glossary: r.glossary ?? [],
+      hasScreenshot: r.image !== void 0
+    };
+    if (r.plural) {
+      return { ...base, plural: { arg: r.plural.arg, categories: r.plural.categories, sourceForms: r.plural.sourceForms } };
+    }
+    return { ...base, source: r.source };
+  });
+  return `Translate every item below into the target locale: ${targetLocale}. All items share this one target language.
+Glossary entries are constraints you MUST apply. Items with hasScreenshot:true have a screenshot supplied as a separate image block above; use it for context. For a scalar item (has \`source\`) return {"id","translation"}; for a plural item (has \`plural\`) return {"id","forms"} with one string per required category. Return JSON {"items":[\u2026]}.
+` + JSON.stringify(items, null, 2);
+}
+var BATCH_SCHEMA = {
+  type: "object",
+  properties: {
+    items: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          translation: { type: "string" },
+          forms: {
+            type: "object",
+            properties: {
+              zero: { type: "string" },
+              one: { type: "string" },
+              two: { type: "string" },
+              few: { type: "string" },
+              many: { type: "string" },
+              other: { type: "string" }
+            },
+            additionalProperties: false
+          }
+        },
+        required: ["id"],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ["items"],
+  additionalProperties: false
+};
+
+// src/server/ai/batch.ts
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+function validateTranslation(req, translation) {
+  if (translation === void 0) return { id: req.id, error: "No translation returned." };
+  if (!placeholdersMatch(req.source, translation)) {
+    return { id: req.id, error: "Placeholder mismatch between source and translation." };
+  }
+  if (req.maxLength !== void 0 && translation.length > req.maxLength) {
+    return { id: req.id, error: `Exceeds maxLength (${translation.length} > ${req.maxLength}).` };
+  }
+  return { id: req.id, translation };
+}
+function validatePlural(req, forms) {
+  if (!forms) return { id: req.id, error: "No translation returned." };
+  const plural = req.plural;
+  if (!plural) return { id: req.id, error: "validatePlural called on a non-plural request." };
+  const cats = plural.categories;
+  const missing = cats.filter((c) => typeof forms[c] !== "string");
+  if (missing.length) return { id: req.id, error: `Missing plural categories: ${missing.join(", ")}.` };
+  const badPh = cats.find((c) => !pluralFormPlaceholdersMatch(c, req.source, forms[c]));
+  if (badPh) return { id: req.id, error: `Placeholder mismatch in plural form "${badPh}".` };
+  if (req.maxLength !== void 0) {
+    const over = cats.find((c) => forms[c].length > req.maxLength);
+    if (over) return { id: req.id, error: `Plural form "${over}" exceeds maxLength (${forms[over].length} > ${req.maxLength}).` };
+  }
+  const out = {};
+  for (const c of cats) out[c] = forms[c];
+  return { id: req.id, forms: out };
+}
+function validateReply(req, item) {
+  return req.plural ? validatePlural(req, item?.forms) : validateTranslation(req, item?.translation);
+}
+async function runBatched(reqs, batchSize, callBatch, onBatchComplete, signal) {
+  const results = [];
+  const total = reqs.length;
+  for (const batch of chunk(reqs, Math.max(1, batchSize))) {
+    if (signal?.aborted) break;
+    const reply = await callBatch(batch, signal);
+    const byId = new Map(reply.map((r) => [r.id, r]));
+    const batchResults = [];
+    for (const req of batch) batchResults.push(validateReply(req, byId.get(req.id)));
+    results.push(...batchResults);
+    onBatchComplete?.(results.length, total, batchResults);
+  }
+  return results;
+}
+
+// src/server/ai/anthropic.ts
+var AnthropicProvider = class {
+  constructor(config, client) {
+    this.config = config;
+    if (client) {
+      this.client = client;
+    } else {
+      if (!process.env.ANTHROPIC_API_KEY) {
+        throw new Error("ANTHROPIC_API_KEY is not set. AI translation requires it; every other feature works offline.");
+      }
+      this.client = new Anthropic({ baseURL: config.endpoint ?? void 0 });
+    }
+  }
+  config;
+  client;
+  supportsVision() {
+    return true;
+  }
+  translate(reqs, onBatchComplete, signal) {
+    return runBatched(reqs, this.config.batchSize, (batch, sig) => this.callBatch(batch, sig), onBatchComplete, signal);
+  }
+  // Build the user message as content blocks: each unique key's screenshot is
+  // sent once (a key recurs once per target locale in a batch — dedupe by key),
+  // then the batch prompt text describes every item.
+  buildUserContent(batch) {
+    const content = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const req of batch) {
+      if (!req.image || seen.has(req.key)) continue;
+      seen.add(req.key);
+      content.push({ type: "text", text: `Screenshot for key "${req.key}":` });
+      content.push({
+        type: "image",
+        source: { type: "base64", media_type: req.image.mediaType, data: req.image.base64 }
+      });
+    }
+    content.push({ type: "text", text: buildBatchPrompt(batch) });
+    return content;
+  }
+  async complete(req) {
+    const content = req.content.map(
+      (b) => b.type === "image" ? { type: "image", source: { type: "base64", media_type: b.mediaType, data: b.base64 } } : { type: "text", text: b.text ?? "" }
+    );
+    const res = await this.client.messages.create({
+      model: this.config.model,
+      max_tokens: req.maxTokens ?? 8192,
+      system: [{ type: "text", text: req.system, cache_control: { type: "ephemeral" } }],
+      output_config: { format: { type: "json_schema", schema: req.schema } },
+      messages: [{ role: "user", content }]
+    });
+    const text = res.content.find((b) => b.type === "text")?.text ?? "{}";
+    try {
+      return JSON.parse(text);
+    } catch {
+      return {};
+    }
+  }
+  async callBatch(batch, signal) {
+    const content = this.buildUserContent(batch);
+    const res = await this.client.messages.create({
+      model: this.config.model,
+      max_tokens: 8192,
+      system: [{ type: "text", text: buildSystemPrompt(), cache_control: { type: "ephemeral" } }],
+      output_config: { format: { type: "json_schema", schema: BATCH_SCHEMA } },
+      messages: [{ role: "user", content }]
+    }, { signal });
+    const text = res.content.find((b) => b.type === "text")?.text ?? "{}";
+    try {
+      const parsed = JSON.parse(text);
+      return parsed.items ?? [];
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/server/ai/openai.ts
+import { createRequire } from "module";
+var OpenAIProvider = class {
+  constructor(config, client) {
+    this.config = config;
+    if (client) {
+      this.client = client;
+      return;
+    }
+    if (!process.env.OPENAI_API_KEY) {
+      throw new Error("OPENAI_API_KEY is not set. AI translation requires it; every other feature works offline.");
+    }
+    const require2 = createRequire(import.meta.url);
+    let OpenAICtor;
+    try {
+      const mod = require2("openai");
+      OpenAICtor = mod.OpenAI ?? mod.default ?? mod;
+    } catch {
+      throw new Error('Provider "openai" requires the OpenAI SDK. Install it: npm i openai');
+    }
+    this.client = new OpenAICtor({ baseURL: config.endpoint ?? void 0 });
+  }
+  config;
+  client;
+  supportsVision() {
+    return true;
+  }
+  translate(reqs, onBatchComplete, signal) {
+    return runBatched(reqs, this.config.batchSize, (batch, sig) => this.callBatch(batch, sig), onBatchComplete, signal);
+  }
+  // User content as an array of parts: each unique key's screenshot once (as an
+  // image_url data URL), then the batch prompt text describing every item.
+  buildUserContent(batch) {
+    const parts = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const req of batch) {
+      if (!req.image || seen.has(req.key)) continue;
+      seen.add(req.key);
+      parts.push({ type: "text", text: `Screenshot for key "${req.key}":` });
+      parts.push({ type: "image_url", image_url: { url: `data:${req.image.mediaType};base64,${req.image.base64}` } });
+    }
+    parts.push({ type: "text", text: buildBatchPrompt(batch) });
+    return parts;
+  }
+  async complete(req) {
+    const content = req.content.map(
+      (b) => b.type === "image" ? { type: "image_url", image_url: { url: `data:${b.mediaType};base64,${b.base64}` } } : { type: "text", text: b.text ?? "" }
+    );
+    const res = await this.client.chat.completions.create({
+      model: this.config.model,
+      max_tokens: req.maxTokens ?? 8192,
+      response_format: { type: "json_schema", json_schema: { name: "completion", schema: req.schema, strict: false } },
+      messages: [
+        { role: "system", content: req.system },
+        { role: "user", content }
+      ]
+    });
+    const text = res.choices?.[0]?.message?.content ?? "{}";
+    try {
+      return JSON.parse(text);
+    } catch {
+      return {};
+    }
+  }
+  async callBatch(batch, signal) {
+    const res = await this.client.chat.completions.create({
+      model: this.config.model,
+      // strict:false — the shared BATCH_SCHEMA marks only `id` required (each
+      // item carries EITHER translation OR forms), which OpenAI's strict mode
+      // (all properties required) disallows. We validate the reply ourselves
+      // via runBatched, so non-strict schema guidance is sufficient.
+      response_format: { type: "json_schema", json_schema: { name: "translations", schema: BATCH_SCHEMA, strict: false } },
+      messages: [
+        { role: "system", content: buildSystemPrompt() },
+        { role: "user", content: this.buildUserContent(batch) }
+      ]
+    }, { signal });
+    const text = res.choices?.[0]?.message?.content ?? "{}";
+    try {
+      const parsed = JSON.parse(text);
+      return parsed.items ?? [];
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/server/ai/bedrock.ts
+import { createRequire as createRequire2 } from "module";
+var IMAGE_FORMATS = {
+  "image/png": "png",
+  "image/jpeg": "jpeg",
+  "image/webp": "webp",
+  "image/gif": "gif"
+};
+var BedrockProvider = class {
+  constructor(config, deps) {
+    this.config = config;
+    if (deps) {
+      this.client = deps.client;
+      this.makeCommand = deps.makeCommand;
+      return;
+    }
+    const region = config.region ?? process.env.AWS_REGION;
+    if (!region) {
+      throw new Error("AWS region is not set. Set config.ai.region or the AWS_REGION environment variable for the bedrock provider.");
+    }
+    const require2 = createRequire2(import.meta.url);
+    let sdk;
+    try {
+      sdk = require2("@aws-sdk/client-bedrock-runtime");
+    } catch {
+      throw new Error('Provider "bedrock" requires the AWS SDK. Install it: npm i @aws-sdk/client-bedrock-runtime');
+    }
+    this.client = new sdk.BedrockRuntimeClient({ region });
+    this.makeCommand = (input) => new sdk.ConverseCommand(input);
+  }
+  config;
+  client;
+  makeCommand;
+  // Meta Llama text models on Bedrock support neither vision nor reliable
+  // forced tool-use; Nova and Claude support both.
+  isMeta() {
+    return this.config.model.includes("meta.");
+  }
+  supportsVision() {
+    return !this.isMeta();
+  }
+  translate(reqs, onBatchComplete, signal) {
+    return runBatched(reqs, this.config.batchSize, (batch, sig) => this.callBatch(batch, sig), onBatchComplete, signal);
+  }
+  buildContentBlocks(batch) {
+    const blocks = [];
+    if (this.supportsVision()) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const req of batch) {
+        if (!req.image || seen.has(req.key)) continue;
+        const format = IMAGE_FORMATS[req.image.mediaType];
+        if (!format) continue;
+        seen.add(req.key);
+        blocks.push({ text: `Screenshot for key "${req.key}":` });
+        blocks.push({ image: { format, source: { bytes: Buffer.from(req.image.base64, "base64") } } });
+      }
+    }
+    blocks.push({ text: buildBatchPrompt(batch) });
+    return blocks;
+  }
+  async complete(req) {
+    const blocks = req.content.map(
+      (b) => b.type === "image" && this.supportsVision() ? { image: { format: IMAGE_FORMATS[b.mediaType ?? ""] ?? "png", source: { bytes: Buffer.from(b.base64 ?? "", "base64") } } } : { text: b.text ?? "" }
+    );
+    const SCHEMA_NAME = "emit_completion";
+    const input = {
+      modelId: this.config.model,
+      system: [{ text: req.system }],
+      messages: [{ role: "user", content: blocks }],
+      ...this.isMeta() ? {} : {
+        toolConfig: {
+          tools: [{ toolSpec: { name: SCHEMA_NAME, inputSchema: { json: req.schema } } }],
+          toolChoice: { tool: { name: SCHEMA_NAME } }
+        }
+      }
+    };
+    const res = await this.client.send(this.makeCommand(input));
+    const content = res.output?.message?.content ?? [];
+    const tool = content.find((b) => b.toolUse)?.toolUse;
+    if (tool?.input) return tool.input;
+    const text = content.find((b) => b.text)?.text ?? "{}";
+    try {
+      return JSON.parse(text);
+    } catch {
+      return {};
+    }
+  }
+  buildInput(batch) {
+    const input = {
+      modelId: this.config.model,
+      system: [{ text: buildSystemPrompt() }],
+      messages: [{ role: "user", content: this.buildContentBlocks(batch) }]
+    };
+    if (!this.isMeta()) {
+      input.toolConfig = {
+        tools: [{ toolSpec: { name: "emit_translations", inputSchema: { json: BATCH_SCHEMA } } }],
+        toolChoice: { tool: { name: "emit_translations" } }
+      };
+    }
+    return input;
+  }
+  async callBatch(batch, signal) {
+    const res = await this.client.send(this.makeCommand(this.buildInput(batch)), { abortSignal: signal });
+    const blocks = res.output?.message?.content ?? [];
+    const tool = blocks.find((b) => b.toolUse)?.toolUse;
+    if (tool?.input?.items) return tool.input.items;
+    const text = blocks.find((b) => b.text)?.text ?? "{}";
+    try {
+      const parsed = JSON.parse(text);
+      return parsed.items ?? [];
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/server/ai/index.ts
+function makeProvider(config) {
+  const ai = config.ai;
+  switch (ai.provider) {
+    case "anthropic":
+      return new AnthropicProvider(ai);
+    case "openai":
+      return new OpenAIProvider(ai);
+    case "bedrock":
+      return new BedrockProvider(ai);
+    default:
+      throw new Error(`Unknown AI provider "${String(ai.provider)}". Supported: anthropic, openai, bedrock.`);
+  }
+}
+
+// src/server/ai/log.ts
+import { appendFileSync, readFileSync as readFileSync7, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+function logPath(projectRoot) {
+  return resolve4(projectRoot, ".glotfile", "ai-log.jsonl");
+}
+function appendAiLog(projectRoot, entry) {
+  mkdirSync4(resolve4(projectRoot, ".glotfile"), { recursive: true });
+  appendFileSync(logPath(projectRoot), JSON.stringify(entry) + "\n", "utf8");
+}
+function readAiLog(projectRoot, limit = 100) {
+  const path = logPath(projectRoot);
+  if (!existsSync6(path)) return [];
+  const lines = readFileSync7(path, "utf8").split("\n").filter((l) => l.trim() !== "");
+  const entries = lines.map((l) => {
+    const e = JSON.parse(l);
+    e.kind ??= "translate";
+    return e;
+  });
+  return entries.reverse().slice(0, limit);
+}
+
+// src/server/import/detect.ts
+import { existsSync as existsSync7, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join3 } 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"];
+function safeIsDir(p) {
+  try {
+    return statSync2(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function listDirs(dir) {
+  return readdirSync3(dir).filter((e) => safeIsDir(join3(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 = [join3(root, "resources", "lang"), join3(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(join3(localeRoot, loc)));
+  return { format: "laravel-php", localeRoot, locales, sourceLocale };
+}
+function detectVue(root) {
+  for (const rel of VUE_DIR_CANDIDATES) {
+    const localeRoot = join3(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(join3(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 = join3(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;
+}
+var DETECTORS = [detectLaravel, detectVue, detectArb];
+var BY_FORMAT = {
+  "laravel-php": detectLaravel,
+  "vue-i18n-json": detectVue,
+  "flutter-arb": detectArb
+};
+function detect(root, formatOverride) {
+  if (!existsSync7(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;
+}
+
+// src/server/import/parsers/vue-i18n-json.ts
+import { readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
+import { join as join4 } from "path";
+
+// 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") {
+      for (const [k, v] of Object.entries(node)) {
+        walk(v, path ? `${path}.${k}` : k);
+      }
+    } else {
+      warnings.push(`skipped non-string value at "${path || "(root)"}"`);
+    }
+  };
+  walk(value, prefix.replace(/\.$/, ""));
+  return out;
+}
+
+// src/server/import/parsers/vue-i18n-json.ts
+var LOCALE_RE2 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+var vueI18nJson2 = {
+  name: "vue-i18n-json",
+  parse(localeRoot, opts) {
+    const warnings = [];
+    const keys = {};
+    const locales = [];
+    for (const file of readdirSync4(localeRoot).sort()) {
+      if (!file.endsWith(".json")) continue;
+      const locale = file.slice(0, -".json".length);
+      if (!LOCALE_RE2.test(locale)) continue;
+      if (opts?.locales && !opts.locales.includes(locale)) continue;
+      let data;
+      try {
+        data = JSON.parse(readFileSync8(join4(localeRoot, file), "utf8"));
+      } catch (e) {
+        warnings.push(`vue-i18n-json: failed to parse ${file}: ${e.message}`);
+        continue;
+      }
+      if (!locales.includes(locale)) locales.push(locale);
+      for (const [key, value] of Object.entries(flattenObject(data, "", warnings))) {
+        (keys[key] ??= { values: {} }).values[locale] = value;
+      }
+    }
+    return { locales, keys, warnings };
+  }
+};
+
+// src/server/import/parsers/laravel-php.ts
+import { readdirSync as readdirSync5, statSync as statSync3 } from "fs";
+import { join as join5, relative as relative2 } from "path";
+import { execFileSync } from "child_process";
+
+// src/server/import/placeholders.ts
+function laravelToCanonical(value) {
+  return value.replace(/:([a-zA-Z][a-zA-Z0-9_]*)/g, "{$1}");
+}
+
+// src/server/import/parsers/laravel-php.ts
+function listDirs2(dir) {
+  return readdirSync5(dir).filter((e) => statSync3(join5(dir, e)).isDirectory());
+}
+function listPhpFiles(dir) {
+  const out = [];
+  const walk = (d) => {
+    for (const e of readdirSync5(d)) {
+      const full = join5(d, e);
+      if (statSync3(full).isDirectory()) walk(full);
+      else if (e.endsWith(".php")) out.push(full);
+    }
+  };
+  walk(dir);
+  return out.sort();
+}
+var PHP_READ_ALL = '$fs=array_filter(array_map("trim",explode("\\n",stream_get_contents(STDIN))),"strlen");$o=[];foreach($fs as $f){try{$o[$f]=require $f;}catch(\\Throwable $e){}}echo json_encode($o);';
+function readPhpArrays(files) {
+  if (files.length === 0) return {};
+  let stdout;
+  try {
+    stdout = execFileSync("php", ["-r", PHP_READ_ALL], {
+      input: files.join("\n"),
+      encoding: "utf8",
+      maxBuffer: 256 * 1024 * 1024
+    });
+  } catch (e) {
+    const err = e;
+    if (err.code === "ENOENT") {
+      throw new Error("php is required to import Laravel PHP files but was not found on PATH");
+    }
+    throw new Error(`php failed to evaluate Laravel lang files: ${err.message}`);
+  }
+  return JSON.parse(stdout);
+}
+var laravelPhp2 = {
+  name: "laravel-php",
+  parse(localeRoot, opts) {
+    const warnings = [];
+    const keys = {};
+    const locales = [];
+    const entries = [];
+    for (const locale of listDirs2(localeRoot).sort()) {
+      if (locale === "vendor") continue;
+      if (opts?.locales && !opts.locales.includes(locale)) continue;
+      const localeDir = join5(localeRoot, locale);
+      locales.push(locale);
+      for (const file of listPhpFiles(localeDir)) {
+        const group = relative2(localeDir, file).replace(/\\/g, "/").replace(/\.php$/, "");
+        entries.push({ locale, group, file });
+      }
+    }
+    const data = readPhpArrays(entries.map((e) => e.file));
+    for (const { locale, group, file } of entries) {
+      if (!(file in data)) {
+        warnings.push(`laravel-php: failed to read ${file}`);
+        continue;
+      }
+      for (const [inner, value] of Object.entries(flattenObject(data[file], "", warnings))) {
+        const key = `${group}.${inner}`;
+        (keys[key] ??= { values: {} }).values[locale] = laravelToCanonical(value);
+      }
+    }
+    return { locales, keys, warnings };
+  }
+};
+
+// src/server/import/parsers/flutter-arb.ts
+import { readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
+import { join as join6 } from "path";
+var LOCALE_RE3 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+function localeFromArbName(file) {
+  const m = file.match(/^(.+)\.arb$/);
+  if (!m) return null;
+  let locale = m[1];
+  if (locale.startsWith("app_")) locale = locale.slice(4);
+  return LOCALE_RE3.test(locale) ? locale : null;
+}
+function placeholderMeta(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const out = {};
+  for (const [name, def] of Object.entries(raw)) {
+    if (!def || typeof def !== "object") continue;
+    const o = def;
+    const d = {};
+    if (typeof o.type === "string") d.type = o.type;
+    if (typeof o.format === "string") d.format = o.format;
+    if (typeof o.example === "string") d.example = o.example;
+    if (Object.keys(d).length) out[name] = d;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+var flutterArb2 = {
+  name: "flutter-arb",
+  parse(localeRoot, opts) {
+    const warnings = [];
+    const keys = {};
+    const locales = [];
+    for (const file of readdirSync6(localeRoot).sort()) {
+      if (!file.endsWith(".arb")) continue;
+      const locale = localeFromArbName(file);
+      if (!locale) continue;
+      if (opts?.locales && !opts.locales.includes(locale)) continue;
+      let data;
+      try {
+        data = JSON.parse(readFileSync9(join6(localeRoot, file), "utf8"));
+      } catch (e) {
+        warnings.push(`flutter-arb: failed to parse ${file}: ${e.message}`);
+        continue;
+      }
+      if (!locales.includes(locale)) locales.push(locale);
+      for (const [key, value] of Object.entries(data)) {
+        if (key.startsWith("@@")) continue;
+        if (key.startsWith("@")) {
+          const meta = placeholderMeta(value?.placeholders);
+          if (meta) (keys[key.slice(1)] ??= { values: {} }).placeholders = meta;
+          continue;
+        }
+        if (typeof value !== "string") {
+          warnings.push(`flutter-arb: skipped non-string ${file}:${key}`);
+          continue;
+        }
+        (keys[key] ??= { values: {} }).values[locale] = value;
+      }
+    }
+    return { locales, keys, warnings };
+  }
+};
+
+// src/server/import/parsers/index.ts
+var REGISTRY = {
+  [vueI18nJson2.name]: vueI18nJson2,
+  [laravelPhp2.name]: laravelPhp2,
+  [flutterArb2.name]: flutterArb2
+};
+function getParser(name) {
+  const p = REGISTRY[name];
+  if (!p) throw new Error(`Unknown format: ${name} (known: ${Object.keys(REGISTRY).join(", ")})`);
+  return p;
+}
+
+// src/server/import/assemble.ts
+var OUTPUT_BY_FORMAT = {
+  "laravel-php": { adapter: "laravel-php", path: "lang/{locale}/{namespace}.php" },
+  "vue-i18n-json": { adapter: "vue-i18n-json", path: "src/locale/{locale}.json" },
+  "flutter-arb": { adapter: "flutter-arb", path: "lib/l10n/app_{locale}.arb" }
+};
+function assemble2(parsed, opts) {
+  const warnings = [...parsed.warnings];
+  const base = OUTPUT_BY_FORMAT[opts.format];
+  if (!base) throw new Error(`No output mapping for format "${opts.format}"`);
+  const rawLocales = [.../* @__PURE__ */ new Set([opts.sourceLocale, ...parsed.locales])];
+  const pairs = rawLocales.map((obs) => [canonLocale(obs), obs]);
+  const inferred = inferLocaleStyle(pairs, getAdapter(base.adapter).defaultLocaleCase);
+  const output = { ...base, ...inferred };
+  const sourceLocale = canonLocale(opts.sourceLocale);
+  const locales = [...new Set(rawLocales.map(canonLocale))].sort();
+  const keys = {};
+  for (const [key, parsed_key] of Object.entries(parsed.keys)) {
+    const entry = { values: {} };
+    const sourceRaw = parsed_key.values[opts.sourceLocale];
+    const sourcePlural = sourceRaw !== void 0 ? parseIcuPlural(sourceRaw) : null;
+    if (sourcePlural) {
+      entry.plural = { arg: sourcePlural.arg };
+      for (const [locale, value] of Object.entries(parsed_key.values)) {
+        const state = locale === opts.sourceLocale ? "source" : "reviewed";
+        const parsedForms = locale === opts.sourceLocale ? sourcePlural : parseIcuPlural(value);
+        if (parsedForms) {
+          const forms = opts.cldr ? exactFormsToCldr(locale, parsedForms.forms) : parsedForms.forms;
+          entry.values[locale] = { forms, state };
+        } else {
+          entry.values[locale] = { forms: { other: value }, state };
+          warnings.push(
+            `key "${key}" locale "${locale}": value is not a parseable ICU plural; preserved under "other".`
+          );
+        }
+      }
+    } else {
+      for (const [locale, value] of Object.entries(parsed_key.values)) {
+        entry.values[locale] = {
+          value,
+          state: locale === opts.sourceLocale ? "source" : "reviewed"
+        };
+      }
+    }
+    if (!(opts.sourceLocale in entry.values)) {
+      warnings.push(
+        `key "${key}" has no ${opts.sourceLocale} (source) value; its values are marked reviewed without a source.`
+      );
+    }
+    const canonValues = {};
+    for (const [loc, lv] of Object.entries(entry.values)) canonValues[canonLocale(loc)] = lv;
+    entry.values = canonValues;
+    if (parsed_key.placeholders) entry.placeholders = parsed_key.placeholders;
+    keys[key] = entry;
+  }
+  return {
+    $schema: "https://glotfile.dev/schema/v1.json",
+    version: CURRENT_VERSION,
+    config: {
+      sourceLocale,
+      locales,
+      outputs: [output],
+      ai: { provider: "anthropic", model: "claude-opus-4-8", endpoint: null, batchSize: 25 },
+      format: { indent: 2, sortKeys: true, finalNewline: true },
+      spelling: { customWords: [] }
+    },
+    glossary: [],
+    keys,
+    warnings
+  };
+}
+
+// src/server/import/run.ts
+function previewImport(projectRoot, format) {
+  const det = detect(projectRoot, format);
+  if (!det) return null;
+  const parsed = getParser(det.format).parse(det.localeRoot, { locales: [det.sourceLocale] });
+  const keys = Object.keys(parsed.keys);
+  const sampleKeys = [];
+  for (const key of keys) {
+    const value = parsed.keys[key].values[det.sourceLocale];
+    if (typeof value === "string") {
+      sampleKeys.push({ key, value });
+      if (sampleKeys.length >= 5) break;
+    }
+  }
+  return {
+    format: det.format,
+    localeRoot: det.localeRoot,
+    locales: det.locales,
+    sourceLocale: det.sourceLocale,
+    keyCount: keys.length,
+    sampleKeys
+  };
+}
+function runImport(opts) {
+  const det = detect(opts.projectRoot, opts.format);
+  if (!det) throw new Error(`No recognized locale files found in ${opts.projectRoot}`);
+  const parser = getParser(det.format);
+  const parsed = parser.parse(
+    det.localeRoot,
+    opts.locales ? { locales: opts.locales } : void 0
+  );
+  const assembled = assemble2(parsed, {
+    sourceLocale: opts.sourceLocale ?? det.sourceLocale,
+    format: det.format,
+    cldr: opts.cldr
+  });
+  const { warnings, ...rest } = assembled;
+  const state = validate(rest);
+  return {
+    state,
+    warnings,
+    keyCount: Object.keys(state.keys).length,
+    localeCount: state.config.locales.length
+  };
+}
+
+// src/server/export-run.ts
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname4, resolve as resolve5 } from "path";
+function effectiveLocales(config) {
+  const limit = config.exportLocales;
+  if (!limit || limit.length === 0) return config.locales;
+  return config.locales.filter((l) => limit.includes(l));
+}
+function narrowForExport(state) {
+  const locales = effectiveLocales(state.config);
+  if (locales.length === state.config.locales.length) return state;
+  return { ...state, config: { ...state.config, locales } };
+}
+function exportToDisk(state, projectRoot, opts) {
+  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;
+  for (const output of outputs) {
+    const result = getAdapter(output.adapter).export(state, output);
+    warnings.push(...result.warnings);
+    const writtenPaths = /* @__PURE__ */ new Set();
+    for (const f of result.files) {
+      const abs = resolve5(projectRoot, f.path);
+      if (writtenPaths.has(abs)) {
+        skipped++;
+        continue;
+      }
+      writtenPaths.add(abs);
+      let current = null;
+      try {
+        current = readFileSync10(abs, "utf8");
+      } catch {
+      }
+      if (current === f.contents) {
+        skipped++;
+        continue;
+      }
+      mkdirSync5(dirname4(abs), { recursive: true });
+      writeFileSync4(abs, f.contents, "utf8");
+      written++;
+    }
+  }
+  return { written, skipped, warnings };
+}
+
+// src/server/api.ts
+var sanitize = (s) => s.replace(/[^\w.\-]+/g, "_");
+var screenshotDirName = (statePath) => basename(statePath).replace(/\.[^.]+$/, "") + "-screenshots";
+function projectName(root) {
+  const nameFile = resolve6(root, ".idea", ".name");
+  if (existsSync8(nameFile)) {
+    try {
+      const name = readFileSync11(nameFile, "utf8").trim();
+      if (name) return name;
+    } catch {
+    }
+  }
+  return basename(root);
+}
+function createApi(deps) {
+  const app = new Hono();
+  const load = () => loadState(deps.statePath);
+  const projectRoot = dirname5(resolve6(deps.statePath));
+  let translateQueue = Promise.resolve();
+  const withTranslateLock = (fn) => {
+    const next = translateQueue.then(fn, fn);
+    translateQueue = next.then(() => {
+    }, () => {
+    });
+    return next;
+  };
+  let autoExportTimer;
+  const scheduleAutoExport = (s) => {
+    if (!deps.autoExport || s.config.autoExport === false) return;
+    clearTimeout(autoExportTimer);
+    autoExportTimer = setTimeout(() => {
+      try {
+        exportToDisk(s, projectRoot);
+      } catch {
+      }
+    }, 200);
+  };
+  const persist = (s) => {
+    saveState(deps.statePath, s);
+    scheduleAutoExport(s);
+  };
+  app.get("/state", (c) => c.json(load()));
+  app.get("/file", (c) => c.json({ path: deps.statePath, name: basename(deps.statePath), dir: projectRoot, project: basename(projectRoot) }));
+  app.get("/files", (c) => {
+    const found = /* @__PURE__ */ new Map();
+    found.set(deps.statePath, { name: basename(deps.statePath), path: deps.statePath });
+    let entries = [];
+    try {
+      entries = readdirSync7(projectRoot);
+    } catch {
+    }
+    for (const name of entries) {
+      let abs;
+      if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync8(resolve6(projectRoot, name, "config.json"))) {
+        abs = resolve6(projectRoot, `${name}.json`);
+      } else if (name === "glotfile.json" || name.endsWith(".glotfile.json")) {
+        abs = resolve6(projectRoot, name);
+      } else {
+        continue;
+      }
+      if (found.has(abs)) continue;
+      try {
+        loadState(abs);
+        found.set(abs, { name: basename(abs), path: abs });
+      } catch {
+      }
+    }
+    const files = [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
+    return c.json(files);
+  });
+  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 = resolve6(projectRoot, path);
+    const inside = resolved === projectRoot || resolved.startsWith(projectRoot + sep);
+    if (!inside) return c.json({ error: "file is outside the project" }, 400);
+    if (!existsSync8(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) });
+  });
+  app.post("/keys", async (c) => {
+    const { key, value, plural } = await c.req.json();
+    if (typeof key !== "string" || !key.trim()) return c.json({ error: "key is required" }, 400);
+    if (typeof value !== "string" || !value.trim()) return c.json({ error: "source value is required" }, 400);
+    if (plural !== void 0 && (typeof plural?.arg !== "string" || !plural.arg.trim())) {
+      return c.json({ error: "plural.arg must be a non-empty string" }, 400);
+    }
+    const s = load();
+    createKey(s, key, value, void 0, plural ? { plural: { arg: plural.arg } } : {});
+    persist(s);
+    console.log(`[key] created ${key}`);
+    return c.json({ ok: true });
+  });
+  app.post("/dictionary", async (c) => {
+    const { word } = await c.req.json();
+    if (typeof word !== "string" || !word.trim()) return c.json({ error: "word is required" }, 400);
+    const s = load();
+    addCustomWord(s, word);
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.delete("/dictionary/:word", (c) => {
+    const s = load();
+    removeCustomWord(s, c.req.param("word"));
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.patch("/keys/:key", async (c) => {
+    const key = c.req.param("key");
+    const body = await c.req.json();
+    const s = load();
+    if (typeof body.rename === "string") renameKey(s, key, body.rename);
+    const target = typeof body.rename === "string" ? body.rename : key;
+    if (body.metadata) setMetadata(s, target, body.metadata);
+    if (typeof body.source === "string") setSourceValue(s, target, body.source);
+    if (typeof body.pluralArg === "string" && body.pluralArg.trim()) setPluralArg(s, target, body.pluralArg.trim());
+    persist(s);
+    if (typeof body.rename === "string") console.log(`[key] renamed ${key} \u2192 ${body.rename}`);
+    return c.json({ ok: true });
+  });
+  function removeOrphanScreenshot(s, screenshot) {
+    if (!screenshot) return;
+    for (const e of Object.values(s.keys)) if (e.screenshot === screenshot) return;
+    const root = dirname5(resolve6(deps.statePath));
+    const abs = resolve6(root, screenshot);
+    const rel = relative3(root, abs);
+    const seg0 = rel.split(sep)[0] ?? "";
+    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync8(abs)) {
+      try {
+        rmSync3(abs);
+      } catch {
+      }
+    }
+  }
+  app.delete("/keys/:key", (c) => {
+    const s = load();
+    const key = c.req.param("key");
+    const shot = s.keys[key]?.screenshot;
+    deleteKey(s, key);
+    removeOrphanScreenshot(s, shot);
+    persist(s);
+    console.log(`[key] deleted ${key}`);
+    return c.json({ ok: true });
+  });
+  app.post("/keys/bulk-clear", async (c) => {
+    const { keys, locales } = await c.req.json();
+    if (!Array.isArray(keys) || keys.length === 0) return c.json({ error: "keys must be a non-empty array" }, 400);
+    if (!Array.isArray(locales)) return c.json({ error: "locales must be an array" }, 400);
+    const s = load();
+    const known = new Set(s.config.locales);
+    for (const l of locales) if (!known.has(l)) return c.json({ error: `Unknown locale: ${l}` }, 400);
+    let cleared = 0;
+    for (const key of keys) {
+      const entry = s.keys[key];
+      if (!entry) continue;
+      for (const locale of locales) {
+        if (locale === s.config.sourceLocale) continue;
+        if (entry.values[locale]) {
+          clearValue(s, key, locale);
+          cleared++;
+        }
+      }
+    }
+    persist(s);
+    console.log(`[bulk] cleared ${cleared} value(s)`);
+    return c.json({ cleared });
+  });
+  app.post("/keys/bulk-delete", async (c) => {
+    const { keys } = await c.req.json();
+    if (!Array.isArray(keys) || keys.length === 0) return c.json({ error: "keys must be a non-empty array" }, 400);
+    const s = load();
+    const removed = [];
+    const shots = [];
+    for (const key of keys) {
+      if (!s.keys[key]) continue;
+      shots.push(s.keys[key].screenshot);
+      deleteKey(s, key);
+      removed.push(key);
+    }
+    for (const shot of shots) removeOrphanScreenshot(s, shot);
+    persist(s);
+    console.log(`[bulk] deleted ${removed.length} key(s)`);
+    return c.json({ removed });
+  });
+  app.post("/keys/bulk-meta", async (c) => {
+    const { keys, addTags, removeTags, skipTranslate } = await c.req.json();
+    if (!Array.isArray(keys) || keys.length === 0) return c.json({ error: "keys must be a non-empty array" }, 400);
+    const s = load();
+    let updated = 0;
+    for (const key of keys) {
+      const entry = s.keys[key];
+      if (!entry) continue;
+      if (Array.isArray(addTags) || Array.isArray(removeTags)) {
+        const tags = new Set(entry.tags ?? []);
+        for (const t of addTags ?? []) if (typeof t === "string" && t.trim()) tags.add(t.trim());
+        for (const t of removeTags ?? []) tags.delete(t);
+        if (tags.size) setMetadata(s, key, { tags: [...tags].sort() });
+        else delete entry.tags;
+      }
+      if (typeof skipTranslate === "boolean") {
+        if (skipTranslate) setMetadata(s, key, { skipTranslate: true });
+        else delete entry.skipTranslate;
+      }
+      updated++;
+    }
+    persist(s);
+    console.log(`[bulk] updated metadata on ${updated} key(s)`);
+    return c.json({ updated });
+  });
+  app.post("/keys/bulk-state", async (c) => {
+    const { keys, locales, state: next } = await c.req.json();
+    if (!Array.isArray(keys) || keys.length === 0) return c.json({ error: "keys must be a non-empty array" }, 400);
+    if (!Array.isArray(locales)) return c.json({ error: "locales must be an array" }, 400);
+    if (next !== "reviewed" && next !== "needs-review") return c.json({ error: "state must be reviewed or needs-review" }, 400);
+    const s = load();
+    const known = new Set(s.config.locales);
+    for (const l of locales) if (!known.has(l)) return c.json({ error: `Unknown locale: ${l}` }, 400);
+    let updated = 0;
+    for (const key of keys) {
+      const entry = s.keys[key];
+      if (!entry) continue;
+      for (const locale of locales) {
+        if (locale === s.config.sourceLocale) continue;
+        if (!entry.values[locale]) continue;
+        setKeyState(s, key, locale, next);
+        updated++;
+      }
+    }
+    persist(s);
+    console.log(`[bulk] set state ${next} on ${updated} value(s)`);
+    return c.json({ updated });
+  });
+  app.put("/keys/:key/values/:locale", async (c) => {
+    const { value } = await c.req.json();
+    if (typeof value !== "string") return c.json({ error: "value must be a string" }, 400);
+    const s = load();
+    const key = c.req.param("key");
+    const locale = c.req.param("locale");
+    if (locale === s.config.sourceLocale) setSourceValue(s, key, value);
+    else setTargetValue(s, key, locale, value);
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.delete("/keys/:key/values/:locale", (c) => {
+    const s = load();
+    clearValue(s, c.req.param("key"), c.req.param("locale"));
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.put("/keys/:key/plural/:locale", async (c) => {
+    const { forms } = await c.req.json();
+    if (!forms || typeof forms !== "object") return c.json({ error: "forms object is required" }, 400);
+    const s = load();
+    const key = c.req.param("key");
+    const locale = c.req.param("locale");
+    if (locale === s.config.sourceLocale) setSourcePluralForms(s, key, forms);
+    else setPluralForms(s, key, locale, forms);
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.post("/keys/:key/plural", async (c) => {
+    const { arg } = await c.req.json();
+    if (typeof arg !== "string" || !arg.trim()) return c.json({ error: "arg is required" }, 400);
+    const s = load();
+    convertToPlural(s, c.req.param("key"), arg);
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.delete("/keys/:key/plural", (c) => {
+    const s = load();
+    convertToScalar(s, c.req.param("key"));
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.put("/keys/:key/values/:locale/state", async (c) => {
+    const { state } = await c.req.json();
+    const s = load();
+    setKeyState(s, c.req.param("key"), c.req.param("locale"), state);
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.post("/keys/:key/notes", async (c) => {
+    const { text } = await c.req.json();
+    if (typeof text !== "string" || !text.trim()) return c.json({ error: "note text is required" }, 400);
+    const s = load();
+    const note = addNote(s, c.req.param("key"), text);
+    persist(s);
+    return c.json(note);
+  });
+  app.put("/keys/:key/notes/:id", async (c) => {
+    const { text } = await c.req.json();
+    if (typeof text !== "string" || !text.trim()) return c.json({ error: "note text is required" }, 400);
+    const s = load();
+    editNote(s, c.req.param("key"), c.req.param("id"), text);
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.delete("/keys/:key/notes/:id", (c) => {
+    const s = load();
+    deleteNote(s, c.req.param("key"), c.req.param("id"));
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.put("/config", async (c) => {
+    const newConfig = await c.req.json();
+    if (!newConfig || !Array.isArray(newConfig.locales)) {
+      return c.json({ error: "config.locales must be an array" }, 400);
+    }
+    const s = load();
+    const removed = s.config.locales.filter((l) => !newConfig.locales.includes(l));
+    for (const l of removed) {
+      for (const e of Object.values(s.keys)) delete e.values[l];
+    }
+    s.config = newConfig;
+    validate(s);
+    persist(s);
+    console.log(`[config] saved \u2014 ${newConfig.locales.length} locale(s), model ${newConfig.ai.model}`);
+    return c.json({ ok: true });
+  });
+  app.get("/glossary", (c) => c.json(load().glossary));
+  app.put("/glossary", async (c) => {
+    const entry = await c.req.json();
+    if (typeof entry?.term !== "string") return c.json({ error: "term must be a string" }, 400);
+    const s = load();
+    upsertGlossaryEntry(s, entry);
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.delete("/glossary/:term", (c) => {
+    const s = load();
+    deleteGlossaryEntry(s, decodeURIComponent(c.req.param("term")));
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.post("/keys/:key/screenshot", async (c) => {
+    const key = c.req.param("key");
+    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 = dirname5(resolve6(deps.statePath));
+    const dirName = screenshotDirName(deps.statePath);
+    const dir = resolve6(root, dirName);
+    mkdirSync6(dir, { recursive: true });
+    const filename = `${sanitize(key)}__${sanitize(file.name)}`;
+    writeFileSync5(resolve6(dir, filename), Buffer.from(await file.arrayBuffer()));
+    const path = `${dirName}/${filename}`;
+    const s = load();
+    const prev = s.keys[key]?.screenshot;
+    setMetadata(s, key, { screenshot: path });
+    if (prev && prev !== path) removeOrphanScreenshot(s, prev);
+    persist(s);
+    return c.json({ path });
+  });
+  app.delete("/keys/:key/screenshot", (c) => {
+    const s = load();
+    const key = c.req.param("key");
+    const shot = s.keys[key]?.screenshot;
+    setMetadata(s, key, { screenshot: void 0 });
+    removeOrphanScreenshot(s, shot);
+    persist(s);
+    return c.json({ ok: true });
+  });
+  app.get("/export/preview", (c) => {
+    const s = narrowForExport(load());
+    const files = [];
+    const warnings = [];
+    for (const output of s.config.outputs) {
+      const result = getAdapter(output.adapter).export(s, output);
+      files.push(...result.files);
+      warnings.push(...result.warnings);
+    }
+    return c.json({ files, warnings });
+  });
+  app.get("/scan/missing", (c) => c.json(findMissing(load())));
+  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;
+    return c.json(runChecks(load(), { only }));
+  });
+  app.get("/stats", (c) => c.json(computeStats(load())));
+  app.get("/import/detect", (c) => {
+    const preview = previewImport(projectRoot);
+    if (!preview) return c.json({ found: false });
+    return c.json({ found: true, ...preview });
+  });
+  app.post("/import", async (c) => {
+    const state = load();
+    if (Object.keys(state.keys).length > 0) {
+      return c.json({ error: "cannot import into a non-empty project" }, 400);
+    }
+    const body = await c.req.json();
+    let result;
+    try {
+      result = runImport({
+        projectRoot,
+        format: body.format,
+        sourceLocale: body.sourceLocale,
+        locales: body.locales,
+        cldr: body.cldr
+      });
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+    persist(result.state);
+    console.log(`[import] ${result.keyCount} key(s) across ${result.localeCount} locale(s)${result.warnings.length ? `, ${result.warnings.length} warning(s)` : ""}`);
+    return c.json({ keyCount: result.keyCount, localeCount: result.localeCount, warnings: result.warnings });
+  });
+  app.post("/export", (c) => {
+    const s = narrowForExport(load());
+    const root = dirname5(resolve6(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 = resolve6(root, f.path);
+        mkdirSync6(dirname5(abs), { recursive: true });
+        writeFileSync5(abs, f.contents, "utf8");
+        count++;
+      }
+    }
+    console.log(`[export] ${count} file(s)${warnings.length ? `, ${warnings.length} warning(s)` : ""}`);
+    return c.json({ files: count, warnings });
+  });
+  app.post("/translate/stream", async (c) => {
+    const signal = c.req.raw.signal;
+    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;
+    return streamSSE(c, (stream) => withTranslateLock(async () => {
+      const s = load();
+      const reqs = selectRequests(s, { onlyMissing: true, keys, locales });
+      if (!reqs.length) {
+        await stream.writeSSE({ event: "done", data: JSON.stringify({ written: 0, errors: [] }) });
+        return;
+      }
+      let provider;
+      try {
+        provider = deps.makeProvider ? deps.makeProvider(s) : makeProvider(s.config);
+      } catch (e) {
+        await stream.writeSSE({ event: "error", data: JSON.stringify({ error: e.message }) });
+        return;
+      }
+      const { skipped } = attachScreenshotsForProvider(reqs, s, projectRoot, provider.supportsVision());
+      if (skipped) console.warn(`Model "${s.config.ai.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
+      console.log(`[translate] ${reqs.length} string(s) \u2192 ${s.config.ai.model}`);
+      let totalWritten = 0;
+      const allErrors = [];
+      const system = buildSystemPrompt();
+      const reqById = new Map(reqs.map((r) => [r.id, r]));
+      await runLocaleParallel(reqs, provider, (done, total, batchResults) => {
+        const { written, errors } = applyResults(s, reqs, batchResults);
+        persist(s);
+        totalWritten += written;
+        allErrors.push(...errors);
+        appendAiLog(projectRoot, {
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "translate",
+          model: s.config.ai.model,
+          system,
+          items: batchResults.map((r) => {
+            const req = reqById.get(r.id);
+            return { id: r.id, key: req?.key ?? "", source: req?.source ?? "", targetLocale: req?.targetLocale, context: req?.context, glossary: req?.glossary, screenshot: req ? s.keys[req.key]?.screenshot : void 0 };
+          }),
+          results: batchResults
+        });
+        console.log(`[translate] ${done}/${total}`);
+        void stream.writeSSE({
+          event: "progress",
+          data: JSON.stringify({ done, total, written: totalWritten, errors })
+        });
+      }, void 0, signal);
+      if (!signal?.aborted) {
+        console.log(`[translate] done \u2014 wrote ${totalWritten}, ${allErrors.length} error(s)`);
+        await stream.writeSSE({ event: "done", data: JSON.stringify({ written: totalWritten, errors: allErrors }) });
+      } else {
+        console.log(`[translate] cancelled \u2014 wrote ${totalWritten} so far`);
+      }
+    }));
+  });
+  app.post("/translate", (c) => withTranslateLock(async () => {
+    const body = await c.req.json().catch(() => ({}));
+    const s = load();
+    const reqs = selectRequests(s, {
+      onlyMissing: body.onlyMissing ?? true,
+      locales: body.locales,
+      keyGlob: body.keyGlob
+    });
+    const force = body.force === true;
+    const toTranslate = [...reqs];
+    let written = 0;
+    let errors = [];
+    if (toTranslate.length) {
+      let provider;
+      try {
+        provider = deps.makeProvider ? deps.makeProvider(s) : makeProvider(s.config);
+      } catch (e) {
+        return c.json({ error: e.message }, 400);
+      }
+      const { skipped } = attachScreenshotsForProvider(toTranslate, s, projectRoot, provider.supportsVision());
+      if (skipped) console.warn(`Model "${s.config.ai.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
+      const results = await runLocaleParallel(toTranslate, provider);
+      ({ written, errors } = applyResults(s, toTranslate, results, void 0, force));
+      const entry = {
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        model: s.config.ai.model,
+        system: buildSystemPrompt(),
+        // Log the screenshot PATH only — never the image bytes.
+        items: toTranslate.map((r) => ({
+          id: r.id,
+          key: r.key,
+          source: r.source,
+          targetLocale: r.targetLocale,
+          context: r.context,
+          glossary: r.glossary,
+          screenshot: s.keys[r.key]?.screenshot
+        })),
+        results
+      };
+      appendAiLog(projectRoot, entry);
+    }
+    persist(s);
+    return c.json({ requested: reqs.length, written, errors });
+  }));
+  app.get("/ai-log", (c) => c.json(readAiLog(projectRoot, 100)));
+  app.post("/scan", async (c) => {
+    const s = load();
+    const existing = loadUsageCache(projectRoot);
+    const result = runScan(projectRoot, s.config.scan ?? {}, existing);
+    const fileCount2 = Object.keys(result.files).length;
+    const refCount = Object.values(result.files).reduce((n, f) => n + f.refs.length, 0);
+    console.log(`[scan] ${fileCount2} file(s), ${refCount} reference(s)`);
+    return c.json({ files: fileCount2, refs: refCount, scannedAt: result.scannedAt });
+  });
+  app.get("/scan", (c) => {
+    const cache2 = loadUsageCache(projectRoot);
+    if (!cache2) return c.json({ indexed: false, files: 0, refs: 0 });
+    const files = Object.keys(cache2.files).length;
+    const refs = Object.values(cache2.files).reduce((n, f) => n + f.refs.length, 0);
+    return c.json({ indexed: true, scannedAt: cache2.scannedAt, files, refs });
+  });
+  app.get("/scan/usage", (c) => {
+    const key = c.req.query("key") ?? "";
+    const cache2 = loadUsageCache(projectRoot);
+    if (!cache2) return c.json({ indexed: false, count: 0, refs: [], prefixCount: 0, prefixRefs: [] });
+    const refs = [];
+    const prefixRefs = [];
+    for (const [file, entry] of Object.entries(cache2.files)) {
+      const abs = resolve6(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 });
+      }
+      for (const p of entry.prefixes) {
+        if (key.startsWith(p.prefix)) {
+          prefixRefs.push({ file, abs, line: p.line, col: p.col, scanner: p.scanner, prefix: p.prefix });
+        }
+      }
+    }
+    const byFileLine = (a, b) => a.file.localeCompare(b.file) || a.line - b.line;
+    refs.sort(byFileLine);
+    prefixRefs.sort(byFileLine);
+    return c.json({
+      indexed: true,
+      scannedAt: cache2.scannedAt,
+      project: projectName(projectRoot),
+      count: refs.length,
+      refs,
+      prefixCount: prefixRefs.length,
+      prefixRefs
+    });
+  });
+  app.get("/scan/used", (c) => {
+    const cache2 = loadUsageCache(projectRoot);
+    if (!cache2) return c.json({ indexed: false, used: [] });
+    return c.json({ indexed: true, scannedAt: cache2.scannedAt, used: computeUsedKeys(load(), cache2) });
+  });
+  app.post("/context/build", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const s = load();
+    const cache2 = loadUsageCache(projectRoot);
+    if (!cache2) return c.json({ error: "No usage index found. Run 'glotfile scan' first." }, 400);
+    const targets = selectContextTargets(s, {
+      all: body.all,
+      keyGlob: body.keyGlob,
+      limit: body.limit,
+      since: body.since,
+      keys: body.keys
+    }, cache2, body.lastRunAt);
+    if (!targets.length) return c.json({ requested: 0, written: 0, errors: [] });
+    let provider;
+    try {
+      provider = deps.makeProvider ? deps.makeProvider(s) : makeProvider(s.config);
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+    const fileCache = /* @__PURE__ */ new Map();
+    for (const target of targets) {
+      const allRefs = Object.entries(cache2.files).flatMap(
+        ([file, entry]) => entry.refs.filter((r) => r.key === target.key).map((r) => ({
+          key: r.key,
+          file,
+          line: r.line,
+          col: r.col,
+          scanner: r.scanner
+        }))
+      );
+      target.usageSnippets = extractSnippets(allRefs, projectRoot, fileCache);
+    }
+    const system = buildContextSystemPrompt();
+    const prompt = buildContextBatchPrompt(targets);
+    const raw = await provider.complete({ system, content: [{ type: "text", text: prompt }], schema: CONTEXT_BATCH_SCHEMA });
+    const batch = raw;
+    const { written, errors } = applyContext(s, targets, batch.items ?? []);
+    appendAiLog(projectRoot, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "context",
+      model: s.config.ai.model,
+      system,
+      items: targets.map((t) => ({ id: t.id, key: t.key, source: t.source })),
+      results: (batch.items ?? []).map((r) => ({ id: r.id, value: r.context, error: r.error }))
+    });
+    persist(s);
+    console.log(`[context] ${written} context(s) written${errors.length ? `, ${errors.length} error(s)` : ""}`);
+    return c.json({ requested: targets.length, written, errors });
+  });
+  app.onError(
+    (err, c) => c.json({ error: err.message }, err instanceof GlotfileError ? 400 : 500)
+  );
+  return app;
+}
+
+// src/server/server.ts
+var here = dirname6(fileURLToPath(import.meta.url));
+var DEFAULT_UI_DIR = join7(here, "..", "ui");
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff"
+};
+async function readFileResponse(absPath) {
+  try {
+    const s = await stat(absPath);
+    if (!s.isFile()) return null;
+    const body = await readFile(absPath);
+    const type = MIME[extname3(absPath).toLowerCase()] ?? "application/octet-stream";
+    return new Response(new Uint8Array(body), { headers: { "content-type": type } });
+  } catch {
+    return null;
+  }
+}
+function buildApp(opts) {
+  const app = new Hono2();
+  app.route("/api", createApi({ statePath: opts.statePath, autoExport: true }));
+  const projectRoot = dirname6(resolve7(opts.statePath));
+  app.get("/:dir/*", async (c, next) => {
+    const dirSeg = c.req.param("dir");
+    if (!dirSeg.endsWith("-screenshots")) return next();
+    const shotsRoot = resolve7(projectRoot, dirSeg);
+    const pathname = decodeURIComponent(new URL(c.req.url).pathname);
+    const rest = pathname.slice(`/${dirSeg}`.length);
+    const target = resolve7(shotsRoot, "." + rest);
+    const inside = target === shotsRoot || target.startsWith(shotsRoot + sep2);
+    if (inside) {
+      const file = await readFileResponse(target);
+      if (file) return file;
+    }
+    return c.notFound();
+  });
+  if (!opts.dev) {
+    const root = resolve7(opts.uiDir ?? DEFAULT_UI_DIR);
+    app.get("/*", async (c) => {
+      const pathname = decodeURIComponent(new URL(c.req.url).pathname);
+      const target = resolve7(root, "." + pathname);
+      const inside = target === root || target.startsWith(root + sep2);
+      if (inside && pathname !== "/") {
+        const file = await readFileResponse(target);
+        if (file) return file;
+      }
+      const index = await readFileResponse(join7(root, "index.html"));
+      if (index) return index;
+      return c.notFound();
+    });
+  }
+  return app;
+}
+function startServer(opts) {
+  const app = buildApp(opts);
+  return new Promise((resolveP) => {
+    const port = opts.dev ? 8787 : 0;
+    const server = serve({ fetch: app.fetch, hostname: "127.0.0.1", port }, (info) => {
+      const url = `http://127.0.0.1:${info.port}`;
+      if (opts.open !== false && !opts.dev) void open(url);
+      resolveP({ url, close: () => server.close() });
+      backgroundScan(opts.statePath);
+    });
+  });
+}
+function backgroundScan(statePath) {
+  const projectRoot = dirname6(resolve7(statePath));
+  Promise.resolve().then(() => {
+    const state = loadState(statePath);
+    const existing = loadUsageCache(projectRoot);
+    const result = runScan(projectRoot, state.config.scan ?? {}, existing);
+    const fileCount2 = Object.keys(result.files).length;
+    const refCount = Object.values(result.files).reduce((n, f) => n + f.refs.length, 0);
+    console.log(`[scan] ${fileCount2} file(s), ${refCount} reference(s)`);
+  }).catch((err) => {
+    console.warn("[scan] failed:", err instanceof Error ? err.message : String(err));
+  });
+}
+export {
+  buildApp,
+  startServer
+};