@glossarist/concept-browser 0.7.87 → 0.7.89

package/package.json

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

package/scripts/__tests__/bibliography.test.mjs

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeBibliography } from '../lib/bibliography.mjs';
+
+describe('normalizeBibliography', () => {
+  it('wraps a bare array into { bibliography: [...] }', () => {
+    const entries = [{ id: 'ISO1' }, { id: 'ISO2' }];
+    expect(normalizeBibliography(entries)).toEqual({ bibliography: entries });
+  });
+
+  it('passes through an already-wrapped object', () => {
+    const wrapped = { bibliography: [{ id: 'ISO1' }] };
+    expect(normalizeBibliography(wrapped)).toBe(wrapped);
+  });
+
+  it('returns an empty wrapper for null/undefined', () => {
+    expect(normalizeBibliography(null)).toEqual({ bibliography: [] });
+    expect(normalizeBibliography(undefined)).toEqual({ bibliography: [] });
+  });
+
+  it('returns an empty wrapper for junk input (non-array, non-wrapped)', () => {
+    expect(normalizeBibliography('string')).toEqual({ bibliography: [] });
+    expect(normalizeBibliography(42)).toEqual({ bibliography: [] });
+    expect(normalizeBibliography({ other: 'shape' })).toEqual({ bibliography: [] });
+  });
+
+  it('handles empty array input', () => {
+    expect(normalizeBibliography([])).toEqual({ bibliography: [] });
+  });
+});

package/scripts/generate-data.mjs

@@ -14,6 +14,7 @@ import { buildVersionHistoryTurtle } from './lib/version-turtle.mjs';
 import { buildBibliographyTurtle } from './lib/bibliography-turtle.mjs';
 import { ttlLit } from './lib/turtle-escape.mjs';
 import { firstNonEmpty } from './lib/first-non-empty.mjs';
+import { normalizeBibliography } from './lib/bibliography.mjs';
 
 // MECE partitive multiplicity: 2 independent axes (ISO 704:2022).
 //   presence × count
@@ -1296,9 +1297,10 @@ async function processDataset(dir, register, opts) {
   // Copy bibliography.yaml → bibliography.json
   const bibPath = path.join(sourceRoot, 'bibliography.yaml');
   if (fs.existsSync(bibPath)) {
-    const bibData = readYaml(bibPath);
+    const rawBib = readYaml(bibPath);
+    const bibData = normalizeBibliography(rawBib);
     writeJson(path.join(DATA, register, 'bibliography.json'), bibData);
-    const bibCount = Array.isArray(bibData?.bibliography) ? bibData.bibliography.length : 0;
+    const bibCount = bibData.bibliography.length;
     console.log(`  Copied bibliography (${bibCount} entries)`);
   }
 

package/scripts/lib/bibliography.mjs

@@ -0,0 +1,18 @@
+/**
+ * Normalize bibliography data into the { bibliography: [...] } shape
+ * expected by BibliographyData.fromJSON.
+ *
+ * Accepts either:
+ *   - A bare array of entries (the canonical YAML source form).
+ *   - An already-wrapped { bibliography: [...] } object.
+ *   - Anything else (treated as empty).
+ *
+ * Ported from origin/fix/bibliography-yaml-array-wrap (2026-06-25).
+ * That branch fell 153 commits behind main and was deleted in the
+ * 2026-07-29 stale-branch purge; this is the unmerged work.
+ */
+export function normalizeBibliography(raw) {
+  if (Array.isArray(raw)) return { bibliography: raw };
+  if (raw && Array.isArray(raw.bibliography)) return raw;
+  return { bibliography: [] };
+}

package/src/__tests__/cross-repo-multiplicity-contract.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Cross-repo MECE multiplicity table SSOT spec.
+ *
+ * Audit (AUDIT-2026-07-29 P2-1): pin that the multiplicity mapping
+ * table is consistent with glossarist-js's SSOT (multiplicityFromPair).
+ *
+ * The concept-browser doesn't redefine the table — it re-exports
+ * `multiplicityFromPair` from glossarist-js via
+ * `src/utils/partitive-multiplicity.ts`. This spec ensures that
+ * re-export stays correct, and that the 5 valid combinations and
+ * the 1 invalid combination match the documented contract.
+ *
+ * Sister specs:
+ *   - glossarist-js test/models/partitive-relation-v4.test.js
+ *   - glossarist-ruby spec/unit/v3/multiplicity_spec.rb
+ *   - concept-model spec/multiplicity_spec.rb
+ *
+ * All four must agree. This spec is the concept-browser side of
+ * that cross-repo contract.
+ */
+import { describe, it, expect } from 'vitest';
+import {
+  partitiveMultiplicityName,
+  rakeStrokeStyle,
+  type PartitivePresence,
+  type PartitiveCount,
+} from '../utils/partitive-multiplicity';
+
+describe('cross-repo MECE multiplicity SSOT contract', () => {
+  // The 5 valid combinations are the source of truth. Any change
+  // here MUST be mirrored in:
+  //   - glossarist-js src/models/multiplicity.js (NAME_BY_PAIR)
+  //   - glossarist-ruby lib/glossarist/v3/multiplicity.rb (NAME_BY_PAIR)
+  //   - concept-model lib/glossarist/concept_model/multiplicity.rb (MAPPING)
+  //   - concept-model schemas/v3/concept.yaml (partitive_member.not.allOf)
+  //   - concept-model ontologies/shapes/glossarist.shacl.ttl (VacuousComboShape)
+  const VALID_COMBINATIONS: Array<{
+    presence: PartitivePresence;
+    count: PartitiveCount;
+    iso704Name: string;
+  }> = [
+    { presence: 'required', count: 'exactly_one',  iso704Name: 'compulsory' },
+    { presence: 'optional', count: 'exactly_one',  iso704Name: 'optional' },
+    { presence: 'required', count: 'multiple',     iso704Name: 'compulsory_multiple' },
+    { presence: 'optional', count: 'multiple',     iso704Name: 'optional_multiple' },
+    { presence: 'required', count: 'at_least_one', iso704Name: 'compulsory_at_least_one' },
+  ];
+
+  it('maps the 5 valid (presence, count) pairs to ISO 704 names', () => {
+    for (const { presence, count, iso704Name } of VALID_COMBINATIONS) {
+      expect(partitiveMultiplicityName(presence, count)).toBe(iso704Name);
+    }
+  });
+
+  it('rejects the vacuous (optional, at_least_one) combination', () => {
+    // This combination is invalid because "may exist, ≥1 if it does"
+    // collapses to "may exist in any number" = (optional, multiple).
+    // The model rejects it at construction; multiplicityFromPair
+    // rejects it at name lookup. Both must surface the error.
+    expect(() => partitiveMultiplicityName('optional', 'at_least_one'))
+      .toThrow(/Invalid multiplicity combination/);
+  });
+
+  it('every valid combination produces a renderable rakeStrokeStyle', () => {
+    // The renderer must accept every valid combination — no missing
+    // branches in the switch. If multiplicityFromPair succeeds,
+    // rakeStrokeStyle must succeed too.
+    for (const { presence, count } of VALID_COMBINATIONS) {
+      const style = rakeStrokeStyle(presence, count, false);
+      expect(style.lineCount).toBeGreaterThanOrEqual(1);
+      expect(style.lineCount).toBeLessThanOrEqual(2);
+      expect(style.strokeWidth).toBeGreaterThan(0);
+    }
+  });
+
+  it('the table has exactly 5 entries (no drift)', () => {
+    expect(VALID_COMBINATIONS).toHaveLength(5);
+  });
+
+  it('no two pairs map to the same ISO 704 name', () => {
+    const names = VALID_COMBINATIONS.map(c => c.iso704Name);
+    expect(new Set(names).size).toBe(names.length);
+  });
+});

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

@@ -0,0 +1,153 @@
+/**
+ * Bridge reverse-map round-trip specs.
+ *
+ * Audit (AUDIT-2026-07-29 P2-1): pin that loading legacy
+ * gl:multiplicity (or older gl:certainty) wire data produces a
+ * glossarist-js v4 model with the correct MECE presence × count
+ * fields. The migration path lives in model-bridge.ts and must
+ * agree with multiplicityFromPair(p, c) at the SSOT level.
+ *
+ * This spec also covers the invalid-combination case: legacy data
+ * carrying the vacuous (optional, at_least_one) combo via
+ * gl:multiplicity cannot exist — there's no ISO 704 name for it —
+ * so we don't test that path here.
+ */
+import { describe, it, expect } from 'vitest';
+import { conceptFromJson } from '../adapters/model-bridge';
+
+interface PartitiveMemberLike {
+  presence: string;
+  count: string;
+  is_delimiting: boolean;
+}
+
+function loadPartitives(doc: Record<string, unknown>): PartitiveMemberLike[] {
+  const concept = conceptFromJson(doc as any);
+  const relations = (concept as any).partitiveRelations ?? [];
+  return relations.flatMap((r: any) =>
+    (r.partitives ?? []).map((m: any) => ({
+      presence: m.presence,
+      count: m.count,
+      is_delimiting: m.is_delimiting,
+    })),
+  );
+}
+
+const BASE_DOC = {
+  '@type': 'gl:Concept',
+  '@id': 'https://example.org/vim/concept/1.3',
+  'gl:identifier': '1.3',
+  'gl:localizedConcept': {},
+};
+
+function docWithRelation(members: unknown[]) {
+  return {
+    ...BASE_DOC,
+    'gl:partitiveRelations': [
+      {
+        'gl:comprehensive': { 'gl:source': 'VIM', 'gl:id': '1.3' },
+        'gl:hasPartitive': members,
+        'gl:completeness': 'complete',
+      },
+    ],
+  };
+}
+
+describe('bridge reverse-map: legacy gl:multiplicity → MECE presence × count', () => {
+  it('compulsory → required + exactly_one', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' }, 'gl:multiplicity': 'compulsory' },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' }, 'gl:multiplicity': 'compulsory' },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0]).toEqual({ presence: 'required', count: 'exactly_one', is_delimiting: false });
+    expect(members[1]).toEqual({ presence: 'required', count: 'exactly_one', is_delimiting: false });
+  });
+
+  it('optional → optional + exactly_one', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' }, 'gl:multiplicity': 'optional' },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' }, 'gl:multiplicity': 'compulsory' },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0]).toEqual({ presence: 'optional', count: 'exactly_one', is_delimiting: false });
+  });
+
+  it('compulsory_multiple → required + multiple', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' }, 'gl:multiplicity': 'compulsory_multiple' },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' }, 'gl:multiplicity': 'compulsory' },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0]).toEqual({ presence: 'required', count: 'multiple', is_delimiting: false });
+  });
+
+  it('optional_multiple → optional + multiple', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' }, 'gl:multiplicity': 'optional_multiple' },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' }, 'gl:multiplicity': 'compulsory' },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0]).toEqual({ presence: 'optional', count: 'multiple', is_delimiting: false });
+  });
+
+  it('compulsory_at_least_one → required + at_least_one', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' }, 'gl:multiplicity': 'compulsory_at_least_one' },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' }, 'gl:multiplicity': 'compulsory' },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0]).toEqual({ presence: 'required', count: 'at_least_one', is_delimiting: false });
+  });
+
+  it('legacy gl:certainty confirmed → required + exactly_one (v2 wire)', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' }, 'gl:certainty': 'confirmed' },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' }, 'gl:certainty': 'confirmed' },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0]).toEqual({ presence: 'required', count: 'exactly_one', is_delimiting: false });
+  });
+
+  it('legacy gl:certainty possible → optional + exactly_one (v2 wire)', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' }, 'gl:certainty': 'possible' },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' }, 'gl:certainty': 'confirmed' },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0]).toEqual({ presence: 'optional', count: 'exactly_one', is_delimiting: false });
+  });
+});
+
+describe('bridge: native MECE gl:presence + gl:count passes through', () => {
+  it('presence=optional + count=multiple loads natively', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' }, 'gl:presence': 'optional', 'gl:count': 'multiple' },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' }, 'gl:presence': 'required', 'gl:count': 'exactly_one' },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0]).toEqual({ presence: 'optional', count: 'multiple', is_delimiting: false });
+    expect(members[1]).toEqual({ presence: 'required', count: 'exactly_one', is_delimiting: false });
+  });
+
+  it('gl:isDelimiting=true preserved', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' }, 'gl:isDelimiting': true },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' } },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0].is_delimiting).toBe(true);
+    expect(members[1].is_delimiting).toBe(false);
+  });
+});
+
+describe('bridge: defaults when no multiplicity fields present', () => {
+  it('member with no presence/count/multiplicity/certainty defaults to required + exactly_one', () => {
+    const doc = docWithRelation([
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.4' } },
+      { 'gl:ref': { 'gl:source': 'VIM', 'gl:id': '1.5' } },
+    ]);
+    const members = loadPartitives(doc);
+    expect(members[0]).toEqual({ presence: 'required', count: 'exactly_one', is_delimiting: false });
+  });
+});

package/src/__tests__/uri-router.test.ts

@@ -103,4 +103,33 @@ describe('UriRouter', () => {
       expect(UriRouter.parseUri('https://example.com/other')).toBeNull();
     });
   });
+
+  describe('SSOT: UriRouter.buildConceptUri is the single concept-URI constructor', () => {
+    // Per AUDIT-2026-07-29 P1-1: ConceptIdentity, the conceptUri()
+    // bridge, and UriRouter.buildConceptUri must all funnel through
+    // UriRouter.buildConceptUri. No inline template literals for
+    // `${uriBase}/${registerId}/concept/${id}` outside UriRouter.
+
+    it('UriRouter.buildConceptUri constructs the canonical URI', () => {
+      expect(UriRouter.buildConceptUri('https://x.org', 'vim', '1.3'))
+        .toBe('https://x.org/vim/concept/1.3');
+    });
+
+    it('UriRouter.buildDomainUri constructs the canonical domain URI', () => {
+      expect(UriRouter.buildDomainUri('https://x.org', 'vim', 'physics'))
+        .toBe('https://x.org/vim/domain/physics');
+    });
+
+    it('ConceptIdentity.uri delegates to UriRouter.buildConceptUri', async () => {
+      const { ConceptIdentity } = await import('../adapters/concept-identity');
+      const id = new ConceptIdentity('1.3', 'vim', 'https://x.org');
+      expect(id.uri).toBe(UriRouter.buildConceptUri('https://x.org', 'vim', '1.3'));
+    });
+
+    it('ConceptIdentity.domainUri delegates to UriRouter.buildDomainUri', async () => {
+      const { ConceptIdentity } = await import('../adapters/concept-identity');
+      const id = new ConceptIdentity('1.3', 'vim', 'https://x.org');
+      expect(id.domainUri('physics')).toBe(UriRouter.buildDomainUri('https://x.org', 'vim', 'physics'));
+    });
+  });
 });

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

@@ -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(87);
+  });
+});

package/src/adapters/GraphDataSource.ts

@@ -137,7 +137,7 @@ export class GraphDataSource {
       if (lc?.domain) {
         edges.push({
           source: sourceUri,
-          target: `${this.uriBase}/${this.registerId}/domain/${slugify(lc.domain)}`,
+          target: UriRouter.buildDomainUri(this.uriBase, this.registerId, slugify(lc.domain)),
           type: 'domain',
           label: lc.domain,
           register: this.registerId,

package/src/adapters/UriRouter.ts

@@ -1,5 +1,4 @@
 import type { Manifest } from './types';
-import { ConceptIdentity } from './concept-identity';
 
 // ── URI pattern matching ────────────────────────────────────────────────────
 
@@ -106,11 +105,16 @@ export class UriRouter {
     return `${uriBase}/${registerId}/concept/${conceptId}`;
   }
 
-  /** Construct a canonical URI for a concept. */
+  /** Construct a canonical domain URI from components. */
+  static buildDomainUri(uriBase: string, registerId: string, domainSlug: string): string {
+    return `${uriBase}/${registerId}/domain/${domainSlug}`;
+  }
+
+  /** Construct a canonical URI for a concept from its register-id + concept-id. */
   buildUri(registerId: string, conceptId: string): string {
     const info = this.registerMap.get(registerId);
     const uriBase = info?.uriBase ?? '';
-    return new ConceptIdentity(conceptId, registerId, uriBase).uri;
+    return UriRouter.buildConceptUri(uriBase, registerId, conceptId);
   }
 
   getRegisteredIds(): string[] {

package/src/adapters/concept-identity.ts

@@ -1,4 +1,5 @@
 import { InvalidConceptIdentityError, InvalidConceptUriError } from '../errors';
+import { UriRouter } from './UriRouter';
 
 export interface ConceptIdentityParts {
   readonly localId: string;
@@ -24,7 +25,10 @@ export class ConceptIdentity implements ConceptIdentityParts {
         { localId, registerId, uriBase },
       );
     }
-    this._uri = `${uriBase}/${registerId}/concept/${localId}`;
+    // Single SSOT for concept URI construction: UriRouter.buildConceptUri.
+    // ConceptIdentity, the conceptUri() bridge, and UriRouter.buildConceptUri
+    // all funnel here — no inline template literals scattered across files.
+    this._uri = UriRouter.buildConceptUri(uriBase, registerId, localId);
     this._slug = localId;
     this._path = `${registerId}/concepts/${localId}`;
   }
@@ -52,7 +56,7 @@ export class ConceptIdentity implements ConceptIdentityParts {
   }
 
   domainUri(domainSlug: string): string {
-    return `${this.uriBase}/${this.registerId}/domain/${domainSlug}`;
+    return UriRouter.buildDomainUri(this.uriBase, this.registerId, domainSlug);
   }
 
   static fromUri(uri: string): ConceptIdentity {

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

@@ -0,0 +1,169 @@
+/**
+ * JSON-LD wire-format types for the model-bridge.
+ *
+ * Extracted from model-bridge.ts to keep the mapper/bridge logic
+ * scannable. The 'gl:' prefix is the Glossarist JSON-LD namespace —
+ * see data/concept-model/ontologies/glossarist.context.jsonld.
+ *
+ * Wire format is dictated by glossarist-js's JSON-LD context, which
+ * is stable. Schema changes are rare and reviewable.
+ */
+
+export interface JsonLdContent {
+  'gl:content'?: string;
+}
+
+export interface JsonLdDate {
+  'gl:date'?: string;
+  'gl:dateType'?: string;
+}
+
+export interface JsonLdPronunciation {
+  'gl:content'?: string;
+  'gl:language'?: string;
+  'gl:script'?: string;
+  'gl:system'?: string;
+  'gl:country'?: string;
+}
+
+export interface JsonLdGrammarInfo {
+  'gl:gender'?: string;
+  'gl:number'?: string;
+  'gl:partOfSpeech'?: string;
+  'gl:noun'?: boolean;
+  'gl:verb'?: boolean;
+  'gl:adj'?: boolean;
+  'gl:adverb'?: boolean;
+  'gl:preposition'?: boolean;
+  'gl:participle'?: boolean;
+}
+
+export interface JsonLdRef {
+  'gl:source'?: string;
+  'gl:id'?: string;
+  'gl:version'?: string;
+  'gl:text'?: string;
+  source?: string;
+  id?: string;
+  version?: string;
+}
+
+export interface JsonLdLocality {
+  'gl:localityType'?: string;
+  'gl:referenceFrom'?: string;
+  'gl:referenceTo'?: string;
+  type?: string;
+  reference_from?: string;
+  reference_to?: string;
+}
+
+export interface JsonLdOrigin {
+  'gl:ref'?: string | JsonLdRef;
+  'gl:locality'?: JsonLdLocality;
+  'gl:link'?: string;
+  'gl:id'?: string;
+  'gl:version'?: string;
+  'gl:source'?: string;
+}
+
+export interface JsonLdSource {
+  'gl:id'?: string;
+  'gl:sourceType'?: string;
+  'gl:sourceStatus'?: string;
+  'gl:modification'?: string;
+  'gl:origin'?: JsonLdOrigin;
+  'gl:sourcedFrom'?: JsonLdOrigin[];
+  'gl:sourced_from'?: JsonLdOrigin[];
+}
+
+export interface JsonLdRelated {
+  'gl:relationshipType'?: string;
+  'gl:ref'?: JsonLdRef;
+  '@id'?: string;
+  'gl:term'?: string;
+  'gl:target'?: string;
+  'gl:sourceId'?: string;
+  'gl:citation'?: JsonLdOrigin;
+}
+
+export interface JsonLdDesignation {
+  '@type'?: string;
+  'gl:term'?: string;
+  'gl:normativeStatus'?: string;
+  'gl:absent'?: unknown;
+  'gl:fieldOfApplication'?: string;
+  'gl:usageInfo'?: string;
+  'gl:geographicalArea'?: string;
+  'gl:language'?: string;
+  'gl:script'?: string;
+  'gl:system'?: string;
+  'gl:international'?: boolean;
+  'gl:termType'?: string;
+  'gl:pronunciation'?: JsonLdPronunciation[];
+  'gl:source'?: JsonLdSource[];
+  'gl:related'?: JsonLdRelated[];
+  'gl:prefix'?: string;
+  'gl:gender'?: string;
+  'gl:grammarInfo'?: JsonLdGrammarInfo[];
+}
+
+export interface JsonLdLocalizedConcept {
+  'gl:languageCode'?: string;
+  'gl:entryStatus'?: string;
+  'gl:classification'?: string;
+  'gl:reviewType'?: string;
+  'gl:domain'?: string;
+  'gl:release'?: string;
+  'gl:lineageSourceSimilarity'?: number;
+  'gl:script'?: string;
+  'gl:system'?: string;
+  'gl:designation'?: JsonLdDesignation[];
+  'gl:definition'?: JsonLdContent[];
+  'gl:notes'?: JsonLdContent[];
+  'gl:annotations'?: JsonLdContent[];
+  'gl:examples'?: JsonLdContent[];
+  'gl:source'?: JsonLdSource[];
+  'gl:dates'?: JsonLdDate[];
+  'gl:references'?: JsonLdRelated[];
+  'gl:reviewDate'?: string;
+  'gl:reviewDecisionDate'?: string;
+  'gl:reviewDecisionEvent'?: string;
+  'gl:reviewStatus'?: string;
+  'gl:reviewDecision'?: string;
+  'gl:reviewDecisionNotes'?: string;
+}
+
+export interface JsonLdPartitiveMember {
+  'gl:ref'?: JsonLdRef;
+  /** ISO 704:2022 MECE: presence (required | optional) */
+  'gl:presence'?: string;
+  /** ISO 704:2022 MECE: count (exactly_one | at_least_one | multiple) */
+  'gl:count'?: string;
+  /** ISO 704:2022: delimiting part (3× stroke width in diagrams) */
+  'gl:isDelimiting'?: boolean;
+  /** Legacy v3 field — one-string multiplicity, split into presence+count */
+  'gl:multiplicity'?: string;
+  /** Legacy v2 field — migrated to presence+count */
+  'gl:certainty'?: string;
+}
+
+export interface JsonLdPartitiveRelation {
+  'gl:comprehensive'?: JsonLdRef;
+  'gl:hasPartitive'?: JsonLdPartitiveMember[];
+  'gl:completeness'?: string;
+  'gl:criterion'?: Record<string, string> | string;
+}
+
+export interface JsonLdConcept {
+  '@type'?: string;
+  '@id'?: string;
+  'gl:identifier'?: string | number;
+  'gl:term'?: string;
+  'gl:localizedConcept'?: Record<string, JsonLdLocalizedConcept>;
+  'gl:related'?: JsonLdRelated[];
+  'gl:partitiveRelations'?: JsonLdPartitiveRelation[];
+  'gl:tags'?: string[];
+  'gl:figureRef'?: unknown[];
+  'gl:tableRef'?: unknown[];
+  'gl:formulaRef'?: unknown[];
+}