glotfile 0.5.4 → 0.6.0

package/dist/server/server.js

@@ -2,7 +2,7 @@
 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";
@@ -121,6 +121,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)) {
@@ -2535,27 +2536,41 @@ var vueI18nJson = {
 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) {
@@ -2565,8 +2580,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 = "bcp47-hyphen";
 var angularXliff = {
@@ -2589,6 +2604,7 @@ var angularXliff = {
     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) {
@@ -2599,17 +2615,18 @@ var angularXliff = {
         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>`);
         }
@@ -2770,7 +2787,7 @@ function checkOutputs(state, root) {
 }
 
 // src/server/api.ts
-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";
 
 // src/server/ai/anthropic.ts
@@ -3675,7 +3692,7 @@ function readLog(projectRoot, limit = 100) {
 import { relative as relative3 } from "path";
 
 // src/server/import/detect.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync2 } from "fs";
 import { join as join4 } from "path";
 var LOCALE_RE = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
 var VUE_DIR_CANDIDATES = ["src/locale", "src/locales", "src/i18n/locales", "locales", "lang"];
@@ -3764,12 +3781,134 @@ function detectApple(root) {
   }
   return best;
 }
-var DETECTORS = [detectLaravel, detectVue, detectArb, detectApple];
+var ANGULAR_DIR_CANDIDATES = [".", "src/locale", "src/locales", "src/i18n", "locale", "locales", "i18n", "translations"];
+function detectAngularXliff(root) {
+  for (const rel of ANGULAR_DIR_CANDIDATES) {
+    const localeRoot = rel === "." ? root : join4(root, rel);
+    if (!safeIsDir(localeRoot)) continue;
+    const files = readdirSync3(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 = readFileSync9(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 readdirSync3(localeRoot).sort()) {
+    if (!/\.ya?ml$/.test(file)) continue;
+    let text;
+    try {
+      text = readFileSync9(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) };
+}
+var I18NEXT_DIR_CANDIDATES = ["public/locales", "static/locales", "locales", "src/locales", "src/i18n/locales"];
+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) && readdirSync3(join4(localeRoot, d)).some((f) => f.endsWith(".json"))
+    );
+    if (locales.length === 0) continue;
+    const sourceLocale = pickSource(locales, (loc) => {
+      try {
+        return readdirSync3(join4(localeRoot, loc)).filter((f) => f.endsWith(".json")).reduce((sum, f) => sum + statSync2(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 readdirSync3(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 readdirSync3(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;
+}
+var GETTEXT_DIR_CANDIDATES = ["locale", "locales", "po", "translations"];
+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) && existsSync9(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;
+}
+var DETECTORS = [
+  detectLaravel,
+  detectVue,
+  detectArb,
+  detectApple,
+  detectAngularXliff,
+  detectRails,
+  detectI18next,
+  detectGettext,
+  detectAppleStringsdict
+];
 var 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
 };
 function detect(root, formatOverride) {
   if (!existsSync9(root)) return null;
@@ -3786,7 +3925,7 @@ function detect(root, formatOverride) {
 }
 
 // src/server/import/parsers/vue-i18n-json.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync10 } from "fs";
 import { join as join5 } from "path";
 
 // src/server/import/flatten.ts
@@ -3826,7 +3965,7 @@ var vueI18nJson2 = {
       if (opts?.locales && !opts.locales.includes(locale)) continue;
       let data;
       try {
-        data = JSON.parse(readFileSync9(join5(localeRoot, file), "utf8"));
+        data = JSON.parse(readFileSync10(join5(localeRoot, file), "utf8"));
       } catch (e) {
         warnings.push(`vue-i18n-json: failed to parse ${file}: ${e.message}`);
         continue;
@@ -3918,7 +4057,7 @@ var laravelPhp2 = {
 };
 
 // src/server/import/parsers/flutter-arb.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync10 } from "fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
 import { join as join7 } from "path";
 var LOCALE_RE3 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
 function localeFromArbName(file) {
@@ -3955,7 +4094,7 @@ var flutterArb2 = {
       if (opts?.locales && !opts.locales.includes(locale)) continue;
       let data;
       try {
-        data = JSON.parse(readFileSync10(join7(localeRoot, file), "utf8"));
+        data = JSON.parse(readFileSync11(join7(localeRoot, file), "utf8"));
       } catch (e) {
         warnings.push(`flutter-arb: failed to parse ${file}: ${e.message}`);
         continue;
@@ -3980,7 +4119,7 @@ var flutterArb2 = {
 };
 
 // src/server/import/parsers/apple-strings.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync11, statSync as statSync4 } from "fs";
+import { readdirSync as readdirSync7, readFileSync as readFileSync12, statSync as statSync4 } from "fs";
 import { join as join8 } from "path";
 var LOCALE_RE4 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
 var TABLE = "Localizable.strings";
@@ -4089,7 +4228,7 @@ var appleStrings2 = {
       let text;
       try {
         if (!statSync4(file).isFile()) continue;
-        text = readFileSync11(file, "utf8");
+        text = readFileSync12(file, "utf8");
       } catch {
         continue;
       }
@@ -4106,12 +4245,747 @@ var appleStrings2 = {
   }
 };
 
+// src/server/import/parsers/angular-xliff.ts
+import { readdirSync as readdirSync8, readFileSync as readFileSync13 } from "fs";
+import { join as join9 } from "path";
+var LOCALE_RE5 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+var FILE_RE = /^messages(?:\.(.+))?\.xlf$/;
+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 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 = readdirSync8(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 = readFileSync13(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 readdirSync9, readFileSync as readFileSync14 } from "fs";
+import { join as join10 } from "path";
+var LOCALE_RE6 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+var DIRECTIVE_RE = /^(msgctxt|msgid_plural|msgid|msgstr)(?:\[(\d+)\])?[ \t]+"(.*)"\s*$/;
+var CONT_RE = /^[ \t]*"(.*)"\s*$/;
+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 = readdirSync9(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 = readdirSync9(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 gettextPo2 = {
+  name: "gettext-po",
+  parse(localeRoot, opts) {
+    const warnings = [];
+    const keys = {};
+    const locales = [];
+    for (const file of discoverPoFiles(localeRoot)) {
+      let entries;
+      try {
+        entries = parseEntries(readFileSync14(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 readdirSync10, readFileSync as readFileSync15, statSync as statSync5 } from "fs";
+import { join as join11 } from "path";
+var LOCALE_RE7 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+var PLURAL_SUFFIX_RE = /^(.+)_(zero|one|two|few|many|other)$/;
+var PLURAL_ARG = "count";
+var DEFAULT_NAMESPACE = "translation";
+function safeIsDir2(p) {
+  try {
+    return statSync5(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(readFileSync15(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 i18nextJson2 = {
+  name: "i18next-json",
+  parse(localeRoot, opts) {
+    const warnings = [];
+    const keys = {};
+    const locales = [];
+    for (const entry of readdirSync10(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 readdirSync10(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 readdirSync11, readFileSync as readFileSync16 } from "fs";
+import { join as join12 } from "path";
+var LOCALE_RE8 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/i;
+var CATEGORY_SET = new Set(PLURAL_CATEGORIES);
+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 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 readdirSync11(localeRoot).sort()) {
+      if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
+      let text;
+      try {
+        text = readFileSync16(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 readdirSync12, readFileSync as readFileSync17, statSync as statSync6 } from "fs";
+import { join as join13 } from "path";
+var LOCALE_RE9 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+var TABLE2 = "Localizable.stringsdict";
+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();
+}
+var VAR_RE = /%#@([^@]*)@/g;
+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 appleStringsdict2 = {
+  name: "apple-stringsdict",
+  parse(localeRoot, opts) {
+    const warnings = [];
+    const keys = {};
+    const locales = [];
+    for (const dir of readdirSync12(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 (!statSync6(file).isFile()) continue;
+        text = readFileSync17(file, "utf8");
+      } catch {
+        continue;
+      }
+      locales.push(locale);
+      const others = readdirSync12(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
 var 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
 };
 function getParser(name) {
   const p = REGISTRY[name];
@@ -4124,7 +4998,14 @@ 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" },
-  "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 }
 };
 function assemble2(parsed, opts) {
   const warnings = [...parsed.warnings];
@@ -4242,7 +5123,7 @@ function runImport(opts) {
 }
 
 // src/server/export-run.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12, readdirSync as readdirSync8, rmdirSync, statSync as statSync5, unlinkSync } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync18, readdirSync as readdirSync13, rmdirSync, statSync as statSync7, unlinkSync } from "fs";
 import { dirname as dirname2, resolve as resolve7, sep } from "path";
 function effectiveLocales(config) {
   const limit = config.exportLocales;
@@ -4285,7 +5166,7 @@ function pruneStaleLocaleFiles(output, validTokens, projectRoot) {
     if (!segment.includes("{locale}") && !segment.includes("{namespace}")) {
       const next = resolve7(dir, segment);
       if (isLast) {
-        if (stale(locale) && existsSync10(next) && statSync5(next).isFile()) {
+        if (stale(locale) && existsSync10(next) && statSync7(next).isFile()) {
           unlinkSync(next);
           deleted++;
           removeEmptyDirs(dir, root);
@@ -4298,7 +5179,7 @@ function pruneStaleLocaleFiles(output, validTokens, projectRoot) {
     const re = segmentRegExp(segment);
     let entries;
     try {
-      entries = readdirSync8(dir, { withFileTypes: true });
+      entries = readdirSync13(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -4341,7 +5222,7 @@ function exportToDisk(state, projectRoot, opts) {
       writtenPaths.add(abs);
       let current = null;
       try {
-        current = readFileSync12(abs, "utf8");
+        current = readFileSync18(abs, "utf8");
       } catch {
       }
       if (current === f.contents) {
@@ -4358,17 +5239,17 @@ function exportToDisk(state, projectRoot, opts) {
 }
 
 // src/server/ui-prefs.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 import { homedir } from "os";
-import { join as join9 } from "path";
+import { join as join14 } from "path";
 var THEMES = ["system", "light", "dark"];
 var isThemeMode = (v) => THEMES.includes(v);
 var isPanelWidth = (v) => typeof v === "number" && Number.isFinite(v) && v >= 120 && v <= 1200;
-var defaultUiPrefsPath = () => join9(homedir(), ".glotfile", "ui.json");
+var defaultUiPrefsPath = () => join14(homedir(), ".glotfile", "ui.json");
 var DEFAULTS = { theme: "system" };
 function readJson(path) {
   try {
-    const parsed = JSON.parse(readFileSync13(path, "utf8"));
+    const parsed = JSON.parse(readFileSync19(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -4387,7 +5268,7 @@ function saveUiPrefs(path, prefs) {
 }
 
 // src/server/local-settings.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 import { resolve as resolve8 } from "path";
 var EDITOR_IDS = ["vscode", "zed", "phpstorm"];
 var isEditorId = (v) => EDITOR_IDS.includes(v);
@@ -4402,7 +5283,7 @@ var DEFAULT_EDITOR = "vscode";
 var settingsPath = (projectRoot) => resolve8(projectRoot, ".glotfile", "settings.json");
 function readJson2(path) {
   try {
-    const parsed = JSON.parse(readFileSync14(path, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -4475,7 +5356,7 @@ 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 {
     }
@@ -4600,7 +5481,7 @@ function createApi(deps) {
       if (depth > 4) return;
       let entries = [];
       try {
-        entries = readdirSync9(dir);
+        entries = readdirSync14(dir);
       } catch {
         return;
       }
@@ -4614,7 +5495,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;
@@ -5395,7 +6276,7 @@ function createApi(deps) {
 
 // src/server/server.ts
 var here = dirname4(fileURLToPath(import.meta.url));
-var DEFAULT_UI_DIR = join10(here, "..", "ui");
+var DEFAULT_UI_DIR = join15(here, "..", "ui");
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -5449,7 +6330,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();
     });