@glossarist/concept-browser 0.7.85 → 0.7.87

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

@@ -3,26 +3,31 @@ import { mount } from '@vue/test-utils';
 import PartitiveRelationDiagram, {
   type PartitiveMemberLabeled,
 } from '../../components/PartitiveRelationDiagram.vue';
+import {
+  rakeStrokeStyle,
+  type PartitivePresence,
+  type PartitiveCount,
+} from '../../utils/partitive-multiplicity';
 
-const members = (n: number, certainty: 'confirmed' | 'possible' = 'confirmed'): PartitiveMemberLabeled[] =>
+const members = (
+  n: number,
+  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}`,
-    certainty,
+    presence: opts.presence ?? 'required',
+    count: opts.count ?? 'exactly_one',
+    isDelimiting: opts.isDelimiting ?? false,
   }));
 
-function svgLinesOf(wrapper: ReturnType<typeof mount>) {
-  return wrapper.findAll('line');
-}
-
-describe('PartitiveRelationDiagram — ISO 704 rake rendering', () => {
+describe('PartitiveRelationDiagram — ISO 704:2022 rake rendering (MECE)', () => {
   it('renders comprehensive + N partitive nodes as text', () => {
     const w = mount(PartitiveRelationDiagram, {
       props: {
         comprehensiveLabel: '1.3',
         partitives: members(3),
         completeness: 'complete',
-        plurality: null,
       },
     });
     const texts = w.findAll('text').map(t => t.text());
@@ -38,135 +43,110 @@ describe('PartitiveRelationDiagram — ISO 704 rake rendering', () => {
         comprehensiveLabel: '1.3',
         partitives: members(2),
         completeness: 'complete',
-        plurality: null,
         criterion: 'physical structure',
       },
     });
     expect(w.findAll('text').map(t => t.text())).toContain('physical structure');
   });
 
-  describe('line variant by plurality', () => {
-    it('single solid line when no plurality (3 lines: stem + spine + 2 drops = 4 actually)', () => {
+  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: '1.3',
+          comprehensiveLabel: '0',
           partitives: members(2),
           completeness: 'complete',
-          plurality: null,
         },
       });
-      // stem (1) + spine (1) + drops (2) = 4 single lines
-      expect(svgLinesOf(w)).toHaveLength(4);
-      // none should be dashed
-      const dashed = svgLinesOf(w).filter(l => l.attributes('stroke-dasharray'));
-      expect(dashed).toHaveLength(0);
+      // stem (1) + spine (1) + 1 drop line per member × 2 members = 4
+      expect(w.findAll('line')).toHaveLength(4);
     });
 
-    it('close-set double solid lines when isShared && !isUncertain', () => {
+    it('required/multiple: each drop has 2 solid lines', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
-          comprehensiveLabel: '1.3',
-          partitives: members(2),
+          comprehensiveLabel: '0',
+          partitives: members(2, { count: 'multiple' }),
           completeness: 'complete',
-          plurality: { isShared: true, isUncertain: false },
         },
       });
-      // stem doubles (2) + spine doubles (2) + drops (2, single) = 6 lines
-      expect(svgLinesOf(w)).toHaveLength(6);
-      const dashed = svgLinesOf(w).filter(l => l.attributes('stroke-dasharray'));
-      expect(dashed).toHaveLength(0);
+      // stem + spine + 2 drop lines per member × 2 = 6
+      expect(w.findAll('line')).toHaveLength(6);
     });
 
-    it('one solid + one dashed when isShared && isUncertain', () => {
+    it('optional/exactly_one: drop is dashed', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
-          comprehensiveLabel: '1.3',
-          partitives: members(2),
+          comprehensiveLabel: '0',
+          partitives: members(2, { presence: 'optional' }),
           completeness: 'complete',
-          plurality: { isShared: true, isUncertain: true },
         },
       });
-      // stem (2: 1 solid + 1 dashed) + spine (2: 1 solid + 1 dashed) + drops (2, single solid) = 6
-      const lines = svgLinesOf(w);
-      expect(lines).toHaveLength(6);
+      // stem + spine (frame, not dashed) + 2 drops (dashed)
+      const lines = w.findAll('line');
       const dashed = lines.filter(l => l.attributes('stroke-dasharray'));
-      // exactly 2 dashed lines (the second stem + the second spine)
       expect(dashed).toHaveLength(2);
     });
-  });
 
-  describe('completeness: partial extends spine', () => {
-    it('extends spine past last tooth when completeness=partial', () => {
+    it('optional/multiple: each drop has 2 dashed lines', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
-          comprehensiveLabel: '1.3',
-          partitives: members(2),
-          completeness: 'partial',
-          plurality: null,
+          comprehensiveLabel: '0',
+          partitives: members(2, { presence: 'optional', count: 'multiple' }),
+          completeness: 'complete',
         },
       });
-      const lines = svgLinesOf(w);
-      // stem + spine + 2 drops = 4 lines (same count, but spine is longer)
-      expect(lines).toHaveLength(4);
-      // The spine line's x2 should be > the last partitive's x
-      const lastMember = w.props('partitives')[1];
-      // visual assertion: the spine line's x2 is greater than the second
-      // partitive's slot x. We can't compute slot exactly without internals,
-      // but we know PARTIAL_TAIL (32) is added.
-      const spineLine = lines.find(l => {
-        const y1 = l.attributes('y1');
-        const y2 = l.attributes('y2');
-        return y1 && y2 && y1 === y2; // horizontal
-      });
-      expect(spineLine).toBeDefined();
-      const x2 = Number(spineLine!.attributes('x2'));
-      // last member x ≈ PADDING_X + NODE_W * 1.5 + GAP_X = 24 + 180 + 16 = 220
-      // spine end with PARTIAL_TAIL = 220 + 32 = 252
-      expect(x2).toBeGreaterThan(220);
-      void lastMember;
+      const lines = w.findAll('line');
+      const dashed = lines.filter(l => l.attributes('stroke-dasharray'));
+      expect(dashed).toHaveLength(4); // 2 members × 2 dashed lines each
     });
-  });
 
-  describe('per-member certainty', () => {
-    it('renders possible members with dashed border', () => {
-      const possibleMembers: PartitiveMemberLabeled[] = [
-        { uri: 'u1', label: '1', certainty: 'confirmed' },
-        { uri: 'u2', label: '2', certainty: 'possible' },
-      ];
+    it('required/at_least_one: each drop has 1 solid + 1 dashed line', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
           comprehensiveLabel: '0',
-          partitives: possibleMembers,
+          partitives: members(2, { count: 'at_least_one' }),
           completeness: 'complete',
-          plurality: null,
         },
       });
-      // Find the rect for the 'possible' member (the 2nd node)
-      const rects = w.findAll('rect');
-      // 1 comp + 2 partitive = 3 rects
-      expect(rects).toHaveLength(3);
-      // The possible member's rect should have a dashed border
-      const possibleRect = rects[2];
-      expect(possibleRect.attributes('stroke-dasharray')).toBeTruthy();
+      const lines = w.findAll('line');
+      // stem + spine (solid) + 1 solid + 1 dashed per member × 2 = 6
+      expect(lines).toHaveLength(6);
+      const dashed = lines.filter(l => l.attributes('stroke-dasharray'));
+      expect(dashed).toHaveLength(2); // 1 dashed per member
     });
 
-    it('emits navigate when a partitive is clicked', async () => {
+    it('delimiting: drops use 3× stroke width', () => {
       const w = mount(PartitiveRelationDiagram, {
         props: {
           comprehensiveLabel: '0',
-          partitives: members(2),
+          partitives: members(2, { isDelimiting: true }),
           completeness: 'complete',
-          plurality: null,
         },
       });
-      // Click any of the partitive <g> elements
-      const groups = w.findAll('g.cursor-pointer');
-      expect(groups.length).toBeGreaterThan(0);
-      await groups[0].trigger('click');
-      expect(w.emitted('navigate')).toBeTruthy();
+      // The drop lines should have stroke-width = 4.5 (vs frame's 1.4)
+      const lines = w.findAll('line');
+      const dropWidths = lines
+        .map(l => Number(l.attributes('stroke-width') || '0'))
+        .filter(w => w > 2); // delimiting width is 4.5
+      expect(dropWidths).toHaveLength(2); // 1 drop per member × 2 members
     });
   });
 
+  it('emits navigate when a partitive is clicked', async () => {
+    const w = mount(PartitiveRelationDiagram, {
+      props: {
+        comprehensiveLabel: '0',
+        partitives: members(2),
+        completeness: 'complete',
+      },
+    });
+    const groups = w.findAll('g.cursor-pointer');
+    expect(groups.length).toBeGreaterThan(0);
+    await groups[0].trigger('click');
+    expect(w.emitted('navigate')).toBeTruthy();
+  });
+
   describe('designation-aware sizing', () => {
     it('uses MIN_NODE_W when labels are short', () => {
       const w = mount(PartitiveRelationDiagram, {
@@ -174,75 +154,57 @@ describe('PartitiveRelationDiagram — ISO 704 rake rendering', () => {
           comprehensiveLabel: '1.3',
           partitives: members(2),
           completeness: 'complete',
-          plurality: null,
         },
       });
       const svg = w.find('svg');
-      // Short labels → MIN_NODE_W=110, total = 2*110 + 16 + 40 = 276
-      const viewBox = svg.attributes('viewBox') || '';
-      const width = Number(viewBox.split(' ')[2]);
+      const width = Number((svg.attributes('viewBox') || '').split(' ')[2]);
       expect(width).toBeLessThan(300);
     });
 
     it('grows nodes for long designations', () => {
-      const longMembers: PartitiveMemberLabeled[] = [
-        { uri: 'u1', label: 'system of quantities', certainty: 'confirmed' },
-        { uri: 'u2', label: 'International System of Units', certainty: 'confirmed' },
-        { uri: 'u3', label: 'base quantity dimension', certainty: 'confirmed' },
-      ];
       const w = mount(PartitiveRelationDiagram, {
         props: {
           comprehensiveLabel: 'coordinate system of quantities',
-          partitives: longMembers,
-          completeness: 'complete',
-          plurality: null,
-        },
-      });
-      const svg = w.find('svg');
-      const viewBox = svg.attributes('viewBox') || '';
-      const width = Number(viewBox.split(' ')[2]);
-      // Each node wider than MIN_NODE_W → total > 3*110 = 330
-      expect(width).toBeGreaterThan(330);
-      // Capped: node width ≤ MAX_NODE_W=220 → total ≤ 3*220 + 2*16 + 40 = 732
-      expect(width).toBeLessThanOrEqual(732);
-    });
-
-    it('wraps long labels to 2 lines via tspan when needed', () => {
-      const longLabel = 'International System of Quantities and Units';
-      const w = mount(PartitiveRelationDiagram, {
-        props: {
-          comprehensiveLabel: longLabel,
           partitives: [
-            { uri: 'u1', label: 'short', certainty: 'confirmed' },
-            { uri: 'u2', label: 'short', certainty: 'confirmed' },
+            { 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',
-          plurality: null,
         },
       });
-      // The comprehensive text should have ≥ 2 tspans (wrapped)
-      const texts = w.findAll('text');
-      const compText = texts[0]; // first text is the comprehensive
-      const tspans = compText.findAll('tspan');
-      expect(tspans.length).toBeGreaterThanOrEqual(2);
+      const width = Number((w.find('svg').attributes('viewBox') || '').split(' ')[2]);
+      expect(width).toBeGreaterThan(330);
     });
+  });
 
-    it('renders the designation (not the conceptId) as the label', () => {
-      const w = mount(PartitiveRelationDiagram, {
-        props: {
-          comprehensiveLabel: 'system of quantities',
-          partitives: [
-            { uri: 'u1', label: 'base quantity', certainty: 'confirmed' },
-            { uri: 'u2', label: 'derived quantity', certainty: 'confirmed' },
-          ],
-          completeness: 'complete',
-          plurality: null,
-        },
+  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).
+    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',
+            partitives: members(1, tc),
+            completeness: 'complete',
+          },
+        });
+        const lines = w.findAll('line');
+        // stem (1) + spine (1) + drop lineCount per member
+        const expectedLines = 2 + expected.lineCount;
+        expect(lines.length).toBe(expectedLines);
       });
-      const allText = w.findAll('text').map(t => t.text());
-      expect(allText).toContain('system of quantities');
-      expect(allText).toContain('base quantity');
-      expect(allText).toContain('derived quantity');
-    });
+    }
   });
 });

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

@@ -1,132 +1,167 @@
 import { describe, it, expect } from 'vitest';
-import type { PartitiveRelation, PartitiveMember, TypeSharedPlurality, ConceptRef } from 'glossarist';
+// glossarist-js 0.4.26's top-level d.ts doesn't re-export the MECE
+// PartitiveRelation/PartitiveMember classes; import 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,
-  TypeSharedPlurality as TypeSharedPluralityModel,
   ConceptRef as ConceptRefModel,
 } from 'glossarist/models';
 
 /**
- * Verifies glossarist-js's native v2 PartitiveRelation model.
+ * 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 `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 {
   return ConceptRefModel.fromJSON({ source, id }) as ConceptRef;
 }
 
-function makePartitive(source: string, id: string, certainty?: 'confirmed' | 'possible'): PartitiveMember {
-  const data: { ref: ConceptRef; certainty?: 'confirmed' | 'possible' } = { ref: makeRef(source, id) };
-  if (certainty) data.certainty = certainty;
+function makePartitive(
+  source: string,
+  id: string,
+  fields: { presence?: 'required' | 'optional'; count?: 'exactly_one' | 'at_least_one' | 'multiple'; isDelimiting?: boolean } = {},
+): PartitiveMember {
+  const data: {
+    ref: ConceptRef;
+    presence?: 'required' | 'optional';
+    count?: 'exactly_one' | 'at_least_one' | 'multiple';
+    is_delimiting?: boolean;
+  } = { ref: makeRef(source, id) };
+  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;
 }
 
-function makePlurality(isShared: boolean, isUncertain = false): TypeSharedPlurality {
-  return TypeSharedPluralityModel.fromJSON({ isShared, isUncertain }) as TypeSharedPlurality;
-}
-
 function makeRelation(opts: {
   comprehensive: ConceptRef;
   partitives: PartitiveMember[];
   completeness?: 'complete' | 'partial';
-  plurality?: TypeSharedPlurality | null;
   criterion?: Record<string, string>;
 }): PartitiveRelation {
   return PartitiveRelationModel.fromJSON(opts as unknown as Record<string, unknown>) as PartitiveRelation;
 }
 
-describe('native v2 PartitiveRelation model (glossarist 0.4.20)', () => {
-  it('PartitiveMember.certainty defaults to confirmed when omitted', () => {
-    const m = makePartitive('test', '1.4');
-    expect(m.certainty).toBe('confirmed');
-  });
+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.presence).toBe('required');
+      expect(m.isRequired).toBe(true);
+      expect(m.isOptional).toBe(false);
+    });
 
-  it('PartitiveMember.certainty is preserved when set to possible', () => {
-    const m = makePartitive('test', '1.4', 'possible');
-    expect(m.certainty).toBe('possible');
-    expect(m.isPossible).toBe(true);
-  });
+    it('count defaults to exactly_one', () => {
+      const m = makePartitive('test', '1.1');
+      expect(m.count).toBe('exactly_one');
+    });
 
-  it('PartitiveMember.ref exposes the typed ConceptRef', () => {
-    const m = makePartitive('test', '1.4');
-    expect(m.ref.source).toBe('test');
-    expect(m.ref.id).toBe('1.4');
-  });
+    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('PartitiveRelation has completeness default of complete', () => {
-    const r = makeRelation({
-      comprehensive: makeRef('test', '1.3'),
-      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+    it('count=multiple is preserved', () => {
+      const m = makePartitive('test', '1.1', { count: 'multiple' });
+      expect(m.count).toBe('multiple');
     });
-    expect(r.completeness).toBe('complete');
-    expect(r.isComplete).toBe(true);
-  });
 
-  it('PartitiveRelation preserves explicit partial completeness', () => {
-    const r = makeRelation({
-      comprehensive: makeRef('test', '1.3'),
-      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
-      completeness: 'partial',
+    it('count=at_least_one is preserved', () => {
+      const m = makePartitive('test', '1.1', { count: 'at_least_one' });
+      expect(m.count).toBe('at_least_one');
     });
-    expect(r.completeness).toBe('partial');
-    expect(r.isPartial).toBe(true);
-  });
 
-  it('PartitiveRelation accepts plurality', () => {
-    const r = makeRelation({
-      comprehensive: makeRef('test', '1.3'),
-      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
-      plurality: makePlurality(true, true),
+    it('is_delimiting defaults to false', () => {
+      const m = makePartitive('test', '1.1');
+      expect(m.is_delimiting).toBe(false);
+      expect(m.isDelimiting).toBe(false);
     });
-    expect(r.hasPlurality()).toBe(true);
-    expect(r.plurality?.isShared).toBe(true);
-    expect(r.plurality?.isUncertain).toBe(true);
-  });
 
-  it('PartitiveRelation accepts criterion as localized hash', () => {
-    const r = makeRelation({
-      comprehensive: makeRef('test', '1.3'),
-      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
-      criterion: { eng: 'physical structure', fra: 'structure physique' },
+    it('is_delimiting is preserved when set to true', () => {
+      const m = makePartitive('test', '1.1', { isDelimiting: true });
+      expect(m.is_delimiting).toBe(true);
+      expect(m.isDelimiting).toBe(true);
     });
-    expect(r.hasCriterion()).toBe(true);
-    expect(r.criterion?.eng).toBe('physical structure');
-  });
 
-  it('rejects < 2 partitives (ISO 704 requirement)', () => {
-    expect(() => makeRelation({
-      comprehensive: makeRef('test', '1.3'),
-      partitives: [makePartitive('test', '1.4')],
-    })).toThrow(/≥2 partitives/);
+    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/);
+    });
   });
 
-  it('rejects self-loops', () => {
-    expect(() => makeRelation({
-      comprehensive: makeRef('test', '1.3'),
-      partitives: [
-        makePartitive('test', '1.3'),
-        makePartitive('test', '1.4'),
-      ],
-    })).toThrow(/self-loop/);
-  });
+  describe('PartitiveRelation', () => {
+    it('accepts 2 members with default axes', () => {
+      const r = makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+      });
+      expect(r.partitives).toHaveLength(2);
+      expect(r.completeness).toBe('complete');
+      expect(r.isComplete).toBe(true);
+      expect(r.isPartial).toBe(false);
+    });
+
+    it('completeness=partial is preserved', () => {
+      const r = makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+        completeness: 'partial',
+      });
+      expect(r.completeness).toBe('partial');
+      expect(r.isPartial).toBe(true);
+    });
+
+    it('isCoordinate true when ≥2 partitives', () => {
+      const r = makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
+      });
+      expect(r.isCoordinate).toBe(true);
+    });
+
+    it('rejects < 2 partitives (ISO 704 requirement)', () => {
+      expect(() => makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [makePartitive('test', '1.4')],
+      })).toThrow(/≥2 partitives/);
+    });
 
-  it('round-trips through toJSON with v2 shape', () => {
-    const r = makeRelation({
-      comprehensive: makeRef('test', '1.3'),
-      partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5', 'possible')],
-      completeness: 'partial',
-      plurality: makePlurality(true),
-      criterion: { eng: 'criterion text' },
+    it('round-trips through toJSON with MECE fields', () => {
+      const r = makeRelation({
+        comprehensive: makeRef('test', '1.3'),
+        partitives: [
+          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<{ presence?: string; count?: string; is_delimiting?: boolean; ref: unknown }>;
+        completeness: string;
+        criterion?: Record<string, string>;
+      };
+      expect(json.comprehensive).toBeDefined();
+      expect(json.partitives).toHaveLength(2);
+      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' });
     });
-    const json = r.toJSON();
-    expect(json.completeness).toBe('partial');
-    expect(json.partitives).toHaveLength(2);
-    expect(json.partitives[1].certainty).toBe('possible');
-    expect(json.plurality?.is_shared).toBe(true);
-    expect(json.criterion?.eng).toBe('criterion text');
   });
 });