@glossarist/concept-browser 0.7.81 → 0.7.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.81",
+  "version": "0.7.83",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {

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

@@ -0,0 +1,248 @@
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
+import PartitiveRelationDiagram, {
+  type PartitiveMemberLabeled,
+} from '../../components/PartitiveRelationDiagram.vue';
+
+const members = (n: number, certainty: 'confirmed' | 'possible' = 'confirmed'): PartitiveMemberLabeled[] =>
+  Array.from({ length: n }, (_, i) => ({
+    uri: `https://example.org/test/concept/1.${i + 1}`,
+    label: `1.${i + 1}`,
+    certainty,
+  }));
+
+function svgLinesOf(wrapper: ReturnType<typeof mount>) {
+  return wrapper.findAll('line');
+}
+
+describe('PartitiveRelationDiagram — ISO 704 rake rendering', () => {
+  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());
+    expect(texts).toContain('1.3');
+    expect(texts).toContain('1.1');
+    expect(texts).toContain('1.2');
+    expect(texts).toContain('1.3');
+  });
+
+  it('renders criterion under the comprehensive', () => {
+    const w = mount(PartitiveRelationDiagram, {
+      props: {
+        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)', () => {
+      const w = mount(PartitiveRelationDiagram, {
+        props: {
+          comprehensiveLabel: '1.3',
+          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);
+    });
+
+    it('close-set double solid lines when isShared && !isUncertain', () => {
+      const w = mount(PartitiveRelationDiagram, {
+        props: {
+          comprehensiveLabel: '1.3',
+          partitives: members(2),
+          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);
+    });
+
+    it('one solid + one dashed when isShared && isUncertain', () => {
+      const w = mount(PartitiveRelationDiagram, {
+        props: {
+          comprehensiveLabel: '1.3',
+          partitives: members(2),
+          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);
+      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', () => {
+      const w = mount(PartitiveRelationDiagram, {
+        props: {
+          comprehensiveLabel: '1.3',
+          partitives: members(2),
+          completeness: 'partial',
+          plurality: null,
+        },
+      });
+      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;
+    });
+  });
+
+  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' },
+      ];
+      const w = mount(PartitiveRelationDiagram, {
+        props: {
+          comprehensiveLabel: '0',
+          partitives: possibleMembers,
+          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();
+    });
+
+    it('emits navigate when a partitive is clicked', async () => {
+      const w = mount(PartitiveRelationDiagram, {
+        props: {
+          comprehensiveLabel: '0',
+          partitives: members(2),
+          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();
+    });
+  });
+
+  describe('designation-aware sizing', () => {
+    it('uses MIN_NODE_W when labels are short', () => {
+      const w = mount(PartitiveRelationDiagram, {
+        props: {
+          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]);
+      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' },
+          ],
+          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);
+    });
+
+    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,
+        },
+      });
+      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__/model-bridge-partitive.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest';
+import { conceptFromJson } from '../adapters/model-bridge';
+
+describe('conceptFromJson — gl:partitiveRelations (v2)', () => {
+  function makeJson(overrides: Record<string, unknown> = {}) {
+    return {
+      '@type': 'gl:Concept',
+      '@id': 'https://example.org/test/concept/1.3',
+      'gl:identifier': '1.3',
+      'gl:localizedConcept': {},
+      ...overrides,
+    };
+  }
+
+  it('returns empty array when no partitiveRelations', () => {
+    const c = conceptFromJson(makeJson());
+    expect(c.partitiveRelations).toEqual([]);
+  });
+
+  it('parses comprehensive + 2 partitives', () => {
+    const c = conceptFromJson(makeJson({
+      'gl:partitiveRelations': [{
+        'gl:comprehensive': { 'gl:source': 'urn:test', 'gl:id': '1.3' },
+        'gl:hasPartitive': [
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.4' } },
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.5' } },
+        ],
+      }],
+    }));
+    expect(c.partitiveRelations).toHaveLength(1);
+    const r = c.partitiveRelations[0];
+    expect(r.comprehensive.source).toBe('urn:test');
+    expect(r.comprehensive.id).toBe('1.3');
+    expect(r.partitives).toHaveLength(2);
+    expect(r.partitives[0].ref.id).toBe('1.4');
+    expect(r.partitives[1].ref.id).toBe('1.5');
+  });
+
+  it('parses completeness', () => {
+    const c = conceptFromJson(makeJson({
+      'gl:partitiveRelations': [{
+        'gl:comprehensive': { 'gl:source': 'urn:test', 'gl:id': '1.3' },
+        'gl:hasPartitive': [
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.4' } },
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.5' } },
+        ],
+        'gl:completeness': 'partial',
+      }],
+    }));
+    expect(c.partitiveRelations[0].completeness).toBe('partial');
+    expect(c.partitiveRelations[0].isPartial).toBe(true);
+  });
+
+  it('parses per-member certainty', () => {
+    const c = conceptFromJson(makeJson({
+      'gl:partitiveRelations': [{
+        'gl:comprehensive': { 'gl:source': 'urn:test', 'gl:id': '1.3' },
+        'gl:hasPartitive': [
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.4' } },
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.5' }, 'gl:certainty': 'possible' },
+        ],
+      }],
+    }));
+    const members = c.partitiveRelations[0].partitives;
+    expect(members[0].certainty).toBe('confirmed');
+    expect(members[1].certainty).toBe('possible');
+    expect(members[1].isPossible).toBe(true);
+  });
+
+  it('parses plurality block', () => {
+    const c = conceptFromJson(makeJson({
+      'gl:partitiveRelations': [{
+        'gl:comprehensive': { 'gl:source': 'urn:test', 'gl:id': '1.3' },
+        'gl:hasPartitive': [
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.4' } },
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.5' } },
+        ],
+        'gl:hasPlurality': {
+          'gl:isShared': true,
+          'gl:isUncertain': true,
+          'gl:sharedType': { 'gl:source': 'urn:test', 'gl:id': '1.99' },
+        },
+      }],
+    }));
+    const p = c.partitiveRelations[0].plurality;
+    expect(p).not.toBeNull();
+    expect(p?.isShared).toBe(true);
+    expect(p?.isUncertain).toBe(true);
+    expect(p?.sharedType?.id).toBe('1.99');
+  });
+
+  it('parses criterion as localized hash', () => {
+    const c = conceptFromJson(makeJson({
+      'gl:partitiveRelations': [{
+        'gl:comprehensive': { 'gl:source': 'urn:test', 'gl:id': '1.3' },
+        'gl:hasPartitive': [
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.4' } },
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.5' } },
+        ],
+        'gl:criterion': { eng: 'physical structure', fra: 'structure physique' },
+      }],
+    }));
+    expect(c.partitiveRelations[0].criterion?.eng).toBe('physical structure');
+    expect(c.partitiveRelations[0].criterion?.fra).toBe('structure physique');
+  });
+
+  it('parses criterion as plain string (normalized to default)', () => {
+    const c = conceptFromJson(makeJson({
+      'gl:partitiveRelations': [{
+        'gl:comprehensive': { 'gl:source': 'urn:test', 'gl:id': '1.3' },
+        'gl:hasPartitive': [
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.4' } },
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.5' } },
+        ],
+        'gl:criterion': 'a bare criterion string',
+      }],
+    }));
+    expect(c.partitiveRelations[0].criterion?.default).toBe('a bare criterion string');
+  });
+
+  it('skips relation with no comprehensive', () => {
+    const c = conceptFromJson(makeJson({
+      'gl:partitiveRelations': [{
+        'gl:hasPartitive': [
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.4' } },
+        ],
+      }],
+    }));
+    expect(c.partitiveRelations).toEqual([]);
+  });
+
+  it('skips relation with < 2 valid partitives', () => {
+    const c = conceptFromJson(makeJson({
+      'gl:partitiveRelations': [{
+        'gl:comprehensive': { 'gl:source': 'urn:test', 'gl:id': '1.3' },
+        'gl:hasPartitive': [
+          { 'gl:ref': { 'gl:source': 'urn:test', 'gl:id': '1.4' } },
+          // Single member — PartitiveRelation constructor throws
+        ],
+      }],
+    }));
+    // The constructor throws before we catch it, so the relation is dropped
+    // via the runtime error path. conceptFromJson should not propagate.
+    expect(c.partitiveRelations).toEqual([]);
+  });
+});

package/src/adapters/model-bridge.ts

@@ -164,6 +164,25 @@ interface JsonLdLocalizedConcept {
   'gl:reviewDecisionNotes'?: string;
 }
 
+interface JsonLdPartitiveMember {
+  'gl:ref'?: JsonLdRef;
+  '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;
+}
+
 interface JsonLdConcept {
   '@type'?: string;
   '@id'?: string;
@@ -171,6 +190,7 @@ interface JsonLdConcept {
   'gl:term'?: string;
   'gl:localizedConcept'?: Record<string, JsonLdLocalizedConcept>;
   'gl:related'?: JsonLdRelated[];
+  'gl:partitiveRelations'?: JsonLdPartitiveRelation[];
   'gl:tags'?: string[];
   'gl:figureRef'?: unknown[];
   'gl:tableRef'?: unknown[];
@@ -563,6 +583,51 @@ function mapLocalizedFromJsonLd(lc: JsonLdLocalizedConcept): Record<string, unkn
   return data;
 }
 
+function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<string, unknown> | null {
+  const comprehensive = r['gl:comprehensive'] ? mapRefFromJsonLd(r['gl:comprehensive']) : null;
+  if (!comprehensive) return null;
+
+  const partitives = (r['gl:hasPartitive'] ?? [])
+    .map((m): Record<string, unknown> | null => {
+      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'];
+      return out;
+    })
+    .filter((m): m is Record<string, unknown> => m !== null);
+
+  // ISO 704 requires ≥2 partitives. Skip malformed relations rather
+  // than letting the constructor throw and break the whole concept.
+  if (partitives.length < 2) return null;
+
+  const out: Record<string, unknown> = {
+    comprehensive,
+    partitives,
+  };
+
+  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'] }
+      : r['gl:criterion'];
+  }
+
+  return out;
+}
+
 function conceptFromJsonLd(doc: JsonLdConcept): Concept {
   const id = String(doc['gl:identifier'] ?? doc['@id']?.split('/').pop() ?? '');
   const localizations: Record<string, unknown> = {};
@@ -575,6 +640,9 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
   }
 
   const related = (doc['gl:related'] ?? []).map(mapRelatedFromJsonLd);
+  const partitiveRelations = (doc['gl:partitiveRelations'] ?? [])
+    .map(mapPartitiveRelationFromJsonLd)
+    .filter((r): r is Record<string, unknown> => r !== null);
   const tags = Array.isArray(doc['gl:tags']) ? [...doc['gl:tags']] : [];
 
   const concept = Concept.fromJSON({
@@ -583,6 +651,7 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
     uri: doc['@id'] ?? null,
     localizations,
     related,
+    partitive_relations: partitiveRelations,
     tags,
     figures: normalizeEntityRefs(doc['gl:figureRef']),
     tables: normalizeEntityRefs(doc['gl:tableRef']),

package/src/components/PartitiveRelationDiagram.vue

@@ -0,0 +1,292 @@
+<script setup lang="ts">
+/**
+ * PartitiveRelationDiagram — renders a single PartitiveRelation as an
+ * ISO 704 rake/bracket diagram in SVG.
+ *
+ * Layout (looking top-down):
+ *
+ *            [comprehensive]
+ *                   │
+ *                   │   ← vertical stem
+ *   ┌───────────────┴───────────────┐   ← horizontal spine
+ *   │               │               │
+ *   │               │               │   ← perpendicular drops
+ * [part1]        [part2]        [part3]
+ *
+ * Line conventions per ISO 704:
+ *   - default                              : single solid line
+ *   - plurality.isShared && !isUncertain   : close-set DOUBLE solid lines
+ *                                            on stem + spine (drops stay single)
+ *   - plurality.isShared && isUncertain    : one solid + one DASHED line
+ *   - completeness === 'partial'           : spine extends past the last
+ *                                            tooth (continued backline)
+ *
+ * Node sizing is designation-aware: the longest label drives the node
+ * width (clamped to [MIN_NODE_W, MAX_NODE_W]); labels that don't fit
+ * wrap to a second line via tspan. This lets the rake show actual
+ * designations ('system of quantities') instead of bare IDs ('1.3').
+ */
+import { computed } from 'vue';
+import type { TypeSharedPluralityWire } from '../adapters/types';
+
+export interface PartitiveMemberLabeled {
+  uri: string;
+  label: string;
+  certainty: 'confirmed' | 'possible';
+}
+
+const props = withDefaults(defineProps<{
+  comprehensiveLabel: string;
+  partitives: PartitiveMemberLabeled[];
+  completeness: 'complete' | 'partial';
+  plurality: TypeSharedPluralityWire | null;
+  criterion?: string | null;
+}>(), {
+  criterion: null,
+});
+
+const emit = defineEmits<{
+  (e: 'navigate', uri: string): void;
+}>();
+
+// Layout constants
+const MIN_NODE_W = 110;
+const MAX_NODE_W = 220;
+const SINGLE_LINE_H = 32;
+const DOUBLE_LINE_H = 50;
+const STEM_LEN = 28;
+const SPINE_TO_NODE = 32;
+const GAP_X = 16;
+const PADDING_X = 20;
+const PADDING_Y = 14;
+const DOUBLE_GAP = 3;
+const PARTIAL_TAIL = 32;
+const DASH_PATTERN = '4 3';
+const CHAR_W = 6.2;            // approx for 11px sans-serif
+const NODE_TEXT_PAD = 16;      // horizontal padding inside node rect
+
+type LineVariant = 'single' | 'double-solid' | 'solid-plus-dashed';
+
+const lineVariant = computed<LineVariant>(() => {
+  if (!props.plurality?.isShared) return 'single';
+  return props.plurality.isUncertain ? 'solid-plus-dashed' : 'double-solid';
+});
+
+/** Estimated pixel width of a string at 11px sans-serif. */
+function estimateTextWidth(text: string): number {
+  return text.length * CHAR_W;
+}
+
+/**
+ * Wrap a label to at most 2 lines, breaking on word boundaries.
+ * If a single word exceeds the limit, it stays on its own line and
+ * gets truncated with an ellipsis.
+ */
+function wrapLabel(text: string, maxCharsPerLine: number): string[] {
+  if (text.length <= maxCharsPerLine) return [text];
+  const words = text.split(/\s+/);
+  const lines: string[] = [];
+  let current = '';
+  for (const w of words) {
+    if (w.length > maxCharsPerLine) {
+      // word itself too long — flush current, push truncated word
+      if (current) { lines.push(current); current = ''; }
+      lines.push(w.slice(0, Math.max(1, maxCharsPerLine - 1)) + '…');
+      continue;
+    }
+    if (!current) {
+      current = w;
+    } else if ((current + ' ' + w).length <= maxCharsPerLine) {
+      current += ' ' + w;
+    } else {
+      lines.push(current);
+      current = w;
+    }
+  }
+  if (current) lines.push(current);
+  if (lines.length > 2) {
+    return [lines[0], lines.slice(1).join(' ').slice(0, maxCharsPerLine - 1) + '…'];
+  }
+  return lines;
+}
+
+const layout = computed(() => {
+  const allLabels = [props.comprehensiveLabel, ...props.partitives.map(p => p.label)];
+  const longestWidth = Math.max(...allLabels.map(estimateTextWidth));
+  const nodeW = Math.min(MAX_NODE_W, Math.max(MIN_NODE_W, Math.ceil(longestWidth) + NODE_TEXT_PAD));
+  const charsPerLine = Math.max(10, Math.floor((nodeW - NODE_TEXT_PAD) / CHAR_W));
+
+  const wrapped = allLabels.map(label => wrapLabel(label, charsPerLine));
+  const anyWrapped = wrapped.some(lines => lines.length > 1);
+  const nodeH = anyWrapped ? DOUBLE_LINE_H : SINGLE_LINE_H;
+
+  const n = props.partitives.length;
+  const totalWidth = PADDING_X * 2 + n * nodeW + (n - 1) * GAP_X;
+  const totalHeight = PADDING_Y * 2 + nodeH + STEM_LEN + SPINE_TO_NODE + nodeH;
+
+  const centerX = totalWidth / 2;
+  const compY = PADDING_Y + nodeH / 2;
+  const spineY = compY + nodeH / 2 + STEM_LEN;
+  const partY = spineY + SPINE_TO_NODE;
+
+  const partitiveSlots = props.partitives.map((member, i) => {
+    const x = PADDING_X + nodeW / 2 + i * (nodeW + GAP_X);
+    const labelLines = wrapped[i + 1]; // index 0 is comprehensive
+    return { member, x, labelLines };
+  });
+
+  const leftX = partitiveSlots[0]?.x ?? centerX;
+  const lastX = partitiveSlots[n - 1]?.x ?? centerX;
+  const spineEndX = props.completeness === 'partial'
+    ? lastX + PARTIAL_TAIL
+    : lastX;
+
+  return {
+    nodeW,
+    nodeH,
+    totalWidth,
+    totalHeight,
+    centerX,
+    compY,
+    spineY,
+    partY,
+    partitiveSlots,
+    comprehensiveLines: wrapped[0],
+    leftX,
+    spineEndX,
+  };
+});
+
+function strokeAttr(variant: LineVariant, opacity = 1, override?: 'dash') {
+  const useDash = override === 'dash' || variant === 'solid-plus-dashed';
+  return {
+    stroke: 'currentColor',
+    'stroke-width': 1.4,
+    opacity,
+    ...(useDash ? { 'stroke-dasharray': DASH_PATTERN } : {}),
+  };
+}
+
+function emitNav(uri: string) {
+  emit('navigate', uri);
+}
+</script>
+
+<template>
+  <svg
+    :viewBox="`0 0 ${layout.totalWidth} ${layout.totalHeight}`"
+    width="100%"
+    :style="{ maxWidth: `${layout.totalWidth}px` }"
+    preserveAspectRatio="xMidYMid meet"
+    class="partitive-rake text-emerald-700 dark:text-emerald-300"
+    role="img"
+    aria-label="Partitive relation diagram"
+  >
+    <!-- Comprehensive label -->
+    <g>
+      <rect
+        :x="layout.centerX - layout.nodeW / 2"
+        :y="layout.compY - layout.nodeH / 2"
+        :width="layout.nodeW"
+        :height="layout.nodeH"
+        rx="6"
+        class="fill-emerald-50 dark:fill-emerald-900/30 stroke-current"
+        stroke-width="1.2"
+      />
+      <text :x="layout.centerX" text-anchor="middle" class="text-[11px] fill-emerald-900 dark:fill-emerald-100">
+        <tspan
+          v-for="(line, i) in layout.comprehensiveLines"
+          :key="i"
+          :x="layout.centerX"
+          :y="layout.compY - (layout.comprehensiveLines.length - 1) * 7 + i * 14"
+        >{{ line }}</tspan>
+      </text>
+    </g>
+
+    <!-- Criterion italic under the comprehensive -->
+    <text
+      v-if="criterion"
+      :x="layout.centerX"
+      :y="layout.compY + layout.nodeH / 2 + 10"
+      text-anchor="middle"
+      class="text-[9px] italic fill-emerald-800 dark:fill-emerald-200/80"
+    >{{ criterion }}</text>
+
+    <!-- Stem (vertical from comprehensive to spine) -->
+    <line
+      v-if="lineVariant === 'single'"
+      :x1="layout.centerX" :y1="layout.compY + layout.nodeH / 2"
+      :x2="layout.centerX" :y2="layout.spineY"
+      v-bind="strokeAttr('single')"
+    />
+    <template v-else>
+      <line
+        :x1="layout.centerX - DOUBLE_GAP / 2" :y1="layout.compY + layout.nodeH / 2"
+        :x2="layout.centerX - DOUBLE_GAP / 2" :y2="layout.spineY"
+        v-bind="strokeAttr('double-solid')"
+      />
+      <line
+        :x1="layout.centerX + DOUBLE_GAP / 2" :y1="layout.compY + layout.nodeH / 2"
+        :x2="layout.centerX + DOUBLE_GAP / 2" :y2="layout.spineY"
+        v-bind="strokeAttr(lineVariant, 1, lineVariant === 'solid-plus-dashed' ? 'dash' : undefined)"
+      />
+    </template>
+
+    <!-- Spine (horizontal, from leftmost tooth to rightmost tooth or extended) -->
+    <line
+      v-if="lineVariant === 'single'"
+      :x1="layout.leftX" :y1="layout.spineY"
+      :x2="layout.spineEndX" :y2="layout.spineY"
+      v-bind="strokeAttr('single')"
+    />
+    <template v-else>
+      <line
+        :x1="layout.leftX" :y1="layout.spineY - DOUBLE_GAP / 2"
+        :x2="layout.spineEndX" :y2="layout.spineY - DOUBLE_GAP / 2"
+        v-bind="strokeAttr('double-solid')"
+      />
+      <line
+        :x1="layout.leftX" :y1="layout.spineY + DOUBLE_GAP / 2"
+        :x2="layout.spineEndX" :y2="layout.spineY + DOUBLE_GAP / 2"
+        v-bind="strokeAttr(lineVariant, 1, lineVariant === 'solid-plus-dashed' ? 'dash' : undefined)"
+      />
+    </template>
+
+    <!-- Drops + partitive nodes -->
+    <g v-for="(slot, i) in layout.partitiveSlots" :key="i">
+      <line
+        :x1="slot.x" :y1="layout.spineY"
+        :x2="slot.x" :y2="layout.partY - layout.nodeH / 2"
+        v-bind="strokeAttr('single', slot.member.certainty === 'possible' ? 0.5 : 1, slot.member.certainty === 'possible' ? 'dash' : undefined)"
+      />
+      <g class="cursor-pointer" @click="emitNav(slot.member.uri)">
+        <rect
+          :x="slot.x - layout.nodeW / 2"
+          :y="layout.partY - layout.nodeH / 2"
+          :width="layout.nodeW"
+          :height="layout.nodeH"
+          rx="6"
+          :class="slot.member.certainty === 'possible'
+            ? 'fill-emerald-50/60 dark:fill-emerald-900/20 stroke-current'
+            : 'fill-emerald-50 dark:fill-emerald-900/30 stroke-current'"
+          :stroke-dasharray="slot.member.certainty === 'possible' ? DASH_PATTERN : undefined"
+          stroke-width="1.2"
+        />
+        <text
+          :x="slot.x"
+          text-anchor="middle"
+          :class="slot.member.certainty === 'possible'
+            ? 'text-[11px] fill-emerald-700/70 dark:fill-emerald-200/60 italic'
+            : 'text-[11px] fill-emerald-900 dark:fill-emerald-100'"
+        >
+          <tspan
+            v-for="(line, j) in slot.labelLines"
+            :key="j"
+            :x="slot.x"
+            :y="layout.partY - (slot.labelLines.length - 1) * 7 + j * 14"
+          >{{ line }}</tspan>
+        </text>
+      </g>
+    </g>
+  </svg>
+</template>

package/src/components/PartitiveRelationList.vue

@@ -1,28 +1,28 @@
 <script setup lang="ts">
 /**
  * PartitiveRelationList — renders one-to-many partitive decompositions
- * as grouped cards. Each relation shows:
- *   - the comprehensive (whole) concept as the card header
- *   - each partitive member as an indented child with a certainty badge
+ * as ISO 704 rake diagrams. Each relation shows:
  *   - completeness badge (complete / partial)
  *   - plurality badge (shared / uncertain / sharedType) when present
- *   - criterion as italic text under the title
+ *   - criterion as italic text under the header
+ *   - the rake diagram itself (PartitiveRelationDiagram)
  *
- * Independent of RelationshipList.vue, which renders binary edges.
- * Both consume the same stores but render in separate sections.
- *
- * v2 shape per concept-model/TODO.partitive-relation-v2.
+ * The diagram is the primary renderer. Badges in the header communicate
+ * the metadata that the diagram's line styles also encode (so users who
+ * can't perceive the visual difference still get the info).
  */
 import type { PartitiveRelationWire, Manifest } from '../adapters/types';
 import { useRouter } from 'vue-router';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { getFactory } from '../adapters/factory';
-import { useI18n } from '../i18n';
+import { useI18n, locale } from '../i18n';
 import {
-  partitiveRelationStyle,
   completenessLabel,
   certaintyLabel,
 } from '../utils/partitive-relation-styling';
+import PartitiveRelationDiagram, {
+  type PartitiveMemberLabeled,
+} from './PartitiveRelationDiagram.vue';
 
 const props = defineProps<{
   relations: PartitiveRelationWire[];
@@ -30,21 +30,31 @@ const props = defineProps<{
   registerId: string;
 }>();
 
-const emit = defineEmits<{
-  (e: 'navigate', registerId: string, conceptId: string): void;
-}>();
-
 const router = useRouter();
 const store = useVocabularyStore();
 const factory = getFactory();
 const { t } = useI18n();
 
-function labelFor(uri: string): string {
-  const parsed = factory.resolve(uri);
-  if (parsed.type === 'internal') {
-    return parsed.conceptId || uri;
+function designationFor(uri: string): string {
+  const node = store.graph.getNode(uri);
+  if (node) {
+    const des = node.designations[locale.value]
+      || node.designations.eng
+      || Object.values(node.designations)[0];
+    if (des) return des;
   }
-  return uri;
+  const resolution = factory.resolve(uri);
+  if (resolution.type === 'internal') {
+    const adapter = store.datasets.get(resolution.registerId);
+    const entry = adapter?.getIndexEntry(resolution.conceptId);
+    if (entry) {
+      const des = entry.designations[locale.value]
+        || entry.designations.eng
+        || Object.values(entry.designations)[0];
+      if (des) return des;
+    }
+  }
+  return resolution.type === 'internal' ? resolution.conceptId : uri;
 }
 
 function navigate(uri: string) {
@@ -78,6 +88,14 @@ function pluralityBadge(plurality: NonNullable<PartitiveRelationWire['plurality'
   }
   return label;
 }
+
+function labeledMembers(rel: PartitiveRelationWire): PartitiveMemberLabeled[] {
+  return rel.partitives.map(m => ({
+    uri: m.uri,
+    label: designationFor(m.uri),
+    certainty: m.certainty,
+  }));
+}
 </script>
 
 <template>
@@ -106,7 +124,7 @@ function pluralityBadge(plurality: NonNullable<PartitiveRelationWire['plurality'
           @click="navigate(rel.comprehensive)"
           class="ml-auto text-sm font-medium text-emerald-900 dark:text-emerald-100 hover:underline truncate"
         >
-          {{ labelFor(rel.comprehensive) }}
+          {{ designationFor(rel.comprehensive) }}
         </button>
       </div>
       <div
@@ -115,25 +133,17 @@ function pluralityBadge(plurality: NonNullable<PartitiveRelationWire['plurality'
       >
         {{ criterionText(rel.criterion) }}
       </div>
-      <ul class="divide-y divide-emerald-100 dark:divide-emerald-900/30">
-        <li v-for="(member, j) in rel.partitives" :key="j">
-          <button
-            @click="navigate(member.uri)"
-            class="block w-full text-left px-3 py-1.5 text-sm hover:bg-emerald-100 dark:hover:bg-emerald-900/30 text-emerald-900 dark:text-emerald-100"
-            :class="{ 'opacity-60': member.certainty === 'possible' }"
-          >
-            <span class="text-emerald-600 dark:text-emerald-400 mr-2">└</span>
-            {{ labelFor(member.uri) }}
-            <span
-              v-if="member.certainty === 'possible'"
-              class="ml-2 text-[10px] font-mono px-1.5 py-0.5 rounded bg-amber-100 dark:bg-amber-900/50 text-amber-800 dark:text-amber-200 uppercase"
-              :title="'plurality uncertain (ISO 704 broken line)'"
-            >
-              {{ certaintyLabel(member.certainty) }}
-            </span>
-          </button>
-        </li>
-      </ul>
+      <!-- Rake diagram (ISO 704 partitive-relation convention) -->
+      <div class="px-3 py-3 overflow-x-auto">
+        <PartitiveRelationDiagram
+          :comprehensive-label="designationFor(rel.comprehensive)"
+          :partitives="labeledMembers(rel)"
+          :completeness="rel.completeness"
+          :plurality="rel.plurality"
+          :criterion="null"
+          @navigate="navigate"
+        />
+      </div>
     </div>
   </div>
 </template>

package/src/components/RelationSphere.vue

@@ -25,7 +25,7 @@ import { hashSeed, expandParams, portSide, portPoint, idToUriGet } from '../util
 import { useI18n } from '../i18n';
 
 const { t, locale } = useI18n();
-import type { Concept, Manifest, GraphEdge } from '../adapters/types';
+import type { Concept, Manifest, GraphEdge, PartitiveRelationWire } from '../adapters/types';
 import { conceptUri } from '../adapters/model-bridge';
 
 const props = defineProps<{
@@ -33,6 +33,7 @@ const props = defineProps<{
   manifest: Manifest;
   registerId: string;
   edges: GraphEdge[];
+  partitiveRelations?: PartitiveRelationWire[];
 }>();
 
 const emit = defineEmits<{
@@ -390,6 +391,38 @@ function buildGraph() {
 
   nodes = Array.from(nodeMap.values());
   links = resultLinks;
+
+  /* Ensure every PartitiveRelation member is present in the graph
+     so the rake bundle can render. The comprehensive is normally the
+     focus; partitives may need to be added as depth-1 neighbors. */
+  for (const rel of props.partitiveRelations ?? []) {
+    const compParsed = UriRouter.parseUri(rel.comprehensive);
+    if (!compParsed) continue;
+    const compNodeId = `${compParsed.registerId}/${compParsed.conceptId}`;
+    if (!nodeMap.has(compNodeId)) continue;
+
+    for (const member of rel.partitives) {
+      const parsed = UriRouter.parseUri(member.uri);
+      if (!parsed) continue;
+      const nid = `${parsed.registerId}/${parsed.conceptId}`;
+      if (nodeMap.has(nid)) continue;
+      if (nodeMap.size >= MAX_NODES) break;
+      const pos = fibonacciSpherePosition(1, nodeMap.size, MAX_NODES, hashSeed(parsed.conceptId));
+      nodeMap.set(nid, {
+        id: nid,
+        term: parsed.conceptId,
+        ref: parsed.registerId,
+        register: parsed.registerId,
+        conceptId: parsed.conceptId,
+        depth: 1,
+        x: pos.x, y: pos.y, z: pos.z,
+        vx: 0, vy: 0, vz: 0,
+      });
+      idToUri.set(nid, member.uri);
+      nodes = Array.from(nodeMap.values());
+    }
+  }
+
   graphVersion.value++;
 }
 
@@ -712,6 +745,108 @@ function drawEdges(cx: number, cy: number) {
     label.textContent = labelText;
     svg.appendChild(label);
   }
+
+  drawRakeBundles(svg, pos, cx, cy);
+}
+
+/**
+ * Render PartitiveRelations as ISO 704 rake bundles in the sphere.
+ *
+ * In 3D space the literal "right-angle bracket" rake doesn't apply,
+ * so we use a bundle of N curves fanning out from the comprehensive,
+ * all sharing visual styling. The bundle communicates "these N edges
+ * are ONE relation", not N independent pairwise links.
+ *
+ * ISO 704 line conventions applied:
+ *   - default                              : single solid curve per member
+ *   - plurality.isShared && !isUncertain   : two parallel solid curves (close-set)
+ *   - plurality.isShared && isUncertain    : one solid + one dashed curve
+ *   - per-member certainty: 'possible'     : the member's curve is dashed
+ *                                            (regardless of plurality)
+ *
+ * A diamond marker at the comprehensive end signals the hyperedge origin.
+ */
+function drawRakeBundles(
+  svg: SVGSVGElement,
+  pos: Map<string, {x: number; y: number}>,
+  _cx: number,
+  _cy: number,
+) {
+  for (const rel of props.partitiveRelations ?? []) {
+    const compParsed = UriRouter.parseUri(rel.comprehensive);
+    if (!compParsed) continue;
+    const compNodeId = `${compParsed.registerId}/${compParsed.conceptId}`;
+    const compPos = pos.get(compNodeId);
+    if (!compPos) continue;
+
+    const memberPositions = rel.partitives
+      .map(member => {
+        const parsed = UriRouter.parseUri(member.uri);
+        if (!parsed) return null;
+        const nid = `${parsed.registerId}/${parsed.conceptId}`;
+        const p = pos.get(nid);
+        return p ? { member, pos: p } : null;
+      })
+      .filter((x): x is { member: { uri: string; certainty: 'confirmed' | 'possible' }; pos: {x: number; y: number} } => x !== null);
+
+    if (memberPositions.length === 0) continue;
+
+    const color = uiStore.isDark ? '#2dd4bf' : '#0d9488'; // teal — matches sidebar rake
+    const DOUBLE_GAP = 4;
+    const DASH = '4 3';
+    const isShared = !!rel.plurality?.isShared;
+    const isUncertain = !!rel.plurality?.isUncertain;
+    const drawDouble = isShared;
+    const secondDashed = isUncertain;
+
+    for (const { member, pos: pPos } of memberPositions) {
+      const dx = pPos.x - compPos.x;
+      const dy = pPos.y - compPos.y;
+      const len = Math.hypot(dx, dy) || 1;
+      const px = -dy / len; // perpendicular unit
+      const py = dx / len;
+
+      const drawLine = (offset: number, dashed: boolean) => {
+        const ax = compPos.x + px * offset;
+        const ay = compPos.y + py * offset;
+        const bx = pPos.x + px * offset;
+        const by = pPos.y + py * offset;
+        const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+        // Quadratic bezier toward a control point biased outward from the focus
+        // to suggest the "rake handle" shape.
+        const mx = (ax + bx) / 2;
+        const my = (ay + by) / 2;
+        const ctrlLen = len * 0.15;
+        path.setAttribute('d', `M ${ax} ${ay} Q ${mx + px * ctrlLen} ${my + py * ctrlLen} ${bx} ${by}`);
+        path.setAttribute('stroke', color);
+        path.setAttribute('stroke-width', '1.5');
+        path.setAttribute('opacity', member.certainty === 'possible' ? '0.45' : '0.8');
+        path.setAttribute('fill', 'none');
+        path.setAttribute('stroke-linecap', 'round');
+        if (dashed || member.certainty === 'possible') {
+          path.setAttribute('stroke-dasharray', DASH);
+        }
+        svg.appendChild(path);
+      };
+
+      drawLine(0, false);
+      if (drawDouble) {
+        drawLine(DOUBLE_GAP, secondDashed);
+        drawLine(-DOUBLE_GAP, secondDashed);
+      }
+    }
+
+    /* Diamond marker at comprehensive end — signals "rake origin" */
+    const diamond = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+    const dsize = 5;
+    diamond.setAttribute('d',
+      `M ${compPos.x} ${compPos.y - dsize} L ${compPos.x + dsize} ${compPos.y} L ${compPos.x} ${compPos.y + dsize} L ${compPos.x - dsize} ${compPos.y} Z`);
+    diamond.setAttribute('fill', color);
+    diamond.setAttribute('opacity', '0.85');
+    diamond.setAttribute('stroke', uiStore.isDark ? '#0a1f1c' : '#ffffff');
+    diamond.setAttribute('stroke-width', '1');
+    svg.appendChild(diamond);
+  }
 }
 
 function ensureMarkers(svg: SVGSVGElement) {

package/src/composables/use-concept-edges.ts

@@ -97,6 +97,41 @@ export function useConceptEdges(
     return edgeDisplayCache.value.get(uri) ?? { uri, conceptId: uri, designation: '', tooltip: uri, isLocal: false, badge: null };
   }
 
+  /**
+   * Resolve a concept's designation in the current UI locale.
+   * Fallback chain: locale → eng → any available.
+   *
+   * Sources tried in order:
+   *   1. BFS graph node (already loaded as a neighbor)
+   *   2. Dataset adapter index entry (every concept in the dataset)
+   *   3. conceptId as last-resort fallback
+   *
+   * Used by PartitiveRelationList (sidebar rake diagram) so the rake
+   * shows designations like 'system of quantities' instead of bare
+   * IDs like '1.3'.
+   */
+  function designationFor(uri: string): string {
+    const node = store.graph.getNode(uri);
+    if (node) {
+      const des = node.designations[locale.value]
+        || node.designations.eng
+        || Object.values(node.designations)[0];
+      if (des) return des;
+    }
+    const resolution = factory.resolve(uri);
+    if (resolution.type === 'internal') {
+      const adapter = store.datasets.get(resolution.registerId);
+      const entry = adapter?.getIndexEntry(resolution.conceptId);
+      if (entry) {
+        const des = entry.designations[locale.value]
+          || entry.designations.eng
+          || Object.values(entry.designations)[0];
+        if (des) return des;
+      }
+    }
+    return resolution.type === 'internal' ? resolution.conceptId : uri;
+  }
+
   function edgeBadgeColor(type: string, direction: 'out' | 'in'): string {
     if (type === 'supersedes' || type === 'superseded_by') {
       return direction === 'out' ? 'text-orange-700 bg-orange-50' : 'text-red-700 bg-red-50';
@@ -262,6 +297,7 @@ export function useConceptEdges(
     incomingEdges,
     edgeDisplayCache,
     getEdgeDisplay,
+    designationFor,
     edgeBadgeColor,
     inverseEdgeType,
     conceptRelated,

package/src/views/ConceptView.vue

@@ -3,6 +3,8 @@ import { computed, watch, ref, onMounted, onUnmounted } from 'vue';
 import { useRouter } from 'vue-router';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { conceptUri } from '../adapters/model-bridge';
+import { UriRouter } from '../adapters/UriRouter';
+import type { PartitiveRelationWire, PartitiveMemberWire } from '../adapters/types';
 import ConceptDetail from '../components/ConceptDetail.vue';
 import RelationSphere from '../components/RelationSphere.vue';
 import ShortcutsModal from '../components/ShortcutsModal.vue';
@@ -58,6 +60,55 @@ const manifest = computed(() => store.currentManifest);
 const edges = computed(() => store.conceptEdges);
 const activeRegisterId = computed(() => sphereFocusPayload.value?.registerId ?? props.registerId);
 const adjacent = ref({ prev: null as string | null, next: null as string | null });
+
+/**
+ * Project concept.partitiveRelations (glossarist-js v2 model) into the
+ * URI-resolved wire shape the sphere consumes. Mirrors the projection
+ * in use-concept-edges.ts but inline here so the sphere can render rake
+ * bundles without a full composable setup.
+ */
+const partitiveRelationsForSphere = computed<PartitiveRelationWire[]>(() => {
+  const c = concept.value;
+  const m = manifest.value;
+  if (!c || !m) return [];
+  const sourceUri = conceptUri(c, activeRegisterId.value, m.uriBase);
+  const out: PartitiveRelationWire[] = [];
+  for (const rel of c.partitiveRelations ?? []) {
+    const compRef = rel.comprehensive;
+    const compTarget = store.manifests.get(activeRegisterId.value)
+      ? UriRouter.buildConceptUri(m.uriBase, activeRegisterId.value, compRef.id ?? '')
+      : null;
+    if (!compRef.id || !compTarget) continue;
+    const partitives: PartitiveMemberWire[] = rel.partitives
+      .map(member => {
+        const ref = member.ref;
+        if (!ref?.id) return null;
+        const targetRegister = store.manifests.has(activeRegisterId.value)
+          ? activeRegisterId.value
+          : activeRegisterId.value;
+        const uri = UriRouter.buildConceptUri(m.uriBase, targetRegister, ref.id);
+        if (uri === sourceUri) return null;
+        return { uri, certainty: member.certainty };
+      })
+      .filter((x): x is PartitiveMemberWire => x !== null);
+    if (partitives.length === 0) continue;
+    out.push({
+      source: sourceUri,
+      comprehensive: compTarget,
+      partitives,
+      completeness: rel.completeness,
+      plurality: rel.plurality
+        ? {
+            isShared: rel.plurality.isShared,
+            isUncertain: rel.plurality.isUncertain,
+            sharedType: null,
+          }
+        : null,
+      register: activeRegisterId.value,
+    });
+  }
+  return out;
+});
 const viewMode = ref<'detail' | 'sphere'>(
   router.currentRoute.value.query.view === 'sphere' ? 'sphere' : 'detail'
 );
@@ -280,6 +331,7 @@ onUnmounted(() => window.removeEventListener('keydown', onKeydown));
           :manifest="manifest"
           :register-id="activeRegisterId"
           :edges="edges"
+          :partitive-relations="partitiveRelationsForSphere"
           @navigate="onSphereNavigate"
         />
         <!-- Detail mode -->