@glossarist/concept-browser 0.7.77 → 0.7.80

package/src/__tests__/build-edges-redundancy.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+/**
+ * Tests for warnBinaryPartitiveRedundancy.
+ *
+ * The function lives inside scripts/build-edges.js (not exported). To
+ * test it in isolation we re-implement the same logic here and verify
+ * the behavior. The production function uses console.warn — we check
+ * the contract by inspecting what gets warned.
+ */
+const BINARY_PARTITIVE_TYPES = new Set(['has_part', 'is_part_of', 'broader_partitive', 'narrower_partitive']);
+
+interface TestEdge {
+  source: string;
+  target: string;
+  type: string;
+}
+
+interface TestRelation {
+  comprehensive: string;
+  partitives?: Array<{ uri?: string } | string>;
+}
+
+function findRedundantBinaries(edges: TestEdge[], relations: TestRelation[]): TestEdge[] {
+  if (!relations?.length) return [];
+  const partitivePairs = new Set<string>();
+  for (const rel of relations) {
+    const members = rel.partitives ?? [];
+    for (const member of members) {
+      const memberUri = typeof member === 'string' ? member : (member.uri ?? '');
+      partitivePairs.add(`${rel.comprehensive}|${memberUri}`);
+      partitivePairs.add(`${memberUri}|${rel.comprehensive}`);
+    }
+  }
+  return edges.filter((e: TestEdge) =>
+    BINARY_PARTITIVE_TYPES.has(e.type)
+    && partitivePairs.has(`${e.source}|${e.target}`),
+  );
+}
+
+describe('binary has_part vs PartitiveRelation redundancy (TODO item 14)', () => {
+  beforeEach(() => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns no redundancies when PartitiveRelation has no members', () => {
+    const edges = [{ source: 'A', target: 'B', type: 'has_part' }];
+    const relations = [{ comprehensive: 'A', partitives: [] }];
+    expect(findRedundantBinaries(edges, relations)).toEqual([]);
+  });
+
+  it('returns no redundancies when there are no binary has_part edges', () => {
+    const edges = [{ source: 'A', target: 'B', type: 'related_concept' }];
+    const relations = [{ comprehensive: 'A', partitives: [{ uri: 'B' }, { uri: 'C' }] }];
+    expect(findRedundantBinaries(edges, relations)).toEqual([]);
+  });
+
+  it('flags binary has_part that duplicates a PartitiveRelation member', () => {
+    const edges = [
+      { source: 'A', target: 'B', type: 'has_part' },
+      { source: 'A', target: 'C', type: 'has_part' },
+    ];
+    const relations = [{ comprehensive: 'A', partitives: [{ uri: 'B' }, { uri: 'C' }, { uri: 'D' }] }];
+    const flagged = findRedundantBinaries(edges, relations);
+    expect(flagged).toHaveLength(2);
+  });
+
+  it('flags inverse direction (is_part_of)', () => {
+    const edges = [{ source: 'B', target: 'A', type: 'is_part_of' }];
+    const relations = [{ comprehensive: 'A', partitives: [{ uri: 'B' }] }];
+    expect(findRedundantBinaries(edges, relations)).toHaveLength(1);
+  });
+
+  it('does not flag non-partitive binary types', () => {
+    const edges = [
+      { source: 'A', target: 'B', type: 'broader_generic' },
+      { source: 'A', target: 'B', type: 'related_concept' },
+    ];
+    const relations = [{ comprehensive: 'A', partitives: [{ uri: 'B' }] }];
+    expect(findRedundantBinaries(edges, relations)).toEqual([]);
+  });
+
+  it('handles broader_partitive / narrower_partitive', () => {
+    const edges = [
+      { source: 'A', target: 'B', type: 'broader_partitive' },
+      { source: 'B', target: 'A', type: 'narrower_partitive' },
+    ];
+    const relations = [{ comprehensive: 'A', partitives: [{ uri: 'B' }, { uri: 'C' }] }];
+    expect(findRedundantBinaries(edges, relations)).toHaveLength(2);
+  });
+
+  it('ignores legacy v1 parts field (no partitives key present)', () => {
+    const edges: TestEdge[] = [{ source: 'A', target: 'B', type: 'has_part' }];
+    const relations = [{ comprehensive: 'A' }] as TestRelation[];
+    expect(findRedundantBinaries(edges, relations)).toEqual([]);
+  });
+});

package/src/__tests__/composables/use-concept-diff.test.ts

@@ -0,0 +1,240 @@
+import { describe, it, expect } from 'vitest';
+import {
+  toDiffableConcept,
+  deriveDiffSections,
+  computeSimilarity,
+  useConceptDiff,
+} from '../../composables/use-concept-diff';
+import type { ConceptDiff } from 'glossarist/diff';
+
+describe('useConceptDiff', () => {
+  describe('toDiffableConcept', () => {
+    it('reads id from conceptId', () => {
+      const c = toDiffableConcept({ conceptId: '1.2.3' });
+      expect(c.id).toBe('1.2.3');
+      expect(c.termid).toBe('1.2.3');
+    });
+
+    it('falls back to id', () => {
+      const c = toDiffableConcept({ id: 'abc' });
+      expect(c.id).toBe('abc');
+    });
+
+    it('collects languages from localizations', () => {
+      const c = toDiffableConcept({
+        id: 'x',
+        localizations: { eng: {}, fra: {} },
+      });
+      expect(c.languages).toEqual(['eng', 'fra']);
+    });
+
+    it('returns null from localization() for unknown lang', () => {
+      const c = toDiffableConcept({ id: 'x', localizations: { eng: {} } });
+      expect(c.localization('deu')).toBeNull();
+    });
+
+    it('localization() returns terms/definitions/notes/examples with defaults', () => {
+      const c = toDiffableConcept({
+        id: 'x',
+        localizations: { eng: { terms: ['t'] } },
+      });
+      const lc = c.localization('eng');
+      expect(lc).not.toBeNull();
+      expect(lc?.terms).toEqual(['t']);
+      expect(lc?.definitions).toEqual([]);
+      expect(lc?.languageCode).toBe('eng');
+    });
+  });
+
+  describe('deriveDiffSections', () => {
+    it('returns empty for null', () => {
+      expect(deriveDiffSections(null, 'eng')).toEqual({});
+    });
+
+    it('returns empty when no localization for lang', () => {
+      const diff = {
+        localization: () => null,
+        localizations: {},
+      } as unknown as ConceptDiff;
+      expect(deriveDiffSections(diff, 'eng')).toEqual({});
+    });
+
+    it('extracts added definition', () => {
+      const diff = {
+        localization: () => ({
+          definitions: { added: [{ value: { content: 'new def' } }] },
+        }),
+      } as unknown as ConceptDiff;
+      const s = deriveDiffSections(diff, 'eng');
+      expect(s.definition?.type).toBe('added');
+      expect(s.definition?.value).toBe('new def');
+    });
+
+    it('extracts removed definition', () => {
+      const diff = {
+        localization: () => ({
+          definitions: { removed: [{ value: { content: 'old def' } }] },
+        }),
+      } as unknown as ConceptDiff;
+      const s = deriveDiffSections(diff, 'eng');
+      expect(s.definition?.type).toBe('removed');
+      expect(s.definition?.value).toBe('old def');
+    });
+
+    it('extracts changed definition hunks', () => {
+      const hunks = [
+        { type: 'equal', text: 'a' },
+        { type: 'added', text: 'b' },
+      ];
+      const diff = {
+        localization: () => ({
+          definitions: { changed: [{ textDiff: { hunks } }] },
+        }),
+      } as unknown as ConceptDiff;
+      const s = deriveDiffSections(diff, 'eng');
+      expect(s.definition?.hunks).toEqual(hunks);
+    });
+
+    it('extracts designations (added + removed + changed)', () => {
+      const diff = {
+        localization: () => ({
+          designations: {
+            added: [{ value: { designation: 'new' } }],
+            removed: [{ value: { designation: 'old' } }],
+            changed: [{ oldValue: { designation: 'a' }, newValue: { designation: 'b' } }],
+          },
+        }),
+      } as unknown as ConceptDiff;
+      const s = deriveDiffSections(diff, 'eng');
+      expect(s.designations?.items).toEqual([
+        { type: 'added', text: 'new' },
+        { type: 'removed', text: 'old' },
+        { type: 'removed', text: 'a' },
+        { type: 'added', text: 'b' },
+      ]);
+    });
+
+    it('extracts notes and examples', () => {
+      const diff = {
+        localization: () => ({
+          notes: { added: [{ value: { content: 'n1' } }] },
+          examples: { removed: [{ value: { content: 'e1' } }] },
+        }),
+      } as unknown as ConceptDiff;
+      const s = deriveDiffSections(diff, 'eng');
+      expect(s.notes?.items).toEqual([{ type: 'added', text: 'n1' }]);
+      expect(s.examples?.items).toEqual([{ type: 'removed', text: 'e1' }]);
+    });
+
+    it('prefers changed hunks over added/removed when both present', () => {
+      const diff = {
+        localization: () => ({
+          definitions: {
+            changed: [{ textDiff: { hunks: [{ type: 'equal', text: 'x' }] } }],
+            added: [{ value: 'should-be-ignored' }],
+          },
+        }),
+      } as unknown as ConceptDiff;
+      const s = deriveDiffSections(diff, 'eng');
+      expect(s.definition?.hunks).toHaveLength(1);
+      expect(s.definition?.type).toBeUndefined();
+    });
+  });
+
+  describe('computeSimilarity', () => {
+    it('returns null for null diff', () => {
+      expect(computeSimilarity(null)).toBeNull();
+    });
+
+    it('returns null when no stats', () => {
+      const diff = {} as ConceptDiff;
+      expect(computeSimilarity(diff)).toBeNull();
+    });
+
+    it('returns null when total is 0', () => {
+      const diff = { stats: { added: 0, removed: 0, changed: 0, total: 0 } } as unknown as ConceptDiff;
+      expect(computeSimilarity(diff)).toBeNull();
+    });
+
+    it('returns 1.0 when nothing changed', () => {
+      const diff = { stats: { added: 0, removed: 0, changed: 0, total: 10 } } as unknown as ConceptDiff;
+      expect(computeSimilarity(diff)).toBe(1);
+    });
+
+    it('returns 0 when everything changed', () => {
+      const diff = { stats: { added: 5, removed: 5, changed: 0, total: 10 } } as unknown as ConceptDiff;
+      expect(computeSimilarity(diff)).toBe(0);
+    });
+
+    it('computes partial similarity', () => {
+      const diff = { stats: { added: 1, removed: 1, changed: 0, total: 10 } } as unknown as ConceptDiff;
+      expect(computeSimilarity(diff)).toBe(0.8);
+    });
+
+    it('clamps to [0, 1]', () => {
+      const over = { stats: { added: 100, removed: 100, changed: 100, total: 10 } } as unknown as ConceptDiff;
+      expect(computeSimilarity(over)).toBe(0);
+    });
+  });
+
+  describe('useConceptDiff composable', () => {
+    it('starts empty', () => {
+      const { diffResult, loading, error } = useConceptDiff();
+      expect(diffResult.value).toBeNull();
+      expect(loading.value).toBe(false);
+      expect(error.value).toBeNull();
+    });
+
+    it('clear() resets state', () => {
+      const { diffResult, error, clear } = useConceptDiff();
+      diffResult.value = {} as ConceptDiff;
+      error.value = 'oops';
+      clear();
+      expect(diffResult.value).toBeNull();
+      expect(error.value).toBeNull();
+    });
+
+    it('diff() sets a ConceptDiff for two real concepts', () => {
+      const { diffResult, diff } = useConceptDiff();
+      const oldData = {
+        id: '1',
+        localizations: {
+          eng: { terms: [{ designation: 'old term', type: 'expression', normative_status: 'preferred' }] },
+        },
+      };
+      const newData = {
+        id: '1',
+        localizations: {
+          eng: { terms: [{ designation: 'new term', type: 'expression', normative_status: 'preferred' }] },
+        },
+      };
+      diff(oldData, newData);
+      expect(diffResult.value).not.toBeNull();
+      expect(diffResult.value?.oldId).toBe('1');
+      expect(diffResult.value?.newId).toBe('1');
+    });
+
+    it('diff() against identical concepts reports hasChanges=false', () => {
+      const { diffResult, diff } = useConceptDiff();
+      const data = {
+        id: '1',
+        localizations: {
+          eng: { terms: [{ designation: 'same', type: 'expression', normative_status: 'preferred' }] },
+        },
+      };
+      diff(data, data);
+      expect(diffResult.value?.hasChanges).toBe(false);
+    });
+
+    it('diff() catches errors and exposes them', () => {
+      const { error, diffResult, diff } = useConceptDiff();
+      // A concept whose `localization` throws — simulates malformed input
+      const bad = {
+        get localizations() { throw new Error('boom'); },
+      } as any;
+      diff(bad, bad);
+      expect(error.value).toBeTruthy();
+      expect(diffResult.value).toBeNull();
+    });
+  });
+});

package/src/__tests__/composables/use-concept-edges-v2.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect } from 'vitest';
+import type { PartitiveRelation, PartitiveMember, TypeSharedPlurality, ConceptRef } from 'glossarist';
+import {
+  PartitiveRelation as PartitiveRelationModel,
+  PartitiveMember as PartitiveMemberModel,
+  TypeSharedPlurality as TypeSharedPluralityModel,
+  ConceptRef as ConceptRefModel,
+} from 'glossarist/models';
+
+/**
+ * Verifies glossarist-js's native v2 PartitiveRelation model.
+ *
+ * The concept-browser now consumes this directly (no `as any`
+ * bridge). These specs lock in the contract so an upstream
+ * regression is caught here.
+ */
+
+function makeRef(source: string, id: string): ConceptRef {
+  return ConceptRefModel.fromJSON({ source, id }) as ConceptRef;
+}
+
+function makePartitive(source: string, id: string, certainty?: 'confirmed' | 'possible'): PartitiveMember {
+  const data: { ref: ConceptRef; certainty?: 'confirmed' | 'possible' } = { ref: makeRef(source, id) };
+  if (certainty) data.certainty = certainty;
+  return PartitiveMemberModel.fromJSON(data as unknown as Record<string, unknown>) as PartitiveMember;
+}
+
+function makePlurality(isShared: boolean, isUncertain = false): TypeSharedPlurality {
+  return TypeSharedPluralityModel.fromJSON({ isShared, isUncertain }) as TypeSharedPlurality;
+}
+
+function makeRelation(opts: {
+  comprehensive: ConceptRef;
+  partitives: PartitiveMember[];
+  completeness?: 'complete' | 'partial';
+  plurality?: TypeSharedPlurality | null;
+  criterion?: Record<string, string>;
+}): PartitiveRelation {
+  return PartitiveRelationModel.fromJSON(opts as unknown as Record<string, unknown>) as PartitiveRelation;
+}
+
+describe('native v2 PartitiveRelation model (glossarist 0.4.20)', () => {
+  it('PartitiveMember.certainty defaults to confirmed when omitted', () => {
+    const m = makePartitive('test', '1.4');
+    expect(m.certainty).toBe('confirmed');
+  });
+
+  it('PartitiveMember.certainty is preserved when set to possible', () => {
+    const m = makePartitive('test', '1.4', 'possible');
+    expect(m.certainty).toBe('possible');
+    expect(m.isPossible).toBe(true);
+  });
+
+  it('PartitiveMember.ref exposes the typed ConceptRef', () => {
+    const m = makePartitive('test', '1.4');
+    expect(m.ref.source).toBe('test');
+    expect(m.ref.id).toBe('1.4');
+  });
+
+  it('PartitiveRelation has completeness default of complete', () => {
+    const r = makeRelation({
+      comprehensive: makeRef('test', '1.3'),
+      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+    });
+    expect(r.completeness).toBe('complete');
+    expect(r.isComplete).toBe(true);
+  });
+
+  it('PartitiveRelation preserves explicit partial completeness', () => {
+    const r = makeRelation({
+      comprehensive: makeRef('test', '1.3'),
+      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+      completeness: 'partial',
+    });
+    expect(r.completeness).toBe('partial');
+    expect(r.isPartial).toBe(true);
+  });
+
+  it('PartitiveRelation accepts plurality', () => {
+    const r = makeRelation({
+      comprehensive: makeRef('test', '1.3'),
+      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+      plurality: makePlurality(true, true),
+    });
+    expect(r.hasPlurality()).toBe(true);
+    expect(r.plurality?.isShared).toBe(true);
+    expect(r.plurality?.isUncertain).toBe(true);
+  });
+
+  it('PartitiveRelation accepts criterion as localized hash', () => {
+    const r = makeRelation({
+      comprehensive: makeRef('test', '1.3'),
+      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+      criterion: { eng: 'physical structure', fra: 'structure physique' },
+    });
+    expect(r.hasCriterion()).toBe(true);
+    expect(r.criterion?.eng).toBe('physical structure');
+  });
+
+  it('rejects < 2 partitives (ISO 704 requirement)', () => {
+    expect(() => makeRelation({
+      comprehensive: makeRef('test', '1.3'),
+      partitives: [makePartitive('test', '1.4')],
+    })).toThrow(/≥2 partitives/);
+  });
+
+  it('rejects self-loops', () => {
+    expect(() => makeRelation({
+      comprehensive: makeRef('test', '1.3'),
+      partitives: [
+        makePartitive('test', '1.3'),
+        makePartitive('test', '1.4'),
+      ],
+    })).toThrow(/self-loop/);
+  });
+
+  it('round-trips through toJSON with v2 shape', () => {
+    const r = makeRelation({
+      comprehensive: makeRef('test', '1.3'),
+      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5', 'possible')],
+      completeness: 'partial',
+      plurality: makePlurality(true),
+      criterion: { eng: 'criterion text' },
+    });
+    const json = r.toJSON();
+    expect(json.completeness).toBe('partial');
+    expect(json.partitives).toHaveLength(2);
+    expect(json.partitives[1].certainty).toBe('possible');
+    expect(json.plurality?.is_shared).toBe(true);
+    expect(json.criterion?.eng).toBe('criterion text');
+  });
+});

package/src/__tests__/composables/use-dataset-stats.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ref, nextTick } from 'vue';
+import { useDatasetStats } from '../../composables/use-dataset-stats';
+
+const okResponse = (body: unknown) => ({
+  ok: true,
+  json: async () => body,
+});
+const notFoundResponse = () => ({ ok: false, json: async () => null });
+
+describe('useDatasetStats', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    vi.restoreAllMocks();
+  });
+
+  it('starts with null stats', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(okResponse(null) as any);
+    const { stats, loading } = useDatasetStats(() => 'reg-1', '/');
+    expect(stats.value).toBeNull();
+    await nextTick();
+    await nextTick();
+    await nextTick();
+    expect(loading.value).toBe(false);
+  });
+
+  it('loads stats.json for the resolved registerId', async () => {
+    const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      okResponse({
+        sourceCount: 5,
+        sources: [],
+        relationshipCount: 12,
+        relationshipTypes: { supersedes: 3 },
+      }) as any,
+    );
+    const { stats } = useDatasetStats(() => 'reg-1', '/');
+    await nextTick();
+    await nextTick();
+    expect(fetchMock).toHaveBeenCalledWith('/data/reg-1/stats.json');
+    expect(stats.value?.sourceCount).toBe(5);
+    expect(stats.value?.relationshipCount).toBe(12);
+  });
+
+  it('handles 404 gracefully (stats stays null)', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(notFoundResponse() as any);
+    const { stats, error } = useDatasetStats(() => 'reg-1', '/');
+    await nextTick();
+    await nextTick();
+    expect(stats.value).toBeNull();
+    expect(error.value).toBeNull();
+  });
+
+  it('handles network errors and exposes error message', async () => {
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('network down'));
+    const { stats, error } = useDatasetStats(() => 'reg-1', '/');
+    await nextTick();
+    await nextTick();
+    await nextTick();
+    expect(stats.value).toBeNull();
+    expect(error.value).toBe('network down');
+  });
+
+  it('reacts to registerId change (Ref form)', async () => {
+    const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      okResponse({ sourceCount: 1, sources: [], relationshipCount: 0, relationshipTypes: {} }) as any,
+    );
+    const registerId = ref('reg-a');
+    useDatasetStats(registerId, '/');
+    await nextTick();
+    expect(fetchMock).toHaveBeenLastCalledWith('/data/reg-a/stats.json');
+
+    registerId.value = 'reg-b';
+    await nextTick();
+    await nextTick();
+    expect(fetchMock).toHaveBeenLastCalledWith('/data/reg-b/stats.json');
+  });
+
+  it('reload() re-fetches the same id', async () => {
+    const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      okResponse({ sourceCount: 7, sources: [], relationshipCount: 0, relationshipTypes: {} }) as any,
+    );
+    const { reload } = useDatasetStats(() => 'reg-1', '/');
+    await nextTick();
+    await nextTick();
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    reload();
+    await nextTick();
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+});

package/src/__tests__/config/page-types.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import {
+  PAGE_TYPES,
+  pageTypeOf,
+  synthesizePages,
+} from '../../config/page-types';
+
+describe('page-types', () => {
+  describe('PAGE_TYPES registry', () => {
+    it('includes home (global index)', () => {
+      expect(pageTypeOf('home')?.scope).toBe('global');
+      expect(pageTypeOf('home')?.route).toBe('');
+    });
+
+    it('includes concepts (dataset index)', () => {
+      expect(pageTypeOf('concepts')?.scope).toBe('dataset');
+      expect(pageTypeOf('concepts')?.route).toBe('');
+    });
+
+    it('includes sources (always synthesized for datasets)', () => {
+      const sources = pageTypeOf('sources');
+      expect(sources?.scope).toBe('dataset');
+      expect(sources?.featureFlag).toBeUndefined();
+      expect(sources?.autoSynthesize).toBe(true);
+    });
+
+    it('each entry has unique type', () => {
+      const types = PAGE_TYPES.map(p => p.type);
+      expect(new Set(types).size).toBe(types.length);
+    });
+
+    it('each entry has unique (scope, route) for autoSynthesized', () => {
+      const auto = PAGE_TYPES.filter(p => p.autoSynthesize);
+      const keys = auto.map(p => `${p.scope}:${p.route}`);
+      expect(new Set(keys).size).toBe(keys.length);
+    });
+  });
+
+  describe('synthesizePages', () => {
+    it('synthesizes global pages respecting default-on features', () => {
+      const pages = synthesizePages('global', {}, new Set());
+      const routes = pages.map(p => p.route);
+      expect(routes).toContain('search');
+      expect(routes).toContain('graph');
+      expect(routes).toContain('ontology');
+      expect(routes).not.toContain('news');
+    });
+
+    it('synthesizes news only when feature flag is truthy', () => {
+      const without = synthesizePages('global', {}, new Set());
+      const withFlag = synthesizePages('global', { news: true }, new Set());
+      expect(without.find(p => p.type === 'news')).toBeUndefined();
+      expect(withFlag.find(p => p.type === 'news')).toBeDefined();
+    });
+
+    it('respects feature off (search=false)', () => {
+      const pages = synthesizePages('global', { search: false }, new Set());
+      expect(pages.find(p => p.type === 'search')).toBeUndefined();
+    });
+
+    it('synthesizes dataset pages', () => {
+      const pages = synthesizePages('dataset', {}, new Set());
+      const types = pages.map(p => p.type);
+      expect(types).toContain('concepts');
+      expect(types).toContain('stats');
+      expect(types).toContain('sources');
+      expect(types).toContain('about');
+    });
+
+    it('skips routes already declared', () => {
+      const pages = synthesizePages('dataset', {}, new Set(['stats']));
+      expect(pages.find(p => p.type === 'stats')).toBeUndefined();
+    });
+
+    it('does not cross-contaminate scopes', () => {
+      const global = synthesizePages('global', {}, new Set());
+      const dataset = synthesizePages('dataset', {}, new Set());
+      expect(global.find(p => p.scope === 'dataset')).toBeUndefined();
+      expect(dataset.find(p => p.scope === 'global')).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/model-bridge-bridges.test.ts

@@ -135,8 +135,9 @@ describe('model-bridge — citation bridge round-trip', () => {
     const lc = concept.localization('eng')!;
     const rc = lc.related[0];
 
-    // All fields preserved through the bridge
-    expect(rc.content).toBe('entity');
+    // All fields preserved through the bridge (glossarist 0.4.20+
+    // normalizes content to a localized hash)
+    expect(rc.content).toEqual({ default: 'entity' });
     expect(getRelatedSourceId(rc)).toBe('vim-2.2');
 
     const citation = getRelatedCitation(rc)!;

package/src/__tests__/model-bridge-citation.test.ts

@@ -60,7 +60,7 @@ describe('model-bridge — reference citation mapping via WeakMap bridges', () =
     const lc = concept.localization('eng')!;
     const related = lc.related;
     expect(related).toHaveLength(1);
-    expect(related[0].content).toBe('entity data type');
+    expect(related[0].content).toEqual({ default: 'entity data type' });
     expect(getRelatedSourceId(related[0])).toBe('iso-10303-2-def');
   });