@mdbase-dev/i18n 0.0.0-stage → 0.1.0-beta.148

package/dist/codemirror/ru.js

@@ -0,0 +1,33 @@
+/** Fixed CodeMirror lookup keys; preserve literal $ substitution tokens. */
+const phrases = {
+    "Control character": "Управляющий символ",
+    "Selection deleted": "Выделение удалено",
+    "Completions": "Варианты дополнения",
+    "Folded lines": "Свёрнутые строки",
+    "Unfolded lines": "Развёрнутые строки",
+    "Fold line": "Свернуть строку",
+    "Unfold line": "Развернуть строку",
+    "folded code": "Свёрнутый код",
+    "unfold": "Развернуть",
+    "to": "–",
+    "Go to line": "Перейти к строке",
+    "go": "Перейти",
+    "Find": "Найти",
+    "Replace": "Заменить",
+    "next": "Далее",
+    "previous": "Назад",
+    "all": "Все",
+    "match case": "Учитывать регистр",
+    "regexp": "Регулярное выражение",
+    "by word": "Слова целиком",
+    "replace": "Заменить",
+    "replace all": "Заменить всё",
+    "close": "Закрыть",
+    "current match": "Текущее совпадение",
+    "on line": "в строке",
+    "replaced match on line $": "Заменено совпадение в строке $",
+    "replaced $ matches": "Заменено совпадений: $",
+    "Diagnostics": "Диагностика",
+    "No diagnostics": "Нет диагностических сообщений"
+};
+export default phrases;

package/dist/codemirror/zh.d.ts

@@ -0,0 +1,3 @@
+/** Fixed CodeMirror lookup keys; preserve literal $ substitution tokens. */
+declare const phrases: Record<string, string>;
+export default phrases;

package/dist/codemirror/zh.js

@@ -0,0 +1,33 @@
+/** Fixed CodeMirror lookup keys; preserve literal $ substitution tokens. */
+const phrases = {
+    "Control character": "控制字符",
+    "Selection deleted": "已删除所选内容",
+    "Completions": "补全建议",
+    "Folded lines": "已折叠行",
+    "Unfolded lines": "已展开行",
+    "Fold line": "折叠行",
+    "Unfold line": "展开行",
+    "folded code": "已折叠代码",
+    "unfold": "展开",
+    "to": "至",
+    "Go to line": "跳转到行",
+    "go": "跳转",
+    "Find": "查找",
+    "Replace": "替换",
+    "next": "下一个",
+    "previous": "上一个",
+    "all": "全部",
+    "match case": "区分大小写",
+    "regexp": "正则表达式",
+    "by word": "全字匹配",
+    "replace": "替换",
+    "replace all": "全部替换",
+    "close": "关闭",
+    "current match": "当前匹配项",
+    "on line": "所在行",
+    "replaced match on line $": "已替换第 $ 行的匹配项",
+    "replaced $ matches": "已替换 $ 个匹配项",
+    "Diagnostics": "诊断",
+    "No diagnostics": "无诊断信息"
+};
+export default phrases;

package/dist/codemirror.d.ts

@@ -0,0 +1,8 @@
+import type { Locale } from "./runtime.js";
+/** Bundled English; pass to EditorState.phrases.of(...). */
+export declare const englishCodeMirrorPhrases: Readonly<Record<string, string>>;
+/** Lazy chunks from the app's own deployment. Reconfigure the facet on activation.
+ * Keys come from CodeMirror 6 view/search/autocomplete/language/commands/lint.
+ * pt is Brazilian Portuguese; zh is Simplified Chinese. Never translate document data.
+ */
+export declare function loadCodeMirrorPhrases(locale: Locale): Promise<Record<string, string>>;

package/dist/codemirror.js

@@ -0,0 +1,17 @@
+import english from "./codemirror/en.js";
+/** Bundled English; pass to EditorState.phrases.of(...). */
+export const englishCodeMirrorPhrases = Object.freeze(english);
+const loaders = {
+    fr: () => import("./codemirror/fr.js"), de: () => import("./codemirror/de.js"),
+    es: () => import("./codemirror/es.js"), ja: () => import("./codemirror/ja.js"),
+    ko: () => import("./codemirror/ko.js"), pt: () => import("./codemirror/pt.js"),
+    it: () => import("./codemirror/it.js"),
+    ru: () => import("./codemirror/ru.js"), zh: () => import("./codemirror/zh.js"),
+};
+/** Lazy chunks from the app's own deployment. Reconfigure the facet on activation.
+ * Keys come from CodeMirror 6 view/search/autocomplete/language/commands/lint.
+ * pt is Brazilian Portuguese; zh is Simplified Chinese. Never translate document data.
+ */
+export async function loadCodeMirrorPhrases(locale) {
+    return { ...(locale === "en" ? english : (await loaders[locale]()).default) };
+}

package/dist/react.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode, type SelectHTMLAttributes } from "react";
+import { type I18nRuntime } from "./runtime.js";
+export declare function LocaleProvider({ runtime, onError, children }: {
+    runtime: I18nRuntime;
+    onError: (error: unknown) => void;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useI18nRuntime(): I18nRuntime;
+/** Native, unstyled select. The app supplies translated label and load-error UI. */
+export declare function LanguagePicker({ label, onError, disabled, ...props }: Omit<SelectHTMLAttributes<HTMLSelectElement>, "value" | "defaultValue" | "onChange" | "aria-label"> & {
+    label: string;
+    onError: (error: unknown) => void;
+}): import("react").JSX.Element;

package/dist/react.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { I18nProvider, useLingui } from "@lingui/react";
+import { createContext, useContext, useEffect, useState } from "react";
+import { isLocale, localeNames, locales } from "./runtime.js";
+const RuntimeContext = createContext(null);
+export function LocaleProvider({ runtime, onError, children }) {
+    useEffect(() => { void runtime.initialize().catch(onError); }, [runtime, onError]);
+    return _jsx(RuntimeContext.Provider, { value: runtime, children: _jsx(I18nProvider, { i18n: runtime.i18n, children: children }) });
+}
+export function useI18nRuntime() {
+    const runtime = useContext(RuntimeContext);
+    if (!runtime)
+        throw new Error("useI18nRuntime requires LocaleProvider");
+    return runtime;
+}
+/** Native, unstyled select. The app supplies translated label and load-error UI. */
+export function LanguagePicker({ label, onError, disabled, ...props }) {
+    const runtime = useI18nRuntime();
+    const { i18n } = useLingui();
+    const [busy, setBusy] = useState(false);
+    return _jsx("select", { ...props, "aria-label": label, value: i18n.locale, disabled: disabled || busy, "aria-busy": busy, onChange: (event) => {
+            const locale = event.currentTarget.value;
+            if (!isLocale(locale))
+                return;
+            setBusy(true);
+            void runtime.selectLocale(locale).catch(onError).finally(() => setBusy(false));
+        }, children: locales.map((locale) => _jsx("option", { value: locale, lang: locale, children: localeNames[locale] }, locale)) });
+}

package/dist/runtime.d.ts

@@ -0,0 +1,42 @@
+import { type I18n } from "@lingui/core";
+export { mergeCatalogues } from "../scripts/catalogues.mjs";
+export declare const locales: readonly ["en", "fr", "de", "es", "ja", "ko", "pt", "ru", "zh", "it"];
+export type Locale = (typeof locales)[number];
+export declare const localeNames: Record<Locale, string>;
+export declare function isLocale(value: unknown): value is Locale;
+export declare function negotiateLocale(preferences: readonly string[]): Locale;
+export interface LocaleStorage {
+    getLocale(): string | null | Promise<string | null>;
+    setLocale(locale: Locale): void | Promise<void>;
+}
+/** JSON imports lose compiled tuple types. This is compiler-owned ICU data, not code. */
+export interface Catalogue {
+    messages: object;
+}
+export interface CatalogueSource {
+    english: Catalogue;
+    loadLocale: (locale: Exclude<Locale, "en">) => Promise<Catalogue>;
+}
+export interface RuntimeOptions extends CatalogueSource {
+    /** Inject the Lingui global singleton when existing core macros target it. */
+    i18n?: I18n;
+    /** Libraries own their PO scope and lazy compiled catalogues, never a provider. */
+    libraries?: readonly CatalogueSource[];
+    storage?: LocaleStorage;
+    preferences?: readonly string[];
+    document?: Pick<Document, "documentElement">;
+}
+export declare function createI18nRuntime(options: RuntimeOptions): {
+    i18n: I18n;
+    /** Idempotent, and deliberately not awaited by the provider's first render. */
+    initialize(): Promise<void>;
+    /** Load failures leave the active catalogue and stored choice untouched. */
+    selectLocale(locale: Locale): Promise<void>;
+};
+export type I18nRuntime = ReturnType<typeof createI18nRuntime>;
+/** Display-only formatting: never use these to serialize record values. */
+export declare function formatters(locale: string): {
+    date: (value: Date | number, options?: Intl.DateTimeFormatOptions) => string;
+    number: (value: number, options?: Intl.NumberFormatOptions) => string;
+    relativeTime: (value: number, unit: Intl.RelativeTimeFormatUnit, options?: Intl.RelativeTimeFormatOptions) => string;
+};

package/dist/runtime.js

@@ -0,0 +1,112 @@
+import { setupI18n } from "@lingui/core";
+import { mergeCatalogues } from "../scripts/catalogues.mjs";
+export { mergeCatalogues } from "../scripts/catalogues.mjs";
+export const locales = ["en", "fr", "de", "es", "ja", "ko", "pt", "ru", "zh", "it"];
+export const localeNames = {
+    en: "English", fr: "Français", de: "Deutsch", es: "Español",
+    ja: "日本語", ko: "한국어", pt: "Português (Brasil)", ru: "Русский", zh: "简体中文", it: "Italiano",
+};
+export function isLocale(value) {
+    return typeof value === "string" && locales.includes(value);
+}
+export function negotiateLocale(preferences) {
+    for (const preference of preferences) {
+        const base = preference.toLowerCase().split(/[-_]/)[0];
+        if (isLocale(base))
+            return base;
+    }
+    return "en";
+}
+const literalInstances = new WeakSet();
+/** Copies values with backslashes encoded, so the user's text survives Lingui's decoding pass. */
+const literalValues = (values) => values && Object.fromEntries(Object.entries(values)
+    .map(([key, value]) => [key, typeof value === "string" ? value.replace(/\\/g, "\\u005c") : value]));
+/**
+ * Lingui decodes \uXXXX/\xXX after interpolation, so `C:\x41dir` would render as `C:Adir`.
+ * Wrap `_` (and `t`, bound to the original `_`) once per instance; shared singletons stay single-encoded.
+ */
+function renderValuesLiterally(i18n) {
+    if (literalInstances.has(i18n))
+        return;
+    literalInstances.add(i18n);
+    const render = i18n._.bind(i18n);
+    const translate = (id, values, options) => typeof id === "object" && id !== null
+        ? render({ ...id, values: literalValues(id.values) }, literalValues(values), options)
+        : render(id, literalValues(values), options);
+    i18n._ = translate;
+    i18n.t = translate;
+}
+export function createI18nRuntime(options) {
+    const i18n = options.i18n ?? setupI18n();
+    renderValuesLiterally(i18n);
+    const sources = [options, ...(options.libraries ?? [])];
+    i18n.load("en", mergeCatalogues(sources.map((source) => source.english)).messages);
+    i18n.activate("en");
+    const document = options.document ?? (typeof globalThis.document === "undefined" ? undefined : globalThis.document);
+    let generation = 0;
+    let initialization;
+    let saving = Promise.resolve();
+    const loaded = new Set(["en"]);
+    const syncDocument = () => {
+        if (document) {
+            document.documentElement.lang = i18n.locale;
+            document.documentElement.dir = "ltr"; // All supported languages use LTR scripts.
+        }
+    };
+    syncDocument();
+    async function activate(locale, persist) {
+        const request = ++generation;
+        if (!loaded.has(locale) && locale !== "en") {
+            const catalogues = await Promise.all(sources.map((source) => source.loadLocale(locale)));
+            if (request !== generation)
+                return;
+            const catalogue = mergeCatalogues(catalogues);
+            i18n.load(locale, catalogue.messages);
+            loaded.add(locale);
+        }
+        if (request !== generation)
+            return;
+        i18n.activate(locale);
+        syncDocument();
+        if (persist && options.storage) {
+            // Serialize async adapters so an older slow write cannot replace a newer choice.
+            const storage = options.storage;
+            saving = saving.catch(() => undefined).then(async () => {
+                if (request === generation)
+                    await storage.setLocale(locale);
+            });
+            await saving;
+        }
+    }
+    return {
+        i18n,
+        /** Idempotent, and deliberately not awaited by the provider's first render. */
+        initialize() {
+            initialization ??= (async () => {
+                const request = generation;
+                const stored = await options.storage?.getLocale();
+                if (request !== generation)
+                    return; // A user choice wins over delayed startup.
+                const preferences = options.preferences ??
+                    (typeof navigator === "undefined" ? [] : navigator.languages);
+                await activate(isLocale(stored) ? stored : negotiateLocale(preferences), false);
+            })();
+            return initialization;
+        },
+        /** Load failures leave the active catalogue and stored choice untouched. */
+        selectLocale(locale) {
+            if (!isLocale(locale))
+                return Promise.reject(new Error("Unsupported locale"));
+            return activate(locale, true);
+        },
+    };
+}
+/** Display-only formatting: never use these to serialize record values. */
+export function formatters(locale) {
+    const intlLocale = locale === "pt" ? "pt-BR" : locale === "zh" ? "zh-CN" : locale;
+    return {
+        date: (value, options) => new Intl.DateTimeFormat(intlLocale, options).format(value),
+        number: (value, options) => new Intl.NumberFormat(intlLocale, options).format(value),
+        relativeTime: (value, unit, options) => new Intl.RelativeTimeFormat(intlLocale, options).format(value, unit),
+    };
+}

package/package.json

@@ -1,6 +1,78 @@
 {
   "name": "@mdbase-dev/i18n",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0-beta.148",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mdbase-dev/mdbase-connect.git",
+    "directory": "packages/i18n"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "scripts/catalogues.mjs",
+    "scripts/catalogues.d.mts",
+    "scripts/bin.mjs",
+    "scripts/cli.mjs",
+    "scripts/config.mjs",
+    "scripts/config.d.mts",
+    "scripts/checks.mjs",
+    "scripts/source.mjs",
+    "README.md"
+  ],
+  "bin": {
+    "mdbase-i18n": "scripts/bin.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./config": "./scripts/config.mjs",
+    "./checks": "./scripts/checks.mjs",
+    "./source": "./scripts/source.mjs",
+    "./codemirror": {
+      "types": "./dist/codemirror.d.ts",
+      "import": "./dist/codemirror.js"
+    }
+  },
+  "dependencies": {
+    "@lingui/cli": "6.9.0",
+    "@lingui/conf": "6.9.0",
+    "@lingui/format-po": "6.9.0",
+    "@lingui/message-utils": "6.9.0",
+    "typescript": "6.0.3"
+  },
+  "peerDependencies": {
+    "@lingui/core": "6.9.0",
+    "@lingui/react": "6.9.0",
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@lingui/core": "6.9.0",
+    "@lingui/react": "6.9.0",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "@testing-library/react": "^16.3.2",
+    "jsdom": "^29.1.1",
+    "vitest": "^4.1.11",
+    "eslint": "^10.1.0",
+    "typescript-eslint": "^8.65.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run && node --test scripts/*.test.mjs",
+    "test:packed": "node --test scripts/cli.test.mjs",
+    "lint": "eslint src scripts",
+    "verify": "pnpm typecheck && pnpm lint && pnpm build && pnpm test"
+  }
 }

package/scripts/bin.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from "./cli.mjs";
+
+main(process.argv[2], process.argv.slice(3)).catch((error) => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/scripts/catalogues.d.mts

@@ -0,0 +1,2 @@
+/** Stable union: identical generated IDs deduplicate; conflicting values fail closed. */
+export declare function mergeCatalogues(catalogues: readonly { messages: object }[]): { messages: object };

package/scripts/catalogues.mjs

@@ -0,0 +1,25 @@
+/** Stable union: identical generated IDs deduplicate; conflicting values fail closed. */
+/**
+ * @param {readonly { messages: object }[]} catalogues
+ * @returns {{ messages: object }}
+ */
+export function mergeCatalogues(catalogues) {
+  /** @param {unknown} value @returns {unknown} */
+  const canonical = (value) => {
+    if (Array.isArray(value)) return value.map(canonical);
+    if (value && typeof value === "object") return Object.fromEntries(
+      Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, value]) => [key, canonical(value)]));
+    return value;
+  };
+  const messages = new Map();
+  const conflicts = new Set();
+  for (const catalogue of catalogues) for (const [id, value] of Object.entries(catalogue.messages)) {
+    const normalized = canonical(value);
+    if (messages.has(id) && JSON.stringify(messages.get(id)) !== JSON.stringify(normalized)) {
+      conflicts.add("Conflicting compiled translation for message ID: " + id +
+        " — " + JSON.stringify(messages.get(id)) + " vs " + JSON.stringify(normalized));
+    } else messages.set(id, normalized);
+  }
+  if (conflicts.size) throw new Error([...conflicts].join("\n"));
+  return { messages: Object.fromEntries([...messages].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) };
+}

package/scripts/checks.mjs

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import { compileMessageOrThrow } from "@lingui/message-utils/compileMessage";
+import { generateMessageId } from "@lingui/message-utils/generateMessageId";
+
+const sorted = (set) => [...set].sort();
+function shape(parts) {
+  const args = new Set(), tags = new Set(), selectors = [];
+  let text = "";
+  for (const part of parts) {
+    if (typeof part === "string") { text += part; continue; }
+    const [name, type, options] = part;
+    args.add(JSON.stringify([name, type ?? "argument"]));
+    if (["plural", "selectordinal", "select"].includes(type)) {
+      assert.ok(options && options.other, "ICU selection requires other");
+      selectors.push({ name, type, options });
+      for (const [key, branch] of Object.entries(options)) {
+        if (key === "offset") continue;
+        const child = shape(branch);
+        child.args.forEach((arg) => args.add(arg));
+        child.tags.forEach((tag) => tags.add(tag));
+      }
+    }
+  }
+  const stack = [];
+  for (const match of text.matchAll(/<(\/?[A-Za-z0-9][^>]*)>/g)) {
+    const tag = match[1];
+    assert.match(tag, /^\/?\d+\/?$/, "Only numeric React placeholders are allowed");
+    const id = tag.replaceAll("/", "");
+    tags.add(id);
+    if (tag.startsWith("/")) assert.equal(stack.pop(), id, "Unbalanced React placeholder");
+    else if (!tag.endsWith("/")) stack.push(id);
+  }
+  assert.equal(stack.length, 0, "Unclosed React placeholder");
+  return { args: sorted(args), tags: sorted(tags), selectors, pounds: (text.match(/#/g) ?? []).length };
+}
+/** Plural categories are language-specific; exact numeric and select cases are contracts. */
+export function assertMessageContract(source, target, locale, onWarning = () => {}, onInfo = () => {}) {
+  const check = (sourceParts, targetParts, path = []) => {
+    const a = shape(sourceParts), b = shape(targetParts);
+    assert.deepEqual(b.args, a.args, "ICU argument names/types changed");
+    assert.deepEqual(b.tags, a.tags, "React placeholder tags changed");
+    assert.equal(b.pounds, a.pounds, "ICU pound markers changed");
+    assert.equal(b.selectors.length, a.selectors.length, "ICU selectors changed");
+    const used = new Set();
+    for (const selector of a.selectors) {
+      const index = b.selectors.findIndex((s, index) => !used.has(index) && s.name === selector.name && s.type === selector.type);
+      assert.ok(index >= 0, "ICU selector changed");
+      used.add(index);
+      const translated = b.selectors[index];
+      const sourceKeys = Object.keys(selector.options).filter((k) => k !== "offset");
+      const targetKeys = Object.keys(translated.options).filter((k) => k !== "offset");
+      assert.equal(translated.options.offset, selector.options.offset, "ICU plural offset changed");
+      if (selector.type === "select") assert.deepEqual(targetKeys.sort(), sourceKeys.sort(), "ICU select cases changed");
+      else {
+        const exact = (keys) => keys.filter((k) => /^=?\d/.test(k)).sort();
+        for (const key of exact(sourceKeys))
+          assert.ok(targetKeys.includes(key), "ICU exact numeric cases changed: missing " + key);
+        const rules = new Intl.PluralRules(locale === "pt" ? "pt-BR" : locale, {
+          type: selector.type === "selectordinal" ? "ordinal" : "cardinal",
+        });
+        const categories = rules.resolvedOptions().pluralCategories;
+        for (const key of targetKeys) assert.ok(/^=?\d/.test(key) || categories.includes(key), "Invalid plural category for " + locale + ": " + key);
+        if (locale !== "en") {
+          // A PO message has no call-site numeric domain: use integer counts.
+          // Exact cases match the original count; CLDR selects count - offset.
+          const reachable = new Set(), uncovered = new Set();
+          for (let count = 0; count <= 999; count++) {
+            const category = rules.select(count - (translated.options.offset ?? 0));
+            reachable.add(category);
+            if (!targetKeys.includes(category) && !targetKeys.includes(String(count))) uncovered.add(category);
+          }
+          const optional = categories.filter((key) => !reachable.has(key) && !targetKeys.includes(key));
+          const location = [...path, selector.name + ", " + selector.type].join(" > ");
+          if (optional.length) onInfo("Optional plural categories absent (outside integer counts 0..999) at " + location + ": " + optional.join(", "));
+          assert.equal(uncovered.size, 0, "Missing plural categories for " + locale + " " + selector.type + " " + selector.name + ": " + sorted(uncovered).join(", "));
+        }
+      }
+      for (const key of targetKeys) {
+        const sourceBranch = selector.options[key] ?? selector.options.other;
+        const targetBranch = translated.options[key];
+        const branchPath = [...path, selector.name + ", " + selector.type + ", " + key];
+        // Compare literal text byte-for-byte, not normalized whole-message copy.
+        // Argument names and nested selector keys are not English prose.
+        const text = sourceBranch.filter((part) => typeof part === "string").join("");
+        if (locale !== "en" && /\p{L}/u.test(text) && JSON.stringify(targetBranch) === JSON.stringify(sourceBranch))
+          onWarning("English-identical ICU branch: " + branchPath.join(" > "));
+        check(sourceBranch, targetBranch, branchPath);
+      }
+    }
+  };
+  check(compileMessageOrThrow(source), compileMessageOrThrow(target));
+}
+export function assertCompleteCatalogue(english, target, locale, allowedIdentical = [], onWarning = console.warn, onInfo = console.info) {
+  const active = (entries) => Object.fromEntries(Object.entries(entries).filter(([, e]) => !e.obsolete));
+  const source = active(english), translated = active(target);
+  assert.deepEqual(Object.keys(translated).sort(), Object.keys(source).sort(), locale + " active catalogue keys differ");
+  for (const [id, entry] of Object.entries(translated)) {
+    assert.equal(id, generateMessageId(entry.message, entry.context), "Explicit/non-generated message ID: " + id);
+    assert.equal(entry.message, source[id].message, "Source message changed: " + id);
+    assert.equal(entry.context ?? "", source[id].context ?? "", "Source context changed: " + id);
+    assert.ok(entry.translation?.trim(), locale + " missing authored translation before fallback: " + id);
+    assert.ok(!entry.extra?.flags?.includes("fuzzy"), locale + " fuzzy translation: " + id);
+    const normalized = (text) => text.replace(/\s+/g, " ").trim().toLowerCase();
+    if (locale !== "en" && normalized(entry.translation) === normalized(entry.message))
+      assert.ok(allowedIdentical.includes(id), locale + " English placeholder (allowlist reviewed proper nouns/terms by ID): " + id);
+    try {
+      assertMessageContract(entry.message, entry.translation, locale, (warning) => {
+        if (!allowedIdentical.includes(id)) onWarning(locale + " message " + id + ": " + warning);
+      }, (info) => onInfo("info: " + locale + " message " + id + ": " + info));
+    }
+    catch (error) { throw new Error(locale + " message " + id + ": " + error.message, { cause: error }); }
+  }
+  return Object.keys(translated).length;
+}

package/scripts/cli.mjs

@@ -0,0 +1,108 @@
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { readFile, readdir, writeFile } from "node:fs/promises";
+import { getConfig } from "@lingui/conf";
+import { formatter } from "@lingui/format-po";
+import { assertCompleteCatalogue } from "./checks.mjs";
+import { inspectUiSource } from "./source.mjs";
+import { locales } from "./config.mjs";
+// Shared with the runtime, but executable before the workspace has any dist.
+import { mergeCatalogues } from "./catalogues.mjs";
+
+const require = createRequire(import.meta.url);
+const lingui = resolve(dirname(require.resolve("@lingui/cli")), "lingui.js");
+function run(args) {
+  const result = spawnSync(process.execPath, [lingui, ...args], { stdio: "inherit" });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error("Lingui " + args.join(" ") + " failed");
+}
+// Lingui 6.9 compiles obsolete PO entries, including English fallback values.
+// Prune at the shared compile boundary, not as a one-off catalogue cleanup.
+async function compile(config, args) {
+  for (const catalogue of config.catalogs) {
+    for (const locale of config.locales) {
+      const filename = catalogue.path.replaceAll("{locale}", locale) + ".po";
+      const existing = await readFile(filename, "utf8");
+      const context = { locale, sourceLocale: config.sourceLocale, filename, existing };
+      const entries = await config.format.parse(existing, context);
+      const active = Object.entries(entries).filter(([, entry]) => !entry.obsolete);
+      if (active.length !== Object.keys(entries).length)
+        await writeFile(filename, await config.format.serialize(Object.fromEntries(active), context));
+    }
+  }
+  run(["compile", "--strict", "--workers", "1", ...args]);
+}
+export async function main(command, args = []) {
+  if (!["extract", "compile", "check", "source"].includes(command))
+    throw new Error("Usage: mdbase-i18n extract|compile|check|source [--config lingui.config.ts] [--compose library/{locale}/messages.json ...]");
+  const compose = [];
+  const linguiArgs = [];
+  for (let index = 0; index < args.length; index++) {
+    if (args[index] !== "--compose") { linguiArgs.push(args[index]); continue; }
+    if (command !== "check") throw new Error("--compose is only supported by check");
+    const start = compose.length;
+    while (index + 1 < args.length && !args[index + 1].startsWith("--")) compose.push(args[++index]);
+    if (compose.length === start) throw new Error("--compose requires compiled JSON paths containing {locale}");
+  }
+  if (compose.some((path) => !path.includes("{locale}") || !path.endsWith(".json")))
+    throw new Error("--compose requires compiled JSON paths containing {locale}");
+  args = linguiArgs;
+  if (command === "extract") return run(["extract", "--workers", "1", ...args]);
+  const configIndex = args.indexOf("--config");
+  const config = getConfig({ configPath: configIndex < 0 ? undefined : args[configIndex + 1] });
+  if (command === "compile") return compile(config, args);
+  let policy = {};
+  try { policy = JSON.parse(await readFile(resolve(config.rootDir, "i18n-policy.json"), "utf8")); }
+  catch (error) { if (error.code !== "ENOENT") throw error; }
+  if (command === "check") {
+    if (JSON.stringify(config.locales) !== JSON.stringify(locales) || config.sourceLocale !== "en" || config.compileNamespace !== "json")
+      throw new Error("Use the ten-locale English-source strict-JSON kit preset");
+    run(["check", "sync", ...args]);
+    for (const catalogue of config.catalogs) {
+      const load = async (locale) => formatter({}).parse(
+        await readFile(catalogue.path.replaceAll("{locale}", locale) + ".po", "utf8"), { locale });
+      const english = await load("en");
+      for (const locale of locales)
+        assertCompleteCatalogue(english, await load(locale), locale, policy.allowIdentical?.[locale]);
+    }
+    await compile(config, args);
+    // Use exactly the runtime's compiled-value equality, including nested ICU objects.
+    // Include every app scope so app/app and library/library collisions also fail.
+    const paths = [...config.catalogs.map((catalogue) => catalogue.path + ".json"),
+      ...compose.map((path) => resolve(config.rootDir, path))];
+    const conflicts = [];
+    for (const locale of locales) {
+      const catalogues = await Promise.all(paths.map(async (path) => {
+        const filename = path.replaceAll("{locale}", locale);
+        const catalogue = JSON.parse(await readFile(filename, "utf8"));
+        if (!catalogue.messages || typeof catalogue.messages !== "object" || Array.isArray(catalogue.messages))
+          throw new Error("Expected compiled catalogue messages: " + filename);
+        return catalogue;
+      }));
+      try { mergeCatalogues(catalogues); }
+      catch (error) { conflicts.push(...error.message.split("\n").map((line) => locale + ": " + line)); }
+    }
+    if (conflicts.length) throw new Error(conflicts.join("\n"));
+  }
+  const source = policy.source ?? {};
+  const includes = source.include ?? config.catalogs.flatMap((catalogue) => catalogue.include);
+  const excludes = [...new Set(["**/node_modules/**", "**/locales/**", "**/*.test.*", "**/*.spec.*",
+    ...config.catalogs.flatMap((catalogue) => catalogue.exclude ?? []), ...(source.exclude ?? [])])];
+  const files = [];
+  // Source includes are directories; excludes are Node's platform-independent glob patterns.
+  const { matchesGlob } = await import("node:path");
+  async function walk(path) {
+    const relative = path.slice(config.rootDir.length + 1).replaceAll("\\", "/");
+    if (excludes.some((pattern) => matchesGlob(relative, pattern))) return;
+    for (const entry of await readdir(path, { withFileTypes: true })) {
+      const child = resolve(path, entry.name);
+      if (entry.isDirectory()) await walk(child);
+      else if (/\.[cm]?[jt]sx?$/.test(entry.name) && !excludes.some((pattern) => matchesGlob(child.slice(config.rootDir.length + 1), pattern))) files.push(child);
+    }
+  }
+  for (const include of new Set(includes)) await walk(resolve(config.rootDir, include.replace("<rootDir>/", "")));
+  const issues = (await Promise.all(files.map(async (file) => inspectUiSource(await readFile(file, "utf8"), file, source)))).flat();
+  if (issues.length) throw new Error(issues.map((i) => i.file + ":" + i.line + " " + i.kind + ": " + i.text).join("\n"));
+  console.log("i18n: catalogue contracts and source guard passed (" + files.length + " modules).");
+}