glotfile 0.5.3 → 0.6.0

package/dist/server/cli.js

@@ -122,6 +122,7 @@ function validate(raw) {
     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.skipSourceLocale !== void 0 && typeof o.skipSourceLocale !== "boolean") fail("config.outputs[].skipSourceLocale 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)) {
@@ -1574,27 +1575,41 @@ var init_vue_i18n_json = __esm({
 function xmlEscape2(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function renderInterpolations(text, ids) {
+function attrEscape(s) {
+  return xmlEscape2(s).replace(/"/g, "&quot;");
+}
+function angularXMeta(placeholders, name) {
+  return /^[A-Z][A-Z0-9_]*$/.test(name) ? placeholders?.[name] : void 0;
+}
+function renderInterpolations(text, ids, placeholders) {
   let out = "";
   let last = 0;
   for (const m of text.matchAll(/\{(\w+)\}/g)) {
     const name = m[1];
-    let id = ids.get(name);
-    if (id === void 0) {
-      id = ids.size === 0 ? "INTERPOLATION" : `INTERPOLATION_${ids.size}`;
-      ids.set(name, id);
+    out += xmlEscape2(text.slice(last, m.index));
+    const meta = angularXMeta(placeholders, name);
+    if (meta) {
+      const ctype = meta.type ? ` ctype="${attrEscape(meta.type)}"` : "";
+      const equiv = meta.example !== void 0 ? ` equiv-text="${attrEscape(meta.example)}"` : "";
+      out += `<x id="${attrEscape(name)}"${ctype}${equiv}/>`;
+    } else {
+      let id = ids.get(name);
+      if (id === void 0) {
+        id = ids.size === 0 ? "INTERPOLATION" : `INTERPOLATION_${ids.size}`;
+        ids.set(name, id);
+      }
+      out += `<x id="${id}" equiv-text="{{${name}}}"/>`;
     }
-    out += xmlEscape2(text.slice(last, m.index)) + `<x id="${id}" equiv-text="{{${name}}}"/>`;
     last = m.index + m[0].length;
   }
   return out + xmlEscape2(text.slice(last));
 }
-function renderPluralIcu(forms, ids) {
+function renderPluralIcu(forms, ids, placeholders) {
   const cats = [
     ...Object.keys(forms).filter((c) => c.startsWith("=")),
     ...PLURAL_CATEGORIES.filter((c) => forms[c] !== void 0)
   ];
-  const branches = cats.map((cat) => `${cat} {${renderInterpolations(forms[cat] ?? "", ids)}}`);
+  const branches = cats.map((cat) => `${cat} {${renderInterpolations(forms[cat] ?? "", ids, placeholders)}}`);
   return `{VAR_PLURAL, plural, ${branches.join(" ")}}`;
 }
 function renderEmbeddedIcu(value) {
@@ -1604,8 +1619,8 @@ function renderEmbeddedIcu(value) {
   );
   return xmlEscape2(renamed);
 }
-function renderScalar(value, ids) {
-  return isIcuPluralOrSelect(value) ? renderEmbeddedIcu(value) : renderInterpolations(value, ids);
+function renderScalar(value, ids, placeholders) {
+  return isIcuPluralOrSelect(value) ? renderEmbeddedIcu(value) : renderInterpolations(value, ids, placeholders);
 }
 var DEFAULT_LOCALE_CASE8, angularXliff;
 var init_angular_xliff = __esm({
@@ -1636,6 +1651,7 @@ var init_angular_xliff = __esm({
         const emptyAs = resolveEmptyAs(output, "source");
         const keys = Object.keys(state.keys).sort();
         for (const locale of state.config.locales) {
+          if (output.skipSourceLocale && locale === sourceLocale) continue;
           const token = resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE8);
           const units = [];
           for (const key of keys) {
@@ -1646,17 +1662,18 @@ var init_angular_xliff = __esm({
             if (entry.plural) {
               const targetForms = resolveForms(entry, locale, sourceLocale, emptyAs);
               if (targetForms === null) continue;
-              source = renderPluralIcu(entry.values[sourceLocale]?.forms ?? {}, ids);
-              target = renderPluralIcu(targetForms, ids);
+              source = renderPluralIcu(entry.values[sourceLocale]?.forms ?? {}, ids, entry.placeholders);
+              target = renderPluralIcu(targetForms, ids, entry.placeholders);
             } else {
               const targetValue = resolveScalar(entry, locale, sourceLocale, emptyAs);
               if (targetValue === null) continue;
-              source = renderScalar(entry.values[sourceLocale]?.value ?? "", ids);
-              target = renderScalar(targetValue, ids);
+              source = renderScalar(entry.values[sourceLocale]?.value ?? "", ids, entry.placeholders);
+              target = renderScalar(targetValue, ids, entry.placeholders);
             }
+            const translated = locale === sourceLocale || (entry.plural ? entry.values[locale]?.forms !== void 0 : !!entry.values[locale]?.value);
             units.push(`      <trans-unit id="${xmlEscape2(key)}" datatype="html">`);
             units.push(`        <source>${source}</source>`);
-            units.push(`        <target>${target}</target>`);
+            units.push(`        <target${translated ? "" : ' state="new"'}>${target}</target>`);
             if (entry.description) {
               units.push(`        <note priority="1" from="description">${xmlEscape2(entry.description)}</note>`);
             }
@@ -2744,6 +2761,46 @@ var init_local_settings = __esm({
   }
 });
 
+// src/server/glossary.ts
+function contains(haystack, needle, caseSensitive) {
+  return caseSensitive ? haystack.includes(needle) : haystack.toLowerCase().includes(needle.toLowerCase());
+}
+function relevantGlossary(source, targetLocale, glossary) {
+  const hints = [];
+  for (const entry of glossary) {
+    if (!contains(source, entry.term, entry.caseSensitive)) continue;
+    hints.push({
+      term: entry.term,
+      doNotTranslate: entry.doNotTranslate,
+      forced: entry.translations?.[targetLocale],
+      notes: entry.notes
+    });
+  }
+  return hints;
+}
+function glossaryViolations(source, value, targetLocale, glossary) {
+  const out = [];
+  for (const entry of glossary) {
+    if (!contains(source, entry.term, entry.caseSensitive)) continue;
+    if (entry.doNotTranslate) {
+      if (!contains(value, entry.term, entry.caseSensitive)) {
+        out.push({ term: entry.term, expected: entry.term, kind: "do-not-translate" });
+      }
+      continue;
+    }
+    const forced = entry.translations?.[targetLocale];
+    if (forced && !contains(value, forced, entry.caseSensitive)) {
+      out.push({ term: entry.term, expected: forced, kind: "forced" });
+    }
+  }
+  return out;
+}
+var init_glossary = __esm({
+  "src/server/glossary.ts"() {
+    "use strict";
+  }
+});
+
 // src/server/glob.ts
 function globToRegExp(glob) {
   const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
@@ -2815,21 +2872,6 @@ function selectRequests(state, opts) {
   }
   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;
-}
 function attachScreenshots(reqs, state, projectRoot) {
   const cache2 = /* @__PURE__ */ new Map();
   for (const req of reqs) {
@@ -2936,6 +2978,7 @@ var MEDIA_TYPES, MAX_IMAGE_BYTES, DEFAULT_LOCALE_CONCURRENCY;
 var init_run = __esm({
   "src/server/ai/run.ts"() {
     "use strict";
+    init_glossary();
     init_placeholders();
     init_plurals();
     init_state();
@@ -3113,7 +3156,7 @@ function findMissing(state) {
     const entry = state.keys[key];
     if (entry.skipTranslate) continue;
     for (const locale of targets) {
-      const v = entry.plural ? entry.values[locale]?.forms?.other?.trim() : entry.values[locale]?.value;
+      const v = entry.plural ? entry.values[locale]?.forms?.other?.trim() : entry.values[locale]?.value?.trim();
       if (!v) out.push({ key, locale });
     }
   }
@@ -3581,24 +3624,83 @@ var init_context = __esm({
   }
 });
 
-// src/server/lint/spelling.ts
-function tokenize(text) {
-  return text.match(new RegExp("\\p{L}[\\p{L}'']*", "gu")) ?? [];
+// src/server/spell.ts
+function spellTokens(value) {
+  return value.replace(ICU_BLOCK, " ").replace(MASK, " ").match(WORD) ?? [];
 }
-function buildAllowWords(glossary, dictionary2 = []) {
+function ignoreWordsFor(glossary, customWords = []) {
   const set = /* @__PURE__ */ new Set();
-  const add = (s) => {
-    for (const w of tokenize(s)) set.add(w.toLowerCase());
+  const add = (text) => {
+    for (const w of text.match(WORD) ?? []) set.add(w.toLowerCase());
   };
-  for (const g of glossary) add(g.term);
-  for (const w of dictionary2) add(w);
+  for (const e of glossary) {
+    add(e.term);
+    for (const t of Object.values(e.translations ?? {})) add(t);
+  }
+  for (const w of customWords) add(w);
   return set;
 }
+async function getSpeller(dictId) {
+  const key = norm(dictId);
+  const existing = instances.get(key);
+  if (existing) return existing;
+  if (unavailable.has(key)) return null;
+  try {
+    const nspellMod = await import("nspell");
+    const nspell = nspellMod.default ?? nspellMod;
+    const dictMod = await import(`dictionary-${key}`);
+    const dictExport = dictMod.default ?? dictMod;
+    const dict = typeof dictExport === "function" ? await dictExport() : dictExport;
+    const speller = nspell(dict);
+    instances.set(key, speller);
+    return speller;
+  } catch {
+    unavailable.add(key);
+    return null;
+  } finally {
+    loading.delete(key);
+  }
+}
+function spellValue(dictId, value, ignore) {
+  const key = norm(dictId);
+  if (unavailable.has(key)) return [];
+  const spell = instances.get(key);
+  if (!spell) {
+    if (!loading.has(key)) {
+      loading.add(key);
+      void getSpeller(key);
+    }
+    return null;
+  }
+  const cacheKey = key + " " + value;
+  let allBad = cache.get(cacheKey);
+  if (!allBad) {
+    allBad = spellTokens(value).filter((w) => !spell.correct(w));
+    cache.set(cacheKey, allBad);
+  }
+  return allBad.filter((w) => !ignore.has(w.toLowerCase()));
+}
+var instances, loading, unavailable, cache, norm, ICU_BLOCK, MASK, WORD;
+var init_spell = __esm({
+  "src/server/spell.ts"() {
+    "use strict";
+    instances = /* @__PURE__ */ new Map();
+    loading = /* @__PURE__ */ new Set();
+    unavailable = /* @__PURE__ */ new Set();
+    cache = /* @__PURE__ */ new Map();
+    norm = (dictId) => dictId.toLowerCase();
+    ICU_BLOCK = /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g;
+    MASK = /\{[^}]*\}|<[^>]*>|:\w+|%[sd]/g;
+    WORD = new RegExp("\\p{L}[\\p{L}''\u2019-]*", "gu");
+  }
+});
+
+// src/server/lint/spelling.ts
 var spellingRule, defaultLoader;
 var init_spelling = __esm({
   "src/server/lint/spelling.ts"() {
     "use strict";
-    init_placeholders();
+    init_spell();
     spellingRule = {
       id: "spelling",
       run(state, ctx) {
@@ -3610,10 +3712,8 @@ var init_spelling = __esm({
             if (!speller) continue;
             const value = entry.values[locale]?.value;
             if (!value) continue;
-            const placeholders = new Set(extractPlaceholders(value).map((p) => p.toLowerCase()));
-            for (const word of tokenize(value)) {
-              const lower = word.toLowerCase();
-              if (placeholders.has(lower) || ctx.allowWords.has(lower)) continue;
+            for (const word of spellTokens(value)) {
+              if (ctx.allowWords.has(word.toLowerCase())) continue;
               if (!speller.correct(word)) {
                 out.push({ ruleId: "spelling", key, locale, message: `possible misspelling: "${word}"` });
               }
@@ -3623,18 +3723,7 @@ var init_spelling = __esm({
         return out;
       }
     };
-    defaultLoader = async (dictId) => {
-      try {
-        const nspellMod = await import("nspell");
-        const nspell2 = nspellMod.default ?? nspellMod;
-        const dictMod = await import(`dictionary-${dictId.toLowerCase()}`);
-        const dictExport = dictMod.default ?? dictMod;
-        const dict = typeof dictExport === "function" ? await dictExport() : dictExport;
-        return nspell2(dict);
-      } catch {
-        return null;
-      }
-    };
+    defaultLoader = (dictId) => getSpeller(dictId);
   }
 });
 
@@ -3645,7 +3734,7 @@ var init_rules = __esm({
     "use strict";
     init_scan();
     init_placeholders();
-    init_run();
+    init_glossary();
     init_spelling();
     emptySourceRule = {
       id: "empty-source",
@@ -3661,17 +3750,14 @@ var init_rules = __esm({
     };
     emptyTranslationRule = {
       id: "empty-translation",
-      run(state, ctx) {
+      // findMissing is the shared "untranslated" walk (also behind the editor's
+      // untranslated check and /scan/missing); a whitespace-only value counts as
+      // missing there, so no separate whitespace pass is needed.
+      run(state) {
         const out = [];
         for (const m of findMissing(state)) {
           out.push({ ruleId: "empty-translation", key: m.key, locale: m.locale, message: "translation is empty or missing" });
         }
-        for (const key of Object.keys(state.keys)) {
-          for (const locale of ctx.targetLocales) {
-            const v = state.keys[key].values[locale]?.value;
-            if (v && !v.trim()) out.push({ ruleId: "empty-translation", key, locale, message: "translation is whitespace-only" });
-          }
-        }
         return out;
       }
     };
@@ -3799,13 +3885,13 @@ var init_rules = __esm({
           for (const locale of ctx.targetLocales) {
             const v = entry.values[locale]?.value;
             if (!v) continue;
-            for (const hint of relevantGlossary(src, locale, ctx.glossary)) {
-              if (hint.doNotTranslate && !v.includes(hint.term)) {
-                out.push({ ruleId: "glossary-violation", key, locale, message: `do-not-translate term "${hint.term}" is missing or altered` });
-              }
-              if (hint.forced && !v.includes(hint.forced)) {
-                out.push({ ruleId: "glossary-violation", key, locale, message: `expected glossary translation "${hint.forced}" for "${hint.term}"` });
-              }
+            for (const viol of glossaryViolations(src, v, locale, ctx.glossary)) {
+              out.push({
+                ruleId: "glossary-violation",
+                key,
+                locale,
+                message: viol.kind === "do-not-translate" ? `do-not-translate term "${viol.term}" is missing or altered` : `expected glossary translation "${viol.expected}" for "${viol.term}"`
+              });
             }
           }
         }
@@ -3866,7 +3952,7 @@ async function runLint(state, options = {}) {
   const active = rules.filter(isActive);
   const spellingOn = active.some((r) => r.id === "spelling");
   const spellers = spellingOn ? await loadSpellers(targetLocales, config, load, warn) : /* @__PURE__ */ new Map();
-  const allowWords = spellingOn ? buildAllowWords(state.glossary, state.config.spelling?.customWords) : /* @__PURE__ */ new Set();
+  const allowWords = spellingOn ? ignoreWordsFor(state.glossary, state.config.spelling?.customWords) : /* @__PURE__ */ new Set();
   const ctx = {
     config,
     sourceLocale: state.config.sourceLocale,
@@ -3904,6 +3990,7 @@ var init_run2 = __esm({
     init_registry();
     init_rules();
     init_spelling();
+    init_spell();
     init_suppress();
   }
 });
@@ -3962,7 +4049,7 @@ var init_accept = __esm({
 });
 
 // src/server/import/detect.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
 import { join as join4 } from "path";
 function safeIsDir(p) {
   try {
@@ -4049,6 +4136,110 @@ function detectApple(root) {
   }
   return best;
 }
+function detectAngularXliff(root) {
+  for (const rel of ANGULAR_DIR_CANDIDATES) {
+    const localeRoot = rel === "." ? root : join4(root, rel);
+    if (!safeIsDir(localeRoot)) continue;
+    const files = readdirSync4(localeRoot).filter((f) => /^messages(\..+)?\.xlf$/.test(f)).sort();
+    if (files.length === 0) continue;
+    const locales = files.map((f) => f.match(/^messages\.(.+)\.xlf$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l));
+    const attrFile = files.includes("messages.xlf") ? "messages.xlf" : files[0];
+    let sourceLocale;
+    try {
+      sourceLocale = readFileSync11(join4(localeRoot, attrFile), "utf8").match(/source-language="([^"]+)"/)?.[1];
+    } catch {
+    }
+    if (!sourceLocale && locales.length === 0) continue;
+    sourceLocale ??= pickSource(locales, () => 0);
+    if (!locales.includes(sourceLocale)) locales.unshift(sourceLocale);
+    return { format: "angular-xliff", localeRoot, locales, sourceLocale };
+  }
+  return null;
+}
+function detectRails(root) {
+  const localeRoot = join4(root, "config", "locales");
+  if (!safeIsDir(localeRoot)) return null;
+  const locales = [];
+  for (const file of readdirSync4(localeRoot).sort()) {
+    if (!/\.ya?ml$/.test(file)) continue;
+    let text;
+    try {
+      text = readFileSync11(join4(localeRoot, file), "utf8");
+    } catch {
+      continue;
+    }
+    for (const m of text.matchAll(/^(["']?)([A-Za-z][\w-]*)\1:\s*(?:#.*)?$/gm)) {
+      const token = m[2];
+      if (LOCALE_RE.test(token) && !locales.includes(token)) locales.push(token);
+    }
+  }
+  if (locales.length === 0) return null;
+  return { format: "rails-yaml", localeRoot, locales, sourceLocale: pickSource(locales, () => 0) };
+}
+function detectI18next(root) {
+  for (const rel of I18NEXT_DIR_CANDIDATES) {
+    const localeRoot = join4(root, rel);
+    if (!safeIsDir(localeRoot)) continue;
+    const locales = listDirs(localeRoot).filter(
+      (d) => LOCALE_RE.test(d) && readdirSync4(join4(localeRoot, d)).some((f) => f.endsWith(".json"))
+    );
+    if (locales.length === 0) continue;
+    const sourceLocale = pickSource(locales, (loc) => {
+      try {
+        return readdirSync4(join4(localeRoot, loc)).filter((f) => f.endsWith(".json")).reduce((sum, f) => sum + statSync3(join4(localeRoot, loc, f)).size, 0);
+      } catch {
+        return 0;
+      }
+    });
+    return { format: "i18next-json", localeRoot, locales, sourceLocale };
+  }
+  return null;
+}
+function gettextLocales(dir) {
+  const locales = [];
+  for (const entry of readdirSync4(dir).sort()) {
+    const flat = entry.match(/^(.+)\.po$/)?.[1];
+    if (flat && LOCALE_RE.test(flat)) {
+      if (!locales.includes(flat)) locales.push(flat);
+      continue;
+    }
+    if (!LOCALE_RE.test(entry) || !safeIsDir(join4(dir, entry))) continue;
+    const sub = join4(dir, entry);
+    const hasPo = (d) => {
+      try {
+        return readdirSync4(d).some((f) => f.endsWith(".po"));
+      } catch {
+        return false;
+      }
+    };
+    if (hasPo(join4(sub, "LC_MESSAGES")) || hasPo(sub)) {
+      if (!locales.includes(entry)) locales.push(entry);
+    }
+  }
+  return locales;
+}
+function detectGettext(root) {
+  for (const rel of GETTEXT_DIR_CANDIDATES) {
+    const localeRoot = join4(root, rel);
+    if (!safeIsDir(localeRoot)) continue;
+    const locales = gettextLocales(localeRoot);
+    if (locales.length === 0) continue;
+    return { format: "gettext-po", localeRoot, locales, sourceLocale: pickSource(locales, () => 0) };
+  }
+  return null;
+}
+function detectAppleStringsdict(root) {
+  const candidates = [root, ...listDirs(root).map((d) => join4(root, d))];
+  let best = null;
+  for (const dir of candidates) {
+    const locales = listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync10(join4(dir, `${l}.lproj`, "Localizable.stringsdict")));
+    if (locales.length === 0) continue;
+    if (!best || locales.length > best.locales.length) {
+      best = { format: "apple-stringsdict", localeRoot: dir, locales, sourceLocale: pickSource(locales, () => 0) };
+    }
+  }
+  return best;
+}
 function detect(root, formatOverride) {
   if (!existsSync10(root)) return null;
   if (formatOverride) {
@@ -4062,18 +4253,36 @@ function detect(root, formatOverride) {
   }
   return null;
 }
-var LOCALE_RE, VUE_DIR_CANDIDATES, DETECTORS, BY_FORMAT;
+var LOCALE_RE, VUE_DIR_CANDIDATES, ANGULAR_DIR_CANDIDATES, I18NEXT_DIR_CANDIDATES, GETTEXT_DIR_CANDIDATES, DETECTORS, BY_FORMAT;
 var init_detect = __esm({
   "src/server/import/detect.ts"() {
     "use strict";
     LOCALE_RE = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
     VUE_DIR_CANDIDATES = ["src/locale", "src/locales", "src/i18n/locales", "locales", "lang"];
-    DETECTORS = [detectLaravel, detectVue, detectArb, detectApple];
+    ANGULAR_DIR_CANDIDATES = [".", "src/locale", "src/locales", "src/i18n", "locale", "locales", "i18n", "translations"];
+    I18NEXT_DIR_CANDIDATES = ["public/locales", "static/locales", "locales", "src/locales", "src/i18n/locales"];
+    GETTEXT_DIR_CANDIDATES = ["locale", "locales", "po", "translations"];
+    DETECTORS = [
+      detectLaravel,
+      detectVue,
+      detectArb,
+      detectApple,
+      detectAngularXliff,
+      detectRails,
+      detectI18next,
+      detectGettext,
+      detectAppleStringsdict
+    ];
     BY_FORMAT = {
       "laravel-php": detectLaravel,
       "vue-i18n-json": (root) => detectVue(root, true),
       "flutter-arb": detectArb,
-      "apple-strings": detectApple
+      "apple-strings": detectApple,
+      "angular-xliff": detectAngularXliff,
+      "rails-yaml": detectRails,
+      "i18next-json": detectI18next,
+      "gettext-po": detectGettext,
+      "apple-stringsdict": detectAppleStringsdict
     };
   }
 });
@@ -4106,7 +4315,7 @@ var init_flatten = __esm({
 });
 
 // src/server/import/parsers/vue-i18n-json.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync11 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
 import { join as join5 } from "path";
 var LOCALE_RE2, vueI18nJson2;
 var init_vue_i18n_json2 = __esm({
@@ -4127,7 +4336,7 @@ var init_vue_i18n_json2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync11(join5(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync12(join5(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`vue-i18n-json: failed to parse ${file}: ${e.message}`);
             continue;
@@ -4232,7 +4441,7 @@ var init_laravel_php2 = __esm({
 });
 
 // src/server/import/parsers/flutter-arb.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync12 } from "fs";
+import { readdirSync as readdirSync7, readFileSync as readFileSync13 } from "fs";
 import { join as join7 } from "path";
 function localeFromArbName(file) {
   const m = file.match(/^(.+)\.arb$/);
@@ -4273,7 +4482,7 @@ var init_flutter_arb2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync12(join7(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync13(join7(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`flutter-arb: failed to parse ${file}: ${e.message}`);
             continue;
@@ -4300,7 +4509,7 @@ var init_flutter_arb2 = __esm({
 });
 
 // src/server/import/parsers/apple-strings.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync13, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync14, statSync as statSync5 } from "fs";
 import { join as join8 } from "path";
 function localeFromLproj(dir) {
   const m = dir.match(/^(.+)\.lproj$/);
@@ -4413,7 +4622,7 @@ var init_apple_strings2 = __esm({
           let text;
           try {
             if (!statSync5(file).isFile()) continue;
-            text = readFileSync13(file, "utf8");
+            text = readFileSync14(file, "utf8");
           } catch {
             continue;
           }
@@ -4432,6 +4641,773 @@ var init_apple_strings2 = __esm({
   }
 });
 
+// src/server/import/parsers/angular-xliff.ts
+import { readdirSync as readdirSync9, readFileSync as readFileSync15 } from "fs";
+import { join as join9 } from "path";
+function decodeEntities(s) {
+  return s.replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d))).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function parseAttrs(s) {
+  const out = {};
+  for (const m of s.matchAll(/([\w-]+)="([^"]*)"/g)) out[m[1]] = decodeEntities(m[2]);
+  return out;
+}
+function decodeInline(raw, addMeta) {
+  let out = "";
+  let last = 0;
+  for (const m of raw.matchAll(/<x\b([^>]*?)\/>/g)) {
+    out += decodeEntities(raw.slice(last, m.index));
+    const attrs = parseAttrs(m[1]);
+    const id = attrs["id"] ?? "X";
+    const equiv = attrs["equiv-text"];
+    const simple = equiv?.match(/^\{\{\s*(\w+)\s*\}\}$/);
+    if (simple) {
+      out += `{${simple[1]}}`;
+    } else {
+      out += `{${id}}`;
+      const meta = {};
+      if (attrs["ctype"]) meta.type = attrs["ctype"];
+      if (equiv !== void 0) meta.example = equiv;
+      addMeta(id, meta);
+    }
+    last = m.index + m[0].length;
+  }
+  return out + decodeEntities(raw.slice(last));
+}
+var LOCALE_RE5, FILE_RE, angularXliff2;
+var init_angular_xliff2 = __esm({
+  "src/server/import/parsers/angular-xliff.ts"() {
+    "use strict";
+    LOCALE_RE5 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+    FILE_RE = /^messages(?:\.(.+))?\.xlf$/;
+    angularXliff2 = {
+      name: "angular-xliff",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        const seen = (loc) => {
+          if (!locales.includes(loc)) locales.push(loc);
+        };
+        const files = readdirSync9(localeRoot).filter((f) => FILE_RE.test(f)).sort((a, b) => (a === "messages.xlf" ? -1 : 0) - (b === "messages.xlf" ? -1 : 0) || a.localeCompare(b));
+        for (const file of files) {
+          const fnameLocale = file.match(FILE_RE)[1];
+          if (fnameLocale !== void 0 && !LOCALE_RE5.test(fnameLocale)) continue;
+          let xml;
+          try {
+            xml = readFileSync15(join9(localeRoot, file), "utf8");
+          } catch (e) {
+            warnings.push(`angular-xliff: failed to read ${file}: ${e.message}`);
+            continue;
+          }
+          const sourceLocale = xml.match(/source-language="([^"]+)"/)?.[1];
+          if (!sourceLocale) {
+            warnings.push(`angular-xliff: ${file} has no source-language attribute; skipped`);
+            continue;
+          }
+          const targetLocale = xml.match(/target-language="([^"]+)"/)?.[1] ?? fnameLocale;
+          if (opts?.locales && !opts.locales.includes(targetLocale ?? sourceLocale)) continue;
+          for (const unit of xml.matchAll(/<trans-unit\b([^>]*)>([\s\S]*?)<\/trans-unit>/g)) {
+            const id = parseAttrs(unit[1])["id"];
+            if (!id) {
+              warnings.push(`angular-xliff: ${file} has a trans-unit without an id; skipped`);
+              continue;
+            }
+            const body = unit[2];
+            const src = body.match(/<source\b[^>]*>([\s\S]*?)<\/source>/);
+            let tgt = body.match(/<target\b([^>]*)>([\s\S]*?)<\/target>/);
+            if (tgt && /\bstate="new"/.test(tgt[1])) tgt = null;
+            const entry = keys[id] ??= { values: {} };
+            const addMeta = (name, meta) => {
+              (entry.placeholders ??= {})[name] ??= meta;
+            };
+            if (src && entry.values[sourceLocale] === void 0) {
+              entry.values[sourceLocale] = decodeInline(src[1], addMeta);
+              seen(sourceLocale);
+            }
+            if (tgt && tgt[2] !== "" && targetLocale !== void 0) {
+              entry.values[targetLocale] = decodeInline(tgt[2], addMeta);
+              seen(targetLocale);
+            }
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
+// src/server/import/parsers/gettext-po.ts
+import { readdirSync as readdirSync10, readFileSync as readFileSync16 } from "fs";
+import { join as join10 } from "path";
+function unescapePo(s) {
+  return s.replace(
+    /\\([\\"ntr])/g,
+    (_, c) => c === "n" ? "\n" : c === "t" ? "	" : c === "r" ? "\r" : c
+  );
+}
+function parseEntries(text) {
+  const entries = [];
+  let cur = null;
+  let append = null;
+  const flush = () => {
+    if (cur && cur.msgid !== void 0) entries.push(cur);
+    cur = null;
+    append = null;
+  };
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") {
+      flush();
+      continue;
+    }
+    if (line.startsWith("#")) continue;
+    const m = line.match(DIRECTIVE_RE);
+    if (m) {
+      const kw = m[1];
+      const idx = m[2];
+      const body = unescapePo(m[3]);
+      if (cur && (kw === "msgctxt" || kw === "msgid" && cur.msgid !== void 0)) flush();
+      cur ??= { plurals: /* @__PURE__ */ new Map() };
+      const entry = cur;
+      if (kw === "msgctxt") {
+        entry.msgctxt = body;
+        append = (c) => {
+          entry.msgctxt = (entry.msgctxt ?? "") + c;
+        };
+      } else if (kw === "msgid") {
+        entry.msgid = body;
+        append = (c) => {
+          entry.msgid = (entry.msgid ?? "") + c;
+        };
+      } else if (kw === "msgid_plural") {
+        entry.msgidPlural = body;
+        append = (c) => {
+          entry.msgidPlural = (entry.msgidPlural ?? "") + c;
+        };
+      } else if (idx !== void 0) {
+        const i = Number(idx);
+        entry.plurals.set(i, body);
+        append = (c) => {
+          entry.plurals.set(i, (entry.plurals.get(i) ?? "") + c);
+        };
+      } else {
+        entry.msgstr = body;
+        append = (c) => {
+          entry.msgstr = (entry.msgstr ?? "") + c;
+        };
+      }
+      continue;
+    }
+    const cont = line.match(CONT_RE);
+    if (cont && append) append(unescapePo(cont[1]));
+  }
+  flush();
+  return entries;
+}
+function discoverPoFiles(root) {
+  const found = [];
+  const entries = readdirSync10(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const e of entries) {
+    if (e.isFile() && e.name.endsWith(".po")) {
+      const base = e.name.slice(0, -3);
+      found.push({ path: join10(root, e.name), rel: e.name, locale: LOCALE_RE6.test(base) ? base : null });
+    } else if (e.isDirectory() && LOCALE_RE6.test(e.name)) {
+      for (const sub of [join10(e.name, "LC_MESSAGES"), e.name]) {
+        let names;
+        try {
+          names = readdirSync10(join10(root, sub)).sort();
+        } catch {
+          continue;
+        }
+        for (const f of names) {
+          if (f.endsWith(".po")) found.push({ path: join10(root, sub, f), rel: join10(sub, f), locale: e.name });
+        }
+      }
+    }
+  }
+  return found;
+}
+var LOCALE_RE6, DIRECTIVE_RE, CONT_RE, gettextPo2;
+var init_gettext_po2 = __esm({
+  "src/server/import/parsers/gettext-po.ts"() {
+    "use strict";
+    init_plurals();
+    LOCALE_RE6 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+    DIRECTIVE_RE = /^(msgctxt|msgid_plural|msgid|msgstr)(?:\[(\d+)\])?[ \t]+"(.*)"\s*$/;
+    CONT_RE = /^[ \t]*"(.*)"\s*$/;
+    gettextPo2 = {
+      name: "gettext-po",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        for (const file of discoverPoFiles(localeRoot)) {
+          let entries;
+          try {
+            entries = parseEntries(readFileSync16(file.path, "utf8"));
+          } catch (e) {
+            warnings.push(`gettext-po: failed to parse ${file.rel}: ${e.message}`);
+            continue;
+          }
+          const header = entries.find((e) => e.msgid === "" && e.msgctxt === void 0);
+          const headerLang = header?.msgstr?.match(/^Language:[ \t]*([A-Za-z0-9_-]+)/m)?.[1];
+          const locale = file.locale ?? headerLang;
+          if (!locale) {
+            warnings.push(`gettext-po: cannot determine locale for ${file.rel}; skipped`);
+            continue;
+          }
+          if (opts?.locales && !opts.locales.includes(locale)) continue;
+          if (!locales.includes(locale)) locales.push(locale);
+          const cats = categoriesFor(locale);
+          for (const entry of entries) {
+            if (entry === header) continue;
+            const key = entry.msgctxt ?? entry.msgid;
+            if (!key) continue;
+            if (entry.msgidPlural !== void 0) {
+              const forms = {};
+              for (const [i, body] of [...entry.plurals].sort((a, b) => a[0] - b[0])) {
+                if (body === "") continue;
+                const cat = cats[i];
+                if (!cat) {
+                  warnings.push(
+                    `gettext-po: ${file.rel} "${key}": msgstr[${i}] exceeds the ${cats.length} plural forms of "${locale}"; ignored`
+                  );
+                  continue;
+                }
+                forms[cat] = body.split("%d").join("{count}");
+              }
+              if (!forms.other) continue;
+              (keys[key] ??= { values: {} }).values[locale] = formsToIcu("count", forms);
+            } else {
+              if (!entry.msgstr) continue;
+              (keys[key] ??= { values: {} }).values[locale] = entry.msgstr;
+            }
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
+// src/server/import/parsers/i18next-json.ts
+import { readdirSync as readdirSync11, readFileSync as readFileSync17, statSync as statSync6 } from "fs";
+import { join as join11 } from "path";
+function safeIsDir2(p) {
+  try {
+    return statSync6(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function fromI18next(value) {
+  if (isIcuPluralOrSelect(value)) return value;
+  return value.replace(/\{\{(\w+)\}\}/g, "{$1}");
+}
+function ingestFile(path, label, prefix, locale, keys, warnings) {
+  let data;
+  try {
+    data = JSON.parse(readFileSync17(path, "utf8"));
+  } catch (e) {
+    warnings.push(`i18next-json: failed to parse ${label}: ${e.message}`);
+    return false;
+  }
+  const fileWarnings = [];
+  const flat = flattenObject(data, "", fileWarnings);
+  for (const w of fileWarnings) warnings.push(`i18next-json: ${label}: ${w}`);
+  const families = /* @__PURE__ */ new Set();
+  for (const [k, v] of Object.entries(flat)) {
+    const m = PLURAL_SUFFIX_RE.exec(k);
+    if (m && m[2] === "other" && v !== "") families.add(m[1]);
+  }
+  const pluralForms = {};
+  for (const [k, raw] of Object.entries(flat)) {
+    if (raw === "") continue;
+    const value = fromI18next(raw);
+    const m = PLURAL_SUFFIX_RE.exec(k);
+    if (m && families.has(m[1])) {
+      (pluralForms[m[1]] ??= {})[m[2]] = value;
+      continue;
+    }
+    if (families.has(k)) {
+      warnings.push(
+        `i18next-json: ${label}: key "${k}" collides with its own plural suffix family; the plural wins`
+      );
+      continue;
+    }
+    (keys[prefix + k] ??= { values: {} }).values[locale] = value;
+  }
+  for (const [base, forms] of Object.entries(pluralForms)) {
+    (keys[prefix + base] ??= { values: {} }).values[locale] = formsToIcu(PLURAL_ARG, forms);
+  }
+  return true;
+}
+var LOCALE_RE7, PLURAL_SUFFIX_RE, PLURAL_ARG, DEFAULT_NAMESPACE, i18nextJson2;
+var init_i18next_json2 = __esm({
+  "src/server/import/parsers/i18next-json.ts"() {
+    "use strict";
+    init_flatten();
+    init_plurals();
+    init_placeholders();
+    LOCALE_RE7 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+    PLURAL_SUFFIX_RE = /^(.+)_(zero|one|two|few|many|other)$/;
+    PLURAL_ARG = "count";
+    DEFAULT_NAMESPACE = "translation";
+    i18nextJson2 = {
+      name: "i18next-json",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        for (const entry of readdirSync11(localeRoot).sort()) {
+          const full = join11(localeRoot, entry);
+          if (safeIsDir2(full)) {
+            if (!LOCALE_RE7.test(entry)) continue;
+            if (opts?.locales && !opts.locales.includes(entry)) continue;
+            let any = false;
+            for (const file of readdirSync11(full).sort()) {
+              if (!file.endsWith(".json")) continue;
+              const ns = file.slice(0, -".json".length);
+              const prefix = ns === DEFAULT_NAMESPACE ? "" : `${ns}.`;
+              if (ingestFile(join11(full, file), `${entry}/${file}`, prefix, entry, keys, warnings)) any = true;
+            }
+            if (any && !locales.includes(entry)) locales.push(entry);
+          } else if (entry.endsWith(".json")) {
+            const locale = entry.slice(0, -".json".length);
+            if (!LOCALE_RE7.test(locale)) continue;
+            if (opts?.locales && !opts.locales.includes(locale)) continue;
+            if (ingestFile(full, entry, "", locale, keys, warnings) && !locales.includes(locale)) {
+              locales.push(locale);
+            }
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
+// src/server/import/parsers/rails-yaml.ts
+import { readdirSync as readdirSync12, readFileSync as readFileSync18 } from "fs";
+import { join as join12 } from "path";
+function fromRuby(value) {
+  return value.replace(/%\{(\w+)\}/g, "{$1}");
+}
+function makeNode() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function decodeDouble(body) {
+  let out = "";
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c !== "\\") {
+      out += c;
+      continue;
+    }
+    const n = body[++i];
+    if (n === void 0) break;
+    out += n === "n" ? "\n" : n === "r" ? "\r" : n === "t" ? "	" : n;
+  }
+  return out;
+}
+function scanQuoted(s, start) {
+  const q = s[start];
+  if (q === '"') {
+    for (let i = start + 1; i < s.length; i++) {
+      if (s[i] === "\\") i++;
+      else if (s[i] === '"') return { text: decodeDouble(s.slice(start + 1, i)), end: i + 1 };
+    }
+    return null;
+  }
+  let out = "";
+  for (let i = start + 1; i < s.length; i++) {
+    if (s[i] === "'") {
+      if (s[i + 1] === "'") {
+        out += "'";
+        i++;
+      } else {
+        return { text: out, end: i + 1 };
+      }
+    } else {
+      out += s[i];
+    }
+  }
+  return null;
+}
+function stripPlainComment(s) {
+  const m = /(^|\s)#/.exec(s);
+  return (m && m.index >= 0 ? s.slice(0, m.index) : s).trim();
+}
+function onlyTrailing(s) {
+  return /^\s*(#.*)?$/.test(s);
+}
+function parseYamlSubset(text, file, warnings) {
+  const roots = {};
+  const lines = text.split(/\r?\n/);
+  let stack = [];
+  let skipDeeperThan = null;
+  let lastLeafIndent = null;
+  for (let n = 0; n < lines.length; n++) {
+    const raw = lines[n];
+    const lineNo = n + 1;
+    if (raw.trim() === "" || raw.trim().startsWith("#")) continue;
+    if (raw.trim() === "---") continue;
+    const indentMatch = /^[ \t]*/.exec(raw)[0];
+    if (indentMatch.includes("	")) {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: tab in indentation; line skipped`);
+      continue;
+    }
+    const indent = indentMatch.length;
+    if (skipDeeperThan !== null) {
+      if (indent > skipDeeperThan) continue;
+      skipDeeperThan = null;
+    }
+    const content = raw.slice(indent);
+    if (content.startsWith("- ") || content === "-") {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: sequences are not supported; node skipped`);
+      skipDeeperThan = indent;
+      continue;
+    }
+    let key;
+    let rest;
+    if (content[0] === '"' || content[0] === "'") {
+      const k = scanQuoted(content, 0);
+      if (!k || content[k.end] !== ":") {
+        warnings.push(`rails-yaml: ${file}:${lineNo}: unparseable quoted key; line skipped`);
+        skipDeeperThan = indent;
+        continue;
+      }
+      key = k.text;
+      rest = content.slice(k.end + 1);
+    } else {
+      const m = /^(.*?):(?=\s|$)/.exec(content);
+      if (!m) {
+        warnings.push(`rails-yaml: ${file}:${lineNo}: not a "key: value" mapping line; line skipped`);
+        skipDeeperThan = indent;
+        continue;
+      }
+      key = m[1].trim();
+      rest = content.slice(m[0].length);
+    }
+    if (lastLeafIndent !== null && indent > lastLeafIndent) {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: unexpected indentation under a scalar; line skipped`);
+      skipDeeperThan = indent - 1;
+      continue;
+    }
+    while (stack.length > 0 && stack[stack.length - 1].indent >= indent) stack.pop();
+    const trimmed = rest.trim();
+    let value;
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      value = null;
+    } else if (trimmed[0] === "&" || trimmed[0] === "*") {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: YAML anchors/aliases are not supported; node skipped`);
+      skipDeeperThan = indent;
+      continue;
+    } else if (trimmed[0] === "|" || trimmed[0] === ">") {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: block scalars are not supported; node skipped`);
+      skipDeeperThan = indent;
+      continue;
+    } else if (trimmed[0] === "[" || trimmed[0] === "{") {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: flow collections are not supported; node skipped`);
+      skipDeeperThan = indent;
+      continue;
+    } else if (trimmed[0] === '"' || trimmed[0] === "'") {
+      const v = scanQuoted(trimmed, 0);
+      if (!v || !onlyTrailing(trimmed.slice(v.end))) {
+        warnings.push(`rails-yaml: ${file}:${lineNo}: unterminated or trailing-garbage quoted value; line skipped`);
+        continue;
+      }
+      value = v.text;
+    } else {
+      value = stripPlainComment(trimmed);
+    }
+    if (stack.length === 0) {
+      if (value !== null) {
+        warnings.push(`rails-yaml: ${file}:${lineNo}: top-level key "${key}" has a scalar value; skipped`);
+        lastLeafIndent = indent;
+        continue;
+      }
+      const root = roots[key] ??= makeNode();
+      stack = [{ indent, node: root }];
+      lastLeafIndent = null;
+      continue;
+    }
+    const parent = stack[stack.length - 1].node;
+    if (key in parent) {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: duplicate key "${key}"; later value wins`);
+    }
+    if (value === null) {
+      const child = makeNode();
+      parent[key] = child;
+      stack.push({ indent, node: child });
+      lastLeafIndent = null;
+    } else {
+      parent[key] = value;
+      lastLeafIndent = indent;
+    }
+  }
+  return { roots };
+}
+function asPluralForms(node) {
+  const entries = Object.entries(node);
+  if (entries.length === 0) return null;
+  const forms = {};
+  for (const [k, v] of entries) {
+    if (!CATEGORY_SET.has(k) || typeof v !== "string") return null;
+    if (v !== "") forms[k] = v;
+  }
+  if (!("other" in forms)) return null;
+  return forms;
+}
+function synthesizeIcu(forms, file, key, warnings) {
+  const parts = [];
+  for (const cat of PLURAL_CATEGORIES) {
+    const body = forms[cat];
+    if (body === void 0) continue;
+    if (body.includes("#")) {
+      warnings.push(
+        `rails-yaml: ${file}: plural "${key}" form "${cat}" contains "#", which ICU reads as the count placeholder`
+      );
+    }
+    parts.push(`${cat} {${fromRuby(body)}}`);
+  }
+  return `{count, plural, ${parts.join(" ")}}`;
+}
+var LOCALE_RE8, CATEGORY_SET, railsYaml2;
+var init_rails_yaml2 = __esm({
+  "src/server/import/parsers/rails-yaml.ts"() {
+    "use strict";
+    init_schema();
+    LOCALE_RE8 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/i;
+    CATEGORY_SET = new Set(PLURAL_CATEGORIES);
+    railsYaml2 = {
+      name: "rails-yaml",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        const wanted = opts?.locales?.map((l) => l.toLowerCase());
+        const addValue = (key, locale, value) => {
+          (keys[key] ??= { values: {} }).values[locale] = value;
+        };
+        const flatten = (node, prefix, locale, file) => {
+          for (const [k, v] of Object.entries(node)) {
+            const key = prefix ? `${prefix}.${k}` : k;
+            if (typeof v === "string") {
+              if (v !== "") addValue(key, locale, fromRuby(v));
+              continue;
+            }
+            const forms = asPluralForms(v);
+            if (forms) addValue(key, locale, synthesizeIcu(forms, file, key, warnings));
+            else flatten(v, key, locale, file);
+          }
+        };
+        for (const file of readdirSync12(localeRoot).sort()) {
+          if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
+          let text;
+          try {
+            text = readFileSync18(join12(localeRoot, file), "utf8");
+          } catch (e) {
+            warnings.push(`rails-yaml: failed to read ${file}: ${e.message}`);
+            continue;
+          }
+          const { roots } = parseYamlSubset(text, file, warnings);
+          for (const token of Object.keys(roots).sort()) {
+            if (!LOCALE_RE8.test(token)) {
+              warnings.push(`rails-yaml: ${file}: top-level key "${token}" is not a locale; subtree skipped`);
+              continue;
+            }
+            if (wanted && !wanted.includes(token.toLowerCase())) continue;
+            if (!locales.includes(token)) locales.push(token);
+            flatten(roots[token], "", token, file);
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
+// src/server/import/parsers/apple-stringsdict.ts
+import { readdirSync as readdirSync13, readFileSync as readFileSync19, statSync as statSync7 } from "fs";
+import { join as join13 } from "path";
+function localeFromLproj2(dir) {
+  const m = dir.match(/^(.+)\.lproj$/);
+  if (!m) return null;
+  return LOCALE_RE9.test(m[1]) ? m[1] : null;
+}
+function decodeEntities2(s) {
+  return s.replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d))).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function parsePlistDict(xml) {
+  let i = 0;
+  const n = xml.length;
+  const skipTrivia = () => {
+    for (; ; ) {
+      while (i < n && /\s/.test(xml[i])) i++;
+      if (xml.startsWith("<!--", i)) {
+        const end = xml.indexOf("-->", i + 4);
+        if (end === -1) throw new Error("unterminated comment");
+        i = end + 3;
+        continue;
+      }
+      if (xml.startsWith("<?", i) || xml.startsWith("<!", i) && !xml.startsWith("<!--", i)) {
+        const end = xml.indexOf(">", i);
+        if (end === -1) throw new Error("unterminated declaration");
+        i = end + 1;
+        continue;
+      }
+      break;
+    }
+  };
+  const readTag = () => {
+    if (xml[i] !== "<") throw new Error(`expected a tag at offset ${i}`);
+    const end = xml.indexOf(">", i);
+    if (end === -1) throw new Error("unterminated tag");
+    let body = xml.slice(i + 1, end).trim();
+    i = end + 1;
+    const closing = body.startsWith("/");
+    if (closing) body = body.slice(1).trim();
+    const selfClosing = body.endsWith("/");
+    if (selfClosing) body = body.slice(0, -1).trim();
+    const name = body.split(/\s/)[0];
+    if (!name) throw new Error(`empty tag at offset ${end}`);
+    return { name, closing, selfClosing };
+  };
+  const readElementText = (name) => {
+    const re = new RegExp(`</${name}\\s*>`, "g");
+    re.lastIndex = i;
+    const m = re.exec(xml);
+    if (!m) throw new Error(`unterminated <${name}>`);
+    const text = xml.slice(i, m.index);
+    i = m.index + m[0].length;
+    return decodeEntities2(text);
+  };
+  const readValue = (tag2) => {
+    if (tag2.name === "dict") return tag2.selfClosing ? {} : readDict();
+    if (tag2.name === "true" || tag2.name === "false") {
+      if (!tag2.selfClosing) readElementText(tag2.name);
+      return tag2.name;
+    }
+    if (["string", "integer", "real", "date", "data"].includes(tag2.name)) {
+      return tag2.selfClosing ? "" : readElementText(tag2.name);
+    }
+    throw new Error(`unsupported plist element <${tag2.name}>`);
+  };
+  const readDict = () => {
+    const out = {};
+    for (; ; ) {
+      skipTrivia();
+      const tag2 = readTag();
+      if (tag2.closing) {
+        if (tag2.name !== "dict") throw new Error(`unexpected </${tag2.name}> inside <dict>`);
+        return out;
+      }
+      if (tag2.name !== "key") throw new Error(`expected <key> inside <dict>, got <${tag2.name}>`);
+      const key = readElementText("key");
+      skipTrivia();
+      const vt = readTag();
+      if (vt.closing) throw new Error(`<key>${key}</key> has no value`);
+      out[key] = readValue(vt);
+    }
+  };
+  skipTrivia();
+  let tag = readTag();
+  if (tag.name === "plist" && !tag.closing && !tag.selfClosing) {
+    skipTrivia();
+    tag = readTag();
+  }
+  if (tag.name !== "dict" || tag.closing) throw new Error("expected a root <dict>");
+  return tag.selfClosing ? {} : readDict();
+}
+function entryToIcu(key, entry, file, warnings) {
+  const warn = (msg) => {
+    warnings.push(`apple-stringsdict: ${file}: key "${key}": ${msg}`);
+    return null;
+  };
+  if (typeof entry !== "object") return warn("value is not a dict; skipped");
+  const fmt = entry["NSStringLocalizedFormatKey"];
+  if (typeof fmt !== "string") return warn("missing NSStringLocalizedFormatKey; skipped");
+  const vars = [...fmt.matchAll(VAR_RE)];
+  if (vars.length !== 1) {
+    return warn(`format key has ${vars.length} %#@\u2026@ variables; only exactly one is supported; skipped`);
+  }
+  const arg = vars[0][1];
+  if (!/^\w+$/.test(arg)) return warn(`variable name "${arg}" is not a valid ICU argument; skipped`);
+  const prefix = fmt.slice(0, vars[0].index);
+  const suffix = fmt.slice(vars[0].index + vars[0][0].length);
+  const varDict = entry[arg];
+  if (typeof varDict !== "object") return warn(`variable "${arg}" has no dict; skipped`);
+  const specType = varDict["NSStringFormatSpecTypeKey"];
+  if (specType !== void 0 && specType !== "NSStringPluralRuleType") {
+    return warn(`variable "${arg}" is not a plural rule (${String(specType)}); skipped`);
+  }
+  const valueType = varDict["NSStringFormatValueTypeKey"];
+  const token = `%${typeof valueType === "string" && valueType ? valueType : "d"}`;
+  const forms = {};
+  for (const cat of PLURAL_CATEGORIES) {
+    const body = varDict[cat];
+    if (typeof body !== "string") continue;
+    forms[cat] = prefix + body.split(token).join(`{${arg}}`) + suffix;
+  }
+  if (forms.other === void 0) return warn(`variable "${arg}" has no "other" form; skipped`);
+  return formsToIcu(arg, forms);
+}
+var LOCALE_RE9, TABLE2, VAR_RE, appleStringsdict2;
+var init_apple_stringsdict2 = __esm({
+  "src/server/import/parsers/apple-stringsdict.ts"() {
+    "use strict";
+    init_schema();
+    init_plurals();
+    LOCALE_RE9 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+    TABLE2 = "Localizable.stringsdict";
+    VAR_RE = /%#@([^@]*)@/g;
+    appleStringsdict2 = {
+      name: "apple-stringsdict",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        for (const dir of readdirSync13(localeRoot).sort()) {
+          const locale = localeFromLproj2(dir);
+          if (!locale) continue;
+          if (opts?.locales && !opts.locales.includes(locale)) continue;
+          const file = join13(localeRoot, dir, TABLE2);
+          let text;
+          try {
+            if (!statSync7(file).isFile()) continue;
+            text = readFileSync19(file, "utf8");
+          } catch {
+            continue;
+          }
+          locales.push(locale);
+          const others = readdirSync13(join13(localeRoot, dir)).filter(
+            (f) => f.endsWith(".stringsdict") && f !== TABLE2
+          );
+          if (others.length) {
+            warnings.push(
+              `apple-stringsdict: ${dir} has other .stringsdict tables (${others.join(", ")}); only ${TABLE2} is imported`
+            );
+          }
+          let root;
+          try {
+            root = parsePlistDict(text);
+          } catch (e) {
+            warnings.push(`apple-stringsdict: failed to parse ${file}: ${e.message}`);
+            continue;
+          }
+          for (const key of Object.keys(root).sort()) {
+            const icu = entryToIcu(key, root[key], file, warnings);
+            if (icu === null) continue;
+            (keys[key] ??= { values: {} }).values[locale] = icu;
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
 // src/server/import/parsers/index.ts
 function getParser(name) {
   const p = REGISTRY[name];
@@ -4446,11 +5422,21 @@ var init_parsers = __esm({
     init_laravel_php2();
     init_flutter_arb2();
     init_apple_strings2();
+    init_angular_xliff2();
+    init_gettext_po2();
+    init_i18next_json2();
+    init_rails_yaml2();
+    init_apple_stringsdict2();
     REGISTRY = {
       [vueI18nJson2.name]: vueI18nJson2,
       [laravelPhp2.name]: laravelPhp2,
       [flutterArb2.name]: flutterArb2,
-      [appleStrings2.name]: appleStrings2
+      [appleStrings2.name]: appleStrings2,
+      [angularXliff2.name]: angularXliff2,
+      [gettextPo2.name]: gettextPo2,
+      [i18nextJson2.name]: i18nextJson2,
+      [railsYaml2.name]: railsYaml2,
+      [appleStringsdict2.name]: appleStringsdict2
     };
   }
 });
@@ -4536,7 +5522,14 @@ var init_assemble = __esm({
       "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" },
-      "apple-strings": { adapter: "apple-strings", path: "{locale}.lproj/Localizable.strings", rootRelative: true }
+      "apple-strings": { adapter: "apple-strings", path: "{locale}.lproj/Localizable.strings", rootRelative: true },
+      // skipSourceLocale: ng extract-i18n owns messages.xlf (the source file); glotfile
+      // only writes the translation files back next to it.
+      "angular-xliff": { adapter: "angular-xliff", path: "messages.{locale}.xlf", rootRelative: true, skipSourceLocale: true },
+      "gettext-po": { adapter: "gettext-po", path: "{locale}.po", rootRelative: true },
+      "i18next-json": { adapter: "i18next-json", path: "{locale}/translation.json", rootRelative: true },
+      "rails-yaml": { adapter: "rails-yaml", path: "config/locales/{locale}.yml" },
+      "apple-stringsdict": { adapter: "apple-stringsdict", path: "{locale}.lproj/Localizable.stringsdict", rootRelative: true }
     };
   }
 });
@@ -4718,120 +5711,22 @@ var init_stats = __esm({
   }
 });
 
-// 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/spell.ts
-import nspell from "nspell";
-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()));
-}
-var LOADERS, instances, loading, unavailable, cache, norm, ICU_BLOCK, MASK, WORD;
-var init_spell = __esm({
-  "src/server/spell.ts"() {
-    "use strict";
-    LOADERS = {
-      en: () => init_dictionary_en().then(() => dictionary_en_exports),
-      es: () => import("dictionary-es"),
-      fr: () => import("dictionary-fr")
-    };
-    instances = /* @__PURE__ */ new Map();
-    loading = /* @__PURE__ */ new Set();
-    unavailable = /* @__PURE__ */ new Set();
-    cache = /* @__PURE__ */ new Map();
-    norm = (locale) => locale.toLowerCase();
-    ICU_BLOCK = /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g;
-    MASK = /\{[^}]*\}|<[^>]*>|:\w+|%[sd]/g;
-    WORD = new RegExp("\\p{L}[\\p{L}''\u2019-]*", "gu");
-  }
-});
-
 // src/server/checks.ts
-function contains(haystack, needle, caseSensitive) {
-  return caseSensitive ? haystack.includes(needle) : haystack.toLowerCase().includes(needle.toLowerCase());
-}
 function runChecks(state, opts = {}) {
   const ruleOff = (id) => state.config.lint?.rules?.[CHECK_RULE[id]] === "off";
   const on = (id) => (!opts.only || opts.only.includes(id)) && !ruleOff(id);
   const issues = [];
   let spellPending = false;
   const { sourceLocale } = state.config;
-  const byTerm = new Map(state.glossary.map((e) => [e.term, e]));
-  const ignore = /* @__PURE__ */ new Set();
-  for (const e of state.glossary) {
-    for (const w of e.term.toLowerCase().split(/\s+/)) if (w) ignore.add(w);
-    for (const t of Object.values(e.translations ?? {})) {
-      for (const w of t.toLowerCase().split(/\s+/)) if (w) ignore.add(w);
+  const ignore = ignoreWordsFor(state.glossary, state.config.spelling?.customWords);
+  if (on("untranslated")) {
+    for (const m of findMissing(state)) {
+      issues.push({ key: m.key, locale: m.locale, check: "untranslated", message: "Not translated yet" });
     }
   }
-  for (const word of state.config.spelling?.customWords ?? []) {
-    const w = word.trim().toLowerCase();
-    if (w) ignore.add(w);
-  }
-  const targetLocales = state.config.locales.filter((l) => l !== sourceLocale);
   for (const key of Object.keys(state.keys).sort()) {
     const entry = state.keys[key];
     const source = entry.values[sourceLocale]?.value ?? "";
-    if (on("untranslated") && !entry.skipTranslate) {
-      for (const locale of targetLocales) {
-        const translated = entry.plural ? (entry.values[locale]?.forms?.other ?? "").trim() !== "" : (entry.values[locale]?.value ?? "").trim() !== "";
-        if (!translated) {
-          issues.push({ key, locale, check: "untranslated", message: "Not translated yet" });
-        }
-      }
-    }
     if (entry.plural) {
       if (on("placeholder")) {
         const sourceForm = entry.values[sourceLocale]?.forms?.other ?? "";
@@ -4875,7 +5770,8 @@ function runChecks(state, opts = {}) {
         });
       }
       if (on("spelling") && !blank) {
-        const bad = spellValue(locale, value, ignore);
+        const dictId = state.config.lint?.spelling?.locales?.[locale] ?? locale;
+        const bad = spellValue(dictId, value, ignore);
         if (bad === null) spellPending = true;
         else if (bad.length) {
           issues.push({
@@ -4905,29 +5801,14 @@ function runChecks(state, opts = {}) {
         });
       }
       if (on("glossary") && source) {
-        for (const hint of relevantGlossary(source, locale, state.glossary)) {
-          const cs = byTerm.get(hint.term)?.caseSensitive;
-          if (hint.doNotTranslate) {
-            if (!contains(value, hint.term, cs)) {
-              issues.push({
-                key,
-                locale,
-                check: "glossary",
-                message: `Do-not-translate term "${hint.term}" is missing from the translation`,
-                detail: [hint.term]
-              });
-            }
-          } else if (hint.forced) {
-            if (!contains(value, hint.forced, cs)) {
-              issues.push({
-                key,
-                locale,
-                check: "glossary",
-                message: `Should use "${hint.forced}" for "${hint.term}"`,
-                detail: [hint.forced]
-              });
-            }
-          }
+        for (const viol of glossaryViolations(source, value, locale, state.glossary)) {
+          issues.push({
+            key,
+            locale,
+            check: "glossary",
+            message: viol.kind === "do-not-translate" ? `Do-not-translate term "${viol.term}" is missing from the translation` : `Should use "${viol.expected}" for "${viol.term}"`,
+            detail: [viol.expected]
+          });
         }
       }
     }
@@ -4943,7 +5824,8 @@ var init_checks = __esm({
   "src/server/checks.ts"() {
     "use strict";
     init_placeholders();
-    init_run();
+    init_glossary();
+    init_scan();
     init_spell();
     init_suppress();
     CHECK_IDS = ["untranslated", "placeholder", "spelling", "length", "glossary"];
@@ -4958,12 +5840,12 @@ var init_checks = __esm({
 });
 
 // src/server/ui-prefs.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 import { homedir } from "os";
-import { join as join9 } from "path";
+import { join as join14 } from "path";
 function readJson2(path) {
   try {
-    const parsed = JSON.parse(readFileSync14(path, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -4988,7 +5870,7 @@ var init_ui_prefs = __esm({
     THEMES = ["system", "light", "dark"];
     isThemeMode = (v) => THEMES.includes(v);
     isPanelWidth = (v) => typeof v === "number" && Number.isFinite(v) && v >= 120 && v <= 1200;
-    defaultUiPrefsPath = () => join9(homedir(), ".glotfile", "ui.json");
+    defaultUiPrefsPath = () => join14(homedir(), ".glotfile", "ui.json");
     DEFAULTS = { theme: "system" };
   }
 });
@@ -4996,13 +5878,13 @@ var init_ui_prefs = __esm({
 // src/server/api.ts
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { readFileSync as readFileSync15, existsSync as existsSync11, readdirSync as readdirSync9, statSync as statSync6, rmSync as rmSync4 } from "fs";
+import { readFileSync as readFileSync21, existsSync as existsSync11, readdirSync as readdirSync14, statSync as statSync8, rmSync as rmSync4 } from "fs";
 import { dirname as dirname3, resolve as resolve9, basename, relative as relative4, sep as sep2 } from "path";
 function projectName(root) {
   const nameFile = resolve9(root, ".idea", ".name");
   if (existsSync11(nameFile)) {
     try {
-      const name = readFileSync15(nameFile, "utf8").trim();
+      const name = readFileSync21(nameFile, "utf8").trim();
       if (name) return name;
     } catch {
     }
@@ -5127,7 +6009,7 @@ function createApi(deps) {
       if (depth > 4) return;
       let entries = [];
       try {
-        entries = readdirSync9(dir);
+        entries = readdirSync14(dir);
       } catch {
         return;
       }
@@ -5141,7 +6023,7 @@ function createApi(deps) {
           filePath = abs;
         } else {
           try {
-            if (statSync6(abs).isDirectory()) walk(abs, depth + 1);
+            if (statSync8(abs).isDirectory()) walk(abs, depth + 1);
           } catch {
           }
           continue;
@@ -5959,7 +6841,7 @@ __export(server_exports, {
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
 import { fileURLToPath } from "url";
-import { dirname as dirname4, join as join10, resolve as resolve10, extname as extname3, sep as sep3 } from "path";
+import { dirname as dirname4, join as join15, resolve as resolve10, extname as extname3, sep as sep3 } from "path";
 import { readFile, stat } from "fs/promises";
 import { createServer } from "net";
 import open from "open";
@@ -6002,7 +6884,7 @@ function buildApp(opts) {
         const file = await readFileResponse(target);
         if (file) return file;
       }
-      const index = await readFileResponse(join10(root, "index.html"));
+      const index = await readFileResponse(join15(root, "index.html"));
       if (index) return index;
       return c.notFound();
     });
@@ -6060,7 +6942,7 @@ var init_server = __esm({
     init_scan();
     init_scanner();
     here = dirname4(fileURLToPath(import.meta.url));
-    DEFAULT_UI_DIR = join10(here, "..", "ui");
+    DEFAULT_UI_DIR = join15(here, "..", "ui");
     MIME = {
       ".html": "text/html; charset=utf-8",
       ".js": "text/javascript; charset=utf-8",
@@ -6104,8 +6986,8 @@ init_scanner();
 init_context();
 init_run2();
 init_outputs();
-import { resolve as resolve11, dirname as dirname5, join as join11 } from "path";
-import { readFileSync as readFileSync16, existsSync as existsSync12, mkdirSync as mkdirSync4, cpSync } from "fs";
+import { resolve as resolve11, dirname as dirname5, join as join16 } from "path";
+import { readFileSync as readFileSync22, existsSync as existsSync12, mkdirSync as mkdirSync4, cpSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/server/lint/locate.ts
@@ -6180,6 +7062,9 @@ function parseArgs(argv) {
   if (first === "help" || first === "--help" || first === "-h") {
     return isCommand(argv[1]) ? { command: argv[1], statePath, help: true } : { command: "help", statePath };
   }
+  if (first === "version" || first === "--version" || first === "-v") {
+    return { command: "version", statePath };
+  }
   if (first !== void 0 && !first.startsWith("-") && !isCommand(first)) {
     return { command: "serve", statePath, unknownCommand: first };
   }
@@ -6413,7 +7298,7 @@ async function runLintCmd(args) {
     }
     return;
   }
-  const rawText = existsSync12(args.statePath) ? readFileSync16(args.statePath, "utf8") : "";
+  const rawText = existsSync12(args.statePath) ? readFileSync22(args.statePath, "utf8") : "";
   const report = await runLint(state, {
     locales: args.locales,
     ruleIds: args.ruleIds,
@@ -6437,7 +7322,7 @@ async function runCheck(args) {
     process.exitCode = 1;
     return;
   }
-  const rawText = existsSync12(args.statePath) ? readFileSync16(args.statePath, "utf8") : "";
+  const rawText = existsSync12(args.statePath) ? readFileSync22(args.statePath, "utf8") : "";
   const root = dirname5(resolve11(args.statePath));
   const lint = await runLint(state, {});
   const findings = sortFindings([...lint.findings, ...checkOutputs(state, root)]);
@@ -6598,10 +7483,10 @@ function runSplit(args) {
     `Split catalog into ${splitDirFor(args.statePath)}/ (config.json, keys.json, locales/ \u2014 up to ${state.config.locales.length} locale files). Removed ${args.statePath}.`
   );
 }
-var SKILL_SRC = join11(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "skill");
+var SKILL_SRC = join16(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "skill");
 function runSkill(args) {
   if (args.print) {
-    console.log(readFileSync16(join11(SKILL_SRC, "SKILL.md"), "utf8").trimEnd());
+    console.log(readFileSync22(join16(SKILL_SRC, "SKILL.md"), "utf8").trimEnd());
     return;
   }
   const dest = resolve11(process.cwd(), ".claude", "skills", "glotfile");
@@ -6732,12 +7617,16 @@ ${formatOpts([...options, ...GLOBAL_OPTS])}`);
       formatOpts(commands),
       "",
       "Global options:",
-      formatOpts(GLOBAL_OPTS),
+      formatOpts([...GLOBAL_OPTS, ["-v, --version", "Print the glotfile version"]]),
       "",
       "Run `glotfile <command> --help` for a command's options."
     ].join("\n")
   );
 }
+function printVersion() {
+  const pkgPath = join16(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
+  console.log(JSON.parse(readFileSync22(pkgPath, "utf8")).version);
+}
 async function main(argv) {
   const args = parseArgs(argv);
   if (args.unknownCommand) {
@@ -6746,6 +7635,7 @@ async function main(argv) {
     return;
   }
   if (args.command === "help") return printHelp();
+  if (args.command === "version") return printVersion();
   if (args.help) return printHelp(args.command);
   loadDotEnv();
   if (args.command === "export") return runExport(args);