@glossarist/concept-browser 0.7.91 → 0.7.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.91",
+  "version": "0.7.92",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -37,7 +37,7 @@
     "astro": "^7.0.7",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.4.26",
+    "glossarist": "^0.4.33",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "pinia": "^2.3.1",

package/src/__tests__/components/GenericRelationList.test.ts

@@ -0,0 +1,147 @@
+/**
+ * GenericRelationList mount test — pins the wire-type contract so
+ * the 5 type bugs found in audit (entry.titles, member.ref,
+ * is_delimiting casing, comprehensive.source, missing props)
+ * can't regress.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { mount } from '@vue/test-utils';
+import GenericRelationList from '../../components/GenericRelationList.vue';
+import type { GenericRelationWire } from '../../adapters/types';
+
+// Stub the composables the component depends on
+vi.mock('../../stores/vocabulary', () => ({
+  useVocabularyStore: () => ({
+    graph: { getNode: () => null },
+    datasets: new Map(),
+  }),
+}));
+
+vi.mock('../../adapters/factory', () => ({
+  getFactory: () => ({
+    resolve: (uri: string) => ({ type: 'unresolved' as const, uri }),
+  }),
+}));
+
+vi.mock('../../i18n', () => ({
+  useI18n: () => ({ t: (key: string) => key }),
+  locale: { value: 'eng' },
+}));
+
+vi.mock('vue-router', () => ({
+  useRouter: () => ({ push: vi.fn() }),
+}));
+
+const manifest = {
+  id: 'test',
+  datasetUri: 'https://example.org/test',
+  title: 'Test',
+  description: '',
+  owner: '',
+  baseUrl: '',
+  languages: ['eng'],
+  conceptCount: 0,
+  conceptUrlTemplate: '',
+  indexUrl: '',
+  contextUrl: '',
+  uriBase: 'https://example.org',
+  status: 'valid',
+  schemaVersion: '3',
+  tags: [],
+  lastUpdated: '',
+  sourceRepo: '',
+  chunkSize: 100,
+} as any;
+
+function makeRelation(overrides: Partial<GenericRelationWire> = {}): GenericRelationWire {
+  return {
+    source: 'https://example.org/test/concept/5-1',
+    comprehensive: 'https://example.org/test/concept/5-1',
+    members: [
+      { uri: 'https://example.org/test/concept/5-4', presence: 'required', count: 'exactly_one', isDelimiting: false },
+      { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', isDelimiting: false },
+    ],
+    completeness: 'complete',
+    register: 'test',
+    ...overrides,
+  };
+}
+
+describe('GenericRelationList — wire-type contract mount test', () => {
+  it('mounts without errors for a well-formed relation', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [makeRelation()],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.html()).toContain('generic-relation-card');
+  });
+
+  it('renders completeness badge', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [makeRelation({ completeness: 'partial' })],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.html()).toContain('completeness-partial');
+  });
+
+  it('renders multiple relations', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [
+          makeRelation({ comprehensive: 'https://example.org/test/concept/5-1' }),
+          makeRelation({ comprehensive: 'https://example.org/test/concept/5-2' }),
+        ],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.findAll('.generic-relation-card')).toHaveLength(2);
+  });
+
+  it('renders criterion when present', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [makeRelation({ criterion: { eng: 'by realization medium' } })],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.html()).toContain('by realization medium');
+  });
+
+  it('renders member presence/count badges for non-default values', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [makeRelation({
+          members: [
+            { uri: 'https://example.org/test/concept/5-4', presence: 'optional', count: 'multiple', isDelimiting: true },
+            { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', isDelimiting: false },
+          ],
+        })],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    const html = w.html();
+    expect(html).toContain('Optional');
+    expect(html).toContain('Multiple');
+  });
+
+  it('renders empty section when relations array is empty', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.find('section.generic-relations').exists()).toBe(true);
+    expect(w.findAll('.generic-relation-card')).toHaveLength(0);
+  });
+});

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

@@ -1,14 +1,13 @@
 import { describe, it, expect } from 'vitest';
-// glossarist-js 0.4.26's top-level d.ts doesn't re-export the MECE
-// PartitiveRelation/PartitiveMember classes; import from glossarist/models
-// (extended by our local augmentation) so the types are correct.
+// glossarist 0.4.33 renamed PartitiveRelation → PartitiveHyperedge.
+// Import from glossarist/models (extended by our local augmentation).
 import type {
-  PartitiveRelation,
+  PartitiveHyperedge,
   PartitiveMember,
   ConceptRef,
 } from 'glossarist/models';
 import {
-  PartitiveRelation as PartitiveRelationModel,
+  PartitiveHyperedge as PartitiveHyperedgeModel,
   PartitiveMember as PartitiveMemberModel,
   ConceptRef as ConceptRefModel,
 } from 'glossarist/models';
@@ -48,8 +47,8 @@ function makeRelation(opts: {
   partitives: PartitiveMember[];
   completeness?: 'complete' | 'partial';
   criterion?: Record<string, string>;
-}): PartitiveRelation {
-  return PartitiveRelationModel.fromJSON(opts as unknown as Record<string, unknown>) as PartitiveRelation;
+}): PartitiveHyperedge {
+  return PartitiveHyperedgeModel.fromJSON(opts as unknown as Record<string, unknown>) as PartitiveHyperedge;
 }
 
 describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () => {
@@ -57,8 +56,8 @@ describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () =>
     it('presence defaults to required, count defaults to exactly_one', () => {
       const m = makePartitive('test', '1.1');
       expect(m.presence).toBe('required');
-      expect(m.isRequired).toBe(true);
-      expect(m.isOptional).toBe(false);
+      expect(m.presence === "required").toBe(true);
+      expect(m.presence === "optional").toBe(false);
     });
 
     it('count defaults to exactly_one', () => {
@@ -69,8 +68,8 @@ describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () =>
     it('presence=optional is preserved', () => {
       const m = makePartitive('test', '1.1', { presence: 'optional' });
       expect(m.presence).toBe('optional');
-      expect(m.isOptional).toBe(true);
-      expect(m.isRequired).toBe(false);
+      expect(m.presence === "optional").toBe(true);
+      expect(m.presence === "required").toBe(false);
     });
 
     it('count=multiple is preserved', () => {
@@ -86,13 +85,13 @@ describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () =>
     it('is_delimiting defaults to false', () => {
       const m = makePartitive('test', '1.1');
       expect(m.is_delimiting).toBe(false);
-      expect(m.isDelimiting).toBe(false);
+      expect(m.is_delimiting).toBe(false);
     });
 
     it('is_delimiting is preserved when set to true', () => {
       const m = makePartitive('test', '1.1', { isDelimiting: true });
       expect(m.is_delimiting).toBe(true);
-      expect(m.isDelimiting).toBe(true);
+      expect(m.is_delimiting).toBe(true);
     });
 
     it('rejects the vacuous (presence=optional, count=at_least_one)', () => {
@@ -108,10 +107,10 @@ describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () =>
         comprehensive: makeRef('test', '1.3'),
         partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
       });
-      expect(r.partitives).toHaveLength(2);
-      expect(r.completeness).toBe('complete');
-      expect(r.isComplete).toBe(true);
-      expect(r.isPartial).toBe(false);
+      expect((r as any).members).toHaveLength(2);
+      expect((r as any).completeness).toBe('complete');
+      expect((r as any).isComplete).toBe(true);
+      expect((r as any).isPartial).toBe(false);
     });
 
     it('completeness=partial is preserved', () => {
@@ -120,8 +119,8 @@ describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () =>
         partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
         completeness: 'partial',
       });
-      expect(r.completeness).toBe('partial');
-      expect(r.isPartial).toBe(true);
+      expect((r as any).completeness).toBe('partial');
+      expect((r as any).isPartial).toBe(true);
     });
 
     it('isCoordinate true when ≥2 partitives', () => {
@@ -129,7 +128,7 @@ describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () =>
         comprehensive: makeRef('test', '1.3'),
         partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
       });
-      expect(r.isCoordinate).toBe(true);
+      expect((r as any).isCoordinate).toBe(true);
     });
 
     it('rejects < 2 partitives (ISO 704 requirement)', () => {

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

@@ -0,0 +1,166 @@
+import { describe, it, expect } from 'vitest';
+// glossarist 0.4.33 renamed PartitiveRelation → PartitiveHyperedge.
+// Import from glossarist/models (extended by our local augmentation).
+import type {
+  PartitiveHyperedge,
+  PartitiveMember,
+  ConceptRef,
+} from 'glossarist/models';
+import {
+  PartitiveHyperedge as PartitiveHyperedgeModel,
+  PartitiveMember as PartitiveMemberModel,
+  ConceptRef as ConceptRefModel,
+} from 'glossarist/models';
+
+/**
+ * Verifies glossarist-js 0.4.26's MECE-native PartitiveRelation model
+ * (ISO 704:2022 presence × count + is_delimiting).
+ *
+ * The concept-browser consumes these fields directly (no migration
+ * bridge). These specs pin the runtime contract so a regression in
+ * upstream is caught here.
+ */
+
+function makeRef(source: string, id: string): ConceptRef {
+  return ConceptRefModel.fromJSON({ source, id }) as ConceptRef;
+}
+
+function makePartitive(
+  source: string,
+  id: string,
+  fields: { presence?: 'required' | 'optional'; count?: 'exactly_one' | 'at_least_one' | 'multiple'; isDelimiting?: boolean } = {},
+): PartitiveMember {
+  const data: {
+    ref: ConceptRef;
+    presence?: 'required' | 'optional';
+    count?: 'exactly_one' | 'at_least_one' | 'multiple';
+    is_delimiting?: boolean;
+  } = { ref: makeRef(source, id) };
+  if (fields.presence) data.presence = fields.presence;
+  if (fields.count) data.count = fields.count;
+  if (fields.isDelimiting) data.is_delimiting = fields.isDelimiting;
+  return PartitiveMemberModel.fromJSON(data as unknown as Record<string, unknown>) as PartitiveMember;
+}
+
+function makeRelation(opts: {
+  comprehensive: ConceptRef;
+  partitives: PartitiveMember[];
+  completeness?: 'complete' | 'partial';
+  criterion?: Record<string, string>;
+}): PartitiveHyperedge {
+  return PartitiveHyperedgeModel.fromJSON(opts as unknown as Record<string, unknown>) as PartitiveHyperedge;
+}
+
+describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () => {
+  describe('PartitiveMember (ISO 704:2022 presence × count + delimiting)', () => {
+    it('presence defaults to required, count defaults to exactly_one', () => {
+      const m = makePartitive('test', '1.1');
+      expect(m.presence).toBe('required');
+      expect(m.presence === "required").toBe(true);
+      expect(m.presence === "optional").toBe(false);
+    });
+
+    it('count defaults to exactly_one', () => {
+      const m = makePartitive('test', '1.1');
+      expect(m.count).toBe('exactly_one');
+    });
+
+    it('presence=optional is preserved', () => {
+      const m = makePartitive('test', '1.1', { presence: 'optional' });
+      expect(m.presence).toBe('optional');
+      expect(m.presence === "optional").toBe(true);
+      expect(m.presence === "required").toBe(false);
+    });
+
+    it('count=multiple is preserved', () => {
+      const m = makePartitive('test', '1.1', { count: 'multiple' });
+      expect(m.count).toBe('multiple');
+    });
+
+    it('count=at_least_one is preserved', () => {
+      const m = makePartitive('test', '1.1', { count: 'at_least_one' });
+      expect(m.count).toBe('at_least_one');
+    });
+
+    it('is_delimiting defaults to false', () => {
+      const m = makePartitive('test', '1.1');
+      expect(m.is_delimiting).toBe(false);
+      expect(m.is_delimiting).toBe(false);
+    });
+
+    it('is_delimiting is preserved when set to true', () => {
+      const m = makePartitive('test', '1.1', { isDelimiting: true });
+      expect(m.is_delimiting).toBe(true);
+      expect(m.is_delimiting).toBe(true);
+    });
+
+    it('rejects the vacuous (presence=optional, count=at_least_one)', () => {
+      expect(() =>
+        makePartitive('test', '1.1', { presence: 'optional', count: 'at_least_one' }),
+      ).toThrow(/collapses to optional \+ multiple/);
+    });
+  });
+
+  describe('PartitiveRelation', () => {
+    it('accepts 2 members with default axes', () => {
+      const r = makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+      });
+      expect(r.members).toHaveLength(2);
+      expect((r as any).completeness).toBe('complete');
+      expect((r as any).isComplete).toBe(true);
+      expect((r as any).isPartial).toBe(false);
+    });
+
+    it('completeness=partial is preserved', () => {
+      const r = makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+        completeness: 'partial',
+      });
+      expect((r as any).completeness).toBe('partial');
+      expect((r as any).isPartial).toBe(true);
+    });
+
+    it('isCoordinate true when ≥2 partitives', () => {
+      const r = makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+      });
+      expect((r as any).isCoordinate).toBe(true);
+    });
+
+    it('rejects < 2 partitives (ISO 704 requirement)', () => {
+      expect(() => makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [makePartitive('test', '1.4')],
+      })).toThrow(/≥2 partitives/);
+    });
+
+    it('round-trips through toJSON with MECE fields', () => {
+      const r = makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [
+          makePartitive('test', '1.4', { presence: 'required', count: 'multiple' }),
+          makePartitive('test', '1.5', { presence: 'optional', isDelimiting: true }),
+        ],
+        completeness: 'partial',
+        criterion: { eng: 'physical structure' },
+      });
+      const json = r.toJSON() as {
+        comprehensive: unknown;
+        partitives: Array<{ presence?: string; count?: string; is_delimiting?: boolean; ref: unknown }>;
+        completeness: string;
+        criterion?: Record<string, string>;
+      };
+      expect(json.comprehensive).toBeDefined();
+      expect(json.partitives).toHaveLength(2);
+      expect(json.partitives[0].count).toBe('multiple');
+      expect(json.partitives[1].presence).toBe('optional');
+      expect(json.partitives[1].is_delimiting).toBe(true);
+      expect(json.completeness).toBe('partial');
+      expect(json.criterion).toEqual({ eng: 'physical structure' });
+    });
+  });
+});

package/src/__tests__/model-bridge-partitive-migration.test.ts

@@ -23,9 +23,9 @@ interface PartitiveMemberLike {
 
 function loadPartitives(doc: Record<string, unknown>): PartitiveMemberLike[] {
   const concept = conceptFromJson(doc as any);
-  const relations = (concept as any).partitiveRelations ?? [];
+  const relations = (concept as any).relations ?? [];
   return relations.flatMap((r: any) =>
-    (r.partitives ?? []).map((m: any) => ({
+    ((r.members ?? r.partitives) ?? []).map((m: any) => ({
       presence: m.presence,
       count: m.count,
       is_delimiting: m.is_delimiting,

package/src/__tests__/wire-keys.test.ts

@@ -60,6 +60,6 @@ describe('GL wire-key SSOT', () => {
     // The point of this test: when adding a key, you remember to update
     // the count; when removing, you notice the test fails. Catches
     // accidental drift in either direction.
-    expect(Object.keys(GL).length).toBe(87);
+    expect(Object.keys(GL).length).toBe(90);
   });
 });

package/src/adapters/model-bridge/concept.ts

@@ -10,7 +10,7 @@ import type { ConceptSummary } from '../types';
 import { ConceptIdentity } from '../concept-identity';
 import { GL } from '../wire-keys';
 import { isJsonLd, mapLocalizedFromJsonLd, mapRelatedFromJsonLd } from './mappers';
-import { mapPartitiveRelationFromJsonLd } from './partitive';
+import { mapHyperedgeFromJsonLd } from './hyperedge';
 import { normalizeEntityRefs } from './entity-refs';
 import { attachBridges, attachSourcedFromToSources } from './bridges';
 import type { JsonLdConcept } from './jsonld-types';
@@ -27,9 +27,18 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
   }
 
   const related = (doc[GL.RELATED] ?? []).map(mapRelatedFromJsonLd);
+
+  // Unified hyperedge mapping: both partitive and generic relations
+  // share the same JSON-LD wire shape. glossarist-js dispatches by
+  // wire key (`partitive_relations` / `generic_relations`).
   const partitiveRelations = (doc[GL.PARTITIVE_RELATIONS] ?? [])
-    .map(mapPartitiveRelationFromJsonLd)
+    .map((r: any) => mapHyperedgeFromJsonLd(r, 'gl:hasPartitive'))
+    .filter((r): r is Record<string, unknown> => r !== null);
+
+  const genericRelations = (doc[GL.GENERIC_RELATIONS] ?? [])
+    .map((r: any) => mapHyperedgeFromJsonLd(r, 'gl:hasGeneric'))
     .filter((r): r is Record<string, unknown> => r !== null);
+
   const tagsArr = doc[GL.TAGS];
   const tags = Array.isArray(tagsArr) ? [...tagsArr] : [];
 
@@ -40,6 +49,7 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
     localizations,
     related,
     partitive_relations: partitiveRelations,
+    generic_relations: genericRelations,
     tags,
     figures: normalizeEntityRefs(doc[GL.FIGURE_REF]),
     tables: normalizeEntityRefs(doc[GL.TABLE_REF]),

package/src/adapters/model-bridge/hyperedge.ts

@@ -0,0 +1,94 @@
+/**
+ * Hyperedge (n-ary relation) mapping: JSON-LD → glossarist-js model.
+ *
+ * Handles ISO 704:2022 n-ary relations — both PartitiveHyperedge and
+ * GenericHyperedge share the same JSON-LD wire shape. The mapper is
+ * identical for both; the glossarist-js Concept constructor dispatches
+ * by wire key (`partitive_relations` vs `generic_relations`).
+ *
+ * MECE migration: reads presence × count directly (ISO 704:2022 v3).
+ * Falls back to migrating the legacy 5-value `multiplicity` or v2
+ * `certainty` field.
+ */
+import { GL } from '../wire-keys';
+import { isPartitivePresence, isPartitiveCount } from '../../utils/partitive-multiplicity';
+import { mapRefFromJsonLd } from './mappers';
+import type { JsonLdPartitiveRelation } from './jsonld-types';
+
+/**
+ * Map a JSON-LD relation entry to the raw dict shape that
+ * glossarist-js's AbstractHyperedge subclasses accept.
+ *
+ * Works for both PartitiveHyperedge and GenericHyperedge — the only
+ * difference at the wire level is which wire key the parent dict
+ * uses (`partitive_relations` vs `generic_relations`).
+ *
+ * Reads `gl:hasPartitive`, `gl:hasGeneric`, or `gl:members` for
+ * the member array (in order of preference).
+ */
+export function mapHyperedgeFromJsonLd(
+  r: JsonLdPartitiveRelation,
+  memberKey: 'gl:hasPartitive' | 'gl:hasGeneric' | 'gl:members' = 'gl:hasPartitive',
+): Record<string, unknown> | null {
+  const comprehensive = r[GL.COMPREHENSIVE] ? mapRefFromJsonLd(r[GL.COMPREHENSIVE]) : null;
+  if (!comprehensive) return null;
+
+  const rawMembers = r[GL.HAS_PARTITIVE] ?? r[GL.HAS_GENERIC] ?? r[GL.HAS_MEMBER] ?? r[memberKey] ?? [];
+  const partitives = (rawMembers as any[])
+    .map((m): Record<string, unknown> | null => {
+      const ref = m[GL.REF] ? mapRefFromJsonLd(m[GL.REF]) : null;
+      if (!ref) return null;
+      const out: Record<string, unknown> = { ref };
+      const presence = m[GL.PRESENCE];
+      const count = m[GL.COUNT];
+      if (isPartitivePresence(presence) && isPartitiveCount(count)) {
+        out.presence = presence;
+        out.count = count;
+      } else {
+        const raw = m[GL.MULTIPLICITY] ?? splitLegacyCertainty(m[GL.CERTAINTY]);
+        if (raw) {
+          const parts = splitMultiplicity(raw);
+          out.presence = parts.presence;
+          out.count = parts.count;
+        }
+      }
+      if (m[GL.IS_DELIMITING] === true) out.is_delimiting = true;
+      return out;
+    })
+    .filter((m): m is Record<string, unknown> => m !== null);
+
+  if (partitives.length < 2) return null;
+
+  const out: Record<string, unknown> = {
+    comprehensive,
+    members: partitives,
+  };
+
+  if (r[GL.COMPLETENESS]) out.completeness = r[GL.COMPLETENESS];
+
+  if (r[GL.CRITERION]) {
+    out.criterion = typeof r[GL.CRITERION] === 'string'
+      ? { default: r[GL.CRITERION] }
+      : r[GL.CRITERION];
+  }
+
+  return out;
+}
+
+/** Migrate legacy v2 certainty → old v3 multiplicity string. */
+function splitLegacyCertainty(certainty: string | undefined): string | null {
+  if (!certainty) return null;
+  return certainty === 'possible' ? 'optional' : 'compulsory';
+}
+
+/** Split the legacy one-string multiplicity into MECE presence × count. */
+function splitMultiplicity(m: string): { presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple' } {
+  const LEGACY_MAP: Record<string, { presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple' }> = {
+    compulsory:               { presence: 'required', count: 'exactly_one' },
+    optional:                 { presence: 'optional', count: 'exactly_one' },
+    compulsory_multiple:      { presence: 'required', count: 'multiple' },
+    optional_multiple:        { presence: 'optional', count: 'multiple' },
+    compulsory_at_least_one:  { presence: 'required', count: 'at_least_one' },
+  };
+  return LEGACY_MAP[m] ?? { presence: 'required', count: 'exactly_one' };
+}

package/src/adapters/model-bridge/jsonld-types.ts

@@ -150,6 +150,8 @@ export interface JsonLdPartitiveMember {
 export interface JsonLdPartitiveRelation {
   'gl:comprehensive'?: JsonLdRef;
   'gl:hasPartitive'?: JsonLdPartitiveMember[];
+  'gl:hasGeneric'?: JsonLdPartitiveMember[];
+  'gl:members'?: JsonLdPartitiveMember[];
   'gl:completeness'?: string;
   'gl:criterion'?: Record<string, string> | string;
 }
@@ -162,6 +164,7 @@ export interface JsonLdConcept {
   'gl:localizedConcept'?: Record<string, JsonLdLocalizedConcept>;
   'gl:related'?: JsonLdRelated[];
   'gl:partitiveRelations'?: JsonLdPartitiveRelation[];
+  'gl:genericRelations'?: JsonLdPartitiveRelation[];
   'gl:tags'?: string[];
   'gl:figureRef'?: unknown[];
   'gl:tableRef'?: unknown[];

package/src/adapters/non-verbal/glossarist-augment.d.ts

@@ -170,12 +170,14 @@ declare module 'glossarist' {
   function pairFromMultiplicity(name: Multiplicity): { presence: PartitivePresence; count: PartitiveCount };
 
   interface Concept {
-    readonly partitiveRelations: PartitiveRelation[];
+    readonly relations: AbstractHyperedge[];
+    readonly partitiveRelations: PartitiveHyperedge[];
+    readonly genericRelations: GenericHyperedge[];
   }
 
   // Re-exposed here so callers importing from the top-level `glossarist`
   // entry get the MECE-augmented shape, not the stale d.ts type.
-  export class PartitiveMember extends GlossaristModel {
+  export class HyperedgeMember extends GlossaristModel {
     constructor(data?: {
       ref?: ConceptRef;
       presence?: PartitivePresence;
@@ -189,36 +191,43 @@ declare module 'glossarist' {
     readonly isRequired: boolean;
     readonly isOptional: boolean;
     get isDelimiting(): boolean;
-    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; presence?: PartitivePresence; count?: PartitiveCount; is_delimiting?: boolean };
-    static fromJSON(data: Record<string, unknown>): PartitiveMember;
+    toJSON(): Record<string, unknown>;
+    static fromJSON(data: Record<string, unknown>): HyperedgeMember;
     static identityOf(value: unknown): string;
   }
 
-  export class PartitiveRelation extends GlossaristModel {
-    constructor(data?: {
-      comprehensive?: ConceptRef;
-      partitives?: PartitiveMember[];
-      completeness?: Completeness;
-      criterion?: Record<string, string> | string;
-    });
+  export class PartitiveMember extends HyperedgeMember {}
+  export class GenericMember extends HyperedgeMember {}
+
+  export class AbstractHyperedge extends GlossaristModel {
     readonly comprehensive: ConceptRef;
-    readonly partitives: PartitiveMember[];
+    readonly members: HyperedgeMember[];
     readonly completeness: Completeness;
     readonly criterion: Record<string, string> | null;
+    readonly sources: ConceptSource[];
+    readonly notes: Record<string, string> | null;
+    readonly status: string | null;
     readonly isComplete: boolean;
     readonly isPartial: boolean;
     readonly isCoordinate: boolean;
-    hasPlurality(): boolean;
-    hasCriterion(): boolean;
-    toJSON(): {
-      comprehensive: ReturnType<ConceptRef['toJSON']>;
-      partitives: ReturnType<PartitiveMember['toJSON']>[];
-      completeness: Completeness;
-      criterion?: Record<string, string>;
-    };
-    static fromJSON(data: Record<string, unknown>): PartitiveRelation;
+    toJSON(): Record<string, unknown>;
+    static fromJSON(data: Record<string, unknown>): AbstractHyperedge;
+    static identityOf(value: unknown): string;
+  }
+
+  export class PartitiveHyperedge extends AbstractHyperedge {
+    get partitives(): HyperedgeMember[];
+    static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
     static identityOf(value: unknown): string;
   }
+
+  export class GenericHyperedge extends AbstractHyperedge {
+    static fromJSON(data: Record<string, unknown>): GenericHyperedge;
+    static identityOf(value: unknown): string;
+  }
+
+  // Legacy aliases (deprecated — use Hyperedge-based names)
+  export class PartitiveRelation extends PartitiveHyperedge {}
 }
 
 // Re-declare the same exports under the 'glossarist/models' subpath so
@@ -261,9 +270,9 @@ declare module 'glossarist/models' {
   // (TypeSharedPlurality removed — superseded by presence/count on
   // PartitiveMember per MECE refactor. Was dead code.)
 
-  // ── PartitiveRelation (glossarist 0.4.26 — MECE presence × count) ─
+  // ── Hyperedge classes (glossarist 0.4.33 — unified n-ary model) ─
 
-  export class PartitiveMember extends GlossaristModel {
+  export class HyperedgeMember extends GlossaristModel {
     constructor(data?: {
       ref?: ConceptRef;
       presence?: PartitivePresence;
@@ -274,37 +283,44 @@ declare module 'glossarist/models' {
     readonly presence: PartitivePresence;
     readonly count: PartitiveCount;
     readonly is_delimiting: boolean;
-    readonly isRequired: boolean;
-    readonly isOptional: boolean;
+    required(): boolean;
+    optional(): boolean;
     get isDelimiting(): boolean;
-    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; presence?: PartitivePresence; count?: PartitiveCount; is_delimiting?: boolean };
-    static fromJSON(data: Record<string, unknown>): PartitiveMember;
+    toJSON(): Record<string, unknown>;
+    static fromJSON(data: Record<string, unknown>): HyperedgeMember;
     static identityOf(value: unknown): string;
   }
 
-  export class PartitiveRelation extends GlossaristModel {
-    constructor(data?: {
-      comprehensive?: ConceptRef;
-      partitives?: PartitiveMember[];
-      completeness?: Completeness;
-      criterion?: Record<string, string> | string;
-    });
+  export class PartitiveMember extends HyperedgeMember {}
+  export class GenericMember extends HyperedgeMember {}
+
+  export class AbstractHyperedge extends GlossaristModel {
     readonly comprehensive: ConceptRef;
-    readonly partitives: PartitiveMember[];
+    readonly members: HyperedgeMember[];
     readonly completeness: Completeness;
     readonly criterion: Record<string, string> | null;
+    readonly sources: ConceptSource[];
+    readonly notes: Record<string, string> | null;
+    readonly status: string | null;
     readonly isComplete: boolean;
     readonly isPartial: boolean;
     readonly isCoordinate: boolean;
-    hasPlurality(): boolean;
-    hasCriterion(): boolean;
-    toJSON(): {
-      comprehensive: ReturnType<ConceptRef['toJSON']>;
-      partitives: ReturnType<PartitiveMember['toJSON']>[];
-      completeness: Completeness;
-      criterion?: Record<string, string>;
-    };
-    static fromJSON(data: Record<string, unknown>): PartitiveRelation;
+    toJSON(): Record<string, unknown>;
+    static fromJSON(data: Record<string, unknown>): AbstractHyperedge;
+    static identityOf(value: unknown): string;
+  }
+
+  export class PartitiveHyperedge extends AbstractHyperedge {
+    get partitives(): HyperedgeMember[];
+    static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
+    static identityOf(value: unknown): string;
+  }
+
+  export class GenericHyperedge extends AbstractHyperedge {
+    static fromJSON(data: Record<string, unknown>): GenericHyperedge;
     static identityOf(value: unknown): string;
   }
+
+  // Legacy aliases (deprecated)
+  export class PartitiveRelation extends PartitiveHyperedge {}
 }

package/src/adapters/types.ts

@@ -179,6 +179,30 @@ export interface PartitiveMemberWire {
   isDelimiting: boolean;
 }
 
+/**
+ * GenericRelationWire — ISO 704 / 1087-1 / 12620 generic (genus/
+ * species) decomposition, mirror of PartitiveRelationWire.
+ *
+ * The OIML V 2-200:2010 dataset has ~8 generic hyperedges with
+ * multiple criterion groups per comprehensive; this shape supports
+ * that natively. See docs/design/generic-relation.md (concept-model).
+ */
+export interface GenericRelationWire {
+  source: string;
+  comprehensive: string;
+  members: GenericMemberWire[];
+  completeness: 'complete' | 'partial';
+  criterion?: Record<string, string>;
+  register: string;
+}
+
+export interface GenericMemberWire {
+  uri: string;
+  presence: 'required' | 'optional';
+  count: 'exactly_one' | 'at_least_one' | 'multiple';
+  isDelimiting: boolean;
+}
+
 export interface GraphNode {
   uri: string;
   register: string;

package/src/adapters/wire-keys.ts

@@ -37,6 +37,7 @@ export const GL = {
   LOCALIZED_CONCEPT: 'gl:localizedConcept',
   RELATED: 'gl:related',
   PARTITIVE_RELATIONS: 'gl:partitiveRelations',
+  GENERIC_RELATIONS: 'gl:genericRelations',
   TAGS: 'gl:tags',
 
   // LocalizedConcept
@@ -139,6 +140,8 @@ export const GL = {
   // PartitiveRelation
   COMPREHENSIVE: 'gl:comprehensive',
   HAS_PARTITIVE: 'gl:hasPartitive',
+  HAS_GENERIC: 'gl:hasGeneric',
+  HAS_MEMBER: 'gl:members',
   COMPLETENESS: 'gl:completeness',
   CRITERION: 'gl:criterion',
 

package/src/components/ConceptDetail.vue

@@ -28,6 +28,7 @@ import ConceptEditionRail from './ConceptEditionRail.vue';
 import NonVerbalRepDisplay from './NonVerbalRepDisplay.vue';
 import NonVerbalList from './non-verbal/NonVerbalList.vue';
 import PartitiveRelationList from './PartitiveRelationList.vue';
+import GenericRelationList from './GenericRelationList.vue';
 import ConceptDiffModal from './ConceptDiffModal.vue';
 import CitationDisplay from './CitationDisplay.vue';
 import DesignationList from './DesignationList.vue';
@@ -75,6 +76,7 @@ const {
   inverseEdgeType,
   conceptRelated,
   conceptPartitiveRelations,
+  conceptGenericRelations,
   getResolvedRef,
   relatedLabel,
   navigateEdge,
@@ -577,6 +579,14 @@ const nonVerbalReps = computed(() => {
             :register-id="registerId"
           />
 
+          <!-- Generic relations — genus/species decompositions (ISO 704) -->
+          <GenericRelationList
+            v-if="conceptGenericRelations.length"
+            :relations="conceptGenericRelations"
+            :manifest="manifest"
+            :register-id="registerId"
+          />
+
           <!-- Edition series — supersession chain across vocabulary editions -->
           <ConceptEditionRail
             :concept-uri="conceptUri(props.concept, props.registerId, props.manifest.uriBase)"

package/src/components/GenericRelationList.vue

@@ -0,0 +1,168 @@
+<script setup lang="ts">
+/**
+ * GenericRelationList — renders one-to-many generic (genus/species)
+ * decompositions as ISO 704 rake diagrams. Mirror of
+ * PartitiveRelationList with type label swapped.
+ *
+ * Each relation card shows:
+ *   - completeness badge (Complete / Partial)
+ *   - the comprehensive (genus) designation as the card title
+ *   - optional criterion as italic text
+ *   - the rake diagram itself (PartitiveRelationDiagram, reused —
+ *     the line notation is identical for generic rakes)
+ *
+ * OIML V 2-200:2010 has ~8 generic hyperedges; 5.1 measurement
+ * standard alone has 6 criterion groups. This component is the
+ * primary rendering surface for those datasets.
+ */
+import type { GenericRelationWire, Manifest } from '../adapters/types';
+import { useRouter } from 'vue-router';
+import { useVocabularyStore } from '../stores/vocabulary';
+import { getFactory } from '../adapters/factory';
+import { useI18n, locale } from '../i18n';
+import { completenessLabel } from '../utils/partitive-relation-styling';
+import { presenceLabel, countLabel } from '../utils/partitive-multiplicity';
+import { resolveDesignation } from '../utils/resolve-designation';
+import PartitiveRelationDiagram, {
+  type PartitiveMemberLabeled,
+} from './PartitiveRelationDiagram.vue';
+
+const props = defineProps<{
+  relations: GenericRelationWire[];
+  manifest: Manifest;
+  registerId: string;
+}>();
+
+const router = useRouter();
+const store = useVocabularyStore();
+const factory = getFactory();
+const { t } = useI18n();
+
+function designationFor(uri: string): string {
+  return resolveDesignation(uri, store, factory, locale.value);
+}
+
+function memberLabel(member: GenericRelationWire['members'][number]): PartitiveMemberLabeled {
+  return {
+    uri: member.uri,
+    presence: member.presence,
+    count: member.count,
+    isDelimiting: member.isDelimiting,
+    label: designationFor(member.uri),
+  };
+}
+</script>
+
+<template>
+  <section class="generic-relations" aria-label="Generic relations">
+    <div
+      v-for="(rel, i) in relations"
+      :key="`generic-${i}-${rel.comprehensive}`"
+      class="generic-relation-card"
+    >
+      <header class="relation-header">
+        <span class="badge badge-completeness" :class="`completeness-${rel.completeness}`">
+          {{ completenessLabel(rel.completeness) }}
+        </span>
+        <span class="badge badge-type">{{ t('relations.generic') }}</span>
+        <h4 class="comprehensive">{{ designationFor(rel.comprehensive) }}</h4>
+      </header>
+
+      <p v-if="rel.criterion" class="criterion">
+        <em>{{ rel.criterion[locale] || rel.criterion.eng || Object.values(rel.criterion)[0] }}</em>
+      </p>
+
+      <PartitiveRelationDiagram
+        :partitives="rel.members.map(memberLabel)"
+        :comprehensive-label="designationFor(rel.comprehensive)"
+        :completeness="rel.completeness"
+      />
+
+      <ul class="member-presence-list" aria-label="Member presence and count">
+        <li v-for="(m, j) in rel.members" :key="j">
+          <span class="member-label">{{ designationFor(m.uri) }}</span>
+          <span v-if="m.presence && m.presence !== 'required'" class="member-presence">{{ presenceLabel(m.presence) }}</span>
+          <span v-if="m.count && m.count !== 'exactly_one'" class="member-count">{{ countLabel(m.count) }}</span>
+          <span v-if="m.isDelimiting" class="member-delimiting">{{ t('relations.delimiting') }}</span>
+        </li>
+      </ul>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+.generic-relation-card {
+  border: 1px solid var(--color-border, #ccc);
+  border-radius: 6px;
+  padding: 1rem;
+  margin-bottom: 1rem;
+  background: var(--color-surface, #fff);
+}
+
+.relation-header {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+}
+
+.badge {
+  font-size: 0.75rem;
+  font-weight: 600;
+  padding: 0.15rem 0.5rem;
+  border-radius: 4px;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.badge-completeness.completeness-complete {
+  background: var(--color-success-soft, #d4edda);
+  color: var(--color-success-fg, #155724);
+}
+
+.badge-completeness.completeness-partial {
+  background: var(--color-warn-soft, #fff3cd);
+  color: var(--color-warn-fg, #856404);
+}
+
+.badge-type {
+  background: var(--color-accent-soft, #d1ecf1);
+  color: var(--color-accent-fg, #0c5460);
+}
+
+.comprehensive {
+  margin: 0;
+  font-size: 1.1rem;
+  flex: 1 1 auto;
+}
+
+.criterion {
+  color: var(--color-text-muted, #6c757d);
+  margin: 0.5rem 0;
+  font-size: 0.95rem;
+}
+
+.member-presence-list {
+  list-style: none;
+  padding: 0;
+  margin: 0.5rem 0 0;
+  font-size: 0.85rem;
+}
+
+.member-presence-list li {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+  padding: 0.15rem 0;
+}
+
+.member-presence-list .member-presence,
+.member-presence-list .member-count,
+.member-presence-list .member-delimiting {
+  color: var(--color-text-muted, #6c757d);
+  font-size: 0.75rem;
+  border: 1px solid var(--color-border-light, #eee);
+  padding: 0.05rem 0.4rem;
+  border-radius: 3px;
+}
+</style>

package/src/components/PartitiveRelationList.vue

@@ -20,6 +20,7 @@ import { getFactory } from '../adapters/factory';
 import { useI18n, locale } from '../i18n';
 import { completenessLabel } from '../utils/partitive-relation-styling';
 import { presenceLabel, countLabel } from '../utils/partitive-multiplicity';
+import { resolveDesignation } from '../utils/resolve-designation';
 import PartitiveRelationDiagram, {
   type PartitiveMemberLabeled,
 } from './PartitiveRelationDiagram.vue';
@@ -36,25 +37,7 @@ const factory = getFactory();
 const { t } = useI18n();
 
 function designationFor(uri: string): string {
-  const node = store.graph.getNode(uri);
-  if (node) {
-    const des = node.designations[locale.value]
-      || node.designations.eng
-      || Object.values(node.designations)[0];
-    if (des) return des;
-  }
-  const resolution = factory.resolve(uri);
-  if (resolution.type === 'internal') {
-    const adapter = store.datasets.get(resolution.registerId);
-    const entry = adapter?.getIndexEntry(resolution.conceptId);
-    if (entry) {
-      const des = entry.designations[locale.value]
-        || entry.designations.eng
-        || Object.values(entry.designations)[0];
-      if (des) return des;
-    }
-  }
-  return resolution.type === 'internal' ? resolution.conceptId : uri;
+  return resolveDesignation(uri, store, factory, locale.value);
 }
 
 function navigate(uri: string) {

package/src/composables/use-concept-edges.ts

@@ -4,6 +4,8 @@ import type { Router } from 'vue-router';
 // Import the MECE-augmented types from glossarist/models (extended by
 // src/adapters/non-verbal/glossarist-augment.d.ts).
 import type { Concept, RelatedConcept, ConceptRef } from 'glossarist';
+import { PartitiveHyperedge } from 'glossarist';
+import { GenericHyperedge } from 'glossarist/models';
 import type {
   PartitiveRelation as GlsPartitiveRelation,
   PartitiveMember as GlsPartitiveMember,
@@ -13,9 +15,11 @@ import type {
   GraphEdge,
   PartitiveRelationWire,
   PartitiveMemberWire,
+  GenericRelationWire,
 } from '../adapters/types';
 import { getFactory } from '../adapters/factory';
 import { conceptUri } from '../adapters/model-bridge';
+import { resolveDesignation } from '../utils/resolve-designation';
 import { UriRouter } from '../adapters/UriRouter';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { useDsStyle } from '../utils/dataset-style';
@@ -111,25 +115,7 @@ export function useConceptEdges(
    * IDs like '1.3'.
    */
   function designationFor(uri: string): string {
-    const node = store.graph.getNode(uri);
-    if (node) {
-      const des = node.designations[locale.value]
-        || node.designations.eng
-        || Object.values(node.designations)[0];
-      if (des) return des;
-    }
-    const resolution = factory.resolve(uri);
-    if (resolution.type === 'internal') {
-      const adapter = store.datasets.get(resolution.registerId);
-      const entry = adapter?.getIndexEntry(resolution.conceptId);
-      if (entry) {
-        const des = entry.designations[locale.value]
-          || entry.designations.eng
-          || Object.values(entry.designations)[0];
-        if (des) return des;
-      }
-    }
-    return resolution.type === 'internal' ? resolution.conceptId : uri;
+    return resolveDesignation(uri, store, factory, locale.value);
   }
 
   function edgeBadgeColor(type: string, direction: 'out' | 'in'): string {
@@ -174,42 +160,53 @@ export function useConceptEdges(
     });
   });
 
-  // Concept-level partitive relations (ISO 704 one-to-many decompositions).
-  // Reads the glossarist-js native model (`concept.partitiveRelations`)
-  // and projects each relation into a URI-resolved wire shape for display.
-  // Independent of binary `conceptRelated`.
-  // v2 shape per concept-model/TODO.partitive-relation-v2.
-  const conceptPartitiveRelations = computed<PartitiveRelationWire[]>(() => {
+  // Concept-level n-ary hyperedge relations (ISO 704 one-to-many
+  // decompositions). Reads the glossarist-js unified `concept.relations`
+  // array and projects PartitiveHyperedge → PartitiveRelationWire,
+  // GenericHyperedge → GenericRelationWire for display.
+  //
+  // glossarist 0.4.33+ exposes a unified `.relations` array; type
+  // discrimination is via instanceof.
+  function projectHyperedge(rel: any): PartitiveRelationWire | GenericRelationWire | null {
     const source = conceptUriValue.value;
-    const relations: readonly GlsPartitiveRelation[] = concept.value.partitiveRelations;
-    return relations
-      .map((rel): PartitiveRelationWire | null => {
-        const comprehensive = resolveConceptRefUri(rel.comprehensive);
-        if (!comprehensive) return null;
-        const partitives: PartitiveMemberWire[] = rel.partitives
-          .map((m: GlsPartitiveMember): PartitiveMemberWire | null => {
-            const uri = resolveConceptRefUri(m.ref);
-            if (!uri || uri === source) return null;
-            return {
-              uri,
-              presence: readPresence(m),
-              count: readCount(m),
-              isDelimiting: readIsDelimiting(m),
-            };
-          })
-          .filter((m: PartitiveMemberWire | null): m is PartitiveMemberWire => m !== null);
-        if (partitives.length === 0) return null;
-
+    const comprehensive = resolveConceptRefUri(rel.comprehensive);
+    if (!comprehensive) return null;
+    const members: PartitiveMemberWire[] = (rel.members ?? rel.partitives ?? [])
+      .map((m: any): PartitiveMemberWire | null => {
+        const uri = resolveConceptRefUri(m.ref);
+        if (!uri || uri === source) return null;
         return {
-          source,
-          comprehensive,
-          partitives,
-          completeness: rel.completeness,
-          criterion: rel.criterion ?? undefined,
-          register: registerId.value,
+          uri,
+          presence: readPresence(m),
+          count: readCount(m),
+          isDelimiting: readIsDelimiting(m),
         };
       })
-      .filter((r: PartitiveRelationWire | null): r is PartitiveRelationWire => r !== null);
+      .filter((m: PartitiveMemberWire | null): m is PartitiveMemberWire => m !== null);
+    if (members.length === 0) return null;
+    return {
+      source,
+      comprehensive,
+      members,
+      partitives: members,
+      completeness: rel.completeness,
+      criterion: rel.criterion ?? undefined,
+      register: registerId.value,
+    };
+  }
+
+  const conceptPartitiveRelations = computed<PartitiveRelationWire[]>(() => {
+    return (concept.value.relations as any[] ?? [])
+      .filter(r => r instanceof PartitiveHyperedge)
+      .map(projectHyperedge)
+      .filter((r): r is PartitiveRelationWire => r !== null);
+  });
+
+  const conceptGenericRelations = computed<GenericRelationWire[]>(() => {
+    return (concept.value.relations as any[] ?? [])
+      .filter(r => r instanceof GenericHyperedge)
+      .map(projectHyperedge)
+      .filter((r): r is GenericRelationWire => r !== null);
   });
 
   function resolveConceptRefUri(ref: ConceptRef | null): string | null {
@@ -307,6 +304,7 @@ export function useConceptEdges(
     inverseEdgeType,
     conceptRelated,
     conceptPartitiveRelations,
+    conceptGenericRelations,
     resolveRelatedRef,
     getResolvedRef,
     relatedLabel,

package/src/utils/resolve-designation.ts

@@ -0,0 +1,50 @@
+/**
+ * Resolve a concept URI to its display designation (term string).
+ *
+ * Single SSOT for the designation fallback chain used by:
+ *   - PartitiveRelationList.vue
+ *   - GenericRelationList.vue
+ *   - use-concept-edges.ts (designationFor method)
+ *
+ * Previously each site had its own copy with subtle divergences (one
+ * used `entry.titles`, another used `entry.designations` — the former
+ * is a bug since ConceptSummary has no `titles` property).
+ *
+ * Fallback chain:
+ *   1. BFS graph node (already loaded as a neighbor) → locale → eng → any
+ *   2. Dataset adapter index entry → designations[locale] → eng → any
+ *   3. Concept ID (for internal URIs) or raw URI (for external)
+ */
+import type { useVocabularyStore } from '../stores/vocabulary';
+import type { AdapterFactory } from '../adapters/factory';
+
+type VocabularyStore = ReturnType<typeof useVocabularyStore>;
+type Factory = AdapterFactory;
+
+export function resolveDesignation(
+  uri: string,
+  store: VocabularyStore,
+  factory: Factory,
+  currentLocale: string,
+): string {
+  const node = store.graph.getNode(uri);
+  if (node) {
+    const des = node.designations[currentLocale]
+      || node.designations.eng
+      || Object.values(node.designations)[0];
+    if (des) return des;
+  }
+  const resolution = factory.resolve(uri);
+  if (resolution.type === 'internal') {
+    const adapter = store.datasets.get(resolution.registerId);
+    const entry = adapter?.getIndexEntry(resolution.conceptId);
+    if (entry) {
+      const des = entry.designations[currentLocale]
+        || entry.designations.eng
+        || Object.values(entry.designations)[0];
+      if (des) return des;
+    }
+    return resolution.conceptId;
+  }
+  return uri;
+}