@glossarist/concept-browser 0.7.84 → 0.7.86

package/src/components/RelationSphere.vue

@@ -26,6 +26,7 @@ import { useI18n } from '../i18n';
 
 const { t, locale } = useI18n();
 import type { Concept, Manifest, GraphEdge, PartitiveRelationWire } from '../adapters/types';
+import { rakeStrokeStyle, type PartitiveMultiplicity } from '../utils/partitive-multiplicity';
 import { conceptUri } from '../adapters/model-bridge';
 
 const props = defineProps<{
@@ -537,11 +538,19 @@ function linkForce() {
     if (links.length === 0) return;
     const target = linkDistance;
     const strength = linkStrength;
+    /* Read muted sets each tick so toggleType/toggleRegister take effect
+       immediately on the next simulation step. */
+    const mutedT = mutedTypes.value;
+    const mutedR = mutedRegisters.value;
     for (const link of links) {
+      if (mutedT.has(link.type)) continue;
       const ai = idToIdx.get(link.source);
       const bi = idToIdx.get(link.target);
       if (ai === undefined || bi === undefined) continue;
       const a = nL[ai], b = nL[bi];
+      /* Skip edges involving a muted register (unless the node is the focus) */
+      if (a.depth !== 0 && mutedR.has(a.register)) continue;
+      if (b.depth !== 0 && mutedR.has(b.register)) continue;
       const dx = b.x - a.x, dy = b.y - a.y, dz = b.z - a.z;
       const d2 = dx*dx + dy*dy + dz*dz;
       if (d2 < 1e-6) continue;
@@ -752,38 +761,33 @@ function drawEdges(cx: number, cy: number) {
 }
 
 /**
- * Render PartitiveRelations as ISO 704 rake/bracket bundles in the sphere.
+ * Render PartitiveRelations as ISO 704:2022 rake brackets in the sphere.
  *
- * Each relation renders as a real bracket:
+ * Each relation renders as a right-angle bracket with stem + spine + drops
+ * (geometry described in detail above). Stem and spine are the structural
+ * frame — always single solid at FRAME_STROKE_WIDTH.
  *
- *     [comprehensive]
- *            |
- *            |          ← single stem (vertical/radial)
- *            |
- *        +---•---+      ← spine midpoint (junction)
- *        |   |   |
- *        |   |   |      ← N branches from spine midpoint
- *      [p1] [p2] [p3]      (one per partitive)
+ * Per-member multiplicity + is_delimiting is encoded on each DROP via
+ * rakeStrokeStyle() (see utils/partitive-multiplicity.ts):
  *
- * In 3D the bracket's "vertical" direction is along the line from
- * comprehensive to the centroid of partitives. The branches fan out
- * from the spine midpoint to each partitive. Right angles are not
- * enforceable in a force-directed layout; instead we use a single
- * shared junction point so the eye reads "ONE relation, N branches".
+ *   multiplicity         is_delimiting  drop visual
+ *   -------------------  --------------  --------------------------------
+ *   compulsory           false           1 solid  @ 1.5px
+ *   compulsory           true            1 solid  @ 4.5px (3× bold)
+ *   optional             false           1 dashed @ 1.5px
+ *   optional             true            1 dashed @ 4.5px
+ *   compulsory_multiple  false           2 solid  @ 1.5px
+ *   compulsory_multiple  true            2 solid  @ 4.5px
+ *   optional_multiple    false           2 dashed @ 1.5px
+ *   optional_multiple    true            2 dashed @ 4.5px
+ *   compulsory_at_least_one         false           1 solid + 1 dashed @ 1.5px
+ *   compulsory_at_least_one         true            1 solid + 1 dashed @ 4.5px
  *
- * ISO 704 line conventions applied (each segment: stem + spine + branches):
- *   - default                              : single solid line
- *   - plurality.isShared && !isUncertain   : two parallel solid lines
- *                                            (close-set; offset ±DOUBLE_GAP/2)
- *   - plurality.isShared && isUncertain    : one solid + one dashed line
+ * completeness === 'partial'  : spine extends past last tooth (continued
+ *                               backline — "more exist but not shown")
  *
- * Per-member certainty:
- *   - confirmed : branch is solid (with the plurality style above)
- *   - possible  : branch is dashed + reduced opacity (overrides plurality
- *                 on that branch only; the stem + spine keep the relation
- *                 style)
- *
- * A diamond marker at the comprehensive end signals the hyperedge origin.
+ * Diamond marker at the comprehensive end signals the hyperedge origin.
+ * Junction marker at the spine midpoint signals the right-angle corner.
  */
 function drawRakeBundles(
   svg: SVGSVGElement,
@@ -791,9 +795,13 @@ function drawRakeBundles(
   _cx: number,
   _cy: number,
 ) {
+  if (mutedTypes.value.has('__partitive__')) return;
   const color = uiStore.isDark ? '#2dd4bf' : '#0d9488';
   const DOUBLE_GAP = 4;
   const DASH = '4 3';
+  const FRAME_STROKE_WIDTH = 1.4;
+  const SPINE_FRACTION = 0.55;       // spine sits 55% from comp toward centroid
+  const PARTIAL_TAIL = 28;           // px extension for completeness: 'partial'
 
   for (const rel of props.partitiveRelations ?? []) {
     const compParsed = UriRouter.parseUri(rel.comprehensive);
@@ -810,109 +818,124 @@ function drawRakeBundles(
         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);
+      .filter((x): x is { member: { uri: string; multiplicity: PartitiveMultiplicity; isDelimiting: boolean }; pos: {x: number; y: number} } => x !== null);
 
     if (memberPositions.length === 0) continue;
 
-    // Spine midpoint = centroid of comprehensive + all partitives.
-    // This is the junction where the stem meets the branches.
-    const cx_part = (compPos.x + memberPositions.reduce((s, m) => s + m.pos.x, 0)) / (memberPositions.length + 1);
-    const cy_part = (compPos.y + memberPositions.reduce((s, m) => s + m.pos.y, 0)) / (memberPositions.length + 1);
+    // 1. Compute stem-axis (comp → centroid of partitives) and spine-axis (perpendicular)
+    const centroidX = memberPositions.reduce((s, m) => s + m.pos.x, 0) / memberPositions.length;
+    const centroidY = memberPositions.reduce((s, m) => s + m.pos.y, 0) / memberPositions.length;
+    const stemDx = centroidX - compPos.x;
+    const stemDy = centroidY - compPos.y;
+    const stemLen = Math.hypot(stemDx, stemDy) || 1;
+    const stemDirX = stemDx / stemLen;     // unit vector along stem
+    const stemDirY = stemDy / stemLen;
+    const spineDirX = -stemDirY;            // perpendicular = spine direction
+    const spineDirY = stemDirX;
+
+    // 2. Spine center: along stem-axis at SPINE_FRACTION from comp
+    const spineCx = compPos.x + stemDirX * stemLen * SPINE_FRACTION;
+    const spineCy = compPos.y + stemDirY * stemLen * SPINE_FRACTION;
+
+    // 3. Tooth positions = projection of each partitive onto spine line
+    const teeth = memberPositions.map(({ member, pos: pPos }) => {
+      const vx = pPos.x - spineCx;
+      const vy = pPos.y - spineCy;
+      const along = vx * spineDirX + vy * spineDirY;
+      const toothX = spineCx + spineDirX * along;
+      const toothY = spineCy + spineDirY * along;
+      return {
+        member,
+        partitivePos: pPos,
+        toothX,
+        toothY,
+        along,
+        style: rakeStrokeStyle(member.multiplicity, member.isDelimiting),
+      };
+    });
 
-    const isShared = !!rel.plurality?.isShared;
-    const isUncertain = !!rel.plurality?.isUncertain;
+    // 4. Spine extents (leftmost to rightmost tooth along spine-axis)
+    let minAlong = teeth[0].along;
+    let maxAlong = teeth[0].along;
+    for (const t of teeth) {
+      if (t.along < minAlong) minAlong = t.along;
+      if (t.along > maxAlong) maxAlong = t.along;
+    }
+    // For completeness: 'partial', extend past last tooth (continued backline)
+    if (rel.completeness === 'partial') maxAlong += PARTIAL_TAIL;
+    const spineStartX = spineCx + spineDirX * minAlong;
+    const spineStartY = spineCy + spineDirY * minAlong;
+    const spineEndX = spineCx + spineDirX * maxAlong;
+    const spineEndY = spineCy + spineDirY * maxAlong;
 
     /**
-     * Draw a single straight line segment with optional parallel offset
-     * and dash style. Used for both stem and branches.
+     * Draw a single straight segment.
+     *
+     * Stem + spine use FRAME_STROKE_WIDTH (single solid frame).
+     * Drops use the per-member multiplicity + delimiting style from
+     * rakeStrokeStyle().
      */
     const drawSegment = (
       ax: number, ay: number, bx: number, by: number,
-      opts: { offset?: number; dashed?: boolean; opacity?: number } = {},
+      opts: { width: number; dashed?: boolean; offset?: number; opacity?: number },
     ) => {
+      const opacity = opts.opacity ?? 0.85;
       const offset = opts.offset ?? 0;
       const dashed = opts.dashed ?? false;
-      const opacity = opts.opacity ?? 0.85;
-      if (offset === 0) {
-        const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
-        line.setAttribute('class', 'rake-seg');
-        line.setAttribute('x1', String(ax));
-        line.setAttribute('y1', String(ay));
-        line.setAttribute('x2', String(bx));
-        line.setAttribute('y2', String(by));
-        line.setAttribute('stroke', color);
-        line.setAttribute('stroke-width', '1.6');
-        line.setAttribute('opacity', String(opacity));
-        line.setAttribute('stroke-linecap', 'round');
-        if (dashed) line.setAttribute('stroke-dasharray', DASH);
-        svg.appendChild(line);
-      } else {
-        // Compute perpendicular unit vector for parallel offset
-        const dx = bx - ax, dy = by - ay;
-        const len = Math.hypot(dx, dy) || 1;
-        const px = -dy / len, py = dx / len;
-        const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
-        line.setAttribute('class', 'rake-seg');
-        line.setAttribute('x1', String(ax + px * offset));
-        line.setAttribute('y1', String(ay + py * offset));
-        line.setAttribute('x2', String(bx + px * offset));
-        line.setAttribute('y2', String(by + py * offset));
-        line.setAttribute('stroke', color);
-        line.setAttribute('stroke-width', '1.6');
-        line.setAttribute('opacity', String(opacity));
-        line.setAttribute('stroke-linecap', 'round');
-        if (dashed) line.setAttribute('stroke-dasharray', DASH);
-        svg.appendChild(line);
-      }
+      const dx = bx - ax, dy = by - ay;
+      const len = Math.hypot(dx, dy) || 1;
+      const px = -dy / len, py = dx / len;
+      const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
+      line.setAttribute('class', 'rake-seg');
+      line.setAttribute('x1', String(ax + px * offset));
+      line.setAttribute('y1', String(ay + py * offset));
+      line.setAttribute('x2', String(bx + px * offset));
+      line.setAttribute('y2', String(by + py * offset));
+      line.setAttribute('stroke', color);
+      line.setAttribute('stroke-width', String(opts.width));
+      line.setAttribute('opacity', String(opacity));
+      line.setAttribute('stroke-linecap', 'square');
+      if (dashed) line.setAttribute('stroke-dasharray', DASH);
+      svg.appendChild(line);
     };
 
-    /**
-     * Draw a segment with the relation's plurality style:
-     * single solid (default), double solid (isShared),
-     * or solid + dashed (isShared + isUncertain).
-     */
-    const drawSegmentWithPlurality = (
-      ax: number, ay: number, bx: number, by: number,
-      opts: { opacity?: number; perMemberPossible?: boolean } = {},
-    ) => {
-      const opacity = opts.opacity ?? 0.85;
-      if (!isShared) {
-        drawSegment(ax, ay, bx, by, { opacity, dashed: opts.perMemberPossible });
-      } else {
-        // Close-set double: two parallel lines offset ±DOUBLE_GAP/2
-        drawSegment(ax, ay, bx, by, { offset: -DOUBLE_GAP / 2, opacity });
-        drawSegment(ax, ay, bx, by, {
-          offset: DOUBLE_GAP / 2,
-          opacity,
-          dashed: isUncertain || opts.perMemberPossible,
-        });
-      }
-    };
+    // 5. Stem: comp → spine center (frame — single solid)
+    drawSegment(compPos.x, compPos.y, spineCx, spineCy, { width: FRAME_STROKE_WIDTH });
 
-    // 1. Stem: comprehensive → spine midpoint
-    drawSegmentWithPlurality(compPos.x, compPos.y, cx_part, cy_part);
+    // 6. Spine: leftmost tooth → rightmost tooth (frame — single solid)
+    if (Math.abs(maxAlong - minAlong) > 1) {
+      drawSegment(spineStartX, spineStartY, spineEndX, spineEndY, { width: FRAME_STROKE_WIDTH });
+    }
 
-    // 2. Branches: spine midpoint → each partitive
-    for (const { member, pos: pPos } of memberPositions) {
-      drawSegmentWithPlurality(cx_part, cy_part, pPos.x, pPos.y, {
-        opacity: member.certainty === 'possible' ? 0.45 : 0.85,
-        perMemberPossible: member.certainty === 'possible',
+    // 7. Drops: tooth → partitive (per-member multiplicity + delimiting)
+    //    Draw 1 or 2 parallel lines per the style.
+    for (const tooth of teeth) {
+      drawSegment(tooth.toothX, tooth.toothY, tooth.partitivePos.x, tooth.partitivePos.y, {
+        width: tooth.style.strokeWidth,
+        dashed: tooth.style.primaryDashed,
       });
+      if (tooth.style.lineCount === 2) {
+        drawSegment(tooth.toothX, tooth.toothY, tooth.partitivePos.x, tooth.partitivePos.y, {
+          width: tooth.style.strokeWidth,
+          dashed: tooth.style.secondaryDashed,
+          offset: DOUBLE_GAP,
+        });
+      }
     }
 
-    // 3. Junction marker at spine midpoint (small filled circle)
+    // 8. Junction marker at spine center (the right-angle corner)
     const junction = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
     junction.setAttribute('class', 'rake-junction');
-    junction.setAttribute('cx', String(cx_part));
-    junction.setAttribute('cy', String(cy_part));
-    junction.setAttribute('r', '3');
+    junction.setAttribute('cx', String(spineCx));
+    junction.setAttribute('cy', String(spineCy));
+    junction.setAttribute('r', '2.5');
     junction.setAttribute('fill', color);
-    junction.setAttribute('opacity', '0.85');
+    junction.setAttribute('opacity', '0.9');
     junction.setAttribute('stroke', uiStore.isDark ? '#0a1f1c' : '#ffffff');
     junction.setAttribute('stroke-width', '1');
     svg.appendChild(junction);
 
-    // 4. Diamond marker at comprehensive end (hyperedge origin signal)
+    // 9. Diamond marker at comprehensive end (hyperedge origin)
     const diamond = document.createElementNS('http://www.w3.org/2000/svg', 'path');
     const dsize = 5;
     diamond.setAttribute('d',
@@ -1249,6 +1272,8 @@ watch(() => [props.concept?.id, props.registerId] as const, ([newId, newReg]) =>
 /* ── Legend — grouped by relation TYPE (not category) ───── */
 const legendItems = computed(() => {
   graphVersion.value;  /* reactive dependency */
+  uiStore.isDark;       /* re-evaluate when dark mode toggles (color depends on it) */
+  mutedTypes.value;     /* re-evaluate when mute set changes */
   const typeMap = new Map<string, { type: string; label: string; color: string; count: number }>();
   for (const link of links) {
     /* Per-type color (with override) so e.g. 'see' and 'references' differ */
@@ -1261,6 +1286,18 @@ const legendItems = computed(() => {
     }
     typeMap.get(key)!.count++;
   }
+  /* Synthetic entry for PartitiveRelations (hyperedge rake bundles).
+     These don't appear in `links` (they're rendered separately), so we
+     inject a legend entry when any are present. */
+  const partitiveCount = props.partitiveRelations?.length ?? 0;
+  if (partitiveCount > 0) {
+    typeMap.set('__partitive__', {
+      type: '__partitive__',
+      label: 'partitive relation',
+      color: uiStore.isDark ? '#2dd4bf' : '#0d9488',
+      count: partitiveCount,
+    });
+  }
   return Array.from(typeMap.values()).sort((a, b) => b.count - a.count);
 });
 
@@ -1285,6 +1322,9 @@ function toggleRegister(reg: string) {
   renderDOM();
   const c = canvasRef.value;
   if (c) drawEdges(c.clientWidth / 2, c.clientHeight * 0.46);
+  /* Re-heat the simulation so nodes "feel" the freed/hidden edges and
+     drift to a new equilibrium instead of staying frozen. */
+  if (sim) sim.alpha(0.5).restart();
 }
 
 async function changeDegree(d: 1 | 2 | 3) {
@@ -1402,6 +1442,10 @@ function toggleType(type: string) {
   mutedTypes.value = n;
   const c = canvasRef.value;
   if (c) drawEdges(c.clientWidth / 2, c.clientHeight * 0.46);
+  /* Re-heat the simulation so nodes drift to a new equilibrium with
+     the freed/hidden edges. The link force reads mutedTypes each tick,
+     so toggling effectively "removes" the edge from the force calc. */
+  if (sim) sim.alpha(0.5).restart();
 }
 
 function isTypeMuted(type: string): boolean {
@@ -1574,9 +1618,12 @@ defineExpose({ navigate });
           <div class="sp-section-label">{{ t('sphere.relationTypes') }}</div>
           <div class="sp-legend-grid">
             <button v-for="item in legendItems" :key="item.type" class="sp-legend-item"
-              :class="{ muted: isTypeMuted(item.type) }" @click="toggleType(item.type)"
+              :class="{ muted: isTypeMuted(item.type), 'is-partitive': item.type === '__partitive__' }"
+              @click="toggleType(item.type)"
               :title="item.type">
-              <span class="sp-swatch" :style="{ background: isTypeMuted(item.type) ? '#b8b9cc' : item.color }"></span>
+              <span v-if="item.type === '__partitive__'" class="sp-swatch sp-swatch-rake"
+                :style="{ '--rake-color': isTypeMuted(item.type) ? '#b8b9cc' : item.color }"></span>
+              <span v-else class="sp-swatch" :style="{ background: isTypeMuted(item.type) ? '#b8b9cc' : item.color }"></span>
               <span>{{ item.label }}</span>
               <span class="sp-count">{{ item.count }}</span>
             </button>
@@ -1825,6 +1872,26 @@ defineExpose({ navigate });
 .sp-legend-item:hover { background: var(--rule); }
 .sp-legend-item.muted { opacity: 0.35; }
 .sp-swatch { width: 18px; height: 2px; flex-shrink: 0; border-radius: 1px; }
+/* Rake swatch — small bracket icon signaling a PartitiveRelation hyperedge
+   (not a single binary edge). Two parallel solid lines (close-set double)
+   with a perpendicular stem, evoking the ISO 704 rake convention. */
+.sp-swatch-rake {
+  width: 18px; height: 10px; position: relative; background: transparent !important;
+  border-radius: 0;
+}
+.sp-swatch-rake::before,
+.sp-swatch-rake::after {
+  content: ''; position: absolute; background: var(--rake-color, #0d9488);
+}
+.sp-swatch-rake::before {
+  /* horizontal spine (close-set double line) */
+  left: 4px; right: 0; top: 3px; height: 1.5px;
+  box-shadow: 0 3px 0 var(--rake-color, #0d9488);
+}
+.sp-swatch-rake::after {
+  /* vertical stem from top of swatch to spine */
+  left: 4px; width: 1.5px; top: 0; height: 4px;
+}
 .sp-count { margin-left: auto; font-family: 'JetBrains Mono', monospace; font-size: 10px; }
 
 .sp-preview {

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

@@ -1,19 +1,18 @@
 import { computed, type ComputedRef } from 'vue';
 import type { Router } from 'vue-router';
+// glossarist 0.4.24's top-level d.ts is incomplete for v3 model fields
+// (multiplicity + is_delimiting). Import the v3-augmented types from
+// glossarist/models (extended by src/adapters/non-verbal/glossarist-augment.d.ts).
+import type { Concept, RelatedConcept, ConceptRef } from 'glossarist';
 import type {
-  Concept,
-  RelatedConcept,
   PartitiveRelation as GlsPartitiveRelation,
   PartitiveMember as GlsPartitiveMember,
-  TypeSharedPlurality as GlsTypeSharedPlurality,
-  ConceptRef,
-} from 'glossarist';
+} from 'glossarist/models';
 import type {
   Manifest,
   GraphEdge,
   PartitiveRelationWire,
   PartitiveMemberWire,
-  TypeSharedPluralityWire,
 } from '../adapters/types';
 import { getFactory } from '../adapters/factory';
 import { conceptUri } from '../adapters/model-bridge';
@@ -24,6 +23,7 @@ import { categorizeRelationship, relationshipLabel, INVERSE_RELATIONSHIPS } from
 import { langLabel } from '../utils/lang';
 import { escapeAttr } from '../utils/escape';
 import { useI18n } from '../i18n';
+import type { PartitiveMultiplicity } from '../utils/partitive-multiplicity';
 
 export interface EdgeDisplay {
   uri: string;
@@ -190,7 +190,11 @@ export function useConceptEdges(
           .map((m: GlsPartitiveMember): PartitiveMemberWire | null => {
             const uri = resolveConceptRefUri(m.ref);
             if (!uri || uri === source) return null;
-            return { uri, certainty: m.certainty };
+            return {
+              uri,
+              multiplicity: readMultiplicity(m),
+              isDelimiting: readIsDelimiting(m),
+            };
           })
           .filter((m: PartitiveMemberWire | null): m is PartitiveMemberWire => m !== null);
         if (partitives.length === 0) return null;
@@ -200,7 +204,6 @@ export function useConceptEdges(
           comprehensive,
           partitives,
           completeness: rel.completeness,
-          plurality: projectPlurality(rel.plurality),
           criterion: rel.criterion ?? undefined,
           register: registerId.value,
         };
@@ -208,24 +211,21 @@ export function useConceptEdges(
       .filter((r: PartitiveRelationWire | null): r is PartitiveRelationWire => r !== null);
   });
 
-  function projectPlurality(p: GlsTypeSharedPlurality | null): TypeSharedPluralityWire | null {
-    if (!p) return null;
-    const sharedTypeRef: ConceptRef | null = p.sharedType;
-    const sharedType = sharedTypeRef
-      ? [sharedTypeRef.source, sharedTypeRef.id].filter(Boolean).join(':') || null
-      : null;
-    return {
-      isShared: p.isShared,
-      isUncertain: p.isUncertain,
-      sharedType,
-    };
-  }
-
   function resolveConceptRefUri(ref: ConceptRef | null): string | null {
     if (!ref) return null;
     return resolveRefUri({ source: ref.source ?? null, id: ref.id ?? null });
   }
 
+  // glossarist 0.4.24 carries multiplicity + is_delimiting natively on
+  // PartitiveMember. Read them directly — no migration adapter needed.
+  function readMultiplicity(m: GlsPartitiveMember): PartitiveMultiplicity {
+    return m.multiplicity;
+  }
+
+  function readIsDelimiting(m: GlsPartitiveMember): boolean {
+    return m.is_delimiting;
+  }
+
   function resolveRefUri(ref: { source: string | null; id: string | null } | null): string | null {
     const target = resolveRelatedRef(ref);
     if (!target) return null;

package/src/utils/partitive-multiplicity.ts

@@ -0,0 +1,106 @@
+/**
+ * ISO 704:2022 §5.5.4.2 — partitive multiplicity + delimiting model.
+ *
+ * Multiplicity (5 values) encodes part-count semantics:
+ *   - compulsory          : exactly one, required
+ *   - optional            : zero or one
+ *   - compulsory_multiple : two or more, required
+ *   - optional_multiple   : zero or more
+ *   - compulsory_at_least_one        : one or more (required, count unknown)
+ *
+ * Delimiting (boolean) is orthogonal — a delimiting part behaves like a
+ * delimiting characteristic in generic relations: it distinguishes the
+ * comprehensive concept from coordinate concepts. Visual encoding:
+ * 3× stroke width (4.5 px vs 1.5 px).
+ *
+ * Adding a new multiplicity value = add one entry to PARTITIVE_MULTIPLICITY.
+ * Renderers consume RakeStrokeStyle via rakeStrokeStyle(); never inspect
+ * the raw multiplicity string. OCP + MECE + DRY.
+ */
+
+export const PARTITIVE_MULTIPLICITY = {
+  compulsory:           { lines: 1, pattern: 'solid',  label: 'Compulsory' },
+  optional:             { lines: 1, pattern: 'dashed',  label: 'Optional' },
+  compulsory_multiple:  { lines: 2, pattern: 'solid',  label: 'Compulsory multiple' },
+  optional_multiple:    { lines: 2, pattern: 'dashed',  label: 'Optional multiple' },
+  compulsory_at_least_one:         { lines: 2, pattern: 'mixed',   label: 'At least one' },
+} as const;
+
+export type PartitiveMultiplicity = keyof typeof PARTITIVE_MULTIPLICITY;
+
+export const PARTITIVE_MULTIPLICITY_VALUES: readonly PartitiveMultiplicity[] =
+  Object.keys(PARTITIVE_MULTIPLICITY) as PartitiveMultiplicity[];
+
+export function isPartitiveMultiplicity(value: unknown): value is PartitiveMultiplicity {
+  return typeof value === 'string' && value in PARTITIVE_MULTIPLICITY;
+}
+
+export type LinePattern = 'solid' | 'dashed' | 'mixed';
+
+export interface MultiplicityDefinition {
+  /** Number of parallel lines used to render the multiplicity. */
+  readonly lines: 1 | 2;
+  /** Dash pattern: solid, dashed, or mixed (one solid + one dashed). */
+  readonly pattern: LinePattern;
+  /** Human-readable label for legends and badges. */
+  readonly label: string;
+}
+
+export function multiplicityDefinition(m: PartitiveMultiplicity): MultiplicityDefinition {
+  return PARTITIVE_MULTIPLICITY[m];
+}
+
+// ── RakeStrokeStyle — the render-ready form consumed by all renderers ────
+
+export interface RakeStrokeStyle {
+  /** 1 or 2 parallel lines. */
+  readonly lineCount: 1 | 2;
+  /** Primary (always-present) line dash. */
+  readonly primaryDashed: boolean;
+  /** Secondary line dash (only meaningful when lineCount === 2). */
+  readonly secondaryDashed: boolean;
+  /** Stroke width in px. 1.5 normal, 4.5 (3×) when is_delimiting. */
+  readonly strokeWidth: number;
+}
+
+export const NORMAL_STROKE_WIDTH = 1.5;
+export const DELIMITING_STROKE_WIDTH = 4.5;   // 3× normal per ISO 704
+
+/**
+ * Compute the render-ready stroke style for a partitive member.
+ *
+ * Pure function — same inputs always yield the same RakeStrokeStyle.
+ * Consumed by both the sidebar rake diagram (PartitiveRelationDiagram)
+ * and the sphere rake bundles (RelationSphere.drawRakeBundles).
+ */
+export function rakeStrokeStyle(
+  multiplicity: PartitiveMultiplicity,
+  isDelimiting: boolean,
+): RakeStrokeStyle {
+  const def = PARTITIVE_MULTIPLICITY[multiplicity];
+  return {
+    lineCount: def.lines,
+    primaryDashed: def.pattern === 'dashed',
+    secondaryDashed: def.pattern === 'dashed' || def.pattern === 'mixed',
+    strokeWidth: isDelimiting ? DELIMITING_STROKE_WIDTH : NORMAL_STROKE_WIDTH,
+  };
+}
+
+// ── Migration from glossarist 0.4.20 certainty → ISO 704 multiplicity ────
+
+/**
+ * glossarist 0.4.20 carries per-member `certainty: 'confirmed' | 'possible'`
+ * (a v0.4 abstraction that conflated "this member exists" with "we're sure
+ * about it"). ISO 704:2022 replaces that with the multiplicity enum.
+ *
+ * Until glossarist publishes native multiplicity support, this helper maps
+ * the legacy field to the closest ISO 704 multiplicity:
+ *   - confirmed → compulsory
+ *   - possible  → optional
+ *
+ * Once glossarist publishes multiplicity natively, the bridge can read
+ * it directly and this helper can be deleted.
+ */
+export function multiplicityFromCertainty(certainty: 'confirmed' | 'possible' | null | undefined): PartitiveMultiplicity {
+  return certainty === 'possible' ? 'optional' : 'compulsory';
+}