feat(i18n): complete the locale backfill — all ten packs reach full key parity (#2872) (#2909)

Translates the remaining 275 keys x 8 packs = 2,200 strings, closing #2872.
Largest namespaces: `grid` (101, mostly the import wizard), `gantt` (58),
`dashboard` (25), plus a long tail across list/auth/fields/marketplace/
capability and nine others.

Every pack is now at parity with en: 2,495 of 2,499 keys, zero keys en lacks.
The four-key remainder is the outbound-message set, absent by design so t()
falls through to English and the cloud confirm gate keeps recognising it.

P3 is now enforceable. The four-namespace ratchet from #2905 is replaced by
all-locales-key-parity.test.ts, asserting: every pack defines every en key;
no pack defines a key en lacks (#2872 part b was 74 keys of exactly this);
and placeholders match en per string — both `{{count}}` and the single-brace
`{count}` form that two gantt.autoScheduleDlg keys use because their call site
does a literal .replace('{count}', …) instead of i18next interpolation. All
three assertions were mutation-tested, single-brace form included.

A bug the test suite could not have caught: the first merge pass produced
DUPLICATE keys in four packs. The key list is the union of what is missing
across all eight, but the insert ran unconditionally, so packs that already
had detail.created/detail.updated got a second copy. Every test still passed
— at runtime the later property wins, so the parity check saw a consistent
object. tsc caught it as TS1117 during `turbo build`; ESLint does not flag it
and a runtime test cannot, since the duplicate is collapsed before JS sees the
object. The merge script now filters per pack.

Translations are model-generated, and dense domain terminology (Gantt
dependency types, the import wizard's upsert/match-field vocabulary) is where
that is weakest. Shipping as a reviewable first draft, not a finished
localization. Mechanically verified: parity both directions, placeholder shape
per string, and that no outbound agent message was translated.


Claude-Session: https://claude.ai/code/session_01TubWYdWquVkS9dj733sDmC

Co-authored-by: Claude <noreply@anthropic.com>

Author: os-zhuang

.changeset/complete-locale-backfill.md

@@ -0,0 +1,55 @@
+---
+"@object-ui/i18n": patch
+---
+
+feat(i18n): complete the locale backfill — all ten packs reach full key parity (objectui#2872)
+
+Translates the remaining **275 keys × 8 packs = 2,200 strings**, closing
+objectui#2872. The largest namespaces are `grid` (101, mostly the import
+wizard), `gantt` (58) and `dashboard` (25), plus a long tail across `list`,
+`auth`, `fields`, `marketplace`, `capability` and nine others.
+
+Every pack is now at parity with `en`: **2,495 of 2,499 keys**, zero keys that
+`en` lacks. The four-key remainder is the outbound-message set, absent by
+design so `t()` falls through to English and the cloud confirm gate keeps
+recognising it — `outbound-agent-messages.test.ts` owns that invariant.
+
+**P3 is now enforceable.** `high-frequency-namespace-parity.test.ts` was scoped
+to four namespaces because full parity would have been a permanently red build.
+That restriction is obsolete, so it is replaced by
+`all-locales-key-parity.test.ts`, which asserts:
+
+- every pack defines every `en` key;
+- no pack defines a key `en` lacks (objectui#2872 part b was 74 keys of exactly
+  this, hidden behind a component-private fallback);
+- **placeholders match `en` per string** — both `{{count}}` and the single-brace
+  `{count}` form, which two `gantt.autoScheduleDlg.*` keys use on purpose
+  because their call site does a literal `.replace('{count}', …)` rather than
+  i18next interpolation. A translation that drops a placeholder renders a
+  sentence with a hole in it and no error, so this is checked mechanically
+  rather than by eye.
+
+All three assertions were mutation-tested, including the single-brace form.
+
+### A bug the test suite could not have caught
+
+The first merge pass produced **duplicate keys** in four packs: the key list is
+the union of what is missing across all eight, but the insert ran
+unconditionally, so packs that already had `detail.created` / `detail.updated`
+got a second copy. Every test still passed — at runtime the later property
+simply wins, so the parity check saw a perfectly consistent object.
+
+`tsc` caught it as TS1117 during `turbo build`. ESLint does not flag it, and a
+runtime test *cannot* — the duplicate is already collapsed before JS sees the
+object. The compiler is the only possible guard here, and CI runs it. The merge
+script now filters per pack against what that pack actually defines.
+
+### Translation quality
+
+Model-generated, and dense domain terminology (Gantt dependency types, the
+import wizard's upsert/match-field vocabulary) is exactly where that is
+weakest. This was raised before starting and the work was requested anyway, so
+it ships as a **reviewable first draft, not a finished localization** — native
+review is still worthwhile. What *is* verified mechanically: key parity in both
+directions, placeholder shape per string, and that no outbound agent message
+was translated.

packages/i18n/src/__tests__/all-locales-key-parity.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Full key parity across all ten locale packs (objectui#2872 P3).
+ *
+ * This replaces the four-namespace ratchet added in objectui#2905. That one was
+ * deliberately scoped because the eight non-Chinese packs were still ~277 keys
+ * behind, and a full assertion would have been a permanently red build rather
+ * than a guard. With the backfill complete, the scope restriction is gone and
+ * the invariant is simply: **every pack defines every `en` key, and no pack
+ * defines a key `en` lacks.**
+ *
+ * Why this needs a test at all: `fallbackLng: 'en'` makes both failure modes
+ * invisible at runtime.
+ *
+ *   - A key missing from `de` renders English. That reads as "not translated
+ *     yet", not "we lost this" — and the missing-key handler is dev-only, so CI
+ *     never sees it.
+ *   - A key added to one pack but never to `en` cannot be translated by anyone
+ *     else and drifts silently. objectui#2872 part (b) was exactly this, 74 keys
+ *     deep, hidden behind a component-private fallback that made English
+ *     "happen to" render.
+ *
+ * The only permitted exception is the outbound-message set below.
+ */
+import { describe, it, expect } from 'vitest';
+import { builtInLocales } from '../locales';
+
+/**
+ * Text the console SENDS to the agent rather than displays. These are absent
+ * from the eight non-gate packs ON PURPOSE, so `t()` falls through to its
+ * English default and the cloud confirm gate keeps recognising the message —
+ * see `outbound-agent-messages.test.ts`, which owns that invariant and asserts
+ * it in both directions. Excluded here so the two guards cannot contradict
+ * each other.
+ */
+const OUTBOUND_KEYS = new Set([
+  'console.ai.planApproveMessage',
+  'console.ai.planApproveDefaultsMessage',
+  'console.ai.planAnswerMessage',
+  'console.ai.changesConfirmMessage',
+]);
+
+function keyPaths(node: unknown, prefix = ''): string[] {
+  return node !== null && typeof node === 'object'
+    ? Object.entries(node as Record<string, unknown>).flatMap(([k, v]) =>
+        keyPaths(v, prefix ? `${prefix}.${k}` : k),
+      )
+    : [prefix];
+}
+
+const keysOf = (pack: unknown) => new Set(keyPaths(pack).filter((k) => !OUTBOUND_KEYS.has(k)));
+
+const EN = keysOf(builtInLocales.en);
+const OTHER_LOCALES = Object.keys(builtInLocales).filter((l) => l !== 'en');
+
+describe('all locale packs are at full key parity with en (objectui#2872)', () => {
+  it('the comparison covers the whole pack — not an empty assertion', () => {
+    // If a refactor breaks `keyPaths`, every diff below becomes trivially empty
+    // and the suite would pass while asserting nothing.
+    expect(EN.size).toBeGreaterThan(2000);
+    expect(OTHER_LOCALES).toHaveLength(9);
+  });
+
+  it.each(OTHER_LOCALES)('%s defines every en key', (lang) => {
+    const missing = [...EN].filter((k) => !keysOf(builtInLocales[lang]).has(k)).sort();
+    expect(missing, `${lang} is missing ${missing.length} key(s)`).toEqual([]);
+  });
+
+  it.each(OTHER_LOCALES)('%s defines no key that en lacks', (lang) => {
+    const extra = [...keysOf(builtInLocales[lang])].filter((k) => !EN.has(k)).sort();
+    expect(extra, `${lang} has ${extra.length} key(s) absent from en`).toEqual([]);
+  });
+
+  it('placeholders match en in every pack', () => {
+    // A translation that drops `{{count}}` renders a sentence with a hole in it
+    // and no error. Two gantt keys use SINGLE braces on purpose — their call
+    // site does a literal `.replace('{count}', …)` instead of i18next
+    // interpolation — so both forms are compared.
+    const DOUBLE = /\{\{\w+\}\}/g;
+    const SINGLE = /(?<!\{)\{\w+\}(?!\})/g;
+    const shape = (v: unknown) =>
+      typeof v === 'string'
+        ? [...(v.match(DOUBLE) ?? []), ...(v.match(SINGLE) ?? [])].sort().join(',')
+        : null;
+    const at = (pack: unknown, dotted: string) =>
+      dotted.split('.').reduce<unknown>((n, p) => (n as Record<string, unknown>)?.[p], pack);
+
+    const mismatches: string[] = [];
+    for (const lang of OTHER_LOCALES) {
+      for (const key of EN) {
+        const a = shape(at(builtInLocales.en, key));
+        const b = shape(at(builtInLocales[lang], key));
+        if (a !== null && b !== null && a !== b) {
+          mismatches.push(`${lang} ${key}: en[${a}] vs ${lang}[${b}]`);
+        }
+      }
+    }
+    expect(mismatches).toEqual([]);
+  });
+});