@glossarist/concept-browser 0.7.27 → 0.7.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.27",
+  "version": "0.7.28",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {

package/scripts/generate-data.mjs

@@ -47,7 +47,7 @@ function loadConceptFile(filePath) {
       const lcData = { ...(doc.data || {}) };
       delete lcData.language_code;
       // Merge top-level fields (terms, definition, notes, etc.) into lcData
-      for (const key of ['terms', 'definition', 'notes', 'examples', 'sources', 'dates', 'domain', 'references', 'entry_status', 'classification', 'review_type', 'review_date', 'review_decision_date', 'review_decision_event', 'review_status', 'review_decision', 'review_decision_notes', 'lineage_source_similarity', 'release', 'script', 'system']) {
+      for (const key of ['terms', 'definition', 'notes', 'annotations', 'examples', 'sources', 'dates', 'domain', 'references', 'entry_status', 'classification', 'review_type', 'review_date', 'review_decision_date', 'review_decision_event', 'review_status', 'review_decision', 'review_decision_notes', 'lineage_source_similarity', 'release', 'script', 'system']) {
         if (doc[key] !== undefined && lcData[key] === undefined) {
           lcData[key] = doc[key];
         }
@@ -106,6 +106,23 @@ function termToDesignation(term) {
   if (term.text) doc['gl:text'] = term.text;
   if (term.image) doc['gl:image'] = term.image;
 
+  if (term.related && term.related.length > 0) {
+    doc['gl:related'] = term.related.map(r => {
+      const rel = {};
+      if (r.type) rel['gl:relationshipType'] = r.type;
+      if (r.target) {
+        rel['gl:target'] = r.target;
+      } else if (r.ref) {
+        const ref = { '@type': 'gl:ConceptRef' };
+        if (r.ref.source) ref['gl:source'] = r.ref.source;
+        if (r.ref.id) ref['gl:id'] = r.ref.id;
+        if (r.ref.text) ref['gl:text'] = r.ref.text;
+        rel['gl:ref'] = ref;
+      }
+      return rel;
+    });
+  }
+
   return doc;
 }
 
@@ -295,6 +312,7 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     if (lc.terms && lc.terms.length > 0) lDoc['gl:designation'] = lc.terms.map(termToDesignation);
     if (lc.definition) lDoc['gl:definition'] = defsToJsonLd(lc.definition);
     if (lc.notes && lc.notes.length > 0) lDoc['gl:notes'] = defsToJsonLd(lc.notes);
+    if (lc.annotations && lc.annotations.length > 0) lDoc['gl:annotations'] = defsToJsonLd(lc.annotations);
     if (lc.examples && lc.examples.length > 0) lDoc['gl:examples'] = defsToJsonLd(lc.examples);
     if (lc.sources && lc.sources.length > 0) lDoc['gl:source'] = sourcesToJsonLd(lc.sources);
     if (lc.lineage_source_similarity !== undefined) lDoc['gl:lineageSourceSimilarity'] = lc.lineage_source_similarity;
@@ -364,6 +382,7 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
         const ref = {};
         if (r.ref.source) ref['gl:source'] = r.ref.source;
         if (r.ref.id) ref['gl:id'] = r.ref.id;
+        if (r.ref.text) ref['gl:text'] = r.ref.text;
         rel['gl:ref'] = ref;
       }
       return rel;

package/src/__tests__/annotations-bridge.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from 'vitest';
+import { conceptFromJson, getAnnotations } from '../adapters/model-bridge';
+
+function makeJsonLdConcept(annotations: { content: string }[] = []) {
+  return {
+    '@type': 'skos:Concept',
+    '@id': 'https://glossarist.org/test/concept/1',
+    'gl:identifier': '1',
+    'gl:localizedConcept': {
+      eng: {
+        'gl:languageCode': 'eng',
+        'gl:designation': [{ '@type': 'Expression', 'gl:term': 'test term' }],
+        'gl:definition': [{ 'gl:content': 'test definition' }],
+        'gl:annotations': annotations.map(a => ({ 'gl:content': a.content })),
+        'gl:notes': [{ 'gl:content': 'a note' }],
+      },
+      fra: {
+        'gl:languageCode': 'fra',
+        'gl:designation': [{ '@type': 'Expression', 'gl:term': 'terme test' }],
+        'gl:definition': [{ 'gl:content': 'définition test' }],
+      },
+    },
+  };
+}
+
+describe('annotations bridge (getAnnotations)', () => {
+  it('preserves annotations from JSON-LD', () => {
+    const doc = makeJsonLdConcept([
+      { content: 'first annotation' },
+      { content: 'second annotation' },
+    ]);
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng');
+    expect(lc).toBeTruthy();
+
+    const ann = getAnnotations(lc!);
+    expect(ann).toHaveLength(2);
+    expect(ann[0].content).toBe('first annotation');
+    expect(ann[1].content).toBe('second annotation');
+  });
+
+  it('returns empty array when no annotations present', () => {
+    const doc = makeJsonLdConcept([]);
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('fra')!;
+    expect(getAnnotations(lc)).toEqual([]);
+  });
+
+  it('returns empty array for language without annotations', () => {
+    const doc = makeJsonLdConcept([{ content: 'only eng' }]);
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('fra')!;
+    expect(getAnnotations(lc)).toEqual([]);
+  });
+
+  it('preserves annotations from glossarist native format', () => {
+    const doc = {
+      id: '1',
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          terms: [{ designation: 'test', type: 'expression' }],
+          definition: [{ content: 'def' }],
+          annotations: [{ content: 'native annotation' }],
+        },
+      },
+    };
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+    const ann = getAnnotations(lc);
+    expect(ann).toHaveLength(1);
+    expect(ann[0].content).toBe('native annotation');
+  });
+
+  it('model-backed fields are unaffected by annotation bridge', () => {
+    const doc = makeJsonLdConcept([{ content: 'annot' }]);
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+
+    expect(lc.definitions).toHaveLength(1);
+    expect(lc.definitions[0].content).toBe('test definition');
+    expect(lc.notes).toHaveLength(1);
+    expect(lc.notes[0].content).toBe('a note');
+    expect(lc.primaryDesignation).toBe('test term');
+    expect(getAnnotations(lc)).toHaveLength(1);
+  });
+});

package/src/__tests__/dataset-adapter.test.ts

@@ -429,6 +429,64 @@ describe('DatasetAdapter', () => {
       expect(edges[0].target).toBe('https://metanorma.github.io/oiml-viml/viml-2000/concept/2.23');
       expect(edges[0].type).toBe('supersedes');
     });
+
+    it('extracts concept-level gl:related "see" edges (OIML pattern)', () => {
+      const urnMap = new Map([
+        ['urn:oiml:pub:v:2:1993', 'vim-1993'],
+      ]);
+      adapter.setUrnMap(urnMap);
+
+      const concept = conceptFromJson({
+        '@id': 'https://metanorma.github.io/oiml-vocab/g18/concept/01643',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': {
+          eng: {
+            'gl:languageCode': 'eng',
+            'gl:designation': [{ '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': 'repeatability' }],
+            'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'the closeness of agreement...' }],
+          },
+        },
+        'gl:related': [
+          {
+            'gl:relationshipType': 'see',
+            'gl:ref': { 'gl:source': 'urn:oiml:pub:v:2:1993', 'gl:id': '3.6' },
+          },
+        ],
+      });
+
+      adapter.manifest = { uriBase: 'https://metanorma.github.io/oiml-vocab' } as any;
+      const edges = adapter.extractEdges(concept);
+      expect(edges.length).toBe(1);
+      expect(edges[0].target).toBe('https://metanorma.github.io/oiml-vocab/vim-1993/concept/3.6');
+      expect(edges[0].type).toBe('see');
+    });
+
+    it('produces a single edge per relation when both concept-level and localization have same target', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/1',
+        '@type': 'gl:Concept',
+        'gl:related': [
+          {
+            'gl:relationshipType': 'see',
+            'gl:ref': { 'gl:source': 'https://glossarist.org/other', 'gl:id': '42' },
+          },
+        ],
+        'gl:localizedConcept': {
+          eng: {
+            'gl:references': [
+              { '@id': 'https://glossarist.org/other/concept/42', 'gl:term': 'related term' },
+            ],
+          },
+        },
+      });
+
+      const edges = adapter.extractEdges(concept);
+      // Concept-level "see" edge + localization "references" edge = 2 edges
+      // (different types: 'see' vs 'references')
+      expect(edges.length).toBe(2);
+      expect(edges.find(e => e.type === 'see')).toBeDefined();
+      expect(edges.find(e => e.type === 'references')).toBeDefined();
+    });
   });
 
   describe('extractDomainEdges', () => {

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

@@ -0,0 +1,211 @@
+import { describe, it, expect } from 'vitest';
+import {
+  conceptFromJson,
+  getDesignationTarget,
+  getRefText,
+} from '../adapters/model-bridge';
+
+// ── Designation relationship: gl:target ────────────────────────────────────
+
+function makeJsonLdWithDesignationRel(target: string | null, relType = 'abbreviated_form_for') {
+  const related = target
+    ? { 'gl:relationshipType': relType, 'gl:target': target }
+    : { 'gl:relationshipType': relType, 'gl:ref': { 'gl:source': 'iso', 'gl:id': '123' } };
+
+  return {
+    '@type': 'skos:Concept',
+    '@id': 'https://glossarist.org/test/concept/1',
+    'gl:identifier': '1',
+    'gl:localizedConcept': {
+      eng: {
+        'gl:languageCode': 'eng',
+        'gl:designation': [{
+          '@type': 'gl:Abbreviation',
+          'gl:term': 'PDF',
+          'gl:related': [related],
+        }],
+        'gl:definition': [{ 'gl:content': 'test definition' }],
+      },
+    },
+  };
+}
+
+describe('designation relationship bridge', () => {
+  it('preserves gl:target as designation target string', () => {
+    const doc = makeJsonLdWithDesignationRel('Portable Document Format');
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+    expect(lc.terms).toHaveLength(1);
+
+    const term = lc.terms[0];
+    expect(term.related).toHaveLength(1);
+
+    const rc = term.related[0];
+    expect(rc.type).toBe('abbreviated_form_for');
+    expect(getDesignationTarget(rc)).toBe('Portable Document Format');
+  });
+
+  it('returns null for concept-level relationships (no target)', () => {
+    const doc = makeJsonLdWithDesignationRel(null);
+    const concept = conceptFromJson(doc);
+    const rc = concept.localization('eng')!.terms[0].related[0];
+    expect(rc.type).toBe('abbreviated_form_for');
+    expect(getDesignationTarget(rc)).toBeNull();
+  });
+
+  it('handles short_form_for designation target', () => {
+    const doc = makeJsonLdWithDesignationRel('kilogram', 'short_form_for');
+    const concept = conceptFromJson(doc);
+    const rc = concept.localization('eng')!.terms[0].related[0];
+    expect(rc.type).toBe('short_form_for');
+    expect(getDesignationTarget(rc)).toBe('kilogram');
+  });
+
+  it('preserves designation target from glossarist native format', () => {
+    const doc = {
+      id: '1',
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          terms: [{
+            designation: 'PDF',
+            type: 'abbreviation',
+            related: [{ type: 'abbreviated_form_for', target: 'Portable Document Format' }],
+          }],
+          definition: [{ content: 'a format' }],
+        },
+      },
+    };
+    const concept = conceptFromJson(doc);
+    const rc = concept.localization('eng')!.terms[0].related[0];
+    expect(getDesignationTarget(rc)).toBe('Portable Document Format');
+  });
+
+  it('designation without related returns empty related array', () => {
+    const doc = {
+      '@type': 'skos:Concept',
+      '@id': 'https://glossarist.org/test/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          'gl:languageCode': 'eng',
+          'gl:designation': [{ '@type': 'gl:Expression', 'gl:term': 'test' }],
+          'gl:definition': [{ 'gl:content': 'def' }],
+        },
+      },
+    };
+    const concept = conceptFromJson(doc);
+    const term = concept.localization('eng')!.terms[0];
+    expect(term.related).toHaveLength(0);
+  });
+});
+
+// ── ConceptRef text: gl:text ───────────────────────────────────────────────
+
+describe('ConceptRef text bridge', () => {
+  it('preserves gl:text as ref text', () => {
+    const doc = {
+      '@type': 'skos:Concept',
+      '@id': 'https://glossarist.org/test/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          'gl:languageCode': 'eng',
+          'gl:designation': [{ '@type': 'gl:Expression', 'gl:term': 'test' }],
+          'gl:definition': [{ 'gl:content': 'def' }],
+          'gl:references': [{
+            'gl:relationshipType': 'broader',
+            'gl:ref': { 'gl:source': 'iso', 'gl:id': '123', 'gl:text': 'Some Term' },
+          }],
+        },
+      },
+    };
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+    expect(lc.related).toHaveLength(1);
+    const rc = lc.related[0];
+    expect(rc.ref).toBeTruthy();
+    expect(rc.ref!.source).toBe('iso');
+    expect(rc.ref!.id).toBe('123');
+    expect(getRefText(rc.ref!)).toBe('Some Term');
+  });
+
+  it('returns null when ref has no text', () => {
+    const doc = {
+      '@type': 'skos:Concept',
+      '@id': 'https://glossarist.org/test/concept/1',
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          'gl:languageCode': 'eng',
+          'gl:designation': [{ '@type': 'gl:Expression', 'gl:term': 'test' }],
+          'gl:definition': [{ 'gl:content': 'def' }],
+          'gl:references': [{
+            'gl:relationshipType': 'broader',
+            'gl:ref': { 'gl:source': 'iso', 'gl:id': '456' },
+          }],
+        },
+      },
+    };
+    const concept = conceptFromJson(doc);
+    const rc = concept.localization('eng')!.related[0];
+    expect(rc.ref).toBeTruthy();
+    expect(getRefText(rc.ref!)).toBeNull();
+  });
+
+  it('preserves ref text from glossarist native format', () => {
+    const doc = {
+      id: '1',
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          terms: [{ designation: 'test', type: 'expression' }],
+          definition: [{ content: 'a test' }],
+          related: [{ type: 'broader', ref: { source: 'iso', id: '123', text: 'Parent Term' } }],
+        },
+      },
+    };
+    const concept = conceptFromJson(doc);
+    const rc = concept.localization('eng')!.related[0];
+    expect(getRefText(rc.ref!)).toBe('Parent Term');
+  });
+});
+
+// ── Generate-data serialization ────────────────────────────────────────────
+
+describe('generate-data designation serialization', () => {
+  it('termToDesignation serializes designation-level related with gl:target', async () => {
+    // We test via the module's internal function by importing the script
+    // Since generate-data.mjs is ESM with side effects, we test the output format
+    // by constructing the expected JSON-LD structure directly.
+    const term = {
+      designation: 'PDF',
+      type: 'abbreviation',
+      normative_status: 'preferred',
+      related: [
+        { type: 'abbreviated_form_for', target: 'Portable Document Format' },
+      ],
+    };
+
+    // Simulate what termToDesignation would produce
+    const doc: Record<string, unknown> = {
+      '@type': 'gl:Abbreviation',
+      'gl:normativeStatus': 'preferred',
+      'gl:term': 'PDF',
+      'gl:related': term.related!.map((r: any) => {
+        const rel: Record<string, unknown> = {};
+        if (r.type) rel['gl:relationshipType'] = r.type;
+        if (r.target) {
+          rel['gl:target'] = r.target;
+        }
+        return rel;
+      }),
+    };
+
+    expect(doc['gl:related']).toHaveLength(1);
+    const rel = (doc['gl:related'] as any[])[0];
+    expect(rel['gl:relationshipType']).toBe('abbreviated_form_for');
+    expect(rel['gl:target']).toBe('Portable Document Format');
+    expect(rel['gl:ref']).toBeUndefined();
+  });
+});

package/src/__tests__/graph.test.ts

@@ -91,6 +91,21 @@ describe('GraphEngine', () => {
       expect(g.edgeCount).toBe(1);
     });
 
+    it('deduplicates edges with matching source+target+type regardless of register field', () => {
+      const g = new GraphEngine();
+      g.addEdge({ source: 'https://example.org/g18/concept/1', target: 'https://example.org/vim-1993/concept/3.6', type: 'see', register: 'vim-1993' });
+      g.addEdge({ source: 'https://example.org/g18/concept/1', target: 'https://example.org/vim-1993/concept/3.6', type: 'see', register: 'g18' });
+      expect(g.edgeCount).toBe(1);
+    });
+
+    it('does not deduplicate when target URIs differ', () => {
+      const g = new GraphEngine();
+      g.addEdge({ source: 'https://example.org/g18/concept/1', target: 'https://example.org/vim-1993/concept/3.6', type: 'see', register: 'vim-1993' });
+      // URN not resolved → different target URI
+      g.addEdge({ source: 'https://example.org/g18/concept/1', target: 'https://example.org/urn:oiml:pub:v:2:1993/concept/3.6', type: 'see', register: 'g18' });
+      expect(g.edgeCount).toBe(2);
+    });
+
     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' });

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

@@ -0,0 +1,162 @@
+import { describe, it, expect } from 'vitest';
+import {
+  RELATIONSHIP_CATEGORIES,
+  INVERSE_RELATIONSHIPS,
+  categorizeRelationship,
+  relationshipLabel,
+  relationshipDefinition,
+} from '../utils/relationship-categories';
+import { ontology } from '../adapters/ontology-registry';
+
+describe('RELATIONSHIP_CATEGORIES (taxonomy-derived)', () => {
+  it('has expected category IDs', () => {
+    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('definitional');
+    expect(ids).toContain('spatiotemporal');
+    expect(ids).toContain('lexical');
+    expect(ids).toContain('designation');
+  });
+
+  it('every 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();
+    }
+  });
+
+  it('no type appears in more than one category', () => {
+    const seen = new Set<string>();
+    for (const cat of RELATIONSHIP_CATEGORIES) {
+      for (const t of cat.types) {
+        expect(seen.has(t), `duplicate type: ${t}`).toBe(false);
+        seen.add(t);
+      }
+    }
+  });
+});
+
+describe('INVERSE_RELATIONSHIPS (taxonomy-derived)', () => {
+  it('every entry is bidirectional', () => {
+    for (const [key, value] of Object.entries(INVERSE_RELATIONSHIPS)) {
+      expect(INVERSE_RELATIONSHIPS[value], `${key} -> ${value} is not bidirectional`).toBe(key);
+    }
+  });
+
+  it('symmetric types map to themselves', () => {
+    const symmetric = ['equivalent', 'exact_match', 'close_match', 'compare', 'contrast',
+      'related_match', 'related_concept', 'homograph', 'false_friend',
+      'sequentially_related', 'spatially_related', 'temporally_related'];
+    for (const type of symmetric) {
+      expect(INVERSE_RELATIONSHIPS[type], `${type} should be self-inverse`).toBe(type);
+    }
+  });
+
+  it('known inverse pairs are correct', () => {
+    expect(INVERSE_RELATIONSHIPS.supersedes).toBe('superseded_by');
+    expect(INVERSE_RELATIONSHIPS.superseded_by).toBe('supersedes');
+    expect(INVERSE_RELATIONSHIPS.broader).toBe('narrower');
+    expect(INVERSE_RELATIONSHIPS.narrower).toBe('broader');
+    expect(INVERSE_RELATIONSHIPS.has_part).toBe('is_part_of');
+    expect(INVERSE_RELATIONSHIPS.is_part_of).toBe('has_part');
+    expect(INVERSE_RELATIONSHIPS.broad_match).toBe('narrow_match');
+    expect(INVERSE_RELATIONSHIPS.narrow_match).toBe('broad_match');
+    expect(INVERSE_RELATIONSHIPS.related_concept_broader).toBe('related_concept_narrower');
+    expect(INVERSE_RELATIONSHIPS.related_concept_narrower).toBe('related_concept_broader');
+  });
+});
+
+describe('categorizeRelationship', () => {
+  it('all 52 taxonomy types resolve to a known category', () => {
+    const allTypes = ontology.getAll('relationshipType');
+    for (const concept of allTypes) {
+      const cat = categorizeRelationship(concept.id);
+      expect(cat.id, `${concept.id} resolved to 'other'`).not.toBe('other');
+    }
+  });
+
+  it('specific category assignments', () => {
+    expect(categorizeRelationship('broader').id).toBe('hierarchical');
+    expect(categorizeRelationship('equivalent').id).toBe('mapping');
+    expect(categorizeRelationship('references').id).toBe('associative');
+    expect(categorizeRelationship('supersedes').id).toBe('lifecycle');
+    expect(categorizeRelationship('compare').id).toBe('comparative');
+    expect(categorizeRelationship('has_definition').id).toBe('definitional');
+    expect(categorizeRelationship('sequentially_related').id).toBe('spatiotemporal');
+    expect(categorizeRelationship('homograph').id).toBe('lexical');
+    expect(categorizeRelationship('abbreviated_form_for').id).toBe('designation');
+  });
+
+  it('returns other for unknown type', () => {
+    expect(categorizeRelationship('unknown_type').id).toBe('other');
+  });
+});
+
+describe('relationshipLabel', () => {
+  it('all 52 taxonomy types produce non-empty labels', () => {
+    const allTypes = ontology.getAll('relationshipType');
+    for (const concept of allTypes) {
+      const label = relationshipLabel(concept.id);
+      expect(label, `${concept.id} has empty label`).toBeTruthy();
+    }
+  });
+
+  it('taxonomy labels match expected values', () => {
+    expect(relationshipLabel('broader_generic')).toBe('broader (generic)');
+    expect(relationshipLabel('related_concept')).toBe('related concept');
+    expect(relationshipLabel('broader')).toBe('broader');
+    expect(relationshipLabel('supersedes')).toBe('supersedes');
+    expect(relationshipLabel('superseded_by')).toBe('superseded by');
+  });
+
+  it('unknown type falls back to title-case computed form', () => {
+    expect(relationshipLabel('some_new_type')).toBe('Some New Type');
+  });
+});
+
+describe('relationshipDefinition', () => {
+  it('all 52 taxonomy types have definitions', () => {
+    const allTypes = ontology.getAll('relationshipType');
+    for (const concept of allTypes) {
+      const def = relationshipDefinition(concept.id);
+      expect(def, `${concept.id} has no definition`).toBeTruthy();
+    }
+  });
+});
+
+describe('taxonomy-code synchronization', () => {
+  it('every type in RELATIONSHIP_CATEGORIES exists in taxonomy', () => {
+    for (const cat of RELATIONSHIP_CATEGORIES) {
+      for (const t of cat.types) {
+        expect(ontology.has('relationshipType', t), `${t} not in taxonomy`).toBe(true);
+      }
+    }
+  });
+
+  it('every type in INVERSE_RELATIONSHIPS exists in taxonomy', () => {
+    for (const key of Object.keys(INVERSE_RELATIONSHIPS)) {
+      expect(ontology.has('relationshipType', key), `${key} not in taxonomy`).toBe(true);
+    }
+  });
+
+  it('every taxonomy entry has a category', () => {
+    const allTypes = ontology.getAll('relationshipType');
+    for (const concept of allTypes) {
+      const cat = categorizeRelationship(concept.id);
+      expect(cat.id, `${concept.id} has no category`).not.toBe('other');
+    }
+  });
+
+  it('all IRIs use consistent gloss:rel/ prefix', () => {
+    const allTypes = ontology.getAll('relationshipType');
+    for (const concept of allTypes) {
+      expect(concept.iri, `${concept.id} IRI: ${concept.iri}`).toMatch(/^gloss:rel\//);
+    }
+  });
+});

package/src/__tests__/taxonomy-colors.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest';
+import { ontology } from '../adapters/ontology-registry';
+import { entryStatusColor, conceptStatusColor } from '../utils/concept-helpers';
+import { designationTypeInfo, normativeStatusInfo, sourceTypeInfo } from '../utils/designation-registry';
+
+describe('OntologyRegistry.getColor', () => {
+  it('returns correct color for conceptStatus', () => {
+    expect(ontology.getColor('conceptStatus', 'valid')).toBe('badge-green');
+    expect(ontology.getColor('conceptStatus', 'superseded')).toBe('bg-red-50 text-red-700');
+    expect(ontology.getColor('conceptStatus', 'draft')).toBe('badge-yellow');
+    expect(ontology.getColor('conceptStatus', 'retired')).toBe('badge-gray');
+  });
+
+  it('returns null for unknown status', () => {
+    expect(ontology.getColor('conceptStatus', 'nonexistent')).toBeNull();
+  });
+
+  it('returns correct colors for normativeStatus', () => {
+    expect(ontology.getColor('normativeStatus', 'preferred')).toBe('bg-emerald-50 text-emerald-700');
+    expect(ontology.getColor('normativeStatus', 'deprecated')).toBe('bg-red-50 text-red-700');
+  });
+
+  it('returns correct colors for designationType', () => {
+    expect(ontology.getColor('designationType', 'expression')).toBe('bg-sky-50 text-sky-700');
+    expect(ontology.getColor('designationType', 'abbreviation')).toBe('bg-amber-50 text-amber-700');
+  });
+
+  it('returns correct colors for sourceType', () => {
+    expect(ontology.getColor('sourceType', 'authoritative')).toBe('badge-purple');
+    expect(ontology.getColor('sourceType', 'lineage')).toBe('badge-blue');
+  });
+});
+
+describe('concept-helpers (ontology-driven colors)', () => {
+  it('entryStatusColor returns taxonomy-driven colors', () => {
+    expect(entryStatusColor('valid')).toBe('badge-green');
+    expect(entryStatusColor('not_valid')).toBe('bg-red-50 text-red-700');
+    expect(entryStatusColor('draft')).toBe('badge-yellow');
+  });
+
+  it('entryStatusColor falls back to badge-gray', () => {
+    expect(entryStatusColor('unknown_status')).toBe('badge-gray');
+  });
+
+  it('conceptStatusColor returns taxonomy-driven colors', () => {
+    expect(conceptStatusColor('valid')).toBe('badge-green');
+    expect(conceptStatusColor('invalid')).toBe('bg-red-50 text-red-700');
+    expect(conceptStatusColor('draft')).toBe('badge-yellow');
+  });
+
+  it('conceptStatusColor handles null', () => {
+    expect(conceptStatusColor(null)).toBe('badge-gray');
+  });
+});
+
+describe('designation-registry (ontology-driven colors)', () => {
+  it('designationTypeInfo uses taxonomy colors', () => {
+    const info = designationTypeInfo({ type: 'expression', designation: 'test' } as any);
+    expect(info.color).toBe('bg-sky-50 text-sky-700');
+  });
+
+  it('normativeStatusInfo uses taxonomy colors', () => {
+    const info = normativeStatusInfo('preferred');
+    expect(info.color).toBe('bg-emerald-50 text-emerald-700');
+  });
+
+  it('sourceTypeInfo uses taxonomy colors', () => {
+    const info = sourceTypeInfo('authoritative');
+    expect(info.color).toBe('badge-purple');
+  });
+});