glotfox 0.0.0-stage → 0.1.0

package/dist/chunk-AQOIF7AF.js

@@ -0,0 +1,1286 @@
+// src/config.ts
+import fs from "node:fs";
+import path from "node:path";
+
+// ../shared/src/formats.ts
+var FILE_FORMATS = ["json", "po", "yaml"];
+var isFileFormat = (v) => FILE_FORMATS.includes(v);
+var FORMAT_EXTENSION = { json: "json", po: "po", yaml: "yaml" };
+var defaultPattern = (format) => `{locale}/{namespace}.${FORMAT_EXTENSION[format]}`;
+var cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function parseMessages(format, text) {
+  if (format === "po") return parsePo(text);
+  if (format === "yaml") return parseYaml(text);
+  return parseJson(text);
+}
+function serializeMessages(format, messages, opts = {}) {
+  const keys = Object.keys(messages).sort(cmp);
+  if (format === "po") return serializePo(keys, messages, opts);
+  if (format === "yaml") return serializeYaml(keys, messages);
+  return JSON.stringify(Object.fromEntries(keys.map((k) => [k, messages[k]])), null, 2) + "\n";
+}
+function parseJson(text) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (e) {
+    throw new Error(`invalid JSON (${e.message})`);
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) throw new Error("must be a JSON object");
+  for (const [k, v] of Object.entries(data)) if (typeof v !== "string") throw new Error(`value of "${k}" must be a string`);
+  return data;
+}
+var PO_ESCAPES = { n: "\n", t: "	", r: "\r", '"': '"', "\\": "\\" };
+var poQuote = (s) => '"' + s.replace(/[\\"\n\t\r]/g, (c) => c === "\n" ? "\\n" : c === "	" ? "\\t" : c === "\r" ? "\\r" : "\\" + c) + '"';
+var poUnquote = (s, line) => {
+  if (!/^".*"$/.test(s)) throw new Error(`line ${line}: expected a quoted string`);
+  return s.slice(1, -1).replace(/\\(.)/g, (_, c) => PO_ESCAPES[c] ?? c);
+};
+var PLURAL_CATEGORIES = {
+  1: ["other"],
+  2: ["one", "other"],
+  3: ["one", "few", "other"],
+  4: ["one", "two", "few", "other"],
+  5: ["one", "two", "few", "many", "other"],
+  6: ["zero", "one", "two", "few", "many", "other"]
+};
+function parsePo(text) {
+  const out = {};
+  let nplurals = 2;
+  let entry = null;
+  let field = null;
+  const flush = () => {
+    const e = entry;
+    entry = null;
+    field = null;
+    if (!e || e.id === void 0) return;
+    if (e.ctxt === void 0 && e.id === "") {
+      const m = /Plural-Forms:[^\n]*nplurals\s*=\s*(\d+)/.exec(e.str ?? "");
+      if (m) nplurals = Number(m[1]);
+      return;
+    }
+    const key = e.ctxt !== void 0 && e.ctxt !== "" ? e.ctxt : e.id;
+    if (key in out) throw new Error(`line ${e.line}: duplicate key "${key}"`);
+    if (e.plural.length > 0) {
+      const names = PLURAL_CATEGORIES[e.plural.length] ?? PLURAL_CATEGORIES[nplurals] ?? PLURAL_CATEGORIES[2];
+      const forms = e.plural.map((s, i) => `${names[i] ?? "other"} {${s.replace(/%d/g, "#")}}`);
+      out[key] = `{count, plural, ${forms.join(" ")}}`;
+    } else {
+      out[key] = e.str ?? "";
+    }
+  };
+  const append = (e, f, s) => {
+    if (f === "ctxt") e.ctxt = (e.ctxt ?? "") + s;
+    else if (f === "id") e.id = (e.id ?? "") + s;
+    else if (f === "str") e.str = (e.str ?? "") + s;
+    else if (f === "plural_id") return;
+    else e.plural[f.plural] = (e.plural[f.plural] ?? "") + s;
+  };
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const n = i + 1;
+    const raw = lines[i].trim();
+    if (raw === "") {
+      flush();
+      continue;
+    }
+    if (raw.startsWith("#")) continue;
+    if (raw.startsWith('"')) {
+      if (!entry || field === null) throw new Error(`line ${n}: unexpected string`);
+      append(entry, field, poUnquote(raw, n));
+      continue;
+    }
+    const m = /^(msgctxt|msgid_plural|msgid|msgstr(?:\[(\d+)\])?)\s+(".*")$/.exec(raw);
+    if (!m) throw new Error(`line ${n}: cannot parse "${raw.slice(0, 40)}"`);
+    const kw = m[1];
+    const value = poUnquote(m[3], n);
+    if (kw === "msgctxt" || kw === "msgid" && entry && (entry.id !== void 0 || entry.str !== void 0 || entry.plural.length)) {
+      flush();
+    }
+    entry ??= { plural: [], line: n };
+    if (kw === "msgctxt") field = "ctxt";
+    else if (kw === "msgid") field = "id";
+    else if (kw === "msgid_plural") field = "plural_id";
+    else if (m[2] !== void 0) field = { plural: Number(m[2]) };
+    else field = "str";
+    append(entry, field, value);
+  }
+  flush();
+  return out;
+}
+function serializePo(keys, messages, opts) {
+  const header = ["", "Content-Type: text/plain; charset=UTF-8", ...opts.locale ? [`Language: ${opts.locale}`] : []];
+  const blocks = ['msgid ""\nmsgstr ""\n' + header.map((h, i) => i === 0 ? "" : poQuote(h + "\n") + "\n").join("")];
+  for (const k of keys) {
+    blocks.push(`msgctxt ${poQuote(k)}
+msgid ${poQuote(k)}
+msgstr ${poQuote(messages[k])}
+`);
+  }
+  return blocks.join("\n");
+}
+var YAML_RESERVED = /^(?:y|n|yes|no|true|false|on|off|null|~)$/i;
+var yamlKey = (k) => /^[A-Za-z][A-Za-z0-9_-]*$/.test(k) && !YAML_RESERVED.test(k) ? k : JSON.stringify(k);
+function serializeYaml(keys, messages) {
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (const k of keys) {
+    let node = root;
+    for (const part of k.split(".")) {
+      if (node.value !== void 0) throw new Error(`key "${k}" conflicts with a shorter key (a key cannot also be a prefix)`);
+      let next = node.children.get(part);
+      if (!next) node.children.set(part, next = { children: /* @__PURE__ */ new Map() });
+      node = next;
+    }
+    if (node.children.size > 0) throw new Error(`key "${k}" conflicts with a longer key (a key cannot also be a prefix)`);
+    node.value = messages[k];
+  }
+  let out = "";
+  const emit = (node, indent) => {
+    for (const [name, child] of node.children) {
+      if (child.value !== void 0) out += `${indent}${yamlKey(name)}: ${JSON.stringify(child.value)}
+`;
+      else {
+        out += `${indent}${yamlKey(name)}:
+`;
+        emit(child, indent + "  ");
+      }
+    }
+  };
+  emit(root, "");
+  return out;
+}
+function yamlQuoted(s, line) {
+  const q = s[0];
+  let i = 1;
+  let value = "";
+  for (; i < s.length; i++) {
+    const c = s[i];
+    if (q === '"' && c === "\\") {
+      const end = s[i + 1] === "u" ? i + 6 : i + 2;
+      try {
+        value += JSON.parse(`"${s.slice(i, end)}"`);
+      } catch {
+        throw new Error(`line ${line}: unsupported escape sequence`);
+      }
+      i = end - 1;
+    } else if (c === q) {
+      if (q === "'" && s[i + 1] === "'") {
+        value += "'";
+        i++;
+      } else return { value, rest: s.slice(i + 1) };
+    } else value += c;
+  }
+  throw new Error(`line ${line}: unterminated quoted string`);
+}
+function parseYaml(text) {
+  const items = [];
+  text.split(/\r?\n/).forEach((raw, idx) => {
+    const line = idx + 1;
+    const content = raw.trimStart();
+    if (content === "" || content.startsWith("#")) return;
+    const indentStr = raw.slice(0, raw.length - content.length);
+    if (indentStr.includes("	")) throw new Error(`line ${line}: tabs are not allowed for indentation`);
+    if (content === "---" || content === "...") return;
+    if (content.startsWith("- ") || content === "-") throw new Error(`line ${line}: lists are not supported`);
+    let key;
+    let rest;
+    if (content[0] === '"' || content[0] === "'") {
+      const q = yamlQuoted(content, line);
+      key = q.value;
+      rest = q.rest.trimStart();
+      if (!rest.startsWith(":")) throw new Error(`line ${line}: expected ":" after key`);
+      rest = rest.slice(1);
+    } else {
+      const m = /^([^\s:#][^:]*?)\s*:(?:\s+|$)(.*)$/.exec(content);
+      if (!m) throw new Error(`line ${line}: expected "key: value"`);
+      key = m[1];
+      rest = m[2];
+    }
+    rest = rest.trim();
+    let value;
+    if (rest === "" || rest.startsWith("#")) value = null;
+    else if (rest[0] === '"' || rest[0] === "'") {
+      const q = yamlQuoted(rest, line);
+      const tail = q.rest.trim();
+      if (tail !== "" && !tail.startsWith("#")) throw new Error(`line ${line}: unexpected text after quoted string`);
+      value = q.value;
+    } else if (/^[|>&*!\[{]/.test(rest)) {
+      throw new Error(`line ${line}: unsupported YAML value (only plain and quoted strings are supported)`);
+    } else value = rest.replace(/\s+#.*$/, "");
+    items.push({ indent: indentStr.length, key, value, line });
+  });
+  const out = {};
+  const walk2 = (pos, indent, prefix) => {
+    while (pos < items.length) {
+      const it = items[pos];
+      if (it.indent < indent) return pos;
+      if (it.indent > indent) throw new Error(`line ${it.line}: unexpected indentation`);
+      pos++;
+      const full = prefix + it.key;
+      if (it.value === null) {
+        const next = items[pos];
+        if (!next || next.indent <= indent) throw new Error(`line ${it.line}: "${full}" has no value`);
+        pos = walk2(pos, next.indent, full + ".");
+      } else {
+        if (full in out) throw new Error(`line ${it.line}: duplicate key "${full}"`);
+        out[full] = it.value;
+      }
+    }
+    return pos;
+  };
+  if (items.length > 0 && walk2(0, items[0].indent, "") < items.length) {
+    throw new Error(`line ${items[0].line}: inconsistent indentation`);
+  }
+  return out;
+}
+
+// src/config.ts
+var CONFIG_FILE = "glotfox.config.json";
+var TOP_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "version",
+  "sourceLocale",
+  "targetLocales",
+  "defaultNamespace",
+  "include",
+  "exclude",
+  "output"
+]);
+var OUTPUT_KEYS = /* @__PURE__ */ new Set(["dir", "pattern", "format", "emptyValues", "types"]);
+var NAMESPACE_RE = /^[a-z0-9][a-z0-9_-]*$/;
+function strArray(v, name) {
+  if (!Array.isArray(v) || v.some((x) => typeof x !== "string")) throw new Error(`${name} must be an array of strings`);
+  return v;
+}
+function normalizeConfig(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new Error("config must be a JSON object");
+  const r = raw;
+  for (const k of Object.keys(r)) if (!TOP_KEYS.has(k)) throw new Error(`unknown config field "${k}"`);
+  const version = r.version ?? 1;
+  if (version !== 1) throw new Error(`unsupported config version ${String(version)}`);
+  if (typeof r.sourceLocale !== "string" || !r.sourceLocale) throw new Error("sourceLocale is required");
+  const targetLocales = strArray(r.targetLocales, "targetLocales");
+  if (new Set(targetLocales).size !== targetLocales.length) throw new Error("targetLocales must not contain duplicates");
+  if (targetLocales.includes(r.sourceLocale)) throw new Error("targetLocales must not contain sourceLocale");
+  const defaultNamespace = r.defaultNamespace ?? "common";
+  if (typeof defaultNamespace !== "string" || !NAMESPACE_RE.test(defaultNamespace)) {
+    throw new Error("defaultNamespace must match [a-z0-9][a-z0-9_-]*");
+  }
+  const o = r.output ?? {};
+  if (typeof o !== "object" || o === null || Array.isArray(o)) throw new Error("output must be an object");
+  for (const k of Object.keys(o)) if (!OUTPUT_KEYS.has(k)) throw new Error(`unknown output field "${k}"`);
+  const format = o.format ?? "json";
+  if (!isFileFormat(format)) throw new Error(`output.format must be one of ${FILE_FORMATS.map((f) => `"${f}"`).join(", ")}`);
+  const pattern = o.pattern ?? defaultPattern(format);
+  if (typeof pattern !== "string" || !pattern.includes("{locale}") || !pattern.includes("{namespace}")) {
+    throw new Error("output.pattern must contain {locale} and {namespace}");
+  }
+  const emptyValues = o.emptyValues ?? "omit";
+  if (emptyValues !== "omit" && emptyValues !== "empty") throw new Error('output.emptyValues must be "omit" or "empty"');
+  const types = o.types ?? null;
+  if (types !== null && typeof types !== "string") throw new Error("output.types must be a string or null");
+  const dir = o.dir ?? "locales";
+  if (typeof dir !== "string") throw new Error("output.dir must be a string");
+  return {
+    version: 1,
+    sourceLocale: r.sourceLocale,
+    targetLocales,
+    defaultNamespace,
+    include: r.include === void 0 ? ["src/**/*"] : strArray(r.include, "include"),
+    exclude: r.exclude === void 0 ? ["**/node_modules/**"] : strArray(r.exclude, "exclude"),
+    output: { dir, pattern, format, emptyValues, types }
+  };
+}
+function loadConfig(cwd) {
+  let dir = path.resolve(cwd);
+  for (; ; ) {
+    const file = path.join(dir, CONFIG_FILE);
+    if (fs.existsSync(file)) {
+      try {
+        return { config: normalizeConfig(JSON.parse(fs.readFileSync(file, "utf8"))), root: dir };
+      } catch (e) {
+        throw new Error(`${file}: ${e.message}`);
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) throw new Error(`${CONFIG_FILE} not found. Run "glotfox init" first.`);
+    dir = parent;
+  }
+}
+
+// src/scan.ts
+var KEY_RE = /^[A-Za-z][A-Za-z0-9_-]*(\.[A-Za-z][A-Za-z0-9_-]*){0,7}$/;
+var MAX_KEY_LENGTH = 128;
+var ESCAPES = { n: "\n", t: "	", r: "\r", b: "\b", f: "\f", v: "\v", "0": "\0" };
+function readString(src, i) {
+  const q = src[i];
+  if (q !== "'" && q !== '"' && q !== "`") return null;
+  let value = "";
+  for (let j = i + 1; j < src.length; j++) {
+    const c = src[j];
+    if (c === "\\") {
+      const n = src[++j];
+      if (n === void 0) return null;
+      value += ESCAPES[n] ?? n;
+    } else if (c === q) return { value, end: j + 1 };
+    else if (q === "`" && c === "$" && src[j + 1] === "{") return null;
+    else if (c === "\n" && q !== "`") return null;
+    else value += c;
+  }
+  return null;
+}
+function skipWs(src, i) {
+  while (i < src.length && /\s/.test(src[i])) i++;
+  return i;
+}
+function readBraces(src, i) {
+  if (src[i] !== "{") return null;
+  let depth = 0;
+  for (let j = i; j < src.length; j++) {
+    const c = src[j];
+    if (c === "'" || c === '"' || c === "`") {
+      let k = j + 1;
+      while (k < src.length && src[k] !== c) k += src[k] === "\\" ? 2 : 1;
+      j = k;
+    } else if (c === "{") depth++;
+    else if (c === "}" && --depth === 0) return { text: src.slice(i, j + 1), end: j + 1 };
+  }
+  return null;
+}
+function objectString(obj, prop) {
+  const m = new RegExp(`(?:^|[\\s{,])${prop}\\s*:\\s*`).exec(obj);
+  if (!m) return void 0;
+  return readString(obj, m.index + m[0].length)?.value;
+}
+function objectNumber(obj, prop) {
+  const m = new RegExp(`(?:^|[\\s{,])${prop}\\s*:\\s*(\\d{1,6})\\s*(?=[,}])`).exec(obj);
+  const n = m ? Number(m[1]) : void 0;
+  return n !== void 0 && n > 0 ? n : void 0;
+}
+function splitNs(raw) {
+  const idx = raw.indexOf(":");
+  return idx > 0 ? { namespace: raw.slice(0, idx), key: raw.slice(idx + 1) } : { namespace: null, key: raw };
+}
+function lineAt(src, index) {
+  let n = 1;
+  for (let i = 0; i < index; i++) if (src.charCodeAt(i) === 10) n++;
+  return n;
+}
+function firstNamespace(src) {
+  const m = /\buseTranslation\s*\(\s*/.exec(src);
+  if (!m) return null;
+  let i = m.index + m[0].length;
+  if (src[i] === "[") i = skipWs(src, i + 1);
+  return readString(src, i)?.value ?? null;
+}
+function scanSource(src) {
+  const out = [];
+  const fileNs = firstNamespace(src);
+  const tCall = /(?:(?<![\w$.])|(?<=\.))t\s*\(\s*/g;
+  for (let m; m = tCall.exec(src); ) {
+    const first = readString(src, m.index + m[0].length);
+    if (!first) continue;
+    const { namespace, key } = splitNs(first.value);
+    const item = { namespace, key, line: lineAt(src, m.index) };
+    let i = skipWs(src, first.end);
+    if (src[i] === ",") {
+      i = skipWs(src, i + 1);
+      const str = readString(src, i);
+      if (str) {
+        item.defaultValue = str.value;
+        const j = skipWs(src, str.end);
+        if (src[j] === ",") {
+          const opts = readBraces(src, skipWs(src, j + 1));
+          if (opts) {
+            item.description = objectString(opts.text, "description");
+            item.maxLength = objectNumber(opts.text, "maxLength");
+            if (!namespace) item.namespace = objectString(opts.text, "ns") ?? null;
+          }
+        }
+      } else {
+        const obj = readBraces(src, i);
+        if (obj) {
+          item.defaultValue = objectString(obj.text, "defaultValue");
+          item.description = objectString(obj.text, "description");
+          item.maxLength = objectNumber(obj.text, "maxLength");
+          if (!namespace) item.namespace = objectString(obj.text, "ns") ?? null;
+        }
+      }
+    }
+    if (item.namespace === null) item.namespace = fileNs;
+    out.push(item);
+  }
+  const trans = /<Trans\b((?:[^>{]|\{[^}]*\})*?)(\/>|>([\s\S]*?)<\/Trans>)/g;
+  for (let m; m = trans.exec(src); ) {
+    const attrs = m[1] ?? "";
+    const attr = (name) => {
+      const a = new RegExp(`\\b${name}\\s*=\\s*(?:\\{\\s*)?`).exec(attrs);
+      return a ? readString(attrs, a.index + a[0].length)?.value : void 0;
+    };
+    const attrNumber = (name) => {
+      const a = new RegExp(`\\b${name}\\s*=\\s*\\{\\s*(\\d{1,6})\\s*\\}`).exec(attrs);
+      return a && Number(a[1]) > 0 ? Number(a[1]) : void 0;
+    };
+    const raw = attr("i18nKey");
+    if (raw === void 0) continue;
+    const { namespace, key } = splitNs(raw);
+    const children = m[3]?.trim();
+    const plainChildren = children && !/[<{]/.test(children) ? children.replace(/\s+/g, " ") : void 0;
+    out.push({
+      namespace: namespace ?? attr("ns") ?? fileNs,
+      key,
+      defaultValue: attr("defaults") ?? plainChildren,
+      description: attr("description"),
+      maxLength: attrNumber("maxLength"),
+      line: lineAt(src, m.index)
+    });
+  }
+  return out;
+}
+
+// src/extract.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// src/glob.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+function globToRegExp(glob) {
+  let re = "";
+  let inBrace = 0;
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        i++;
+        if (glob[i + 1] === "/") {
+          i++;
+          re += "(?:.*/)?";
+        } else re += ".*";
+      } else re += "[^/]*";
+    } else if (c === "?") re += "[^/]";
+    else if (c === "{") {
+      inBrace++;
+      re += "(?:";
+    } else if (c === "}" && inBrace) {
+      inBrace--;
+      re += ")";
+    } else if (c === "," && inBrace) re += "|";
+    else re += c.replace(/[.+^$()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${re}$`);
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+function walk(root, rel = "") {
+  const out = [];
+  let entries;
+  try {
+    entries = fs2.readdirSync(path2.join(root, rel), { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const r = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      if (!SKIP_DIRS.has(e.name)) out.push(...walk(root, r));
+    } else if (e.isFile()) out.push(r);
+  }
+  return out.sort();
+}
+function matchFiles(root, include, exclude) {
+  const inc = include.map(globToRegExp);
+  const exc = exclude.map(globToRegExp);
+  return walk(root).filter((f) => inc.some((r) => r.test(f)) && !exc.some((r) => r.test(f)));
+}
+
+// src/extract.ts
+var sortObject = (o) => Object.fromEntries(Object.entries(o).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+function filePath(root, config, locale, namespace) {
+  const rel = config.output.pattern.replace("{locale}", locale).replace("{namespace}", namespace);
+  return path3.resolve(root, config.output.dir, rel);
+}
+function metaFilePath(root, config, locale, namespace) {
+  const file = filePath(root, config, locale, `${namespace}.meta`);
+  return config.output.format === "json" ? file : file.replace(/\.[^./\\]+$/, ".json");
+}
+function readJsonObject(file) {
+  if (!fs3.existsSync(file)) return {};
+  let data;
+  try {
+    data = JSON.parse(fs3.readFileSync(file, "utf8"));
+  } catch (e) {
+    throw new Error(`${file}: invalid JSON (${e.message})`);
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) throw new Error(`${file}: must be a JSON object`);
+  return data;
+}
+function readMessages(file, config) {
+  if (!fs3.existsSync(file)) return {};
+  try {
+    return parseMessages(config.output.format, fs3.readFileSync(file, "utf8"));
+  } catch (e) {
+    throw new Error(`${file}: ${e.message}`);
+  }
+}
+function existingNamespaces(root, config, locale) {
+  const base = path3.resolve(root, config.output.dir);
+  const [pre, post] = config.output.pattern.replace("{locale}", locale).split("{namespace}");
+  const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`^${esc(pre)}([a-z0-9][a-z0-9_-]*)${esc(post)}$`);
+  const names = [];
+  for (const f of walk(base)) {
+    const m = re.exec(f);
+    if (m) names.push(m[1]);
+  }
+  return names;
+}
+function write(file, text, opts, res) {
+  if (fs3.existsSync(file) && fs3.readFileSync(file, "utf8") === text) return;
+  res.written.push(file);
+  if (opts.dryRun) return;
+  fs3.mkdirSync(path3.dirname(file), { recursive: true });
+  fs3.writeFileSync(file, text);
+}
+function scanProject(root, config) {
+  const uses = [];
+  const warnings = [];
+  const files = matchFiles(root, config.include, config.exclude);
+  for (const rel of files) {
+    if (!/\.(?:[cm]?[jt]s|[jt]sx)$/.test(rel)) continue;
+    for (const item of scanSource(fs3.readFileSync(path3.join(root, rel), "utf8"))) {
+      const ns = item.namespace ?? config.defaultNamespace;
+      const where = `${rel}:${item.line}`;
+      if (!NAMESPACE_RE.test(ns)) {
+        warnings.push(`${where}: invalid namespace "${ns}", skipped`);
+        continue;
+      }
+      if (item.key.length > MAX_KEY_LENGTH || !KEY_RE.test(item.key)) {
+        warnings.push(`${where}: invalid key "${item.key}", skipped`);
+        continue;
+      }
+      uses.push({
+        id: `${ns}:${item.key}`,
+        namespace: ns,
+        key: item.key,
+        file: rel.split(path3.sep).join("/"),
+        line: item.line,
+        defaultValue: item.defaultValue,
+        description: item.description,
+        maxLength: item.maxLength
+      });
+    }
+  }
+  return { files: files.length, uses, warnings };
+}
+function extract(opts) {
+  const { config, root } = loadConfig(opts.cwd);
+  const res = { files: 0, found: [], added: [], unused: [], warnings: [], written: [] };
+  const found = /* @__PURE__ */ new Map();
+  const scanned = scanProject(root, config);
+  res.files = scanned.files;
+  res.warnings.push(...scanned.warnings);
+  for (const use of scanned.uses) {
+    const keys = found.get(use.namespace) ?? /* @__PURE__ */ new Map();
+    found.set(use.namespace, keys);
+    const prev = keys.get(use.key) ?? {};
+    keys.set(use.key, {
+      value: prev.value ?? use.defaultValue,
+      description: prev.description ?? use.description,
+      maxLength: prev.maxLength ?? use.maxLength
+    });
+  }
+  const src = config.sourceLocale;
+  const namespaces = /* @__PURE__ */ new Set([...found.keys(), ...existingNamespaces(root, config, src)]);
+  for (const ns of [...namespaces].sort()) {
+    const keys = found.get(ns) ?? /* @__PURE__ */ new Map();
+    const srcFile = filePath(root, config, src, ns);
+    const messages = readMessages(srcFile, config);
+    const meta = readJsonObject(metaFilePath(root, config, src, ns));
+    let metaChanged = false;
+    for (const [key, info] of [...keys].sort(([a], [b]) => a < b ? -1 : 1)) {
+      const id = `${ns}:${key}`;
+      res.found.push(id);
+      if (!(key in messages)) {
+        const clash = Object.keys(messages).find((k) => k.startsWith(`${key}.`) || key.startsWith(`${k}.`));
+        if (clash) {
+          res.warnings.push(`${id}: conflicts with existing key "${clash}" (a key cannot also be a prefix), skipped`);
+          continue;
+        }
+        if (info.value === void 0) res.warnings.push(`${id}: no default text found, using the key as placeholder`);
+        messages[key] = info.value ?? key;
+        res.added.push(id);
+      }
+      for (const field of ["description", "maxLength"]) {
+        const next = info[field];
+        if (next === void 0) continue;
+        const entry = meta[key] ??= {};
+        if (typeof entry !== "object" || entry === null) break;
+        if ((entry[field] === void 0 || opts.force) && entry[field] !== next) {
+          entry[field] = next;
+          metaChanged = true;
+        }
+      }
+    }
+    for (const key of Object.keys(messages)) if (!keys.has(key)) res.unused.push(`${ns}:${key}`);
+    const render2 = (m, locale) => serializeMessages(config.output.format, m, { locale });
+    write(srcFile, render2(messages, src), opts, res);
+    if (metaChanged) write(metaFilePath(root, config, src, ns), JSON.stringify(sortObject(meta), null, 2) + "\n", opts, res);
+    for (const locale of config.targetLocales) {
+      const file = filePath(root, config, locale, ns);
+      const target = readMessages(file, config);
+      if (config.output.emptyValues === "empty") {
+        for (const key of Object.keys(messages)) if (!(key in target)) target[key] = "";
+      }
+      write(file, render2(target, locale), opts, res);
+    }
+  }
+  return res;
+}
+
+// src/init.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+function init(opts) {
+  const file = path4.join(opts.cwd, CONFIG_FILE);
+  if (fs4.existsSync(file) && !opts.force) throw new Error(`${CONFIG_FILE} already exists (use --force to overwrite)`);
+  const dirs = ["src", "app", "pages", "components"].filter((d) => fs4.existsSync(path4.join(opts.cwd, d)));
+  const exts = "{ts,tsx,js,jsx,mjs,cjs}";
+  const config = {
+    version: 1,
+    sourceLocale: opts.sourceLocale ?? "en",
+    targetLocales: opts.targetLocales ?? [],
+    defaultNamespace: "common",
+    include: (dirs.length ? dirs : ["src"]).map((d) => `${d}/**/*.${exts}`),
+    exclude: ["**/*.test.*", "**/*.spec.*", "**/node_modules/**"],
+    output: { dir: "locales", pattern: "{locale}/{namespace}.json" }
+  };
+  normalizeConfig(config);
+  fs4.writeFileSync(file, JSON.stringify(config, null, 2) + "\n");
+  return file;
+}
+
+// src/types.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+var ARG_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var PRIMITIVE = "string | number";
+var TAG = "(chunks: never[]) => unknown";
+function messageArgs(message) {
+  const args = /* @__PURE__ */ new Map();
+  const add = (name, type) => {
+    if (!args.has(name)) args.set(name, /* @__PURE__ */ new Set());
+    args.get(name).add(type);
+  };
+  let i = 0;
+  const fail = (why) => {
+    throw new Error(`${why} at position ${i}`);
+  };
+  const skipWs2 = () => {
+    while (i < message.length && /\s/.test(message[i])) i++;
+  };
+  const readUntil = (re) => {
+    const start = i;
+    while (i < message.length && !re.test(message[i])) i++;
+    return message.slice(start, i).trim();
+  };
+  const parseText = (depth, inPlural) => {
+    while (i < message.length) {
+      const c = message[i];
+      if (c === "'") {
+        const n = message[i + 1];
+        if (n === "'") i += 2;
+        else if (n === "{" || n === "}" || inPlural && n === "#" || n === "<") {
+          i++;
+          while (i < message.length) {
+            if (message[i] === "'") {
+              if (message[i + 1] === "'") i += 2;
+              else {
+                i++;
+                break;
+              }
+            } else i++;
+          }
+        } else i++;
+      } else if (c === "}") {
+        if (depth === 0) fail("unmatched '}'");
+        return;
+      } else if (c === "{") {
+        i++;
+        parseArgument();
+      } else if (c === "<") {
+        const m = /^<(\/?)([A-Za-z][\w-]*)\s*\/?>/.exec(message.slice(i));
+        if (m) {
+          if (!m[1]) add(m[2], TAG);
+          i += m[0].length;
+        } else i++;
+      } else i++;
+    }
+    if (depth > 0) fail("missing '}'");
+  };
+  const parseArgument = () => {
+    const name = readUntil(/[,}]/);
+    if (!ARG_RE.test(name)) fail(`invalid argument name "${name}"`);
+    if (message[i] === "}") {
+      i++;
+      add(name, PRIMITIVE);
+      return;
+    }
+    if (i >= message.length) fail("missing '}'");
+    i++;
+    const type = readUntil(/[,}]/);
+    if (type === "number" || type === "date" || type === "time") {
+      add(name, type === "number" ? "number" : "Date | number");
+      let depth = 1;
+      while (i < message.length && depth > 0) {
+        if (message[i] === "{") depth++;
+        else if (message[i] === "}") depth--;
+        i++;
+      }
+      if (depth > 0) fail("missing '}'");
+      return;
+    }
+    if (type !== "plural" && type !== "selectordinal" && type !== "select") fail(`unsupported argument type "${type}"`);
+    if (message[i] !== ",") fail("expected ','");
+    i++;
+    const isSelect = type === "select";
+    const selectors = [];
+    skipWs2();
+    const offset = /^offset:\s*\d+/.exec(message.slice(i));
+    if (offset) i += offset[0].length;
+    for (; ; ) {
+      skipWs2();
+      if (i >= message.length) fail("missing '}'");
+      if (message[i] === "}") break;
+      const sel = readUntil(/[\s{}]/);
+      skipWs2();
+      if (!sel || message[i] !== "{") fail("expected branch");
+      i++;
+      parseText(1, !isSelect);
+      i++;
+      selectors.push(sel);
+    }
+    i++;
+    if (!selectors.includes("other")) fail(`"${name}" is missing the required "other" branch`);
+    if (isSelect) {
+      const lits = selectors.filter((s) => s !== "other").map((s) => JSON.stringify(s));
+      add(name, [...lits, "(string & {})"].join(" | "));
+    } else add(name, "number");
+  };
+  parseText(0, false);
+  return args;
+}
+function argsType(args) {
+  if (args === null) return "{ [name: string]: unknown }";
+  if (args.size === 0) return "{}";
+  const fields = [...args].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, types]) => `${JSON.stringify(name)}: ${[...types].map((x) => `(${x})`).join(" | ")}`);
+  return `{ ${fields.join("; ")} }`;
+}
+function renderTypes(catalog, defaultNamespace, warnings = []) {
+  const lines = [];
+  let keys = 0;
+  for (const ns of [...catalog.keys()].sort()) {
+    const messages = catalog.get(ns);
+    for (const key of Object.keys(messages).sort()) {
+      let args = null;
+      try {
+        args = messageArgs(messages[key]);
+      } catch (e) {
+        warnings.push(`${ns}:${key}: cannot parse message (${e.message}); placeholders are untyped`);
+      }
+      const type = argsType(args);
+      lines.push(`  ${JSON.stringify(`${ns}:${key}`)}: ${type};`);
+      if (ns === defaultNamespace) lines.push(`  ${JSON.stringify(key)}: ${type};`);
+      keys++;
+    }
+  }
+  const text = `// Generated by "glotfox types". Do not edit.
+/* eslint-disable */
+
+/** Placeholder values required by each translation key (\`namespace:key\`, or just \`key\` in the default namespace). */
+export interface GlotfoxMessages {
+${lines.join("\n")}
+}
+
+export type TranslationKey = keyof GlotfoxMessages;
+
+/** Options that may accompany any call. */
+export interface TranslateOptions {
+  defaultValue?: string;
+  description?: string;
+  /** Character limit of the translation; read by "glotfox extract", ignored at runtime. */
+  maxLength?: number;
+  ns?: string;
+}
+
+type TranslateArgs<K extends TranslationKey> = keyof GlotfoxMessages[K] extends never
+  ? [options?: TranslateOptions]
+  : [values: GlotfoxMessages[K] & TranslateOptions];
+
+/** Type-safe translate function: unknown keys and missing or mistyped placeholders are compile errors. */
+export type TFunction = <K extends TranslationKey>(key: K, ...args: TranslateArgs<K>) => string;
+`;
+  return { text, keys };
+}
+function generateTypes(opts) {
+  const { config, root } = loadConfig(opts.cwd);
+  const out = opts.out ?? config.output.types;
+  if (!out) throw new Error('no output file: set "output.types" in glotfox.config.json or pass --out <file>');
+  const catalog = /* @__PURE__ */ new Map();
+  for (const ns of existingNamespaces(root, config, config.sourceLocale)) {
+    if (ns.endsWith(".meta")) continue;
+    catalog.set(ns, readMessages(filePath(root, config, config.sourceLocale, ns), config));
+  }
+  const warnings = [];
+  const { text, keys } = renderTypes(catalog, config.defaultNamespace, warnings);
+  const file = path5.resolve(root, out);
+  let written = false;
+  if (!(fs5.existsSync(file) && fs5.readFileSync(file, "utf8") === text)) {
+    written = true;
+    if (!opts.dryRun) {
+      fs5.mkdirSync(path5.dirname(file), { recursive: true });
+      fs5.writeFileSync(file, text);
+    }
+  }
+  return { file, keys, warnings, written };
+}
+
+// src/sync.ts
+import fs6 from "node:fs";
+import path6 from "node:path";
+var DEFAULT_API_URL = "https://glotfox.app.dukauskas.lt";
+var PUSH_BATCH = 500;
+var MAX_REFERENCES = 50;
+var Api = class {
+  base;
+  key;
+  doFetch;
+  projectId;
+  constructor(opts) {
+    const key = opts.apiKey ?? process.env.GLOTFOX_API_KEY;
+    if (!key) throw new Error("missing API key: set GLOTFOX_API_KEY (create one in the GlotFox dashboard)");
+    this.key = key;
+    this.base = (opts.apiUrl ?? process.env.GLOTFOX_API_URL ?? DEFAULT_API_URL).replace(/\/+$/, "");
+    this.doFetch = opts.fetch ?? fetch;
+  }
+  async request(method, route, body) {
+    const res = await this.doFetch(`${this.base}/api/v1${route}`, {
+      method,
+      headers: { authorization: `Bearer ${this.key}`, ...body === void 0 ? {} : { "content-type": "application/json" } },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    const text = await res.text();
+    let data;
+    try {
+      data = text ? JSON.parse(text) : void 0;
+    } catch {
+      data = void 0;
+    }
+    if (!res.ok) {
+      const msg = data?.error ?? res.statusText;
+      throw new Error(`${method} ${route} failed: ${res.status} ${msg}`);
+    }
+    return data;
+  }
+  async project(route) {
+    this.projectId ??= (await this.request("GET", "/project")).id;
+    return `/projects/${this.projectId}${route}`;
+  }
+};
+async function push(opts) {
+  const { config, root } = loadConfig(opts.cwd);
+  const src = config.sourceLocale;
+  const refs = /* @__PURE__ */ new Map();
+  for (const use of scanProject(root, config).uses) {
+    const list = refs.get(use.id) ?? [];
+    refs.set(use.id, list);
+    if (list.length < MAX_REFERENCES && !list.some((r) => r.file === use.file && r.line === use.line)) {
+      list.push({ file: use.file, line: use.line });
+    }
+  }
+  const keys = [];
+  for (const ns of existingNamespaces(root, config, src).sort()) {
+    if (ns.endsWith(".meta")) continue;
+    const messages = readMessages(filePath(root, config, src, ns), config);
+    const metaFile = metaFilePath(root, config, src, ns);
+    const meta = fs6.existsSync(metaFile) ? JSON.parse(fs6.readFileSync(metaFile, "utf8")) : {};
+    for (const [key, value] of Object.entries(messages)) {
+      if (value === "") throw new Error(`${ns}:${key}: source value must not be empty`);
+      const { description, maxLength } = meta[key] ?? {};
+      keys.push({
+        key: `${ns}:${key}`,
+        value,
+        ...typeof description === "string" ? { context: description } : {},
+        ...typeof maxLength === "number" && Number.isInteger(maxLength) && maxLength > 0 ? { maxLength } : {},
+        references: refs.get(`${ns}:${key}`) ?? []
+      });
+    }
+  }
+  const res = { keys: keys.length, created: 0, updated: 0 };
+  if (opts.dryRun) return res;
+  const api = new Api(opts);
+  for (let i = 0; i < keys.length; i += PUSH_BATCH) {
+    const r = await api.request("POST", await api.project("/translation-keys"), {
+      keys: keys.slice(i, i + PUSH_BATCH)
+    });
+    res.created += r.created;
+    res.updated += r.updated;
+  }
+  return res;
+}
+async function pull(opts) {
+  const { config, root } = loadConfig(opts.cwd);
+  const api = new Api(opts);
+  const res = { written: [], received: {} };
+  for (const locale of config.targetLocales) {
+    const { translations } = await api.request(
+      "GET",
+      await api.project(`/translations/${encodeURIComponent(locale)}?status=approved`)
+    );
+    res.received[locale] = translations.length;
+    const byNs = /* @__PURE__ */ new Map();
+    for (const t of translations) {
+      const i = t.key.indexOf(":");
+      const ns = t.key.slice(0, i);
+      byNs.set(ns, { ...byNs.get(ns), [t.key.slice(i + 1)]: t.value });
+    }
+    for (const [ns, approved] of [...byNs].sort(([a], [b]) => a < b ? -1 : 1)) {
+      const file = filePath(root, config, locale, ns);
+      const merged = { ...readMessages(file, config), ...approved };
+      const text = serializeMessages(config.output.format, merged, { locale });
+      if (fs6.existsSync(file) && fs6.readFileSync(file, "utf8") === text) continue;
+      res.written.push(file);
+      if (opts.dryRun) continue;
+      fs6.mkdirSync(path6.dirname(file), { recursive: true });
+      fs6.writeFileSync(file, text);
+    }
+  }
+  return res;
+}
+
+// ../shared/src/qa.ts
+var ARG_RE2 = /^[A-Za-z0-9_.-]+$/;
+var TAG_RE = /^<(\/?)([A-Za-z][\w-]*)\s*\/?>/;
+var ParseError = class extends Error {
+  constructor(message, pos) {
+    super(message);
+    this.pos = pos;
+  }
+};
+function parseIcu(message) {
+  let i = 0;
+  const placeholders = /* @__PURE__ */ new Map();
+  const note = (p) => {
+    const id = `${p.kind}:${p.name}`;
+    if (!placeholders.has(id)) placeholders.set(id, p);
+  };
+  const fail = (why) => {
+    throw new ParseError(why, i);
+  };
+  const skipWs2 = () => {
+    while (i < message.length && /\s/.test(message[i])) i++;
+  };
+  const readUntil = (re) => {
+    const start = i;
+    while (i < message.length && !re.test(message[i])) i++;
+    return message.slice(start, i).trim();
+  };
+  const parseNodes = (depth, inPlural) => {
+    const nodes = [];
+    let text = "";
+    const flush = () => {
+      if (text) nodes.push({ t: "text", text });
+      text = "";
+    };
+    while (i < message.length) {
+      const c = message[i];
+      if (c === "'") {
+        const n = message[i + 1];
+        if (n === "'") {
+          text += "'";
+          i += 2;
+        } else if (n === "{" || n === "}" || n === "<" || inPlural && n === "#") {
+          i++;
+          while (i < message.length) {
+            if (message[i] === "'") {
+              if (message[i + 1] === "'") {
+                text += "'";
+                i += 2;
+              } else {
+                i++;
+                break;
+              }
+            } else text += message[i++];
+          }
+        } else {
+          text += c;
+          i++;
+        }
+      } else if (c === "}") {
+        if (depth === 0) fail("unmatched '}'");
+        flush();
+        return nodes;
+      } else if (c === "{") {
+        flush();
+        i++;
+        nodes.push(parseArgument());
+      } else if (c === "<") {
+        const m = TAG_RE.exec(message.slice(i));
+        if (m) {
+          if (!m[1]) note({ kind: "tag", name: m[2], text: m[0] });
+          i += m[0].length;
+        } else {
+          text += c;
+          i++;
+        }
+      } else {
+        text += c;
+        i++;
+      }
+    }
+    if (depth > 0) fail("missing '}'");
+    flush();
+    return nodes;
+  };
+  const parseArgument = () => {
+    const name = readUntil(/[,}]/);
+    if (!ARG_RE2.test(name)) fail(`invalid argument name "${name}"`);
+    note({ kind: "arg", name, text: `{${name}}` });
+    if (message[i] === "}") {
+      i++;
+      return { t: "arg", name };
+    }
+    if (i >= message.length) fail("missing '}'");
+    i++;
+    const type = readUntil(/[,}]/);
+    if (type === "number" || type === "date" || type === "time") {
+      let depth = 1;
+      while (i < message.length && depth > 0) {
+        if (message[i] === "{") depth++;
+        else if (message[i] === "}") depth--;
+        i++;
+      }
+      if (depth > 0) fail("missing '}'");
+      return { t: "arg", name };
+    }
+    if (type !== "plural" && type !== "selectordinal" && type !== "select") fail(`unsupported argument type "${type}"`);
+    if (message[i] !== ",") fail("expected ','");
+    i++;
+    const isSelect = type === "select";
+    skipWs2();
+    const offset = /^offset:\s*\d+/.exec(message.slice(i));
+    if (offset) i += offset[0].length;
+    const branches = [];
+    for (; ; ) {
+      skipWs2();
+      if (i >= message.length) fail("missing '}'");
+      if (message[i] === "}") break;
+      const sel = readUntil(/[\s{}]/);
+      skipWs2();
+      if (!sel || message[i] !== "{") fail("expected branch");
+      if (!isSelect && !/^(=\d+|zero|one|two|few|many|other)$/.test(sel)) fail(`invalid plural selector "${sel}"`);
+      i++;
+      branches.push({ sel, nodes: parseNodes(1, !isSelect) });
+      i++;
+    }
+    i++;
+    if (branches.length === 0) fail(`"${name}" has no branches`);
+    return { t: "choice", name, type, branches };
+  };
+  try {
+    return { nodes: parseNodes(0, false), placeholders };
+  } catch (e) {
+    if (e instanceof ParseError) return { nodes: [], placeholders, error: { message: e.message, pos: e.pos } };
+    throw e;
+  }
+}
+function textOf(nodes, out = []) {
+  for (const n of nodes) {
+    if (n.t === "text") out.push(n.text);
+    else if (n.t === "choice") for (const b of n.branches) textOf(b.nodes, out);
+  }
+  return out;
+}
+function render(nodes) {
+  let s = "";
+  for (const n of nodes) {
+    if (n.t === "text") s += n.text;
+    else if (n.t === "choice") {
+      let best = "";
+      for (const b of n.branches) {
+        const r = render(b.nodes);
+        if (r.length > best.length) best = r;
+      }
+      s += best;
+    }
+  }
+  return s;
+}
+function choices(nodes, out = []) {
+  for (const n of nodes) {
+    if (n.t === "choice") {
+      out.push(n);
+      for (const b of n.branches) choices(b.nodes, out);
+    }
+  }
+  return out;
+}
+var cpLength = (s) => [...s].length;
+var PUNCT_MAP = { "\u061F": "?", "\uFF1F": "?", "\uFF01": "!", "\u3002": ".", "\uFF1A": ":", "\u2026": "\u2026" };
+var ENDING_PUNCT = /[.!?:…؟？！。：]+$/u;
+function endingPunctuation(text) {
+  const m = ENDING_PUNCT.exec(text.trimEnd());
+  if (!m) return "";
+  return [...m[0].replace(/\.{3,}/g, "\u2026")].map((c) => PUNCT_MAP[c] ?? c).join("");
+}
+function asciiDigits(s) {
+  return s.replace(new RegExp("\\p{Nd}", "gu"), (c) => {
+    const cp = c.codePointAt(0);
+    let start = cp;
+    while (new RegExp("^\\p{Nd}$", "u").test(String.fromCodePoint(start - 1))) start--;
+    return String((cp - start) % 10);
+  });
+}
+function digitRuns(s) {
+  return asciiDigits(s).match(/\d+/g) ?? [];
+}
+var escapeRe = (s) => s.replace(/[.*+?^$()|[\]\\{}]/g, "\\$&");
+var containsTerm = (text, term) => new RegExp(`(?<![\\p{L}\\p{N}])${escapeRe(term)}(?![\\p{L}\\p{N}])`, "iu").test(text);
+function requiredCategories(locale, type) {
+  try {
+    return new Intl.PluralRules(locale, { type }).resolvedOptions().pluralCategories;
+  } catch {
+    return null;
+  }
+}
+function checkTranslation({ source, target, locale, maxLength, glossary }) {
+  if (!target.trim()) return [];
+  const issues = [];
+  const add = (code, severity, message, range) => issues.push({ code, severity, message, ...range ? { range } : {} });
+  const src = parseIcu(source);
+  const tgt = parseIcu(target);
+  if (tgt.error) {
+    add("icu-invalid", "error", `Not valid ICU MessageFormat: ${tgt.error.message}`, {
+      start: Math.min(tgt.error.pos, target.length),
+      end: Math.min(tgt.error.pos + 1, target.length)
+    });
+  }
+  const bothParse = !src.error && !tgt.error;
+  const srcPh = bothParse ? [...src.placeholders.values()] : [];
+  const tgtPh = bothParse ? [...tgt.placeholders.values()] : [];
+  const id = (p) => `${p.kind}:${p.name}`;
+  const show = (p) => p.kind === "arg" ? `{${p.name}}` : `<${p.name}>`;
+  const tgtIds = new Set(tgtPh.map(id));
+  const srcIds = new Set(srcPh.map(id));
+  for (const p of srcPh) if (!tgtIds.has(id(p))) add("placeholder-missing", "warning", `Placeholder ${show(p)} is missing from the translation`);
+  for (const p of tgtPh) {
+    if (srcIds.has(id(p))) continue;
+    const start = target.indexOf(p.text);
+    add("placeholder-extra", "warning", `Placeholder ${show(p)} is not in the source`, start < 0 ? void 0 : { start, end: start + p.text.length });
+  }
+  if (!tgt.error) {
+    for (const c of choices(tgt.nodes)) {
+      if (c.type === "select") {
+        if (!c.branches.some((b) => b.sel === "other")) add("icu-invalid", "error", `"${c.name}" (select) is missing the required "other" branch`);
+        continue;
+      }
+      const have2 = new Set(c.branches.map((b) => b.sel));
+      if (!have2.has("other")) {
+        add("plural-categories", "error", `"${c.name}" (${c.type}) is missing the required "other" category`);
+        continue;
+      }
+      const need = requiredCategories(locale, c.type === "plural" ? "cardinal" : "ordinal");
+      const missing = (need ?? []).filter((k) => !have2.has(k));
+      if (missing.length) {
+        add("plural-categories", "warning", `"${c.name}" (${c.type}) is missing ${locale} categories: ${missing.join(", ")}`);
+      }
+    }
+  }
+  const rendered = tgt.error ? target : render(tgt.nodes);
+  if (maxLength !== void 0 && cpLength(rendered) > maxLength) {
+    add("too-long", "warning", `Translation is ${cpLength(rendered)} characters, over the limit of ${maxLength}`);
+  }
+  for (const t of glossary ?? []) {
+    if (!t.term || !containsTerm(source, t.term)) continue;
+    const expected = t.doNotTranslate ? t.term : t.translations[locale];
+    if (expected && !target.toLowerCase().includes(expected.toLowerCase())) {
+      add("glossary", "warning", `Glossary: "${t.term}" should be "${expected}"`);
+    }
+  }
+  const lead = (s) => /^\s*/.exec(s)[0];
+  const trail = (s) => /\s*$/.exec(s)[0];
+  if (lead(source) !== lead(target)) {
+    add("whitespace", "warning", "Leading whitespace differs from the source", { start: 0, end: lead(target).length });
+  }
+  if (trail(source) !== trail(target)) {
+    add("whitespace", "warning", "Trailing whitespace differs from the source", { start: target.length - trail(target).length, end: target.length });
+  }
+  const sp = endingPunctuation(source);
+  const tp = endingPunctuation(target);
+  if (sp !== tp) {
+    const end = target.trimEnd().length;
+    add(
+      "punctuation",
+      "warning",
+      sp ? tp ? `Ending punctuation "${tp}" differs from the source "${sp}"` : `Source ends with "${sp}"` : `Translation ends with "${tp}" but the source does not`,
+      { start: end - tp.length, end }
+    );
+  }
+  const srcText = src.error ? source : textOf(src.nodes).join(" ");
+  const tgtText = tgt.error ? target : textOf(tgt.nodes).join(" ");
+  const have = new Set(digitRuns(tgtText));
+  const lostNumbers = [...new Set(digitRuns(srcText))].filter((n) => !have.has(n));
+  if (lostNumbers.length) add("numbers", "warning", `Number(s) from the source missing: ${lostNumbers.join(", ")}`);
+  const srcRendered = src.error ? source : render(src.nodes);
+  if (target.trim() === source.trim() && new RegExp("\\p{L}", "u").test(srcRendered) && cpLength(srcRendered.trim()) >= 4) {
+    add("untranslated", "warning", "Translation is identical to the source");
+  }
+  return issues;
+}
+
+// src/check.ts
+function qaFindings(cwd) {
+  const { config, root } = loadConfig(cwd);
+  const out = [];
+  for (const locale of config.targetLocales) {
+    for (const ns of existingNamespaces(root, config, locale)) {
+      if (ns.endsWith(".meta")) continue;
+      const source = readMessages(filePath(root, config, config.sourceLocale, ns), config);
+      const target = readMessages(filePath(root, config, locale, ns), config);
+      for (const [key, value] of Object.entries(target)) {
+        if (typeof source[key] !== "string" || typeof value !== "string") continue;
+        for (const issue of checkTranslation({ source: source[key], target: value, locale })) {
+          out.push({ locale, key: `${ns}:${key}`, issue });
+        }
+      }
+    }
+  }
+  return out;
+}
+function check(opts) {
+  const ex = extract({ cwd: opts.cwd, dryRun: true });
+  const warnings = [...ex.warnings];
+  let typesStale = false;
+  let typesFile;
+  if (loadConfig(opts.cwd).config.output.types) {
+    const t = generateTypes({ cwd: opts.cwd, dryRun: true });
+    warnings.push(...t.warnings);
+    typesStale = t.written;
+    typesFile = t.file;
+  }
+  const issues = qaFindings(opts.cwd);
+  const failing = issues.some((f) => f.issue.severity === "error" || opts.strict);
+  return { missing: ex.added, typesStale, typesFile, warnings, issues, ok: ex.added.length === 0 && !typesStale && !failing };
+}
+
+export {
+  normalizeConfig,
+  loadConfig,
+  scanSource,
+  extract,
+  init,
+  messageArgs,
+  generateTypes,
+  push,
+  pull,
+  check
+};