@glossarist/concept-browser 0.3.7 → 0.4.0

package/src/__tests__/designation-registry.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect } from 'vitest';
+import { Expression, Abbreviation } from 'glossarist';
+import {
+  designationTypeInfo,
+  normativeStatusInfo,
+  abbreviationDetails,
+  grammarBadges,
+  pronunciationLabel,
+  pronunciationTooltip,
+  termTypeInfo,
+  sourceStatusInfo,
+  sourceTypeInfo,
+} from '../utils/designation-registry';
+
+describe('designationTypeInfo', () => {
+  it('returns info for expression', () => {
+    const d = Expression.fromJSON({ type: 'expression', designation: 'test' });
+    const info = designationTypeInfo(d);
+    expect(info.label).toBe('expression');
+    expect(info.color).toContain('sky');
+  });
+
+  it('returns info for abbreviation', () => {
+    const d = Abbreviation.fromJSON({ type: 'abbreviation', designation: 'ISO' });
+    const info = designationTypeInfo(d);
+    expect(info.label).toBe('abbreviation');
+    expect(info.color).toContain('amber');
+  });
+
+  it('returns info for symbol with broader hierarchy', () => {
+    const d = { type: 'letter_symbol', designation: 'x' } as any;
+    const info = designationTypeInfo(d);
+    expect(info.label).toBe('letter symbol');
+  });
+
+  it('returns fallback for unknown type', () => {
+    const d = { type: 'custom', designation: 'x' } as any;
+    const info = designationTypeInfo(d);
+    expect(info.label).toBe('custom');
+  });
+});
+
+describe('normativeStatusInfo', () => {
+  it('returns preferred', () => {
+    const info = normativeStatusInfo('preferred');
+    expect(info.label).toBe('preferred');
+    expect(info.color).toContain('emerald');
+  });
+
+  it('returns deprecated', () => {
+    const info = normativeStatusInfo('deprecated');
+    expect(info.label).toBe('deprecated');
+    expect(info.color).toContain('red');
+  });
+
+  it('returns empty for null', () => {
+    const info = normativeStatusInfo(null);
+    expect(info.label).toBe('');
+  });
+});
+
+describe('sourceStatusInfo', () => {
+  it('returns identical status', () => {
+    const info = sourceStatusInfo('identical');
+    expect(info.label).toBe('identical');
+  });
+
+  it('returns modified status', () => {
+    const info = sourceStatusInfo('modified');
+    expect(info.label).toBe('modified');
+    expect(info.definition).toBeTruthy();
+  });
+
+  it('returns empty for null', () => {
+    const info = sourceStatusInfo(null);
+    expect(info.label).toBe('');
+  });
+});
+
+describe('sourceTypeInfo', () => {
+  it('returns authoritative', () => {
+    const info = sourceTypeInfo('authoritative');
+    expect(info.label).toBe('authoritative');
+    expect(info.color).toContain('purple');
+  });
+
+  it('returns lineage', () => {
+    const info = sourceTypeInfo('lineage');
+    expect(info.label).toBe('lineage');
+    expect(info.color).toContain('blue');
+  });
+});
+
+describe('termTypeInfo', () => {
+  it('returns term type with definition', () => {
+    const info = termTypeInfo('acronym');
+    expect(info.label).toBe('acronym');
+    expect(info.definition).toBeTruthy();
+    expect(info.category).toBe('abbreviation');
+  });
+
+  it('returns empty for null', () => {
+    const info = termTypeInfo(null);
+    expect(info.label).toBe('');
+  });
+});
+
+describe('abbreviationDetails', () => {
+  it('identifies acronym', () => {
+    const d = Abbreviation.fromJSON({ type: 'abbreviation', designation: 'ISO', acronym: true });
+    expect(abbreviationDetails(d)).toContain('acronym');
+    expect(abbreviationDetails(d)).not.toContain('initialism');
+  });
+
+  it('identifies initialism', () => {
+    const d = Abbreviation.fromJSON({ type: 'abbreviation', designation: 'UN', initialism: true });
+    expect(abbreviationDetails(d)).toContain('initialism');
+  });
+
+  it('identifies truncation', () => {
+    const d = Abbreviation.fromJSON({ type: 'abbreviation', designation: 'info', truncation: true });
+    expect(abbreviationDetails(d)).toContain('truncation');
+  });
+});
+
+describe('grammarBadges', () => {
+  it('returns gender badge with ontology label', () => {
+    const d = Expression.fromJSON({ type: 'expression', designation: 'test', grammar_info: [{ gender: 'f' }] });
+    const badges = grammarBadges((d as any).grammarInfo[0]);
+    expect(badges).toEqual([{ label: 'feminine', definition: 'Feminine grammatical gender.' }]);
+  });
+
+  it('returns gender and number badges', () => {
+    const d = Expression.fromJSON({ type: 'expression', designation: 'test', grammar_info: [{ gender: 'm', number: 'singular' }] });
+    const badges = grammarBadges((d as any).grammarInfo[0]);
+    expect(badges[0].label).toBe('masculine');
+    expect(badges[1].label).toBe('singular');
+  });
+});
+
+describe('pronunciationLabel', () => {
+  it('shows content with system', () => {
+    const p = { content: '/tɛst/', system: 'IPA', language: null, script: null, country: null } as any;
+    expect(pronunciationLabel(p)).toBe('/tɛst/ (IPA)');
+  });
+
+  it('shows content only', () => {
+    const p = { content: '/t/', system: null, language: null, script: null, country: null } as any;
+    expect(pronunciationLabel(p)).toBe('/t/');
+  });
+});
+
+describe('pronunciationTooltip', () => {
+  it('includes all metadata', () => {
+    const p = { content: '/t/', system: 'IPA', language: 'en', script: 'Latn', country: 'US' } as any;
+    const tip = pronunciationTooltip(p);
+    expect(tip).toContain('Language: en');
+    expect(tip).toContain('System: IPA');
+    expect(tip).toContain('Country: US');
+  });
+});

package/src/__tests__/graph.test.ts

@@ -91,6 +91,37 @@ describe('GraphEngine', () => {
       expect(g.edgeCount).toBe(1);
     });
 
+    it('keeps separate edges for different languages', () => {
+      const g = new GraphEngine();
+      g.addEdge({ source: 'uri:a', target: 'uri:b', type: 'references', register: 'test', lang: 'eng' });
+      g.addEdge({ source: 'uri:a', target: 'uri:b', type: 'references', register: 'test', lang: 'fra' });
+      expect(g.edgeCount).toBe(2);
+    });
+
+    it('deduplicates edges with same source+target+type+lang', () => {
+      const g = new GraphEngine();
+      g.addEdge({ source: 'uri:a', target: 'uri:b', type: 'references', register: 'test', lang: 'eng' });
+      g.addEdge({ source: 'uri:a', target: 'uri:b', type: 'references', register: 'test', lang: 'eng' });
+      expect(g.edgeCount).toBe(1);
+    });
+
+    it('creates domain stub with correct fields', () => {
+      const g = new GraphEngine();
+      g.addEdge({
+        source: 'https://glossarist.org/isotc211/concept/3',
+        target: 'https://glossarist.org/isotc211/domain/iso-19105',
+        type: 'domain',
+        label: 'ISO 19105',
+        register: 'isotc211',
+        lang: 'eng',
+      });
+      const domainNode = g.getNode('https://glossarist.org/isotc211/domain/iso-19105');
+      expect(domainNode?.register).toBe('isotc211');
+      expect(domainNode?.nodeType).toBe('domain');
+      expect(domainNode?.status).toBe('domain');
+      expect(domainNode?.loaded).toBe(false);
+    });
+
     it('extracts register from URI for stub nodes', () => {
       const g = new GraphEngine();
       g.addEdge({
@@ -172,6 +203,37 @@ describe('GraphEngine', () => {
       const sub = g.getSubgraph('uri:a', 5);
       expect(sub.nodes.length).toBe(2);
     });
+
+    it('does not traverse past domain nodes in getSubgraph', () => {
+      const g = new GraphEngine();
+      g.addNode(makeNode('https://glossarist.org/test/concept/a', 'a'));
+      g.addNode(makeNode('https://glossarist.org/test/concept/b', 'b'));
+      g.addNode(makeNode('https://glossarist.org/test/concept/c', 'c'));
+      g.addNode(makeNode('https://glossarist.org/test/concept/d', 'd'));
+
+      g.addEdge({
+        source: 'https://glossarist.org/test/concept/a',
+        target: 'https://glossarist.org/test/domain/iso-12345',
+        type: 'domain', register: 'test', label: 'ISO 12345', lang: 'eng',
+      });
+      g.addEdge({
+        source: 'https://glossarist.org/test/concept/b',
+        target: 'https://glossarist.org/test/domain/iso-12345',
+        type: 'domain', register: 'test', label: 'ISO 12345', lang: 'eng',
+      });
+      g.addEdge({
+        source: 'https://glossarist.org/test/concept/c',
+        target: 'https://glossarist.org/test/domain/iso-12345',
+        type: 'domain', register: 'test', label: 'ISO 12345', lang: 'eng',
+      });
+
+      const sub = g.getSubgraph('https://glossarist.org/test/concept/a', 3);
+      const nodeUris = sub.nodes.map(n => n.uri);
+      expect(nodeUris).toContain('https://glossarist.org/test/concept/a');
+      expect(nodeUris).toContain('https://glossarist.org/test/domain/iso-12345');
+      expect(nodeUris).not.toContain('https://glossarist.org/test/concept/b');
+      expect(nodeUris).not.toContain('https://glossarist.org/test/concept/c');
+    });
   });
 
   describe('getAllNodes', () => {

package/src/__tests__/language-detail.test.ts

@@ -1,9 +1,26 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { mount, flushPromises } from '@vue/test-utils';
+import { mount } from '@vue/test-utils';
 import LanguageDetail from '../components/LanguageDetail.vue';
 import { useVocabularyStore } from '../stores/vocabulary';
-import type { LocalizedConcept } from '../adapters/types';
-import { createTestRouter, setupPinia, makeManifest, makeLocalizedConcept, makeAdapterStub } from './test-helpers';
+import { conceptFromJson } from '../adapters/model-bridge';
+import { createTestRouter, setupPinia, makeManifest, makeAdapterStub } from './test-helpers';
+
+function makeConceptJson(overrides: Record<string, any> = {}) {
+  return {
+    '@id': 'https://glossarist.org/test/concept/1',
+    '@type': 'gl:Concept',
+    'gl:identifier': '1',
+    'gl:localizedConcept': {
+      eng: {
+        '@type': 'gl:LocalizedConcept',
+        'gl:languageCode': 'eng',
+        'gl:entryStatus': 'valid',
+        ...overrides.eng,
+      },
+      ...(overrides.otherLangs || {}),
+    },
+  };
+}
 
 describe('LanguageDetail', () => {
   let pinia: ReturnType<typeof setupPinia>;
@@ -17,33 +34,58 @@ describe('LanguageDetail', () => {
     store.datasets.set('test', makeAdapterStub());
   });
 
-  function mountDetail(lcs: Record<string, LocalizedConcept>, activeLang = 'eng') {
+  function mountDetail(conceptJson: Record<string, any>, activeLang = 'eng') {
+    const concept = conceptFromJson(conceptJson);
     return mount(LanguageDetail, {
       global: { plugins: [pinia, router], directives: { math: () => {} } },
-      props: { localizedConcepts: lcs, activeLang },
+      props: { concept, activeLang },
     });
   }
 
   it('renders language selector buttons', () => {
-    const eng = makeLocalizedConcept();
-    const fra = makeLocalizedConcept({ '@id': '.../fra', 'gl:languageCode': 'fra' });
-    const wrapper = mountDetail({ eng, fra });
+    const json = makeConceptJson({
+      eng: {},
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:entryStatus': 'valid',
+        },
+      },
+    });
+    const wrapper = mountDetail(json);
     expect(wrapper.text()).toContain('English');
     expect(wrapper.text()).toContain('French');
   });
 
   it('highlights active language button', () => {
-    const eng = makeLocalizedConcept();
-    const fra = makeLocalizedConcept({ '@id': '.../fra', 'gl:languageCode': 'fra' });
-    const wrapper = mountDetail({ eng, fra }, 'eng');
+    const json = makeConceptJson({
+      eng: {},
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:entryStatus': 'valid',
+        },
+      },
+    });
+    const wrapper = mountDetail(json, 'eng');
     const buttons = wrapper.findAll('button').filter(b => b.text().includes('English'));
     expect(buttons[0].classes()).toContain('bg-ink-800');
   });
 
   it('emits update:activeLang on language click', async () => {
-    const eng = makeLocalizedConcept();
-    const fra = makeLocalizedConcept({ '@id': '.../fra', 'gl:languageCode': 'fra' });
-    const wrapper = mountDetail({ eng, fra }, 'eng');
+    const json = makeConceptJson({
+      eng: {},
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:entryStatus': 'valid',
+        },
+      },
+    });
+    const wrapper = mountDetail(json, 'eng');
     const fraBtn = wrapper.findAll('button').find(b => b.text().includes('French'));
     expect(fraBtn).toBeDefined();
     await fraBtn!.trigger('click');
@@ -51,96 +93,111 @@ describe('LanguageDetail', () => {
   });
 
   it('shows entry status badge', () => {
-    const eng = makeLocalizedConcept({ 'gl:entryStatus': 'valid' });
-    const wrapper = mountDetail({ eng });
+    const json = makeConceptJson({
+      eng: { 'gl:entryStatus': 'valid' },
+    });
+    const wrapper = mountDetail(json);
     expect(wrapper.text()).toContain('valid');
   });
 
-  it('shows designations', () => {
-    const eng = makeLocalizedConcept({
-      'gl:designation': [
-        { '@type': 'gl:Expression', 'gl:term': 'road', 'gl:normativeStatus': 'preferred' },
-      ],
+  it('shows designations with ontology labels', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:designation': [
+          { '@type': 'gl:Expression', 'gl:term': 'road', 'gl:normativeStatus': 'preferred' },
+        ],
+      },
     });
-    const wrapper = mountDetail({ eng });
+    const wrapper = mountDetail(json);
     expect(wrapper.text()).toContain('road');
-    expect(wrapper.text()).toContain('Expression');
-    expect(wrapper.text()).toContain('Preferred');
+    expect(wrapper.text()).toContain('expression');
+    expect(wrapper.text()).toContain('preferred');
   });
 
   it('shows definition', () => {
-    const eng = makeLocalizedConcept({
-      'gl:definition': [{ '@type': 'gl:Definition', 'gl:content': 'A paved surface for vehicles.' }],
+    const json = makeConceptJson({
+      eng: {
+        'gl:definition': [{ '@type': 'gl:Definition', 'gl:content': 'A paved surface for vehicles.' }],
+      },
     });
-    const wrapper = mountDetail({ eng });
+    const wrapper = mountDetail(json);
     expect(wrapper.text()).toContain('Definition');
     expect(wrapper.text()).toContain('paved surface');
   });
 
   it('shows notes', () => {
-    const eng = makeLocalizedConcept({
-      'gl:notes': [{ '@type': 'gl:Note', 'gl:content': 'This is a note.' }],
+    const json = makeConceptJson({
+      eng: {
+        'gl:notes': [{ '@type': 'gl:Note', 'gl:content': 'This is a note.' }],
+      },
     });
-    const wrapper = mountDetail({ eng });
+    const wrapper = mountDetail(json);
     expect(wrapper.text()).toContain('Notes');
     expect(wrapper.text()).toContain('This is a note');
   });
 
   it('shows examples', () => {
-    const eng = makeLocalizedConcept({
-      'gl:examples': [{ '@type': 'gl:Example', 'gl:content': 'A highway is a road.' }],
+    const json = makeConceptJson({
+      eng: {
+        'gl:examples': [{ '@type': 'gl:Example', 'gl:content': 'A highway is a road.' }],
+      },
     });
-    const wrapper = mountDetail({ eng });
+    const wrapper = mountDetail(json);
     expect(wrapper.text()).toContain('Examples');
     expect(wrapper.text()).toContain('A highway is a road');
   });
 
   it('shows sources', () => {
-    const eng = makeLocalizedConcept({
-      'gl:source': [{ '@type': 'gl:Source', 'gl:sourceType': 'authoritative', 'gl:origin': { '@type': 'gl:Origin', 'gl:ref': 'ISO 7010' } }],
+    const json = makeConceptJson({
+      eng: {
+        'gl:source': [{ '@type': 'gl:Source', 'gl:sourceType': 'authoritative', 'gl:origin': { '@type': 'gl:Origin', 'gl:ref': { '@type': 'gl:Ref', 'gl:source': 'ISO 7010' } } }],
+      },
     });
-    const wrapper = mountDetail({ eng });
+    const wrapper = mountDetail(json);
     expect(wrapper.text()).toContain('Sources');
     expect(wrapper.text()).toContain('ISO 7010');
   });
 
   it('shows term-only state for language without definition', () => {
-    const eng = makeLocalizedConcept({
-      'gl:designation': [{ '@type': 'gl:Expression', 'gl:term': 'test', 'gl:normativeStatus': 'preferred' }],
+    const json = makeConceptJson({
+      eng: {
+        'gl:designation': [{ '@type': 'gl:Expression', 'gl:term': 'test', 'gl:normativeStatus': 'preferred' }],
+      },
     });
-    delete (eng as any)['gl:definition'];
-    delete (eng as any)['gl:notes'];
-    delete (eng as any)['gl:examples'];
-    const wrapper = mountDetail({ eng });
+    const wrapper = mountDetail(json);
     expect(wrapper.text()).toContain('Term only in English');
   });
 
   it('shows no data message for missing language', () => {
-    const eng = makeLocalizedConcept();
-    const wrapper = mountDetail({ eng }, 'zho');
+    const json = makeConceptJson({ eng: {} });
+    const wrapper = mountDetail(json, 'zho');
     expect(wrapper.text()).toContain('No data available');
   });
 
-  it('shows designation type badges', () => {
-    const eng = makeLocalizedConcept({
-      'gl:designation': [
-        { '@type': 'gl:Symbol', 'gl:term': 'H₂O', 'gl:normativeStatus': 'preferred' },
-        { '@type': 'gl:Abbreviation', 'gl:term': 'abbr', 'gl:normativeStatus': 'admitted' },
-      ],
+  it('shows designation type badges with ontology labels', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:designation': [
+          { '@type': 'gl:Symbol', 'gl:term': 'H₂O', 'gl:normativeStatus': 'preferred' },
+          { '@type': 'gl:Abbreviation', 'gl:term': 'abbr', 'gl:normativeStatus': 'admitted' },
+        ],
+      },
     });
-    const wrapper = mountDetail({ eng });
-    expect(wrapper.text()).toContain('Symbol');
-    expect(wrapper.text()).toContain('Abbreviation');
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('symbol');
+    expect(wrapper.text()).toContain('abbreviation');
   });
 
-  it('shows gender and plurality when present', () => {
-    const eng = makeLocalizedConcept({
-      'gl:designation': [
-        { '@type': 'gl:Expression', 'gl:term': 'route', 'gl:normativeStatus': 'preferred', 'gl:gender': 'f', 'gl:plurality': 'singular' },
-      ],
+  it('shows grammar info with ontology labels when present', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:designation': [
+          { '@type': 'gl:Expression', 'gl:term': 'route', 'gl:normativeStatus': 'preferred', 'gl:grammarInfo': [{ 'gl:gender': 'f', 'gl:number': 'singular' }] },
+        ],
+      },
     });
-    const wrapper = mountDetail({ eng });
-    expect(wrapper.text()).toContain('f');
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('feminine');
     expect(wrapper.text()).toContain('singular');
   });
 });

package/src/__tests__/ontology-registry.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { ontology } from '../adapters/ontology-registry';
+
+describe('OntologyRegistry', () => {
+  it('loads all 10 taxonomies', () => {
+    expect(ontology.getAll('conceptStatus').length).toBe(7);
+    expect(ontology.getAll('entryStatus').length).toBe(4);
+    expect(ontology.getAll('normativeStatus').length).toBe(4);
+    expect(ontology.getAll('sourceType').length).toBe(2);
+    expect(ontology.getAll('sourceStatus').length).toBe(10);
+    expect(ontology.getAll('relationshipType').length).toBe(14);
+    expect(ontology.getAll('designationType').length).toBe(5);
+    expect(ontology.getAll('termType').length).toBe(24);
+    expect(ontology.getAll('grammarGender').length).toBe(4);
+    expect(ontology.getAll('grammarNumber').length).toBe(3);
+  });
+
+  it('returns correct labels for conceptStatus', () => {
+    expect(ontology.getLabel('conceptStatus', 'valid')).toBe('valid');
+    expect(ontology.getLabel('conceptStatus', 'superseded')).toBe('superseded');
+    expect(ontology.getLabel('conceptStatus', 'not_valid')).toBe('not valid');
+  });
+
+  it('returns correct labels for grammarGender', () => {
+    expect(ontology.getLabel('grammarGender', 'm')).toBe('masculine');
+    expect(ontology.getLabel('grammarGender', 'f')).toBe('feminine');
+    expect(ontology.getLabel('grammarGender', 'n')).toBe('neuter');
+    expect(ontology.getLabel('grammarGender', 'c')).toBe('common');
+  });
+
+  it('returns altLabel for grammarGender', () => {
+    expect(ontology.getAltLabel('grammarGender', 'm')).toBe('m');
+    expect(ontology.getAltLabel('grammarGender', 'f')).toBe('f');
+  });
+
+  it('returns definitions for every taxonomy value', () => {
+    for (const status of ['draft', 'submitted', 'not_valid', 'invalid', 'valid', 'superseded', 'retired']) {
+      expect(ontology.getDefinition('conceptStatus', status)).toBeTruthy();
+    }
+    for (const gender of ['m', 'f', 'n', 'c']) {
+      expect(ontology.getDefinition('grammarGender', gender)).toBeTruthy();
+    }
+    for (const status of ['identical', 'similar', 'modified', 'restyle', 'context_added', 'generalisation', 'specialisation', 'unspecified', 'related', 'not_equal']) {
+      expect(ontology.getDefinition('sourceStatus', status)).toBeTruthy();
+    }
+  });
+
+  it('returns correct hierarchy for designationType', () => {
+    expect(ontology.getBroader('designationType', 'abbreviation')).toBe('expression');
+    expect(ontology.getBroader('designationType', 'letter_symbol')).toBe('symbol');
+    expect(ontology.getBroader('designationType', 'graphical_symbol')).toBe('symbol');
+    expect(ontology.getBroader('designationType', 'expression')).toBeNull();
+    expect(ontology.getBroader('designationType', 'symbol')).toBeNull();
+  });
+
+  it('returns narrower for designationType', () => {
+    const childrenOfExpression = ontology.getNarrower('designationType', 'expression');
+    expect(childrenOfExpression.map(c => c.id)).toContain('abbreviation');
+
+    const childrenOfSymbol = ontology.getNarrower('designationType', 'symbol');
+    expect(childrenOfSymbol.map(c => c.id)).toEqual(expect.arrayContaining(['letter_symbol', 'graphical_symbol']));
+  });
+
+  it('returns broader for termType', () => {
+    expect(ontology.getBroader('termType', 'acronym')).toBe('abbreviation');
+    expect(ontology.getBroader('termType', 'initialism')).toBe('abbreviation');
+  });
+
+  it('returns null for unknown taxonomy/value', () => {
+    expect(ontology.getConcept('conceptStatus', 'nonexistent')).toBeNull();
+    expect(ontology.getLabel('conceptStatus', 'nonexistent')).toBe('nonexistent');
+    expect(ontology.getDefinition('conceptStatus', 'nonexistent')).toBeNull();
+  });
+
+  it('returns scheme IRIs', () => {
+    expect(ontology.getScheme('conceptStatus')).toContain('status');
+    expect(ontology.getScheme('grammarGender')).toContain('gender');
+  });
+
+  it('has() checks work', () => {
+    expect(ontology.has('conceptStatus', 'valid')).toBe(true);
+    expect(ontology.has('conceptStatus', 'nonexistent')).toBe(false);
+  });
+
+  it('normativeStatus includes correct labels', () => {
+    expect(ontology.getLabel('normativeStatus', 'preferred')).toBe('preferred');
+    expect(ontology.getLabel('normativeStatus', 'admitted')).toBe('admitted');
+    expect(ontology.getLabel('normativeStatus', 'deprecated')).toBe('deprecated');
+    expect(ontology.getLabel('normativeStatus', 'superseded')).toBe('superseded');
+  });
+
+  it('relationshipType has all glossarist-specific types', () => {
+    const types = ontology.getAll('relationshipType').map(c => c.id);
+    expect(types).toContain('deprecates');
+    expect(types).toContain('supersedes');
+    expect(types).toContain('superseded_by');
+    expect(types).toContain('compare');
+    expect(types).toContain('contrast');
+    expect(types).toContain('homograph');
+    expect(types).toContain('false_friend');
+    expect(types).toContain('abbreviated_form_for');
+    expect(types).toContain('short_form_for');
+    expect(types).toContain('sequentially_related');
+    expect(types).toContain('spatially_related');
+    expect(types).toContain('temporally_related');
+    expect(types).toContain('related_concept_broader');
+    expect(types).toContain('related_concept_narrower');
+  });
+});

package/src/__tests__/relationship-categories.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { categorizeRelationship, relationshipLabel, RELATIONSHIP_CATEGORIES } from '../utils/relationship-categories';
+
+describe('RELATIONSHIP_CATEGORIES', () => {
+  it('has expected categories', () => {
+    const ids = RELATIONSHIP_CATEGORIES.map(c => c.id);
+    expect(ids).toContain('hierarchical');
+    expect(ids).toContain('mapping');
+    expect(ids).toContain('associative');
+    expect(ids).toContain('lifecycle');
+    expect(ids).toContain('comparative');
+    expect(ids).toContain('spatiotemporal');
+    expect(ids).toContain('lexical');
+    expect(ids).toContain('designation');
+  });
+
+  it('each category has required fields', () => {
+    for (const cat of RELATIONSHIP_CATEGORIES) {
+      expect(cat.id).toBeTruthy();
+      expect(cat.label).toBeTruthy();
+      expect(cat.types.length).toBeGreaterThan(0);
+      expect(cat.color).toBeTruthy();
+    }
+  });
+});
+
+describe('categorizeRelationship', () => {
+  it('categorizes broader as hierarchical', () => {
+    expect(categorizeRelationship('broader').id).toBe('hierarchical');
+  });
+
+  it('categorizes equivalent as mapping', () => {
+    expect(categorizeRelationship('equivalent').id).toBe('mapping');
+  });
+
+  it('categorizes references as associative', () => {
+    expect(categorizeRelationship('references').id).toBe('associative');
+  });
+
+  it('categorizes supersedes as lifecycle', () => {
+    expect(categorizeRelationship('supersedes').id).toBe('lifecycle');
+  });
+
+  it('categorizes compare as comparative', () => {
+    expect(categorizeRelationship('compare').id).toBe('comparative');
+  });
+
+  it('returns other for unknown type', () => {
+    expect(categorizeRelationship('unknown_type').id).toBe('other');
+  });
+});
+
+describe('relationshipLabel', () => {
+  it('formats snake_case as title case', () => {
+    expect(relationshipLabel('broader_generic')).toBe('Broader Generic');
+    expect(relationshipLabel('related_concept')).toBe('Related Concept');
+  });
+
+  it('handles single word', () => {
+    expect(relationshipLabel('broader')).toBe('Broader');
+  });
+});