@glossarist/concept-browser 0.7.91 → 0.7.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.91",
+  "version": "0.7.93",
   "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.34",
     "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', delimitingCharacteristic: { eng: "test characteristic" } },
+      { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', delimitingCharacteristic: { eng: "test characteristic" } },
+    ],
+    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', delimitingCharacteristic: { eng: "delimiting by light sensors" } },
+            { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', delimitingCharacteristic: { eng: "test characteristic" } },
+          ],
+        })],
+        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__/components/GenericRelationList.test.ts.bak

@@ -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';
@@ -40,7 +39,7 @@ function makePartitive(
   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;
+  return new PartitiveMemberModel(data as any) as PartitiveMember;
 }
 
 function makeRelation(opts: {
@@ -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 new PartitiveHyperedgeModel(opts as any) 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', () => {
@@ -85,14 +84,14 @@ 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 as any).is_delimiting).toBe(false);
+      expect((m as any).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 as any).is_delimiting).toBe(true);
+      expect((m as any).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 as any).is_delimiting).toBe(false);
+      expect((m as any).is_delimiting).toBe(false);
+    });
+
+    it('is_delimiting is preserved when set to true', () => {
+      const m = makePartitive('test', '1.1', { isDelimiting: true });
+      expect((m as any).is_delimiting).toBe(true);
+      expect((m as any).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 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', () => {
+      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(91);
   });
 });

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

@@ -0,0 +1,65 @@
+/**
+ * Wire-key SSOT contract.
+ *
+ * Audit-driven (AUDIT-2026-07-29 P1-3).
+ *
+ * The GL record is the single source of truth for the JSON-LD wire-format
+ * keys used across src/adapters/. This spec pins:
+ *
+ *   - Every entry is a string starting with 'gl:' (or '@' for JSON-LD core)
+ *   - No two entries share the same value (injectivity — one key, one name)
+ *   - The set of values matches what's declared in jsonld-types.ts
+ *     (catches drift if someone adds a key to one but not the other)
+ */
+import { describe, it, expect } from 'vitest';
+import { GL } from '../adapters/wire-keys';
+
+describe('GL wire-key SSOT', () => {
+  it('every value is a non-empty string', () => {
+    for (const value of Object.values(GL)) {
+      expect(typeof value).toBe('string');
+      expect(value.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('every value starts with gl: or @ (JSON-LD namespace)', () => {
+    for (const value of Object.values(GL)) {
+      expect(value.startsWith('gl:') || value.startsWith('@')).toBe(true);
+    }
+  });
+
+  it('no two entries share the same value (injectivity)', () => {
+    const values = Object.values(GL);
+    expect(new Set(values).size).toBe(values.length);
+  });
+
+  it('MECE keys are present (presence, count, isDelimiting, multiplicity, certainty)', () => {
+    expect(GL.PRESENCE).toBe('gl:presence');
+    expect(GL.COUNT).toBe('gl:count');
+    expect(GL.IS_DELIMITING).toBe('gl:isDelimiting');
+    expect(GL.MULTIPLICITY).toBe('gl:multiplicity');
+    expect(GL.CERTAINTY).toBe('gl:certainty');
+  });
+
+  it('JSON-LD core keys are present', () => {
+    expect(GL.ID).toBe('@id');
+    expect(GL.TYPE).toBe('@type');
+  });
+
+  it('LOCAL_ID is distinct from ID (one is gl:id, the other @id)', () => {
+    // Both represent "id" but in different namespaces:
+    //   GL.ID (@id)        — JSON-LD IRI for the concept
+    //   GL.LOCAL_ID (gl:id) — source-local id within ConceptSource/Origin/Ref
+    expect(GL.ID).toBe('@id');
+    expect(GL.LOCAL_ID).toBe('gl:id');
+    expect(GL.ID).not.toBe(GL.LOCAL_ID);
+  });
+
+  it('count matches documented set (no drift)', () => {
+    // Update this number when adding a new key.
+    // 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(90);
+  });
+});