@glossarist/concept-browser 0.7.86 → 0.7.88

package/src/__tests__/partitive-relation.test.ts

@@ -13,6 +13,14 @@ function extractPartitiveRelations(
   const relations: PartitiveRelationWire[] = [];
   const sourceUri = concept['@id'];
 
+  const LEGACY_MULTIPLICITY_MAP: Record<string, { presence: string; count: string }> = {
+    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' },
+  };
+
   const resolveConceptUri = (ref: any): string | null => {
     const source = ref?.['gl:source'] || ref?.source;
     const id = ref?.['gl:id'] || ref?.id;
@@ -21,6 +29,29 @@ function extractPartitiveRelations(
     return `${uriBase}/${reg}/concept/${id}`;
   };
 
+  const resolvePresence = (member: any): 'required' | 'optional' => {
+    const p = member['gl:presence'] ?? member.presence;
+    if (p === 'required' || p === 'optional') return p as 'required' | 'optional';
+    const multiplicity = member['gl:multiplicity'] ?? member.multiplicity;
+    if (typeof multiplicity === 'string' && LEGACY_MULTIPLICITY_MAP[multiplicity]) {
+      return LEGACY_MULTIPLICITY_MAP[multiplicity].presence as 'required' | 'optional';
+    }
+    const certainty = member['gl:certainty'] ?? member.certainty;
+    return certainty === 'possible' ? 'optional' : 'required';
+  };
+
+  const resolveCount = (member: any): 'exactly_one' | 'at_least_one' | 'multiple' => {
+    const c = member['gl:count'] ?? member.count;
+    if (c === 'exactly_one' || c === 'at_least_one' || c === 'multiple') {
+      return c as 'exactly_one' | 'at_least_one' | 'multiple';
+    }
+    const multiplicity = member['gl:multiplicity'] ?? member.multiplicity;
+    if (typeof multiplicity === 'string' && LEGACY_MULTIPLICITY_MAP[multiplicity]) {
+      return LEGACY_MULTIPLICITY_MAP[multiplicity].count as 'exactly_one' | 'at_least_one' | 'multiple';
+    }
+    return 'exactly_one';
+  };
+
   for (const rel of concept['gl:partitiveRelations'] || []) {
     const comprehensive = resolveConceptUri(rel['gl:comprehensive']);
     if (!comprehensive) continue;
@@ -30,16 +61,14 @@ function extractPartitiveRelations(
         const memberRef = member['gl:ref'] || member;
         const uri = resolveConceptUri(memberRef);
         if (!uri || uri === sourceUri) return null;
-        const multiplicity = member['gl:multiplicity'] || 'compulsory';
-        const isDelimiting = member['gl:isDelimiting'] === true;
-        if (!isValidMultiplicity(multiplicity)) {
-          throw new Error(
-            `Invalid partitive member multiplicity: "${multiplicity}". Allowed: compulsory, optional, compulsory_multiple, optional_multiple, compulsory_at_least_one`,
-          );
-        }
-        return { uri, multiplicity, isDelimiting };
+        return {
+          uri,
+          presence: resolvePresence(member),
+          count: resolveCount(member),
+          isDelimiting: member['gl:isDelimiting'] === true || member.isDelimiting === true,
+        };
       })
-      .filter((p: any): p is { uri: string; multiplicity: 'compulsory' | 'optional' | 'compulsory_multiple' | 'optional_multiple' | 'compulsory_at_least_one'; isDelimiting: boolean } => p !== null);
+      .filter((p: any): p is { uri: string; presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple'; isDelimiting: boolean } => p !== null);
 
     if (partitives.length === 0) continue;
 
@@ -61,17 +90,13 @@ function extractPartitiveRelations(
   return relations;
 }
 
-function isValidMultiplicity(value: unknown): value is 'compulsory' | 'optional' | 'compulsory_multiple' | 'optional_multiple' | 'compulsory_at_least_one' {
-  return ['compulsory', 'optional', 'compulsory_multiple', 'optional_multiple', 'compulsory_at_least_one'].includes(value as string);
-}
-
-describe('extractPartitiveRelations', () => {
+describe('extractPartitiveRelations (MECE presence × count)', () => {
   const uriBase = 'https://example.org';
   const urnMap = new Map([['urn:vim:pub:v:2:2012', 'vim-2012']]);
   const registerId = 'vim-2012';
   const sourceUri = `${uriBase}/${registerId}/concept/1.3`;
 
-  it('extracts a complete relation with two compulsory members', () => {
+  it('extracts a complete relation with two required/exactly_one members', () => {
     const concept = {
       '@id': sourceUri,
       'gl:partitiveRelations': [
@@ -90,8 +115,8 @@ describe('extractPartitiveRelations', () => {
     expect(result).toHaveLength(1);
     expect(result[0].comprehensive).toBe(`${uriBase}/${registerId}/concept/1.3`);
     expect(result[0].partitives).toEqual([
-      { uri: `${uriBase}/${registerId}/concept/1.4`, multiplicity: 'compulsory', isDelimiting: false },
-      { uri: `${uriBase}/${registerId}/concept/1.5`, multiplicity: 'compulsory', isDelimiting: false },
+      { uri: `${uriBase}/${registerId}/concept/1.4`, presence: 'required', count: 'exactly_one', isDelimiting: false },
+      { uri: `${uriBase}/${registerId}/concept/1.5`, presence: 'required', count: 'exactly_one', isDelimiting: false },
     ]);
     expect(result[0].completeness).toBe('complete');
   });
@@ -129,7 +154,7 @@ describe('extractPartitiveRelations', () => {
     expect(rel.completeness).toBe('partial');
   });
 
-  it('reads per-member multiplicity + isDelimiting', () => {
+  it('reads per-member presence + count + isDelimiting (v3 native)', () => {
     const concept = {
       '@id': sourceUri,
       'gl:partitiveRelations': [
@@ -137,51 +162,56 @@ describe('extractPartitiveRelations', () => {
           'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
           'gl:hasPartitive': [
             { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
-            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.5' }, 'gl:multiplicity': 'optional' },
-            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.6' }, 'gl:multiplicity': 'compulsory_multiple' },
-            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.7' }, 'gl:multiplicity': 'compulsory_at_least_one', 'gl:isDelimiting': true },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.5' }, 'gl:presence': 'optional' },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.6' }, 'gl:count': 'multiple' },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.7' }, 'gl:count': 'at_least_one', 'gl:isDelimiting': true },
           ],
         },
       ],
     };
     const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
     expect(rel.partitives).toEqual([
-      { uri: `${uriBase}/${registerId}/concept/1.4`, multiplicity: 'compulsory', isDelimiting: false },
-      { uri: `${uriBase}/${registerId}/concept/1.5`, multiplicity: 'optional', isDelimiting: false },
-      { uri: `${uriBase}/${registerId}/concept/1.6`, multiplicity: 'compulsory_multiple', isDelimiting: false },
-      { uri: `${uriBase}/${registerId}/concept/1.7`, multiplicity: 'compulsory_at_least_one', isDelimiting: true },
+      { uri: `${uriBase}/${registerId}/concept/1.4`, presence: 'required', count: 'exactly_one', isDelimiting: false },
+      { uri: `${uriBase}/${registerId}/concept/1.5`, presence: 'optional', count: 'exactly_one', isDelimiting: false },
+      { uri: `${uriBase}/${registerId}/concept/1.6`, presence: 'required', count: 'multiple', isDelimiting: false },
+      { uri: `${uriBase}/${registerId}/concept/1.7`, presence: 'required', count: 'at_least_one', isDelimiting: true },
     ]);
   });
 
-  it('throws on invalid completeness', () => {
+  it('migrates legacy gl:multiplicity into presence + count (one-release compat)', () => {
     const concept = {
       '@id': sourceUri,
       'gl:partitiveRelations': [
         {
           'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
           'gl:hasPartitive': [
-            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' }, 'gl:multiplicity': 'optional_multiple' },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.5' }, 'gl:multiplicity': 'compulsory_at_least_one' },
           ],
-          'gl:completeness': 'closed',
         },
       ],
     };
-    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*completeness.*closed/);
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.partitives).toEqual([
+      { uri: `${uriBase}/${registerId}/concept/1.4`, presence: 'optional', count: 'multiple', isDelimiting: false },
+      { uri: `${uriBase}/${registerId}/concept/1.5`, presence: 'required', count: 'at_least_one', isDelimiting: false },
+    ]);
   });
 
-  it('throws on invalid multiplicity', () => {
+  it('throws on invalid completeness', () => {
     const concept = {
       '@id': sourceUri,
       'gl:partitiveRelations': [
         {
           'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
           'gl:hasPartitive': [
-            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' }, 'gl:multiplicity': 'maybe' },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
           ],
+          'gl:completeness': 'closed',
         },
       ],
     };
-    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*multiplicity.*maybe/);
+    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*completeness.*closed/);
   });
 
   it('skips a relation whose comprehensive cannot be resolved', () => {

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__/utils/partitive-multiplicity.test.ts

@@ -1,113 +1,137 @@
+/**
+ * MECE refactor of partitive-multiplicity (ISO 704:2022).
+ *
+ * Types + enums come from glossarist-js (the SSOT for the model).
+ * The render-ready stroke style is the only browser-specific concern;
+ * its truth table is pinned here so future rendering edits stay
+ * aligned with the spec.
+ */
 import { describe, it, expect } from 'vitest';
 import {
-  PARTITIVE_MULTIPLICITY,
-  PARTITIVE_MULTIPLICITY_VALUES,
-  isPartitiveMultiplicity,
-  multiplicityDefinition,
+  PARTITIVE_PRESENCE,
+  PARTITIVE_COUNT,
+  isPartitivePresence,
+  isPartitiveCount,
+  presenceLabel,
+  countLabel,
   rakeStrokeStyle,
-  multiplicityFromCertainty,
+  partitiveMultiplicityName,
   NORMAL_STROKE_WIDTH,
   DELIMITING_STROKE_WIDTH,
-  type PartitiveMultiplicity,
+  type PartitivePresence,
+  type PartitiveCount,
 } from '../../utils/partitive-multiplicity';
 
-describe('partitive-multiplicity registry', () => {
-  it('has exactly 5 ISO 704:2022 multiplicity values', () => {
-    expect(PARTITIVE_MULTIPLICITY_VALUES).toEqual([
-      'compulsory',
-      'optional',
-      'compulsory_multiple',
-      'optional_multiple',
-      'compulsory_at_least_one',
-    ]);
+describe('presence axis (re-exported from glossarist)', () => {
+  it('has exactly 2 values: required, optional', () => {
+    expect([...PARTITIVE_PRESENCE.VALUES]).toEqual(['required', 'optional']);
   });
 
-  it('compulsory: 1 line, solid', () => {
-    expect(multiplicityDefinition('compulsory')).toEqual({
-      lines: 1, pattern: 'solid', label: 'Compulsory',
-    });
+  it('isPartitivePresence narrows known values', () => {
+    expect(isPartitivePresence('required')).toBe(true);
+    expect(isPartitivePresence('optional')).toBe(true);
+    expect(isPartitivePresence('unknown')).toBe(false);
+    expect(isPartitivePresence(null)).toBe(false);
+    expect(isPartitivePresence(42)).toBe(false);
   });
 
-  it('optional: 1 line, dashed', () => {
-    expect(multiplicityDefinition('optional')).toEqual({
-      lines: 1, pattern: 'dashed', label: 'Optional',
-    });
+  it('presenceLabel returns human-readable labels', () => {
+    expect(presenceLabel('required')).toBe('Required');
+    expect(presenceLabel('optional')).toBe('Optional');
+  });
+});
+
+describe('count axis (re-exported from glossarist)', () => {
+  it('has exactly 3 values: exactly_one, at_least_one, multiple', () => {
+    expect([...PARTITIVE_COUNT.VALUES]).toEqual(['exactly_one', 'at_least_one', 'multiple']);
   });
 
-  it('compulsory_multiple: 2 lines, solid', () => {
-    expect(multiplicityDefinition('compulsory_multiple')).toEqual({
-      lines: 2, pattern: 'solid', label: 'Compulsory multiple',
-    });
+  it('isPartitiveCount narrows known values', () => {
+    expect(isPartitiveCount('exactly_one')).toBe(true);
+    expect(isPartitiveCount('at_least_one')).toBe(true);
+    expect(isPartitiveCount('multiple')).toBe(true);
+    expect(isPartitiveCount('unknown')).toBe(false);
+    expect(isPartitiveCount(null)).toBe(false);
   });
 
-  it('optional_multiple: 2 lines, dashed', () => {
-    expect(multiplicityDefinition('optional_multiple')).toEqual({
-      lines: 2, pattern: 'dashed', label: 'Optional multiple',
-    });
+  it('countLabel returns human-readable labels', () => {
+    expect(countLabel('exactly_one')).toBe('Exactly one');
+    expect(countLabel('at_least_one')).toBe('At least one');
+    expect(countLabel('multiple')).toBe('Multiple');
   });
+});
 
-  it('compulsory_at_least_one: 2 lines, mixed (one solid + one dashed)', () => {
-    expect(multiplicityDefinition('compulsory_at_least_one')).toEqual({
-      lines: 2, pattern: 'mixed', label: 'At least one',
-    });
+describe('partitiveMultiplicityName (glossarist SSOT)', () => {
+  it('maps the 5 valid combinations to ISO 704 names', () => {
+    expect(partitiveMultiplicityName('required', 'exactly_one')).toBe('compulsory');
+    expect(partitiveMultiplicityName('optional', 'exactly_one')).toBe('optional');
+    expect(partitiveMultiplicityName('required', 'multiple')).toBe('compulsory_multiple');
+    expect(partitiveMultiplicityName('optional', 'multiple')).toBe('optional_multiple');
+    expect(partitiveMultiplicityName('required', 'at_least_one')).toBe('compulsory_at_least_one');
   });
 
-  it('isPartitiveMultiplicity narrows known values', () => {
-    expect(isPartitiveMultiplicity('compulsory')).toBe(true);
-    expect(isPartitiveMultiplicity('compulsory_at_least_one')).toBe(true);
-    expect(isPartitiveMultiplicity('unknown')).toBe(false);
-    expect(isPartitiveMultiplicity(null)).toBe(false);
-    expect(isPartitiveMultiplicity(42)).toBe(false);
+  it('rejects the vacuous (optional, at_least_one) combination', () => {
+    expect(() => partitiveMultiplicityName('optional', 'at_least_one'))
+      .toThrow(/collapses to optional \+ multiple/);
   });
 });
 
-describe('rakeStrokeStyle', () => {
-  const cases: Array<{
-    name: string;
-    multiplicity: PartitiveMultiplicity;
-    isDelimiting: boolean;
-    expected: {
-      lineCount: 1 | 2;
-      primaryDashed: boolean;
-      secondaryDashed: boolean;
-      strokeWidth: number;
-    };
-  }> = [
-    // 5 multiplicity × 2 delimiting = 10 variants
-    { name: 'compulsory / non-delimiting',          multiplicity: 'compulsory',          isDelimiting: false, expected: { lineCount: 1, primaryDashed: false, secondaryDashed: false, strokeWidth: NORMAL_STROKE_WIDTH } },
-    { name: 'compulsory / delimiting',              multiplicity: 'compulsory',          isDelimiting: true,  expected: { lineCount: 1, primaryDashed: false, secondaryDashed: false, strokeWidth: DELIMITING_STROKE_WIDTH } },
-    { name: 'optional / non-delimiting',            multiplicity: 'optional',            isDelimiting: false, expected: { lineCount: 1, primaryDashed: true,  secondaryDashed: true,  strokeWidth: NORMAL_STROKE_WIDTH } },
-    { name: 'optional / delimiting',                multiplicity: 'optional',            isDelimiting: true,  expected: { lineCount: 1, primaryDashed: true,  secondaryDashed: true,  strokeWidth: DELIMITING_STROKE_WIDTH } },
-    { name: 'compulsory_multiple / non-delimiting', multiplicity: 'compulsory_multiple', isDelimiting: false, expected: { lineCount: 2, primaryDashed: false, secondaryDashed: false, strokeWidth: NORMAL_STROKE_WIDTH } },
-    { name: 'compulsory_multiple / delimiting',     multiplicity: 'compulsory_multiple', isDelimiting: true,  expected: { lineCount: 2, primaryDashed: false, secondaryDashed: false, strokeWidth: DELIMITING_STROKE_WIDTH } },
-    { name: 'optional_multiple / non-delimiting',   multiplicity: 'optional_multiple',   isDelimiting: false, expected: { lineCount: 2, primaryDashed: true,  secondaryDashed: true,  strokeWidth: NORMAL_STROKE_WIDTH } },
-    { name: 'optional_multiple / delimiting',       multiplicity: 'optional_multiple',   isDelimiting: true,  expected: { lineCount: 2, primaryDashed: true,  secondaryDashed: true,  strokeWidth: DELIMITING_STROKE_WIDTH } },
-    { name: 'compulsory_at_least_one / non-delimiting',        multiplicity: 'compulsory_at_least_one',        isDelimiting: false, expected: { lineCount: 2, primaryDashed: false, secondaryDashed: true,  strokeWidth: NORMAL_STROKE_WIDTH } },
-    { name: 'compulsory_at_least_one / delimiting',            multiplicity: 'compulsory_at_least_one',        isDelimiting: true,  expected: { lineCount: 2, primaryDashed: false, secondaryDashed: true,  strokeWidth: DELIMITING_STROKE_WIDTH } },
-  ];
+describe('rakeStrokeStyle (MECE rendering truth table)', () => {
+  const presenceCases: PartitivePresence[] = ['required', 'optional'];
+  const countCases: PartitiveCount[] = ['exactly_one', 'at_least_one', 'multiple'];
+  const delimitingCases = [false, true];
 
-  for (const c of cases) {
-    it(`${c.name} → ${JSON.stringify(c.expected)}`, () => {
-      expect(rakeStrokeStyle(c.multiplicity, c.isDelimiting)).toEqual(c.expected);
-    });
+  for (const presence of presenceCases) {
+    for (const count of countCases) {
+      for (const isDelimiting of delimitingCases) {
+        const expectedWidth = isDelimiting ? DELIMITING_STROKE_WIDTH : NORMAL_STROKE_WIDTH;
+        const expectedPrimaryDashed = presence === 'optional';
+        const expectedLineCount: 1 | 2 = count === 'exactly_one' ? 1 : 2;
+        // When lineCount=1, secondaryDashed is unused (no second line).
+        // Implementation choice: set it to false as the default.
+        // When lineCount=2:
+        //   - at_least_one: secondary always dashed ("possibly more")
+        //   - multiple: secondary mirrors primary
+        const expectedSecondaryDashed = expectedLineCount === 1
+          ? false
+          : count === 'at_least_one'
+            ? true
+            : expectedPrimaryDashed;
+
+        it(`${presence} × ${count}${isDelimiting ? ' / delimiting' : ''}`, () => {
+          expect(rakeStrokeStyle(presence, count, isDelimiting)).toEqual({
+            lineCount: expectedLineCount,
+            primaryDashed: expectedPrimaryDashed,
+            secondaryDashed: expectedSecondaryDashed,
+            strokeWidth: expectedWidth,
+          });
+        });
+      }
+    }
   }
 
-  it('delimiting strokeWidth is exactly 3× normal (per ISO 704)', () => {
+  it('delimiting strokeWidth is 3× normal (per ISO 704 convention)', () => {
     expect(DELIMITING_STROKE_WIDTH / NORMAL_STROKE_WIDTH).toBe(3);
   });
-});
-
-describe('multiplicityFromCertainty (glossarist 0.4.20 migration)', () => {
-  it('confirmed → compulsory', () => {
-    expect(multiplicityFromCertainty('confirmed')).toBe('compulsory');
-  });
 
-  it('possible → optional', () => {
-    expect(multiplicityFromCertainty('possible')).toBe('optional');
+  it('exactly_one always produces a single line, regardless of presence', () => {
+    for (const presence of presenceCases) {
+      const style = rakeStrokeStyle(presence, 'exactly_one', false);
+      expect(style.lineCount).toBe(1);
+      expect(style.primaryDashed).toBe(presence === 'optional');
+    }
   });
 
-  it('null / undefined → compulsory (default)', () => {
-    expect(multiplicityFromCertainty(null)).toBe('compulsory');
-    expect(multiplicityFromCertainty(undefined)).toBe('compulsory');
+  it('at_least_one differs from multiple by secondary line dash pattern', () => {
+    for (const presence of presenceCases) {
+      const atleastOne = rakeStrokeStyle(presence, 'at_least_one', false);
+      const multiple = rakeStrokeStyle(presence, 'multiple', false);
+      expect(atleastOne.lineCount).toBe(2);
+      expect(multiple.lineCount).toBe(2);
+      // at_least_one: secondary always dashed (possibly more)
+      expect(atleastOne.secondaryDashed).toBe(true);
+      // multiple: secondary matches primary
+      expect(multiple.secondaryDashed).toBe(multiple.primaryDashed);
+    }
   });
 });

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.ts

@@ -25,6 +25,10 @@ import {
   DATE_TYPES,
   ConceptRef,
 } from 'glossarist';
+import {
+  isPartitivePresence,
+  isPartitiveCount,
+} from '../utils/partitive-multiplicity';
 import {
   LetterSymbol,
   GrammarInfo,
@@ -166,11 +170,15 @@ interface JsonLdLocalizedConcept {
 
 interface JsonLdPartitiveMember {
   'gl:ref'?: JsonLdRef;
-  /** ISO 704:2022 v3 field (native in glossarist 0.4.24). */
-  'gl:multiplicity'?: string;
-  /** ISO 704:2022 v3 field (native in glossarist 0.4.24). */
+  /** 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 v2 field — still read for backward compat with older datasets. */
+  /** Legacy v3 field — one-string multiplicity, split into presence+count */
+  'gl:multiplicity'?: string;
+  /** Legacy v2 field — migrated to presence+count */
   'gl:certainty'?: string;
 }
 
@@ -590,16 +598,23 @@ function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<stri
       const ref = m['gl:ref'] ? mapRefFromJsonLd(m['gl:ref']) : null;
       if (!ref) return null;
       const out: Record<string, unknown> = { ref };
-      // ISO 704:2022 multiplicity + is_delimiting (v3). Fall back to
-      // legacy gl:certainty for backward compat.
-      if (m['gl:multiplicity']) {
-        out.multiplicity = m['gl:multiplicity'];
-      } else if (m['gl:certainty']) {
-        out.multiplicity = m['gl:certainty'] === 'possible' ? 'optional' : 'compulsory';
-      }
-      if (m['gl:isDelimiting'] === true) {
-        out.is_delimiting = true;
+      // ISO 704:2022 MECE: prefer presence × count from JSON-LD. Fall back
+      // to migrating the legacy one-string `multiplicity` or v2 `certainty`
+      // so data in transit from older glossarist versions still loads.
+      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:isDelimiting'] === true) out.is_delimiting = true;
       return out;
     })
     .filter((m): m is Record<string, unknown> => m !== null);
@@ -624,6 +639,24 @@ function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<stri
   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' };
+}
+
 function conceptFromJsonLd(doc: JsonLdConcept): Concept {
   const id = String(doc['gl:identifier'] ?? doc['@id']?.split('/').pop() ?? '');
   const localizations: Record<string, unknown> = {};