@lokascript/i18n 2.11.1 → 3.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lokascript/i18n",
-  "version": "2.11.1",
-  "description": "Grammar transformation and keyword translation for hyperscript",
+  "version": "3.0.0",
+  "description": "Keyword dictionaries, keyword providers and grammar profiles for hyperscript",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -64,8 +64,8 @@
   },
   "homepage": "https://github.com/codetalcott/hyperfixi/tree/main/packages/i18n#readme",
   "dependencies": {
-    "@hyperfixi/core": "^2.11.1",
-    "@lokascript/semantic": "^2.11.1",
+    "@hyperfixi/core": "^3.0.0",
+    "@lokascript/semantic": "^3.0.0",
     "esbuild": "^0.28.0",
     "happy-dom": "^20.10.6",
     "vite": "^8.1.4"

package/src/browser.ts

@@ -137,11 +137,4 @@ export {
   getDirectMapping,
   translateWordDirect,
   getSupportedDirectPairs,
-  // Transformer
-  GrammarTransformer,
-  parseStatement,
-  toLocale,
-  toEnglish,
-  translate,
-  examples as grammarExamples,
 } from './grammar';

package/src/compatibility/browser-tests/grammar-demo.spec.ts

@@ -6,6 +6,11 @@
  */
 import { test, expect } from '@playwright/test';
 
+// NOTE (2026-08-28): no `playwright.config` in this package points at this
+// directory — core's config has `testDir: './src/compatibility/browser-tests'`,
+// which is core's own tree — so CI does not run this file. It is kept correct
+// rather than deleted, but do not read a green CI as evidence it passes.
+
 test.describe('Grammar Transformation Demo', () => {
   test.beforeEach(async ({ page }) => {
     await page.goto('http://127.0.0.1:3000/examples/multilingual/index.html');
@@ -13,17 +18,26 @@ test.describe('Grammar Transformation Demo', () => {
     await page.waitForFunction(() => window.LokaScriptI18n !== undefined, { timeout: 5000 });
   });
 
-  test('should load LokaScriptI18n bundle with GrammarTransformer', async ({ page }) => {
+  test('the i18n bundle exposes vocabulary and profiles, not a translator', async ({ page }) => {
+    // Was `should load LokaScriptI18n bundle with GrammarTransformer`. That
+    // bundle no longer carries a translator: the grammar transformer was retired
+    // 2026-08-28 (4/24 canonical-valid on an en -> L -> en round trip against the
+    // real hyperscript.org parser, where semantic measures 24/24). The demo page
+    // translates through `hyperfixi.translate`, which IS semantic's.
     const hasI18n = await page.evaluate(() => !!window.LokaScriptI18n);
     expect(hasI18n).toBe(true);
 
-    const hasTransformer = await page.evaluate(() => !!window.LokaScriptI18n.GrammarTransformer);
-    expect(hasTransformer).toBe(true);
-
-    const hasTranslate = await page.evaluate(
-      () => typeof window.LokaScriptI18n.translate === 'function'
-    );
-    expect(hasTranslate).toBe(true);
+    const surface = await page.evaluate(() => ({
+      transformer: typeof (window.LokaScriptI18n as Record<string, unknown>).GrammarTransformer,
+      translate: typeof (window.LokaScriptI18n as Record<string, unknown>).translate,
+      getProfile: typeof (window.LokaScriptI18n as Record<string, unknown>).getProfile,
+      hyperfixiTranslate: typeof (window as unknown as { hyperfixi?: Record<string, unknown> })
+        .hyperfixi?.translate,
+    }));
+    expect(surface.transformer).toBe('undefined');
+    expect(surface.translate).toBe('undefined');
+    expect(surface.getProfile).toBe('function');
+    expect(surface.hyperfixiTranslate).toBe('function');
   });
 
   test('should have profile functions available', async ({ page }) => {

package/src/constants.ts

@@ -61,6 +61,7 @@ export const COMMAND_PRIMARY_ROLES: Readonly<Record<string, SemanticRole>> = {
   if: 'condition',
   unless: 'condition',
   while: 'condition',
+  when: 'condition', // reactive `when <expr> changes` — the watched expression
   repeat: 'loopType',
   go: 'destination',
   scroll: 'destination',

package/src/dictionaries/bn.ts

@@ -181,7 +181,11 @@ export const bengaliDictionary: Dictionary = {
     random: 'এলোমেলো',
     length: 'দৈর্ঘ্য',
     index: 'সূচক',
-    empty: 'খালি-করুন',
+    // The EXPRESSION `empty` is the state predicate (`if my value is empty`),
+    // not the command: `খালি-করুন` is the imperative "empty it!" and belongs to
+    // the `empty` COMMAND, which keeps it. Kept in step with the semantic
+    // lexicon by `lexicon-parity.test.ts`.
+    empty: 'খালি',
     'starts with': 'দিয়ে_শুরু',
     'ends with': 'দিয়ে_শেষ',
     'ignoring case': 'কেস_উপেক্ষা',

package/src/grammar/index.ts

@@ -59,12 +59,18 @@ export {
   getSupportedDirectPairs,
 } from './direct-mappings';
 
-// Transformer
-export {
-  GrammarTransformer,
-  parseStatement,
-  toLocale,
-  toEnglish,
-  translate,
-  examples,
-} from './transformer';
+// Transformer — RETIRED 2026-08-28.
+//
+// `transformer.ts` (2,747 lines) exported `GrammarTransformer`, `parseStatement`,
+// `toLocale`, `toEnglish`, `translate` and `examples`. Every consumer has moved to
+// @lokascript/semantic, which is what the 3,657-row corpus is written by and what
+// every runtime surface in this repo already called: `@hyperscript-tools/i18n`
+// (#999), the vite-plugin's generated bundle (#997), and the classic-i18n browser
+// bundle, which dropped the four helpers rather than pay +173 KB gzipped to keep
+// them (#998).
+//
+// The rest of this directory STAYS and is not part of that retirement: `profiles/`
+// is imported by i18n's own `runtime.ts` and re-exported to the classic-i18n
+// bundle; `types.ts` backs `constants.ts` and the role helpers above;
+// `direct-mappings.ts` is part of the browser API (`types-browser/i18n-api.ts`
+// declares it). This was never "delete the grammar directory".

package/src/grammar/profiles.test.ts

@@ -0,0 +1,440 @@
+/**
+ * Grammar PROFILES and role-transformation tests.
+ *
+ * What this file is: the surviving ~400 lines of the old 2,780-line
+ * `grammar.test.ts`, which tested `GrammarTransformer` and the five profile /
+ * role / dictionary describes below in one place. The transformer is retired
+ * (see grammar/index.ts); these are not.
+ *
+ * They cover the half of `grammar/` that STAYS and has its own consumers:
+ * `profiles/` (i18n's `runtime.ts`, and the classic-i18n browser bundle's
+ * `getProfile` / `getSupportedGrammarLocales` / `profiles` surface), the role
+ * helpers in `types.ts` (`reorderRoles` / `insertMarkers` / `joinTokens`, which
+ * `constants.ts` imports from), and the has/have dictionary entries.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  getProfile,
+  getSupportedLocales,
+  profiles,
+  englishProfile,
+  japaneseProfile,
+  chineseProfile,
+  arabicProfile,
+} from './profiles';
+import {
+  reorderRoles,
+  insertMarkers,
+  joinTokens,
+  UNIVERSAL_PATTERNS,
+  LANGUAGE_FAMILY_DEFAULTS,
+  type SemanticRole,
+} from './types';
+
+describe('Language Profiles', () => {
+  it('should have profiles for all supported locales', () => {
+    const locales = getSupportedLocales();
+    // Explicit expected list — when adding a profile, append it here so the
+    // count assertion stays meaningful without becoming a magic number.
+    const expectedLocales = [
+      'en',
+      'ja',
+      'ko',
+      'zh',
+      'ar',
+      'tr',
+      'es',
+      'de',
+      'fr',
+      'pt',
+      'id',
+      'ms',
+      'qu',
+      'sw',
+      'bn',
+      'it',
+      'ru',
+      'uk',
+      'vi',
+      'hi',
+      'tl',
+      'th',
+      'pl',
+      'he',
+    ];
+    for (const code of expectedLocales) {
+      expect(locales, `missing profile: ${code}`).toContain(code);
+    }
+    expect(locales.length).toBe(expectedLocales.length);
+  });
+
+  it('should return undefined for unknown locales', () => {
+    expect(getProfile('xx')).toBeUndefined();
+    expect(getProfile('xyz')).toBeUndefined();
+  });
+
+  describe('English Profile', () => {
+    it('should have SVO word order', () => {
+      expect(englishProfile.wordOrder).toBe('SVO');
+    });
+
+    it('should use prepositions', () => {
+      expect(englishProfile.adpositionType).toBe('preposition');
+    });
+
+    it('should have required markers', () => {
+      const onMarker = englishProfile.markers.find(m => m.form === 'on');
+      expect(onMarker).toBeDefined();
+      expect(onMarker?.role).toBe('event');
+      expect(onMarker?.required).toBe(true);
+    });
+  });
+
+  describe('Japanese Profile', () => {
+    it('should have SOV word order', () => {
+      expect(japaneseProfile.wordOrder).toBe('SOV');
+    });
+
+    it('should use postpositions', () => {
+      expect(japaneseProfile.adpositionType).toBe('postposition');
+    });
+
+    it('should have particle markers', () => {
+      const woMarker = japaneseProfile.markers.find(m => m.form === 'を');
+      expect(woMarker).toBeDefined();
+      expect(woMarker?.role).toBe('patient');
+      expect(woMarker?.position).toBe('postposition');
+    });
+
+    it('should place patient before action in canonical order', () => {
+      const patientIndex = japaneseProfile.canonicalOrder.indexOf('patient');
+      const actionIndex = japaneseProfile.canonicalOrder.indexOf('action');
+      expect(patientIndex).toBeLessThan(actionIndex);
+    });
+  });
+
+  describe('Arabic Profile', () => {
+    it('should have VSO word order', () => {
+      expect(arabicProfile.wordOrder).toBe('VSO');
+    });
+
+    it('should be RTL', () => {
+      expect(arabicProfile.direction).toBe('rtl');
+    });
+
+    it('should place action first in canonical order', () => {
+      expect(arabicProfile.canonicalOrder[0]).toBe('action');
+    });
+  });
+
+  describe('Chinese Profile', () => {
+    it('should have isolating morphology', () => {
+      expect(chineseProfile.morphology).toBe('isolating');
+    });
+
+    it('should have circumfix markers for events', () => {
+      const eventMarkers = chineseProfile.markers.filter(m => m.role === 'event');
+      const hasPreposition = eventMarkers.some(m => m.position === 'preposition');
+      const hasPostposition = eventMarkers.some(m => m.position === 'postposition');
+      expect(hasPreposition).toBe(true);
+      expect(hasPostposition).toBe(true);
+    });
+  });
+});
+
+// =============================================================================
+// Statement Parsing Tests
+// =============================================================================
+
+describe('Role Transformation', () => {
+  describe('reorderRoles', () => {
+    it('should reorder roles according to target order', () => {
+      const roles = new Map<SemanticRole, ParsedElement>([
+        ['action', { role: 'action', value: 'increment' }],
+        ['patient', { role: 'patient', value: '#count' }],
+        ['event', { role: 'event', value: 'click' }],
+      ]);
+
+      // Japanese order: patient, event, action
+      const reordered = reorderRoles(roles, ['patient', 'event', 'action']);
+
+      expect(reordered[0].role).toBe('patient');
+      expect(reordered[1].role).toBe('event');
+      expect(reordered[2].role).toBe('action');
+    });
+
+    it('should skip roles not present in input', () => {
+      const roles = new Map<SemanticRole, ParsedElement>([
+        ['action', { role: 'action', value: 'toggle' }],
+        ['patient', { role: 'patient', value: '.active' }],
+      ]);
+
+      const reordered = reorderRoles(roles, ['patient', 'destination', 'action']);
+
+      expect(reordered.length).toBe(2);
+      expect(reordered[0].role).toBe('patient');
+      expect(reordered[1].role).toBe('action');
+    });
+  });
+
+  describe('insertMarkers', () => {
+    it('should insert preposition markers before elements', () => {
+      const elements: ParsedElement[] = [
+        { role: 'destination', value: '#output', translated: '#output' },
+      ];
+      const markers = [
+        {
+          form: 'to',
+          role: 'destination' as SemanticRole,
+          position: 'preposition' as const,
+          required: false,
+        },
+      ];
+
+      const result = insertMarkers(elements, markers, 'preposition');
+      expect(result).toEqual(['to', '#output']);
+    });
+
+    it('should insert postposition markers after elements', () => {
+      const elements: ParsedElement[] = [
+        { role: 'patient', value: '#count', translated: '#count' },
+      ];
+      const markers = [
+        {
+          form: 'を',
+          role: 'patient' as SemanticRole,
+          position: 'postposition' as const,
+          required: true,
+        },
+      ];
+
+      const result = insertMarkers(elements, markers, 'postposition');
+      expect(result).toEqual(['#count', 'を']);
+    });
+
+    it('should use translated values when available', () => {
+      const elements: ParsedElement[] = [
+        { role: 'action', value: 'increment', translated: '増加' },
+      ];
+
+      const result = insertMarkers(elements, [], 'none');
+      expect(result).toEqual(['増加']);
+    });
+  });
+
+  describe('joinTokens', () => {
+    it('should join regular tokens with spaces', () => {
+      const result = joinTokens(['hello', 'world']);
+      expect(result).toBe('hello world');
+    });
+
+    it('should handle empty array', () => {
+      const result = joinTokens([]);
+      expect(result).toBe('');
+    });
+
+    it('should handle single token', () => {
+      const result = joinTokens(['hello']);
+      expect(result).toBe('hello');
+    });
+
+    it('should attach suffix markers without space (Quechua -ta)', () => {
+      // #count + -ta → #countta
+      const result = joinTokens(['#count', '-ta']);
+      expect(result).toBe('#countta');
+    });
+
+    it('should attach prefix markers without space (Arabic بـ-)', () => {
+      // بـ- + الماوس → بـالماوس
+      const result = joinTokens(['بـ-', 'الماوس']);
+      expect(result).toBe('بـالماوس');
+    });
+
+    it('should handle multiple suffix markers (Turkish case suffixes)', () => {
+      // value + -i + another → valuei another
+      const result = joinTokens(['value', '-i', 'another']);
+      expect(result).toBe('valuei another');
+    });
+
+    it('should handle Japanese particles with normal spacing', () => {
+      // Japanese particles don't use hyphen notation, so they get spaces
+      const result = joinTokens(['#count', 'を', 'クリック', 'で', '増加']);
+      expect(result).toBe('#count を クリック で 増加');
+    });
+
+    it('should handle Quechua agglutinative chain', () => {
+      // #count + -ta + click + -pi + increment
+      const result = joinTokens(['#count', '-ta', 'click', '-pi', 'increment']);
+      expect(result).toBe('#countta clickpi increment');
+    });
+
+    it('should handle mixed prefix and regular tokens', () => {
+      const result = joinTokens(['كـ-', 'JSON', 'format']);
+      expect(result).toBe('كـJSON format');
+    });
+  });
+});
+
+// =============================================================================
+// Grammar Transformer Tests
+// =============================================================================
+
+describe('Universal Patterns', () => {
+  it('should define event-increment pattern', () => {
+    const pattern = UNIVERSAL_PATTERNS.eventIncrement;
+    expect(pattern.name).toBe('event-increment');
+    expect(pattern.roles).toContain('event');
+    expect(pattern.roles).toContain('action');
+    expect(pattern.roles).toContain('patient');
+  });
+
+  it('should define put-into pattern', () => {
+    const pattern = UNIVERSAL_PATTERNS.putInto;
+    expect(pattern.name).toBe('put-into');
+    expect(pattern.roles).toContain('action');
+    expect(pattern.roles).toContain('patient');
+    expect(pattern.roles).toContain('destination');
+  });
+
+  it('should define wait-duration pattern', () => {
+    const pattern = UNIVERSAL_PATTERNS.waitDuration;
+    expect(pattern.roles).toContain('action');
+    expect(pattern.roles).toContain('quantity');
+  });
+});
+
+// =============================================================================
+// Language Family Defaults Tests
+// =============================================================================
+
+describe('Language Family Defaults', () => {
+  it('should have Germanic defaults', () => {
+    const germanic = LANGUAGE_FAMILY_DEFAULTS.germanic;
+    expect(germanic.wordOrder).toBe('SVO');
+    expect(germanic.adpositionType).toBe('preposition');
+  });
+
+  it('should have Japonic defaults', () => {
+    const japonic = LANGUAGE_FAMILY_DEFAULTS.japonic;
+    expect(japonic.wordOrder).toBe('SOV');
+    expect(japonic.adpositionType).toBe('postposition');
+  });
+
+  it('should have Semitic defaults', () => {
+    const semitic = LANGUAGE_FAMILY_DEFAULTS.semitic;
+    expect(semitic.wordOrder).toBe('VSO');
+    expect(semitic.direction).toBe('rtl');
+  });
+
+  it('should have Sinitic defaults', () => {
+    const sinitic = LANGUAGE_FAMILY_DEFAULTS.sinitic;
+    expect(sinitic.morphology).toBe('isolating');
+  });
+});
+
+// =============================================================================
+// Examples Tests
+// =============================================================================
+
+describe('Has/Have Operator Translations', () => {
+  describe('Dictionary Entries', () => {
+    // Import dictionaries to verify has/have entries exist
+    it('should have has/have in English dictionary', async () => {
+      const { en } = await import('../dictionaries/en');
+      expect(en.logical.has).toBe('has');
+      expect(en.logical.have).toBe('have');
+    });
+
+    it('should have has/have in Spanish dictionary', async () => {
+      const { es } = await import('../dictionaries/es');
+      expect(es.logical.has).toBe('tiene'); // third-person
+      expect(es.logical.have).toBe('tengo'); // first-person
+    });
+
+    it('should have has/have in Japanese dictionary', async () => {
+      const { ja } = await import('../dictionaries/ja');
+      expect(ja.logical.has).toBe('ある');
+      expect(ja.logical.have).toBe('ある');
+    });
+
+    it('should have has/have in German dictionary', async () => {
+      const { de } = await import('../dictionaries/de');
+      expect(de.logical.has).toBe('hat'); // third-person
+      expect(de.logical.have).toBe('habe'); // first-person
+    });
+
+    it('should have has/have in French dictionary', async () => {
+      const { fr } = await import('../dictionaries/fr');
+      expect(fr.logical.has).toBe('a'); // third-person
+      expect(fr.logical.have).toBe('ai'); // first-person
+    });
+
+    it('should have has/have in Korean dictionary', async () => {
+      const { ko } = await import('../dictionaries/ko');
+      expect(ko.logical.has).toBe('있다');
+      expect(ko.logical.have).toBe('있다');
+    });
+
+    it('should have has/have in Chinese dictionary', async () => {
+      const { zh } = await import('../dictionaries/zh');
+      expect(zh.logical.has).toBe('有');
+      expect(zh.logical.have).toBe('有');
+    });
+
+    it('should have has/have in Arabic dictionary', async () => {
+      const { ar } = await import('../dictionaries/ar');
+      expect(ar.logical.has).toBe('لديه'); // third-person
+      expect(ar.logical.have).toBe('لدي'); // first-person
+    });
+  });
+
+  describe('Conjugating Languages', () => {
+    // Languages that have different forms for has (3rd person) vs have (1st person)
+    const conjugatingLanguages = [
+      { code: 'es', has: 'tiene', have: 'tengo' },
+      { code: 'de', has: 'hat', have: 'habe' },
+      { code: 'fr', has: 'a', have: 'ai' },
+      { code: 'pt', has: 'tem', have: 'tenho' },
+      { code: 'it', has: 'ha', have: 'ho' },
+      { code: 'pl', has: 'ma', have: 'mam' },
+    ];
+
+    for (const lang of conjugatingLanguages) {
+      it(`should have different has/have forms in ${lang.code}`, async () => {
+        const dict = await import(`../dictionaries/${lang.code}`);
+        const dictionary = Object.values(dict)[0] as { logical: { has: string; have: string } };
+        expect(dictionary.logical.has).toBe(lang.has);
+        expect(dictionary.logical.have).toBe(lang.have);
+      });
+    }
+  });
+
+  describe('Non-Conjugating Languages', () => {
+    // Languages that use the same form for both has and have
+    const sameFormLanguages = [
+      { code: 'ja', form: 'ある' },
+      { code: 'ko', form: '있다' },
+      { code: 'zh', form: '有' },
+      { code: 'tr', form: 'var' },
+      { code: 'id', form: 'punya' },
+      { code: 'vi', form: 'có' },
+      { code: 'th', form: 'มี' },
+      { code: 'tl', form: 'may' },
+      { code: 'ms', form: 'ada' },
+    ];
+
+    for (const lang of sameFormLanguages) {
+      it(`should have same has/have form in ${lang.code}`, async () => {
+        const dict = await import(`../dictionaries/${lang.code}`);
+        const dictionary = Object.values(dict)[0] as { logical: { has: string; have: string } };
+        expect(dictionary.logical.has).toBe(lang.form);
+        expect(dictionary.logical.have).toBe(lang.form);
+      });
+    }
+  });
+});
+
+// =============================================================================
+// Possessive Dot Notation Translation Tests
+// =============================================================================

package/src/index.ts

@@ -223,11 +223,4 @@ export {
   malayProfile,
   quechuaProfile,
   swahiliProfile,
-  // Transformer
-  GrammarTransformer,
-  parseStatement,
-  toLocale,
-  toEnglish,
-  translate,
-  examples as grammarExamples,
 } from './grammar';

package/src/lexicon-parity.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Profile `lexicon` ↔ i18n Dictionary parity
+ *
+ * The semantic profile gained a `lexicon` block (2026-08-26) carrying the six
+ * Dictionary categories it never modelled — the vocabulary that appears INSIDE
+ * role values (`true`, `value`, `seconds`) rather than as a command verb or a
+ * role marker. The renderer needs it: without it, `set @disabled to true`
+ * renders into Spanish as `… a true` instead of `… a verdadero`, the Spanish
+ * parser cannot bind the value back, and the role is silently dropped.
+ *
+ * This test is the oracle for that move: every entry in the hand-authored
+ * dictionary must be reachable from the profile with the SAME rendering. It
+ * lives in @lokascript/i18n rather than @lokascript/semantic because semantic
+ * builds first and cannot import the dictionaries.
+ *
+ * Direction of authority: the dictionary is the incumbent, so it wins. A
+ * mismatch here means the profile drifted from a curated translation, not that
+ * the dictionary is stale.
+ *
+ * Nothing is deleted while this passes — the dictionaries remain the source for
+ * i18n's own consumers. It exists so a later derive-flip can be made safely.
+ */
+import { describe, it, expect } from 'vitest';
+import { dictionaries } from './dictionaries';
+import { KNOWN_PROFILES, getLexicon } from '@lokascript/semantic';
+import type { LanguageProfile } from '@lokascript/semantic';
+// The lexicons are separate modules so a parse-only consumer can drop them; the
+// package's main entry pulls all 24 in (via `languages/_all`), which is what the
+// import above already gives us. A consumer taking only `core` + `languages/{code}`
+// would get none — that is the point of the split.
+
+const CATEGORIES = [
+  'events',
+  'logical',
+  'temporal',
+  'values',
+  'attributes',
+  'expressions',
+] as const;
+
+const profiles = KNOWN_PROFILES as Readonly<Record<string, LanguageProfile>>;
+const codes = Object.keys(dictionaries).filter(c => profiles[c]);
+
+describe('profile.lexicon ↔ i18n dictionary parity', () => {
+  it('covers every language that has both a dictionary and a profile', () => {
+    expect(codes.length).toBe(24);
+  });
+
+  describe.each(codes)('%s', code => {
+    const dict = dictionaries[code] as unknown as Record<string, Record<string, string>>;
+    const lexicon = (getLexicon(code) ?? {}) as Record<string, Record<string, { primary: string }>>;
+
+    it('has registered render vocabulary', () => {
+      expect(getLexicon(code), `${code} has no registered lexicon`).toBeDefined();
+    });
+
+    for (const category of CATEGORIES) {
+      const entries = dict[category] ?? {};
+      const keys = Object.keys(entries);
+      if (keys.length === 0) continue;
+
+      it(`${category}: all ${keys.length} dictionary entries are present with the same rendering`, () => {
+        const missing: string[] = [];
+        const diverged: string[] = [];
+        for (const key of keys) {
+          const onProfile = lexicon[category]?.[key];
+          if (!onProfile) {
+            missing.push(key);
+          } else if (onProfile.primary !== entries[key]) {
+            diverged.push(`${key}: profile=${onProfile.primary} dictionary=${entries[key]}`);
+          }
+        }
+        expect({ missing, diverged }).toEqual({ missing: [], diverged: [] });
+      });
+    }
+  });
+});