@glossarist/concept-browser 0.7.85 → 0.7.87

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

@@ -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,89 +29,96 @@ 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}`;
+  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 { isShared, isUncertain, sharedType };
+    return 'exactly_one';
   };
 
   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') {
-          throw new Error(
-            `Invalid partitive member certainty: "${certainty}". Allowed: confirmed, possible`,
-          );
-        }
-        return { uri, certainty };
+        return {
+          uri,
+          presence: resolvePresence(member),
+          count: resolveCount(member),
+          isDelimiting: member['gl:isDelimiting'] === true || member.isDelimiting === true,
+        };
       })
-      .filter((p: any): p is { uri: string; certainty: 'confirmed' | 'possible' } => 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;
+
     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;
 }
 
-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/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 required/exactly_one 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`, 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');
-    expect(result[0].criterion).toEqual({ eng: 'measurement result composition' });
   });
 
   it('defaults completeness to complete when omitted', () => {
@@ -111,9 +126,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 +154,7 @@ describe('extractPartitiveRelations', () => {
     expect(rel.completeness).toBe('partial');
   });
 
-  it('resolves plurality block (isShared + sharedType)', () => {
+  it('reads per-member presence + count + isDelimiting (v3 native)', () => {
     const concept = {
       '@id': sourceUri,
       'gl:partitiveRelations': [
@@ -147,57 +162,39 @@ 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: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 },
           ],
-          '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();
+    expect(rel.partitives).toEqual([
+      { 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('preserves per-member certainty', () => {
+  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.5' }, 'gl:certainty': 'possible' },
+            { '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' },
           ],
         },
       ],
     };
     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`, presence: 'optional', count: 'multiple', isDelimiting: false },
+      { uri: `${uriBase}/${registerId}/concept/1.5`, presence: 'required', count: 'at_least_one', isDelimiting: false },
     ]);
   });
 
@@ -217,21 +214,6 @@ describe('extractPartitiveRelations', () => {
     expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*completeness.*closed/);
   });
 
-  it('throws on invalid 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:certainty': 'maybe' },
-          ],
-        },
-      ],
-    };
-    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*certainty.*maybe/);
-  });
-
   it('skips a relation whose comprehensive cannot be resolved', () => {
     const concept = {
       '@id': sourceUri,
@@ -252,7 +234,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 +247,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,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_PRESENCE,
+  PARTITIVE_COUNT,
+  isPartitivePresence,
+  isPartitiveCount,
+  presenceLabel,
+  countLabel,
+  rakeStrokeStyle,
+  partitiveMultiplicityName,
+  NORMAL_STROKE_WIDTH,
+  DELIMITING_STROKE_WIDTH,
+  type PartitivePresence,
+  type PartitiveCount,
+} from '../../utils/partitive-multiplicity';
+
+describe('presence axis (re-exported from glossarist)', () => {
+  it('has exactly 2 values: required, optional', () => {
+    expect([...PARTITIVE_PRESENCE.VALUES]).toEqual(['required', 'optional']);
+  });
+
+  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('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('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('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');
+  });
+});
+
+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('rejects the vacuous (optional, at_least_one) combination', () => {
+    expect(() => partitiveMultiplicityName('optional', 'at_least_one'))
+      .toThrow(/collapses to optional \+ multiple/);
+  });
+});
+
+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 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 3× normal (per ISO 704 convention)', () => {
+    expect(DELIMITING_STROKE_WIDTH / NORMAL_STROKE_WIDTH).toBe(3);
+  });
+
+  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('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);
+    }
+  });
+});