@glossarist/concept-browser 0.7.85 → 0.7.86

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

@@ -1,62 +1,30 @@
 import { describe, it, expect } from 'vitest';
 import {
   partitiveRelationStyle,
-  pluralityColor,
   completenessLabel,
-  certaintyLabel,
 } from '../utils/partitive-relation-styling';
-import type { TypeSharedPluralityWire } from '../adapters/types';
 
 describe('partitive-relation-styling', () => {
-  describe('partitiveRelationStyle', () => {
-    it('returns full opacity for complete', () => {
-      expect(partitiveRelationStyle('complete', null, false).opacity).toBe(1.0);
-    });
-
-    it('returns reduced opacity for partial', () => {
-      expect(partitiveRelationStyle('partial', null, false).opacity).toBe(0.6);
-    });
-
-    it('uses teal badge class for complete with no plurality', () => {
-      expect(partitiveRelationStyle('complete', null, false).badgeClass).toBe('badge-teal');
-    });
-
-    it('uses blue badge class for isShared plurality', () => {
-      const p: TypeSharedPluralityWire = { isShared: true, isUncertain: false };
-      expect(partitiveRelationStyle('complete', p, false).badgeClass).toBe('badge-blue');
-    });
-
-    it('uses yellow badge class when isShared + isUncertain', () => {
-      const p: TypeSharedPluralityWire = { isShared: true, isUncertain: true };
-      expect(partitiveRelationStyle('complete', p, false).badgeClass).toBe('badge-yellow');
+  describe('partitiveRelationStyle (relation-level frame)', () => {
+    it('returns teal color in light mode', () => {
+      expect(partitiveRelationStyle('complete', false).color).toBe('#0d9488');
     });
 
-    it('returns different colors in dark mode', () => {
-      const light = partitiveRelationStyle('complete', null, false);
-      const dark = partitiveRelationStyle('complete', null, true);
-      expect(light.color).not.toBe(dark.color);
+    it('returns teal color in dark mode', () => {
+      expect(partitiveRelationStyle('complete', true).color).toBe('#2dd4bf');
     });
 
-    it('ignores plurality when isShared is false', () => {
-      const p: TypeSharedPluralityWire = { isShared: false, isUncertain: true };
-      expect(partitiveRelationStyle('complete', p, false).badgeClass).toBe('badge-teal');
-    });
-  });
-
-  describe('pluralityColor', () => {
-    it('returns blue for isShared', () => {
-      const p: TypeSharedPluralityWire = { isShared: true, isUncertain: false };
-      expect(pluralityColor(p, false)).toBe('#3b82f6');
+    it('returns full opacity for complete', () => {
+      expect(partitiveRelationStyle('complete', false).opacity).toBe(1.0);
     });
 
-    it('returns amber when isUncertain', () => {
-      const p: TypeSharedPluralityWire = { isShared: true, isUncertain: true };
-      expect(pluralityColor(p, false)).toBe('#f59e0b');
+    it('returns reduced opacity for partial', () => {
+      expect(partitiveRelationStyle('partial', false).opacity).toBe(0.6);
     });
 
-    it('returns dark-mode variants', () => {
-      expect(pluralityColor({ isShared: true, isUncertain: false }, true)).toBe('#60a5fa');
-      expect(pluralityColor({ isShared: true, isUncertain: true }, true)).toBe('#fbbf24');
+    it('uses teal badge class regardless of completeness', () => {
+      expect(partitiveRelationStyle('complete', false).badgeClass).toBe('badge-teal');
+      expect(partitiveRelationStyle('partial', false).badgeClass).toBe('badge-teal');
     });
   });
 
@@ -69,14 +37,4 @@ describe('partitive-relation-styling', () => {
       expect(completenessLabel('partial')).toBe('Partial');
     });
   });
-
-  describe('certaintyLabel', () => {
-    it('labels confirmed', () => {
-      expect(certaintyLabel('confirmed')).toBe('Confirmed');
-    });
-
-    it('labels possible', () => {
-      expect(certaintyLabel('possible')).toBe('Possible');
-    });
-  });
 });

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

@@ -21,89 +21,79 @@ function extractPartitiveRelations(
     return `${uriBase}/${reg}/concept/${id}`;
   };
 
-  const resolvePlurality = (plurality: any) => {
-    if (!plurality) return null;
-    const isShared = plurality['gl:isShared'] ?? plurality.is_shared;
-    if (typeof isShared !== 'boolean') return null;
-    const isUncertain = plurality['gl:isUncertain'] ?? plurality.is_uncertain ?? false;
-    const sharedTypeRef = plurality['gl:sharedType'] ?? plurality.shared_type;
-    let sharedType = null;
-    if (sharedTypeRef) {
-      const s = sharedTypeRef['gl:source'] ?? sharedTypeRef.source;
-      const i = sharedTypeRef['gl:id'] ?? sharedTypeRef.id;
-      if (s && i) sharedType = `${s}:${i}`;
-    }
-    return { isShared, isUncertain, sharedType };
-  };
-
   for (const rel of concept['gl:partitiveRelations'] || []) {
     const comprehensive = resolveConceptUri(rel['gl:comprehensive']);
     if (!comprehensive) continue;
+
     const partitives = (rel['gl:hasPartitive'] || [])
       .map((member: any) => {
-        const ref = member['gl:ref'] || member;
-        const uri = resolveConceptUri(ref);
+        const memberRef = member['gl:ref'] || member;
+        const uri = resolveConceptUri(memberRef);
         if (!uri || uri === sourceUri) return null;
-        const certainty = member['gl:certainty'] || 'confirmed';
-        if (certainty !== 'confirmed' && certainty !== 'possible') {
+        const multiplicity = member['gl:multiplicity'] || 'compulsory';
+        const isDelimiting = member['gl:isDelimiting'] === true;
+        if (!isValidMultiplicity(multiplicity)) {
           throw new Error(
-            `Invalid partitive member certainty: "${certainty}". Allowed: confirmed, possible`,
+            `Invalid partitive member multiplicity: "${multiplicity}". Allowed: compulsory, optional, compulsory_multiple, optional_multiple, compulsory_at_least_one`,
           );
         }
-        return { uri, certainty };
+        return { uri, multiplicity, isDelimiting };
       })
-      .filter((p: any): p is { uri: string; certainty: 'confirmed' | 'possible' } => p !== null);
+      .filter((p: any): p is { uri: string; multiplicity: 'compulsory' | 'optional' | 'compulsory_multiple' | 'optional_multiple' | 'compulsory_at_least_one'; isDelimiting: boolean } => p !== null);
+
     if (partitives.length === 0) continue;
+
     const completeness = rel['gl:completeness'] || 'complete';
     if (completeness !== 'complete' && completeness !== 'partial') {
       throw new Error(
         `Invalid partitive relation completeness: "${completeness}". Allowed: complete, partial`,
       );
     }
+
     relations.push({
       source: sourceUri,
       comprehensive,
       partitives,
       completeness,
-      plurality: resolvePlurality(rel['gl:hasPlurality']) as PartitiveRelationWire['plurality'],
-      criterion: rel['gl:criterion'],
       register: registerId,
     });
   }
   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', () => {
   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/2.9`;
+  const sourceUri = `${uriBase}/${registerId}/concept/1.3`;
 
-  it('extracts a complete relation with two confirmed members', () => {
+  it('extracts a complete relation with two compulsory members', () => {
     const concept = {
       '@id': sourceUri,
       'gl:partitiveRelations': [
         {
-          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          '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': '2.10' } },
-            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.26' } },
+            { '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:completeness': 'complete',
-          'gl:criterion': { eng: 'measurement result composition' },
         },
       ],
     };
 
     const result = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
     expect(result).toHaveLength(1);
-    expect(result[0].comprehensive).toBe(`${uriBase}/${registerId}/concept/2.9`);
+    expect(result[0].comprehensive).toBe(`${uriBase}/${registerId}/concept/1.3`);
     expect(result[0].partitives).toEqual([
-      { uri: `${uriBase}/${registerId}/concept/2.10`, certainty: 'confirmed' },
-      { uri: `${uriBase}/${registerId}/concept/2.26`, certainty: 'confirmed' },
+      { uri: `${uriBase}/${registerId}/concept/1.4`, multiplicity: 'compulsory', isDelimiting: false },
+      { uri: `${uriBase}/${registerId}/concept/1.5`, multiplicity: 'compulsory', isDelimiting: false },
     ]);
     expect(result[0].completeness).toBe('complete');
-    expect(result[0].criterion).toEqual({ eng: 'measurement result composition' });
   });
 
   it('defaults completeness to complete when omitted', () => {
@@ -111,9 +101,9 @@ describe('extractPartitiveRelations', () => {
       '@id': sourceUri,
       'gl:partitiveRelations': [
         {
-          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          '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': '2.10' } },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
           ],
         },
       ],
@@ -139,7 +129,7 @@ describe('extractPartitiveRelations', () => {
     expect(rel.completeness).toBe('partial');
   });
 
-  it('resolves plurality block (isShared + sharedType)', () => {
+  it('reads per-member multiplicity + isDelimiting', () => {
     const concept = {
       '@id': sourceUri,
       'gl:partitiveRelations': [
@@ -147,57 +137,19 @@ 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:hasPlurality': {
-            'gl:isShared': true,
-            'gl:isUncertain': false,
-            'gl:sharedType': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.99' },
-          },
-        },
-      ],
-    };
-    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
-    expect(rel.plurality).toEqual({
-      isShared: true,
-      isUncertain: false,
-      sharedType: 'urn:vim:pub:v:2:2012:1.99',
-    });
-  });
-
-  it('returns null plurality when isShared missing', () => {
-    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:hasPlurality': { 'gl:isUncertain': true },
-        },
-      ],
-    };
-    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
-    expect(rel.plurality).toBeNull();
-  });
-
-  it('preserves per-member certainty', () => {
-    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.5' }, 'gl:certainty': 'possible' },
+            { '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 },
           ],
         },
       ],
     };
     const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
     expect(rel.partitives).toEqual([
-      { uri: `${uriBase}/${registerId}/concept/1.4`, certainty: 'confirmed' },
-      { uri: `${uriBase}/${registerId}/concept/1.5`, certainty: 'possible' },
+      { 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 },
     ]);
   });
 
@@ -217,19 +169,19 @@ describe('extractPartitiveRelations', () => {
     expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*completeness.*closed/);
   });
 
-  it('throws on invalid member certainty', () => {
+  it('throws on invalid multiplicity', () => {
     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:certainty': 'maybe' },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' }, 'gl:multiplicity': 'maybe' },
           ],
         },
       ],
     };
-    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*certainty.*maybe/);
+    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*multiplicity.*maybe/);
   });
 
   it('skips a relation whose comprehensive cannot be resolved', () => {
@@ -252,7 +204,7 @@ describe('extractPartitiveRelations', () => {
       '@id': sourceUri,
       'gl:partitiveRelations': [
         {
-          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
           'gl:hasPartitive': [{ 'gl:ref': { 'gl:id': '1.4' } }],
         },
       ],
@@ -265,17 +217,17 @@ describe('extractPartitiveRelations', () => {
       '@id': sourceUri,
       'gl:partitiveRelations': [
         {
-          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          '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': '2.10' } },
-            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' } },
+            { '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.3' } },
           ],
         },
       ],
     };
     const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
     expect(rel.partitives).toHaveLength(1);
-    expect(rel.partitives[0].uri).toBe(`${uriBase}/${registerId}/concept/2.10`);
+    expect(rel.partitives[0].uri).toBe(`${uriBase}/${registerId}/concept/1.4`);
   });
 
   it('returns empty array when concept has no partitiveRelations', () => {

package/src/__tests__/scripts/migrate-v1-to-v3.d.mts

@@ -0,0 +1,8 @@
+// Type shim for the .mjs script — vitest needs declared types.
+// The actual functions are imported by value (see below).
+declare module '../../../scripts/migrate-v1-to-v3.mjs' {
+  export function isV1PartitiveRelation(rel: unknown): boolean;
+  export function migrateRelation(rel: unknown): unknown;
+  export function migrateConceptData(data: unknown): unknown;
+  export function isAlreadyMigrated(content: unknown): boolean;
+}

package/src/__tests__/scripts/migrate-v1-to-v3.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+// .mjs scripts have no type declarations. The .d.mts shim provides them.
+import {
+  isV1PartitiveRelation,
+  migrateRelation,
+  migrateConceptData,
+  isAlreadyMigrated,
+} from '../../../scripts/migrate-v1-to-v3.mjs';
+
+describe('migrate-v1-to-v3 pure conversion', () => {
+  describe('isV1PartitiveRelation', () => {
+    it('returns true for v1 shape (has parts array)', () => {
+      expect(isV1PartitiveRelation({ comprehensive: {}, parts: [] })).toBe(true);
+    });
+
+    it('returns false for v3 shape (has partitives array)', () => {
+      expect(isV1PartitiveRelation({ comprehensive: {}, partitives: [] })).toBe(false);
+    });
+
+    it('returns falsy for null/undefined', () => {
+      expect(isV1PartitiveRelation(null)).toBeFalsy();
+      expect(isV1PartitiveRelation(undefined)).toBeFalsy();
+    });
+  });
+
+  describe('migrateRelation', () => {
+    it('converts v1 → v3 fields', () => {
+      const v1 = {
+        comprehensive: { source: 'urn:test', id: '1.3' },
+        parts: [
+          { source: 'urn:test', id: '1.4' },
+          { source: 'urn:test', id: '1.5' },
+        ],
+        enumeration: 'closed',
+      };
+      const v3 = migrateRelation(v1) as null | { comprehensive: { source: string; id: string }; completeness: string; partitives: Array<{ ref: { source: string; id: string }; certainty: string }> };
+      expect(v3).not.toBeNull();
+      expect(v3!.comprehensive).toEqual({ source: 'urn:test', id: '1.3' });
+      expect(v3!.completeness).toBe('complete');
+      expect(v3!.partitives).toHaveLength(2);
+      expect(v3!.partitives[0].ref).toEqual({ source: 'urn:test', id: '1.4' });
+      expect(v3!.partitives[1].ref).toEqual({ source: 'urn:test', id: '1.5' });
+    });
+
+    it('maps v1 enumeration: open → v3 completeness: partial', () => {
+      const v3 = migrateRelation({
+        comprehensive: { source: 'urn:test', id: '1.3' },
+        parts: [{ source: 'urn:test', id: '1.4' }, { source: 'urn:test', id: '1.5' }],
+        enumeration: 'open',
+      }) as null | { completeness: string };
+      expect(v3).not.toBeNull();
+      expect(v3!.completeness).toBe('partial');
+    });
+
+    it('drops v1 markers (multiplicity carries that info now)', () => {
+      const v3 = migrateRelation({
+        comprehensive: {}, parts: [{ source: 'x', id: 'a' }, { source: 'x', id: 'b' }],
+        markers: ['double', 'dashed'],
+      });
+      expect(v3).not.toHaveProperty('markers');
+    });
+
+    it('preserves v1 content if present (forward-compat)', () => {
+      const v3 = migrateRelation({
+        comprehensive: {}, parts: [{ source: 'x', id: 'a' }, { source: 'x', id: 'b' }],
+        content: 'some prose',
+      }) as null | { content?: string };
+      expect(v3).not.toBeNull();
+      expect(v3!.content).toBe('some prose');
+    });
+
+    it('returns null for already-migrated relation (v3 shape)', () => {
+      expect(migrateRelation({
+        comprehensive: {},
+        partitives: [{ ref: {}, certainty: 'confirmed' }],
+      })).toBeNull();
+    });
+  });
+
+  describe('migrateConceptData', () => {
+    it('returns null for empty partitive_relations', () => {
+      expect(migrateConceptData({ partitive_relations: [] })).toBeNull();
+    });
+
+    it('migrates a concept with multiple relations', () => {
+      const v1Data = {
+        other_field: 'preserved',
+        partitive_relations: [
+          { comprehensive: {}, parts: [{ source: 'x', id: 'a' }, { source: 'x', id: 'b' }] },
+          { comprehensive: {}, parts: [{ source: 'x', id: 'c' }, { source: 'x', id: 'd' }] },
+        ],
+      };
+      const v3 = migrateConceptData(v1Data) as null | { other_field: string; partitive_relations: Array<{ partitives: Array<{ ref: { source: string; id: string } }> }> };
+      expect(v3!.other_field).toBe('preserved');
+      expect(v3!.partitive_relations).toHaveLength(2);
+      expect(v3!.partitive_relations[0].partitives[0].ref).toEqual({ source: 'x', id: 'a' });
+      expect(v3!.partitive_relations[1].partitives[1].ref).toEqual({ source: 'x', id: 'd' });
+    });
+  });
+
+  describe('isAlreadyMigrated', () => {
+    it('detects v3 (partitives array present)', () => {
+      expect(isAlreadyMigrated({ data: { partitive_relations: [{ partitives: [] }] } })).toBe(true);
+    });
+
+    it('returns false for v1 (parts but no partitives)', () => {
+      expect(isAlreadyMigrated({ data: { partitive_relations: [{ parts: [] }] } })).toBe(false);
+    });
+
+    it('returns false for empty data', () => {
+      expect(isAlreadyMigrated({ data: {} })).toBe(false);
+      expect(isAlreadyMigrated(null)).toBe(false);
+    });
+  });
+});

package/src/__tests__/utils/partitive-multiplicity.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import {
+  PARTITIVE_MULTIPLICITY,
+  PARTITIVE_MULTIPLICITY_VALUES,
+  isPartitiveMultiplicity,
+  multiplicityDefinition,
+  rakeStrokeStyle,
+  multiplicityFromCertainty,
+  NORMAL_STROKE_WIDTH,
+  DELIMITING_STROKE_WIDTH,
+  type PartitiveMultiplicity,
+} 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',
+    ]);
+  });
+
+  it('compulsory: 1 line, solid', () => {
+    expect(multiplicityDefinition('compulsory')).toEqual({
+      lines: 1, pattern: 'solid', label: 'Compulsory',
+    });
+  });
+
+  it('optional: 1 line, dashed', () => {
+    expect(multiplicityDefinition('optional')).toEqual({
+      lines: 1, pattern: 'dashed', label: 'Optional',
+    });
+  });
+
+  it('compulsory_multiple: 2 lines, solid', () => {
+    expect(multiplicityDefinition('compulsory_multiple')).toEqual({
+      lines: 2, pattern: 'solid', label: 'Compulsory multiple',
+    });
+  });
+
+  it('optional_multiple: 2 lines, dashed', () => {
+    expect(multiplicityDefinition('optional_multiple')).toEqual({
+      lines: 2, pattern: 'dashed', label: 'Optional 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',
+    });
+  });
+
+  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);
+  });
+});
+
+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 } },
+  ];
+
+  for (const c of cases) {
+    it(`${c.name} → ${JSON.stringify(c.expected)}`, () => {
+      expect(rakeStrokeStyle(c.multiplicity, c.isDelimiting)).toEqual(c.expected);
+    });
+  }
+
+  it('delimiting strokeWidth is exactly 3× normal (per ISO 704)', () => {
+    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('null / undefined → compulsory (default)', () => {
+    expect(multiplicityFromCertainty(null)).toBe('compulsory');
+    expect(multiplicityFromCertainty(undefined)).toBe('compulsory');
+  });
+});

package/src/adapters/model-bridge.ts

@@ -166,20 +166,18 @@ 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). */
+  'gl:isDelimiting'?: boolean;
+  /** Legacy v2 field — still read for backward compat with older datasets. */
   'gl:certainty'?: string;
 }
 
-interface JsonLdTypeSharedPlurality {
-  'gl:isShared'?: boolean;
-  'gl:isUncertain'?: boolean;
-  'gl:sharedType'?: JsonLdRef;
-}
-
 interface JsonLdPartitiveRelation {
   'gl:comprehensive'?: JsonLdRef;
   'gl:hasPartitive'?: JsonLdPartitiveMember[];
   'gl:completeness'?: string;
-  'gl:hasPlurality'?: JsonLdTypeSharedPlurality;
   'gl:criterion'?: Record<string, string> | string;
 }
 
@@ -592,7 +590,16 @@ 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 };
-      if (m['gl:certainty']) out.certainty = m['gl:certainty'];
+      // 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;
+      }
       return out;
     })
     .filter((m): m is Record<string, unknown> => m !== null);
@@ -608,17 +615,6 @@ function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<stri
 
   if (r['gl:completeness']) out.completeness = r['gl:completeness'];
 
-  const plurality = r['gl:hasPlurality'];
-  if (plurality && typeof plurality['gl:isShared'] === 'boolean') {
-    const p: Record<string, unknown> = { isShared: plurality['gl:isShared'] };
-    if (typeof plurality['gl:isUncertain'] === 'boolean') {
-      p.isUncertain = plurality['gl:isUncertain'];
-    }
-    const sharedType = plurality['gl:sharedType'] ? mapRefFromJsonLd(plurality['gl:sharedType']) : null;
-    if (sharedType) p.sharedType = sharedType;
-    out.plurality = p;
-  }
-
   if (r['gl:criterion']) {
     out.criterion = typeof r['gl:criterion'] === 'string'
       ? { default: r['gl:criterion'] }