@glossarist/concept-browser 0.7.86 → 0.7.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.86",
+  "version": "0.7.88",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -37,7 +37,7 @@
     "astro": "^7.0.7",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.4.24",
+    "glossarist": "^0.4.26",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "pinia": "^2.3.1",

package/scripts/build-edges.js

@@ -3,14 +3,6 @@ function buildConceptUri(uriBase, registerId, conceptId) {
 }
 
 const VALID_COMPLETENESS = new Set(['complete', 'partial']);
-const VALID_CERTAINTY = new Set(['confirmed', 'possible']);
-const VALID_MULTIPLICITY = new Set([
-  'compulsory',
-  'optional',
-  'compulsory_multiple',
-  'optional_multiple',
-  'compulsory_at_least_one',
-]);
 
 function validateCompleteness(value) {
   if (value == null) return 'complete';
@@ -32,26 +24,40 @@ function validateCompleteness(value) {
  *   confirmed → compulsory
  *   possible  → optional
  */
-function resolveMultiplicity(member) {
-  const m = member['gl:multiplicity'] ?? member.multiplicity;
-  if (m != null) {
-    if (!VALID_MULTIPLICITY.has(m)) {
-      throw new Error(
-        `Invalid partitive member multiplicity: "${m}". Allowed: ${[...VALID_MULTIPLICITY].join(', ')}`,
-      );
-    }
-    return m;
+const VALID_PRESENCE = new Set(['required', 'optional']);
+const VALID_COUNT = new Set(['exactly_one', 'at_least_one', 'multiple']);
+const LEGACY_MULTIPLICITY_MAP = {
+  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' },
+};
+
+function resolvePresence(member) {
+  const p = member['gl:presence'] ?? member.presence;
+  if (p != null) {
+    if (!VALID_PRESENCE.has(p)) throw new Error(`Invalid presence: "${p}"`);
+    return p;
   }
-  const certainty = member['gl:certainty'] ?? member.certainty;
-  if (certainty != null) {
-    if (!VALID_CERTAINTY.has(certainty)) {
-      throw new Error(
-        `Invalid partitive member certainty: "${certainty}". Allowed: confirmed, possible`,
-      );
-    }
-    return certainty === 'possible' ? 'optional' : 'compulsory';
+  return migrateMultiplicity(member).presence;
+}
+
+function resolveCount(member) {
+  const c = member['gl:count'] ?? member.count;
+  if (c != null) {
+    if (!VALID_COUNT.has(c)) throw new Error(`Invalid count: "${c}"`);
+    return c;
   }
-  return 'compulsory';
+  return migrateMultiplicity(member).count;
+}
+
+function migrateMultiplicity(member) {
+  const m = member['gl:multiplicity'] ?? member.multiplicity;
+  if (m && LEGACY_MULTIPLICITY_MAP[m]) return LEGACY_MULTIPLICITY_MAP[m];
+  const certainty = member['gl:certainty'] ?? member.certainty;
+  if (certainty === 'possible') return { presence: 'optional', count: 'exactly_one' };
+  return { presence: 'required', count: 'exactly_one' };
 }
 
 function resolveIsDelimiting(member) {
@@ -216,7 +222,8 @@ function extractPartitiveRelations(concept, registerId, uriBase, urnMap) {
         if (!uri || uri === sourceUri) return null;
         return {
           uri,
-          multiplicity: resolveMultiplicity(p),
+          presence: resolvePresence(p),
+          count: resolveCount(p),
           isDelimiting: resolveIsDelimiting(p),
         };
       })

package/scripts/generate-data.mjs

@@ -15,20 +15,27 @@ import { buildBibliographyTurtle } from './lib/bibliography-turtle.mjs';
 import { ttlLit } from './lib/turtle-escape.mjs';
 import { firstNonEmpty } from './lib/first-non-empty.mjs';
 
-// Legacy v2 → v3 migration helper: derive a gl:certainty value from the
-// new ISO 704:2022 multiplicity so consumers that still read certainty
-// keep working during the one-release-cycle deprecation window.
-const CERTAINTY_FROM_MULTIPLICITY = {
-  compulsory: 'confirmed',
+// MECE partitive multiplicity: 2 independent axes (ISO 704:2022).
+//   presence × count
+// Legacy 5-value `multiplicity` and 2-value `certainty` map into the
+// 2-axis model — keep emitting them for one release cycle so consumers
+// that still read the legacy fields keep working.
+const LEGACY_MULTIPLICITY_MAP = {
+  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 LEGACY_CERTAINTY_FROM_AXIS = {
+  required: 'confirmed',
   optional: 'possible',
-  compulsory_multiple: 'confirmed',
-  optional_multiple: 'possible',
-  compulsory_at_least_one: 'confirmed',
 };
-function multiplicityToCertainty(multiplicity) {
-  return multiplicity in CERTAINTY_FROM_MULTIPLICITY
-    ? CERTAINTY_FROM_MULTIPLICITY[multiplicity]
-    : null;
+
+function splitMultiplicity(multiplicity) {
+  return multiplicity in LEGACY_MULTIPLICITY_MAP
+    ? LEGACY_MULTIPLICITY_MAP[multiplicity]
+    : { presence: 'required', count: 'exactly_one' };
 }
 
 function buildConceptUri(uriBase, registerId, conceptId) {
@@ -710,17 +717,27 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
           } else {
             m['gl:ref'] = refToJsonLd(member, 'gl:ConceptRef');
           }
-          // ISO 704:2022 multiplicity + is_delimiting (v3 wire shape).
-          // Emit both new and legacy fields for one release cycle so
-          // consumers that still read gl:certainty keep working.
-          if (member.multiplicity) m['gl:multiplicity'] = member.multiplicity;
+          // ISO 704:2022 MECE axes: presence × count.
+          // Prefer explicit YAML values; fall back to migrating from the
+          // legacy 5-value `multiplicity` enum for one release cycle.
+          const presence = member.presence
+            ?? splitMultiplicity(member.multiplicity ?? '').presence;
+          const count = member.count
+            ?? splitMultiplicity(member.multiplicity ?? '').count;
+
+          m['gl:presence'] = presence;
+          m['gl:count'] = count;
+
           if (member.is_delimiting === true || member.isDelimiting === true) {
             m['gl:isDelimiting'] = true;
           }
-          // Legacy gl:certainty — derived from multiplicity when not set
-          // explicitly. Remove after consumers migrate to multiplicity.
+
+          // Legacy gl:multiplicity + gl:certainty — emitted for one
+          // release cycle. Remove after downstream consumers migrate to
+          // presence + count.
+          if (member.multiplicity) m['gl:multiplicity'] = member.multiplicity;
           const legacyCertainty = member.certainty
-            ?? multiplicityToCertainty(member.multiplicity);
+            ?? LEGACY_CERTAINTY_FROM_AXIS[presence];
           if (legacyCertainty) m['gl:certainty'] = legacyCertainty;
           return m;
         });
@@ -1005,13 +1022,8 @@ async function processDataset(dir, register, opts) {
     partitiveRelations: {
       count: 0,
       byCompleteness: { complete: 0, partial: 0 },
-      byMemberMultiplicity: {
-        compulsory: 0,
-        optional: 0,
-        compulsory_multiple: 0,
-        optional_multiple: 0,
-        compulsory_at_least_one: 0,
-      },
+      byPresence: { required: 0, optional: 0 },
+      byCount: { exactly_one: 0, at_least_one: 0, multiple: 0 },
       delimitingMembers: 0,
       withCriterion: 0,
       withoutCriterion: 0,
@@ -1048,11 +1060,13 @@ async function processDataset(dir, register, opts) {
           (s.partitiveRelations.byCompleteness[completeness] || 0) + 1;
         const partitives = rel.partitives || [];
         for (const member of partitives) {
-          // Prefer multiplicity; fall back to legacy certainty for one release.
-          const multiplicity = member.multiplicity
-            ?? (member.certainty === 'possible' ? 'optional' : 'compulsory');
-          s.partitiveRelations.byMemberMultiplicity[multiplicity] =
-            (s.partitiveRelations.byMemberMultiplicity[multiplicity] || 0) + 1;
+          const axes = splitMultiplicity(member.multiplicity ?? '');
+          const presence = member.presence ?? axes.presence;
+          const count = member.count ?? axes.count;
+          s.partitiveRelations.byPresence[presence] =
+            (s.partitiveRelations.byPresence[presence] || 0) + 1;
+          s.partitiveRelations.byCount[count] =
+            (s.partitiveRelations.byCount[count] || 0) + 1;
           if (member.is_delimiting === true || member.isDelimiting === true) {
             s.partitiveRelations.delimitingMembers += 1;
           }

package/src/__tests__/components/PartitiveRelationDiagram.test.ts

@@ -3,20 +3,25 @@ import { mount } from '@vue/test-utils';
 import PartitiveRelationDiagram, {
   type PartitiveMemberLabeled,
 } from '../../components/PartitiveRelationDiagram.vue';
-import { rakeStrokeStyle, type PartitiveMultiplicity } from '../../utils/partitive-multiplicity';
+import {
+  rakeStrokeStyle,
+  type PartitivePresence,
+  type PartitiveCount,
+} from '../../utils/partitive-multiplicity';
 
 const members = (
   n: number,
-  opts: { multiplicity?: PartitiveMultiplicity; isDelimiting?: boolean } = {},
+  opts: { presence?: PartitivePresence; count?: PartitiveCount; isDelimiting?: boolean } = {},
 ): PartitiveMemberLabeled[] =>
   Array.from({ length: n }, (_, i) => ({
     uri: `https://example.org/test/concept/1.${i + 1}`,
     label: `1.${i + 1}`,
-    multiplicity: opts.multiplicity ?? 'compulsory',
+    presence: opts.presence ?? 'required',
+    count: opts.count ?? 'exactly_one',
     isDelimiting: opts.isDelimiting ?? false,
   }));
 
-describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering', () => {
+describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering (MECE)', () => {
   it('renders comprehensive + N partitive nodes as text', () => {
     const w = mount(PartitiveRelationDiagram, {
       props: {
@@ -44,8 +49,8 @@ describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering', () => {
     expect(w.findAll('text').map(t => t.text())).toContain('physical structure');
   });
 
-  describe('per-member multiplicity line rendering', () => {
-    it('compulsory: stem + spine + 1 solid line per drop', () => {
+  describe('per-member line rendering (presence × count × isDelimiting)', () => {
+    it('required/exactly_one: stem + spine + 1 solid line per drop', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
           comprehensiveLabel: '0',
@@ -57,11 +62,11 @@ describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering', () => {
       expect(w.findAll('line')).toHaveLength(4);
     });
 
-    it('compulsory_multiple: each drop has 2 lines', () => {
+    it('required/multiple: each drop has 2 solid lines', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
           comprehensiveLabel: '0',
-          partitives: members(2, { multiplicity: 'compulsory_multiple' }),
+          partitives: members(2, { count: 'multiple' }),
           completeness: 'complete',
         },
       });
@@ -69,11 +74,11 @@ describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering', () => {
       expect(w.findAll('line')).toHaveLength(6);
     });
 
-    it('optional: drop is dashed', () => {
+    it('optional/exactly_one: drop is dashed', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
           comprehensiveLabel: '0',
-          partitives: members(2, { multiplicity: 'optional' }),
+          partitives: members(2, { presence: 'optional' }),
           completeness: 'complete',
         },
       });
@@ -83,11 +88,11 @@ describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering', () => {
       expect(dashed).toHaveLength(2);
     });
 
-    it('optional_multiple: each drop has 2 dashed lines', () => {
+    it('optional/multiple: each drop has 2 dashed lines', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
           comprehensiveLabel: '0',
-          partitives: members(2, { multiplicity: 'optional_multiple' }),
+          partitives: members(2, { presence: 'optional', count: 'multiple' }),
           completeness: 'complete',
         },
       });
@@ -96,11 +101,11 @@ describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering', () => {
       expect(dashed).toHaveLength(4); // 2 members × 2 dashed lines each
     });
 
-    it('compulsory_at_least_one: each drop has 1 solid + 1 dashed line', () => {
+    it('required/at_least_one: each drop has 1 solid + 1 dashed line', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
           comprehensiveLabel: '0',
-          partitives: members(2, { multiplicity: 'compulsory_at_least_one' }),
+          partitives: members(2, { count: 'at_least_one' }),
           completeness: 'complete',
         },
       });
@@ -161,9 +166,9 @@ describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering', () => {
         props: {
           comprehensiveLabel: 'coordinate system of quantities',
           partitives: [
-            { uri: 'u1', label: 'system of quantities', multiplicity: 'compulsory', isDelimiting: false },
-            { uri: 'u2', label: 'International System of Units', multiplicity: 'compulsory', isDelimiting: false },
-            { uri: 'u3', label: 'base quantity dimension', multiplicity: 'compulsory', isDelimiting: false },
+            { uri: 'u1', label: 'system of quantities', presence: 'required', count: 'exactly_one', isDelimiting: false },
+            { uri: 'u2', label: 'International System of Units', presence: 'required', count: 'exactly_one', isDelimiting: false },
+            { uri: 'u3', label: 'base quantity dimension', presence: 'required', count: 'exactly_one', isDelimiting: false },
           ],
           completeness: 'complete',
         },
@@ -173,20 +178,21 @@ describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering', () => {
     });
   });
 
-  describe('consistency with rakeStrokeStyle helper', () => {
+  describe('consistency with rakeStrokeStyle helper (MECE truth table)', () => {
     // Ensure the component's line rendering matches the pure helper
     // (single source of truth — both must agree).
-    it('renders exactly the line count + dash pattern the helper predicts', () => {
-      const testCases: Array<{ multiplicity: PartitiveMultiplicity; isDelimiting: boolean }> = [
-        { multiplicity: 'compulsory', isDelimiting: false },
-        { multiplicity: 'compulsory', isDelimiting: true },
-        { multiplicity: 'optional', isDelimiting: false },
-        { multiplicity: 'compulsory_multiple', isDelimiting: false },
-        { multiplicity: 'optional_multiple', isDelimiting: false },
-        { multiplicity: 'compulsory_at_least_one', isDelimiting: false },
-      ];
-      for (const tc of testCases) {
-        const expected = rakeStrokeStyle(tc.multiplicity, tc.isDelimiting);
+    const testCases: Array<{ presence: PartitivePresence; count: PartitiveCount; isDelimiting: boolean }> = [
+      { presence: 'required', count: 'exactly_one', isDelimiting: false },
+      { presence: 'required', count: 'exactly_one', isDelimiting: true },
+      { presence: 'optional', count: 'exactly_one', isDelimiting: false },
+      { presence: 'required', count: 'multiple', isDelimiting: false },
+      { presence: 'optional', count: 'multiple', isDelimiting: false },
+      { presence: 'required', count: 'at_least_one', isDelimiting: false },
+      { presence: 'optional', count: 'at_least_one', isDelimiting: false },
+    ];
+    for (const tc of testCases) {
+      it(`${tc.presence} × ${tc.count}${tc.isDelimiting ? ' / delimiting' : ''}`, () => {
+        const expected = rakeStrokeStyle(tc.presence, tc.count, tc.isDelimiting);
         const w = mount(PartitiveRelationDiagram, {
           props: {
             comprehensiveLabel: '0',
@@ -198,7 +204,7 @@ describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering', () => {
         // stem (1) + spine (1) + drop lineCount per member
         const expectedLines = 2 + expected.lineCount;
         expect(lines.length).toBe(expectedLines);
-      }
-    });
+      });
+    }
   });
 });

package/src/__tests__/composables/use-concept-edges-v2.test.ts

@@ -1,8 +1,12 @@
 import { describe, it, expect } from 'vitest';
-// glossarist 0.4.24's top-level d.ts doesn't re-export the v3
+// glossarist-js 0.4.26's top-level d.ts doesn't re-export the MECE
 // PartitiveRelation/PartitiveMember classes; import from glossarist/models
-// (which our local augmentation extends) so the types are correct.
-import type { PartitiveRelation, PartitiveMember, ConceptRef } from 'glossarist/models';
+// (extended by our local augmentation) so the types are correct.
+import type {
+  PartitiveRelation,
+  PartitiveMember,
+  ConceptRef,
+} from 'glossarist/models';
 import {
   PartitiveRelation as PartitiveRelationModel,
   PartitiveMember as PartitiveMemberModel,
@@ -10,12 +14,12 @@ import {
 } from 'glossarist/models';
 
 /**
- * Verifies glossarist-js 0.4.24's native v3 PartitiveRelation model
- * (ISO 704:2022 multiplicity + is_delimiting).
+ * Verifies glossarist-js 0.4.26's MECE-native PartitiveRelation model
+ * (ISO 704:2022 presence × count + is_delimiting).
  *
- * The concept-browser now consumes this directly (no migration adapter,
- * no `as any` bridge). These specs lock in the contract so an upstream
- * regression is caught here.
+ * The concept-browser consumes these fields directly (no migration
+ * bridge). These specs pin the runtime contract so a regression in
+ * upstream is caught here.
  */
 
 function makeRef(source: string, id: string): ConceptRef {
@@ -25,16 +29,17 @@ function makeRef(source: string, id: string): ConceptRef {
 function makePartitive(
   source: string,
   id: string,
-  multiplicity?: 'compulsory' | 'optional' | 'compulsory_multiple' | 'optional_multiple' | 'compulsory_at_least_one',
-  isDelimiting?: boolean,
+  fields: { presence?: 'required' | 'optional'; count?: 'exactly_one' | 'at_least_one' | 'multiple'; isDelimiting?: boolean } = {},
 ): PartitiveMember {
   const data: {
     ref: ConceptRef;
-    multiplicity?: typeof multiplicity;
+    presence?: 'required' | 'optional';
+    count?: 'exactly_one' | 'at_least_one' | 'multiple';
     is_delimiting?: boolean;
   } = { ref: makeRef(source, id) };
-  if (multiplicity) data.multiplicity = multiplicity;
-  if (isDelimiting) data.is_delimiting = isDelimiting;
+  if (fields.presence) data.presence = fields.presence;
+  if (fields.count) data.count = fields.count;
+  if (fields.isDelimiting) data.is_delimiting = fields.isDelimiting;
   return PartitiveMemberModel.fromJSON(data as unknown as Record<string, unknown>) as PartitiveMember;
 }
 
@@ -47,18 +52,35 @@ function makeRelation(opts: {
   return PartitiveRelationModel.fromJSON(opts as unknown as Record<string, unknown>) as PartitiveRelation;
 }
 
-describe('useConceptEdges — native v3 PartitiveRelation (glossarist 0.4.24)', () => {
-  describe('PartitiveMember (ISO 704:2022 multiplicity + delimiting)', () => {
-    it('multiplicity defaults to compulsory when omitted', () => {
+describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () => {
+  describe('PartitiveMember (ISO 704:2022 presence × count + delimiting)', () => {
+    it('presence defaults to required, count defaults to exactly_one', () => {
       const m = makePartitive('test', '1.1');
-      expect(m.multiplicity).toBe('compulsory');
-      expect(m.isCompulsory).toBe(true);
+      expect(m.presence).toBe('required');
+      expect(m.isRequired).toBe(true);
+      expect(m.isOptional).toBe(false);
     });
 
-    it('multiplicity is preserved when set to optional', () => {
-      const m = makePartitive('test', '1.1', 'optional');
-      expect(m.multiplicity).toBe('optional');
+    it('count defaults to exactly_one', () => {
+      const m = makePartitive('test', '1.1');
+      expect(m.count).toBe('exactly_one');
+    });
+
+    it('presence=optional is preserved', () => {
+      const m = makePartitive('test', '1.1', { presence: 'optional' });
+      expect(m.presence).toBe('optional');
       expect(m.isOptional).toBe(true);
+      expect(m.isRequired).toBe(false);
+    });
+
+    it('count=multiple is preserved', () => {
+      const m = makePartitive('test', '1.1', { count: 'multiple' });
+      expect(m.count).toBe('multiple');
+    });
+
+    it('count=at_least_one is preserved', () => {
+      const m = makePartitive('test', '1.1', { count: 'at_least_one' });
+      expect(m.count).toBe('at_least_one');
     });
 
     it('is_delimiting defaults to false', () => {
@@ -68,19 +90,20 @@ describe('useConceptEdges — native v3 PartitiveRelation (glossarist 0.4.24)',
     });
 
     it('is_delimiting is preserved when set to true', () => {
-      const m = makePartitive('test', '1.1', 'compulsory', true);
+      const m = makePartitive('test', '1.1', { isDelimiting: true });
       expect(m.is_delimiting).toBe(true);
+      expect(m.isDelimiting).toBe(true);
     });
 
-    it('multiplicity + is_delimiting are orthogonal axes', () => {
-      const m = makePartitive('test', '1.1', 'compulsory_multiple', true);
-      expect(m.multiplicity).toBe('compulsory_multiple');
-      expect(m.is_delimiting).toBe(true);
+    it('rejects the vacuous (presence=optional, count=at_least_one)', () => {
+      expect(() =>
+        makePartitive('test', '1.1', { presence: 'optional', count: 'at_least_one' }),
+      ).toThrow(/collapses to optional \+ multiple/);
     });
   });
 
   describe('PartitiveRelation', () => {
-    it('accepts 2 compulsory members with completeness=complete', () => {
+    it('accepts 2 members with default axes', () => {
       const r = makeRelation({
         comprehensive: makeRef('test', '1.3'),
         partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
@@ -101,21 +124,6 @@ describe('useConceptEdges — native v3 PartitiveRelation (glossarist 0.4.24)',
       expect(r.isPartial).toBe(true);
     });
 
-    it('member with compulsory_multiple has isCompulsory false', () => {
-      const m = makePartitive('test', '1.4', 'compulsory_multiple');
-      expect(m.isCompulsory).toBe(false);
-      expect(m.multiplicity).not.toBe('compulsory');
-    });
-
-    it('all compulsory-single members have isCompulsory true', () => {
-      const r = makeRelation({
-        comprehensive: makeRef('test', '1.3'),
-        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
-      });
-      expect(r.partitives[0].isCompulsory).toBe(true);
-      expect(r.partitives[1].isCompulsory).toBe(true);
-    });
-
     it('isCoordinate true when ≥2 partitives', () => {
       const r = makeRelation({
         comprehensive: makeRef('test', '1.3'),
@@ -131,27 +139,26 @@ describe('useConceptEdges — native v3 PartitiveRelation (glossarist 0.4.24)',
       })).toThrow(/≥2 partitives/);
     });
 
-    it('round-trips through toJSON with v3 fields', () => {
+    it('round-trips through toJSON with MECE fields', () => {
       const r = makeRelation({
         comprehensive: makeRef('test', '1.3'),
         partitives: [
-          makePartitive('test', '1.4', 'compulsory', false),
-          makePartitive('test', '1.5', 'compulsory_multiple', true),
+          makePartitive('test', '1.4', { presence: 'required', count: 'multiple' }),
+          makePartitive('test', '1.5', { presence: 'optional', isDelimiting: true }),
         ],
         completeness: 'partial',
         criterion: { eng: 'physical structure' },
       });
       const json = r.toJSON() as {
         comprehensive: unknown;
-        partitives: Array<{ multiplicity?: string; is_delimiting?: boolean; ref: unknown }>;
+        partitives: Array<{ presence?: string; count?: string; is_delimiting?: boolean; ref: unknown }>;
         completeness: string;
         criterion?: Record<string, string>;
       };
       expect(json.comprehensive).toBeDefined();
       expect(json.partitives).toHaveLength(2);
-      // compulsory is the default multiplicity — not emitted in toJSON
-      expect(json.partitives[0].multiplicity).toBeUndefined();
-      expect(json.partitives[1].multiplicity).toBe('compulsory_multiple');
+      expect(json.partitives[0].count).toBe('multiple');
+      expect(json.partitives[1].presence).toBe('optional');
       expect(json.partitives[1].is_delimiting).toBe(true);
       expect(json.completeness).toBe('partial');
       expect(json.criterion).toEqual({ eng: 'physical structure' });