test: pin what the i18n split and the guard numbers were relying on

Two invariants this repository states and nothing was checking.

Every shell language says everything. The compiler enforces that for en
and zh-CN only -- the other five are Partial<I18nMessages>, so a missing
key is silent and t() falls back to English, which reads like a
translation somebody chose rather than one nobody wrote. All seven are
complete today (99 strings each); this is what keeps them that way, and
it is the check a new UI string has to pass. Reverse-validated: dropping
one key from ja fails with its name.

And every runtime guard has a unique number. The number is the guard's
name in prose -- CLAUDE.md, the exploration records and a good many commit
messages say "guard 8" and expect that to identify one file. Two pairs had
drifted into sharing one (comment-selection/font-loading on 8,
hint-fallback/unload-prompt on 11), quietly making four of those
references ambiguous, and chrome and shared-worker had no number at all.
Renumbered so 1..16 is unique and complete, without moving any number
that existing records already point at.

Found by reading today's work over rather than by anything failing.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MKNHFQ1kek1cHeqhbH37Pk

Author: chaxus

CLAUDE.md

@@ -65,7 +65,9 @@ lib/                  # 应用层（纯 TypeScript，只在本站点用）
   editor-theme.ts       # 站点主题 → 编辑器 uiTheme 的跟随
   onlyoffice-editor.ts  # 编辑器生命周期门面：挂载/重建/loadEditorApi，并对外统一导出下面这些模块
   onlyoffice/           # 编辑器周边（2026-08-19 从 1975 行的单文件拆出，公开导出面不变）
-    iframe-guards.ts      # 14 条运行时守卫的编排；每条守卫一个文件在 guards/
+    iframe-guards.ts      # 16 条运行时守卫的编排；每条守卫一个文件在 guards/，
+                          # 文件头注释开头的编号就是它的身份（文档和提交信息里说
+                          # "守卫 8" 指的就是那个号），guards-numbering.test.ts 钉住不重号
     guards/               # chrome / shared-worker / fetch-fonts / image-pipeline /
                           # serverless-save / long-action / series-settings /
                           # font-loading / comment-selection / canvas-loss /

lib/onlyoffice/guards/chrome.ts

@@ -1,7 +1,7 @@
 import { COMPACT_VIEWPORT_MAX_WIDTH } from '../viewport';
 
 /**
- * Strip the OnlyOffice chrome that has no place in a single-user local editor
+ * 1. Strip the OnlyOffice chrome that has no place in a single-user local editor
  * -- the current-user / co-users widgets, which describe a collaboration
  * session this build cannot have -- and hide the right panel on phone-sized
  * viewports. There is no DocEditor config switch for either in this build.

lib/onlyoffice/guards/font-loading.ts

@@ -1,11 +1,11 @@
 /**
- * 8. Font-load acceleration. The SDK's CFontLoader works through fonts_loading
+ * 15. Font-load acceleration. The SDK's CFontLoader works through fonts_loading
  * strictly one family at a time (LoadFontAsync for the faces of
  * fonts_loading[0], poll every 50ms until they land, shift, repeat), so a real
  * CJK deck's 30 families cost 30 serial round trips of multi-MB downloads --
  * minutes on a cold CDN path. Two coordinated patches, both
  * semantics-preserving:
- * 8a. IsNeedDefaultFonts -> false: the Word/Slide editors preload
+ * 15a. IsNeedDefaultFonts -> false: the Word/Slide editors preload
  *    Arial/Symbol/Wingdings/Courier/Times (12 files, 3.2 MB) on every open
  *    "just in case"; the runtime path (LoadDocumentFonts2) already fetches any
  *    of them on first actual use.

lib/onlyoffice/guards/shared-worker.ts

@@ -1,5 +1,5 @@
 /**
- * Shadow SharedWorker inside the editor iframe. The SDK's local spellchecker
+ * 2. Shadow SharedWorker inside the editor iframe. The SDK's local spellchecker
  * prefers `new SharedWorker(spell.js, ...)`, and loading that script on a cold
  * profile of a service-worker-controlled origin hangs forever in Chromium (the
  * request never settles; warm profiles are immune only because the previous

lib/onlyoffice/guards/unload-prompt.ts

@@ -1,5 +1,5 @@
 /**
- * 11. One unload prompt, and the right one.
+ * 16. One unload prompt, and the right one.
  *
  * The vendor sets `window.onbeforeunload` inside the editor frame whenever the
  * document is editable, so a same-origin frame plus the app's own guard means

test/unit/guards-numbering.test.ts

@@ -0,0 +1,55 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+/**
+ * Every runtime guard has a number, and no two share one.
+ *
+ * The number is the guard's name in prose: CLAUDE.md, the exploration records
+ * and a good many commit messages say "guard 8" or "守卫 10" and expect that to
+ * identify one file. Two of them had drifted into sharing a number by
+ * 2026-09-12 -- comment-selection and font-loading both called themselves 8,
+ * hint-fallback and unload-prompt both 11 -- which quietly made four of those
+ * references ambiguous, and two guards had no number at all.
+ *
+ * Numbers are also the one thing here that must never be recycled: "guard 5"
+ * has to keep meaning what the record that mentions it meant. So this checks
+ * uniqueness and coverage, not that the set is tidy.
+ */
+const GUARDS = resolve(__dirname, '../../lib/onlyoffice/guards');
+
+/** The leading `N.` or `Guard N` of a file's own doc comment. */
+function numberOf(source: string): number | null {
+  const match = /^ \* (?:Guard )?(\d+)[.:]?\s/m.exec(source.slice(0, 400));
+  return match ? Number(match[1]) : null;
+}
+
+describe('runtime guard numbering', () => {
+  const files = readdirSync(GUARDS).filter((name) => name.endsWith('.ts'));
+
+  it('finds the guards (a bad path would make the checks below vacuous)', () => {
+    expect(files.length).toBeGreaterThanOrEqual(16);
+  });
+
+  it('gives every guard a number', () => {
+    const unnumbered = files.filter((name) => numberOf(readFileSync(resolve(GUARDS, name), 'utf8')) === null);
+    expect(unnumbered, 'guards without a number in their doc comment').toEqual([]);
+  });
+
+  it('gives no two guards the same number', () => {
+    const byNumber = new Map<number, string[]>();
+    for (const name of files) {
+      const n = numberOf(readFileSync(resolve(GUARDS, name), 'utf8'))!;
+      byNumber.set(n, [...(byNumber.get(n) ?? []), name]);
+    }
+    const shared = [...byNumber.entries()]
+      .filter(([, names]) => names.length > 1)
+      .map(([n, names]) => `${n}: ${names.join(', ')}`);
+    expect(shared, 'guards sharing a number').toEqual([]);
+  });
+
+  it('numbers them 1..N with no gaps', () => {
+    const numbers = files.map((name) => numberOf(readFileSync(resolve(GUARDS, name), 'utf8'))!).sort((a, b) => a - b);
+    expect(numbers).toEqual(Array.from({ length: files.length }, (_, i) => i + 1));
+  });
+});

test/unit/i18n-completeness.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import { de } from '../../packages/shared/src/i18n/messages/de';
+import { en } from '../../packages/shared/src/i18n/messages/en';
+import { es } from '../../packages/shared/src/i18n/messages/es';
+import { ja } from '../../packages/shared/src/i18n/messages/ja';
+import { ko } from '../../packages/shared/src/i18n/messages/ko';
+import { pt } from '../../packages/shared/src/i18n/messages/pt';
+import { zhCN } from '../../packages/shared/src/i18n/messages/zh-CN';
+import { LanguageCode, SHELL_LOCALES } from '@ranuts/shared/i18n';
+
+/**
+ * Every language this site claims to ship says everything.
+ *
+ * The compiler only enforces that for en and zh-CN: they are typed
+ * `I18nMessages`, the other five are `Partial<I18nMessages>` so that staying
+ * complete is a choice rather than something a half-finished translation
+ * cannot compile against. The cost of that choice is that a missing key is
+ * silent -- `t()` falls back to English, which reads like a translation
+ * somebody chose rather than one nobody wrote.
+ *
+ * CLAUDE.md and the README both say all seven tables are complete. This is
+ * what makes that true rather than aspirational, and it is the check a new UI
+ * string has to pass: add it to en, and this fails until the other six have it.
+ *
+ * Imported from source rather than from the built package: the tables are
+ * internal, and the point is to compare them against each other.
+ */
+// Keyed by the internal language code, which is what SHELL_LOCALES holds --
+// `zh` there, `zh-CN` as a file name and as the tag the vendor wants.
+const asTable = (table: object): Record<string, unknown> => table as Record<string, unknown>;
+
+const TABLES: Record<string, Record<string, unknown>> = {
+  [LanguageCode.EN]: asTable(en),
+  [LanguageCode.ZH]: asTable(zhCN),
+  [LanguageCode.JA]: asTable(ja),
+  [LanguageCode.KO]: asTable(ko),
+  [LanguageCode.DE]: asTable(de),
+  [LanguageCode.ES]: asTable(es),
+  [LanguageCode.PT]: asTable(pt),
+};
+
+describe('message tables', () => {
+  it('covers every language the shell offers (and nothing it does not)', () => {
+    expect(Object.keys(TABLES).sort()).toEqual([...SHELL_LOCALES].sort());
+  });
+
+  it('gives every language every string en has', () => {
+    const reference = Object.keys(en).sort();
+    expect(reference.length).toBeGreaterThan(50);
+    for (const [locale, table] of Object.entries(TABLES)) {
+      const missing = reference.filter((key) => !(key in table));
+      expect(missing, `${locale} is missing ${missing.length} string(s)`).toEqual([]);
+    }
+  });
+
+  it('has no string a language invented on its own', () => {
+    // An extra key is a typo that will never be read -- `t()` looks up by the
+    // name en uses.
+    const reference = new Set(Object.keys(en));
+    for (const [locale, table] of Object.entries(TABLES)) {
+      const extra = Object.keys(table).filter((key) => !reference.has(key));
+      expect(extra, `${locale} has ${extra.length} string(s) en does not`).toEqual([]);
+    }
+  });
+
+  it('leaves no string empty', () => {
+    for (const [locale, table] of Object.entries(TABLES)) {
+      const blank = Object.entries(table)
+        .filter(([, value]) => typeof value === 'string' && value.trim() === '')
+        .map(([key]) => key);
+      expect(blank, `${locale} has blank string(s)`).toEqual([]);
+    }
+  });
+});