@glossarist/concept-browser 0.7.85 → 0.7.87

package/src/components/PartitiveRelationList.vue

@@ -1,25 +1,25 @@
 <script setup lang="ts">
 /**
  * PartitiveRelationList — renders one-to-many partitive decompositions
- * 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 header
- *   - the rake diagram itself (PartitiveRelationDiagram)
+ * as ISO 704 rake diagrams. Each relation card shows:
+ *   - completeness badge (Complete / Partial)
+ *   - the comprehensive's designation as the card title
+ *   - optional criterion as italic text
+ *   - the rake diagram itself (PartitiveRelationDiagram), where each
+ *     drop's line style encodes its multiplicity + is_delimiting per
+ *     ISO 704:2022 (5 multiplicity values × 2 delimiting states).
  *
- * 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).
+ * Header badges communicate metadata that the diagram's line styles
+ * also encode — for users who can't perceive the visual difference
+ * (screen readers, low vision, monochrome displays).
  */
 import type { PartitiveRelationWire, Manifest } from '../adapters/types';
 import { useRouter } from 'vue-router';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { getFactory } from '../adapters/factory';
 import { useI18n, locale } from '../i18n';
-import {
-  completenessLabel,
-  certaintyLabel,
-} from '../utils/partitive-relation-styling';
+import { completenessLabel } from '../utils/partitive-relation-styling';
+import { presenceLabel, countLabel } from '../utils/partitive-multiplicity';
 import PartitiveRelationDiagram, {
   type PartitiveMemberLabeled,
 } from './PartitiveRelationDiagram.vue';
@@ -77,25 +77,25 @@ function criterionText(criterion?: Record<string, string>): string | null {
     ?? null;
 }
 
-function pluralityBadge(plurality: NonNullable<PartitiveRelationWire['plurality']>): string {
-  if (!plurality.isShared) return '';
-  let label = t('partitive.plurality.shared') || 'shared type';
-  if (plurality.isUncertain) {
-    label = `${label} (${t('partitive.plurality.uncertain') || 'uncertain'})`;
-  }
-  if (plurality.sharedType) {
-    label = `${label}: ${plurality.sharedType}`;
-  }
-  return label;
-}
-
+/**
+ * Build a per-member view-model carrying the resolved designation plus
+ * the multiplicity + is_delimiting fields the diagram needs.
+ */
 function labeledMembers(rel: PartitiveRelationWire): PartitiveMemberLabeled[] {
   return rel.partitives.map(m => ({
     uri: m.uri,
     label: designationFor(m.uri),
-    certainty: m.certainty,
+    presence: m.presence,
+    count: m.count,
+    isDelimiting: m.isDelimiting,
   }));
 }
+
+/** Tooltip text for a member, shown on hover. */
+function memberTooltip(m: { presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple'; isDelimiting: boolean }): string {
+  const label = `${presenceLabel(m.presence)} · ${countLabel(m.count).toLowerCase()}`;
+  return m.isDelimiting ? `Delimiting · ${label}` : label;
+}
 </script>
 
 <template>
@@ -113,13 +113,6 @@ function labeledMembers(rel: PartitiveRelationWire): PartitiveMemberLabeled[] {
         <span class="text-[10px] font-mono px-1.5 py-0.5 rounded bg-emerald-200 dark:bg-emerald-800 text-emerald-900 dark:text-emerald-100 uppercase">
           {{ completenessLabel(rel.completeness) }}
         </span>
-        <span
-          v-if="rel.plurality && rel.plurality.isShared"
-          class="text-[10px] font-mono px-1.5 py-0.5 rounded bg-amber-200 dark:bg-amber-800 text-amber-900 dark:text-amber-100 uppercase"
-          :title="pluralityBadge(rel.plurality)"
-        >
-          {{ pluralityBadge(rel.plurality) }}
-        </span>
         <button
           @click="navigate(rel.comprehensive)"
           class="ml-auto text-sm font-medium text-emerald-900 dark:text-emerald-100 hover:underline truncate"
@@ -133,14 +126,14 @@ function labeledMembers(rel: PartitiveRelationWire): PartitiveMemberLabeled[] {
       >
         {{ criterionText(rel.criterion) }}
       </div>
-      <!-- Rake diagram (ISO 704 partitive-relation convention) -->
+      <!-- Rake diagram (ISO 704:2022 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"
+          :member-tooltip="memberTooltip"
           @navigate="navigate"
         />
       </div>

package/src/components/RelationSphere.vue

@@ -25,7 +25,8 @@ import { hashSeed, expandParams, portSide, portPoint, idToUriGet } from '../util
 import { useI18n } from '../i18n';
 
 const { t, locale } = useI18n();
-import type { Concept, Manifest, GraphEdge, PartitiveRelationWire } from '../adapters/types';
+import type { Concept, Manifest, GraphEdge, PartitiveRelationWire, PartitiveMemberWire } from '../adapters/types';
+import { rakeStrokeStyle } from '../utils/partitive-multiplicity';
 import { conceptUri } from '../adapters/model-bridge';
 
 const props = defineProps<{
@@ -760,41 +761,33 @@ function drawEdges(cx: number, cy: number) {
 }
 
 /**
- * Render PartitiveRelations as ISO 704 right-angle rake brackets.
+ * Render PartitiveRelations as ISO 704:2022 rake brackets in the sphere.
  *
- * Each relation renders as a true bracket with 90° angles:
+ * 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]
- *              │
- *              │          ← stem (along stem-axis)
- *              │
- *   ┌──────────●──────────┐   ← spine (perpendicular to stem-axis; right angle at junction)
- *   │          │          │
- *   │          │          │   ← drops (parallel to stem-axis; right angle at each tooth)
- * [p1]       [p2]       [p3]
+ * Per-member multiplicity + is_delimiting is encoded on each DROP via
+ * rakeStrokeStyle() (see utils/partitive-multiplicity.ts):
  *
- * Geometry:
- *   1. stem-axis = direction from comprehensive to centroid of partitives
- *   2. spine-axis = perpendicular to stem-axis
- *   3. spine-center = point along stem-axis at SPINE_FRACTION (60%) from comp
- *   4. For each partitive Pi:
- *        - Project Pi onto spine-axis → tooth position
- *        - Drop goes from tooth straight to Pi (parallel to stem-axis by construction)
+ *   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
  *
- * All bends are exactly 90° because tooth_i is the foot of perpendicular
- * from Pi to the spine line.
- *
- * ISO 704 line conventions:
- *   - default                            : single solid line per segment
- *   - plurality.isShared && !isUncertain : TWO parallel solid lines (close-set)
- *   - plurality.isShared && isUncertain  : one solid + one dashed line
- *   - completeness === 'partial'         : spine extends past last tooth
- *                                           (continued backline — "more exist")
- *
- * Per-member certainty 'possible' → that drop is dashed + reduced opacity
- * (stem and spine keep relation style).
+ * completeness === 'partial'  : spine extends past last tooth (continued
+ *                               backline — "more exist but not shown")
  *
  * 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,
@@ -806,6 +799,7 @@ function drawRakeBundles(
   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'
 
@@ -824,7 +818,7 @@ 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: PartitiveMemberWire; pos: {x: number; y: number} } => x !== null);
 
     if (memberPositions.length === 0) continue;
 
@@ -850,7 +844,14 @@ function drawRakeBundles(
       const along = vx * spineDirX + vy * spineDirY;
       const toothX = spineCx + spineDirX * along;
       const toothY = spineCy + spineDirY * along;
-      return { member, partitivePos: pPos, toothX, toothY, along };
+      return {
+        member,
+        partitivePos: pPos,
+        toothX,
+        toothY,
+        along,
+        style: rakeStrokeStyle(member.presence, member.count, member.isDelimiting),
+      };
     });
 
     // 4. Spine extents (leftmost to rightmost tooth along spine-axis)
@@ -867,23 +868,22 @@ function drawRakeBundles(
     const spineEndX = spineCx + spineDirX * maxAlong;
     const spineEndY = spineCy + spineDirY * maxAlong;
 
-    const isShared = !!rel.plurality?.isShared;
-    const isUncertain = !!rel.plurality?.isUncertain;
-
     /**
-     * Draw a single straight segment with optional parallel offset
-     * (used to render the close-set double line) and dash style.
+     * 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;
       const dx = bx - ax, dy = by - ay;
       const len = Math.hypot(dx, dy) || 1;
-      // Perpendicular to THIS segment (not the spine-axis) for parallel offset
       const px = -dy / len, py = dx / len;
       const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
       line.setAttribute('class', 'rake-seg');
@@ -892,50 +892,35 @@ function drawRakeBundles(
       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('stroke-width', String(opts.width));
       line.setAttribute('opacity', String(opacity));
-      line.setAttribute('stroke-linecap', 'square');   // sharp corners at right angles
+      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 {
-        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 (along stem-axis)
-    drawSegmentWithPlurality(compPos.x, compPos.y, spineCx, spineCy);
+    // 5. Stem: comp → spine center (frame — single solid)
+    drawSegment(compPos.x, compPos.y, spineCx, spineCy, { width: FRAME_STROKE_WIDTH });
 
-    // 6. Spine: leftmost tooth → rightmost tooth (along spine-axis)
-    //     (skip if only one tooth — no horizontal extent)
+    // 6. Spine: leftmost tooth → rightmost tooth (frame — single solid)
     if (Math.abs(maxAlong - minAlong) > 1) {
-      drawSegmentWithPlurality(spineStartX, spineStartY, spineEndX, spineEndY);
+      drawSegment(spineStartX, spineStartY, spineEndX, spineEndY, { width: FRAME_STROKE_WIDTH });
     }
 
-    // 7. Drops: tooth → partitive (parallel to stem-axis by construction)
+    // 7. Drops: tooth → partitive (per-member multiplicity + delimiting)
+    //    Draw 1 or 2 parallel lines per the style.
     for (const tooth of teeth) {
-      drawSegmentWithPlurality(tooth.toothX, tooth.toothY, tooth.partitivePos.x, tooth.partitivePos.y, {
-        opacity: tooth.member.certainty === 'possible' ? 0.5 : 0.85,
-        perMemberPossible: tooth.member.certainty === 'possible',
+      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,
+        });
+      }
     }
 
     // 8. Junction marker at spine center (the right-angle corner)

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

@@ -1,19 +1,18 @@
 import { computed, type ComputedRef } from 'vue';
 import type { Router } from 'vue-router';
+// glossarist-js's top-level d.ts is incomplete for v3 model fields.
+// Import the MECE-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 PartitivePresence, type PartitiveCount } from '../utils/partitive-multiplicity';
 
 export interface EdgeDisplay {
   uri: string;
@@ -190,7 +190,12 @@ 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,
+              presence: readPresence(m),
+              count: readCount(m),
+              isDelimiting: readIsDelimiting(m),
+            };
           })
           .filter((m: PartitiveMemberWire | null): m is PartitiveMemberWire => m !== null);
         if (partitives.length === 0) return null;
@@ -200,7 +205,6 @@ export function useConceptEdges(
           comprehensive,
           partitives,
           completeness: rel.completeness,
-          plurality: projectPlurality(rel.plurality),
           criterion: rel.criterion ?? undefined,
           register: registerId.value,
         };
@@ -208,24 +212,25 @@ 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 });
   }
 
+  // Read presence + count directly from the glossarist-js model
+  // (MECE native, since glossarist 0.4.26).
+  function readPresence(m: GlsPartitiveMember): PartitivePresence {
+    return m.presence;
+  }
+
+  function readCount(m: GlsPartitiveMember): PartitiveCount {
+    return m.count;
+  }
+
+  function readIsDelimiting(m: GlsPartitiveMember): boolean {
+    return m.is_delimiting === true;
+  }
+
   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,99 @@
+/**
+ * ISO 704:2022 §5.5.4.2 — partitive multiplicity model (MECE).
+ *
+ * Two independent axes:
+ *
+ *   presence: 'required' | 'optional'
+ *     Is this part always present?
+ *
+ *   count: 'exactly_one' | 'at_least_one' | 'multiple'
+ *     How many instances?
+ *
+ * 6 combinations, 5 visually distinct (optional + at_least_one
+ * collapses to 2-dashed = same as optional + multiple) and the
+ * invalid combo (optional, at_least_one) is rejected at construction
+ * by glossarist-js.
+ *
+ * Types are re-exported from glossarist-js — the model is the SSOT.
+ * The render-ready `rakeStrokeStyle(presence, count, isDelimiting)`
+ * helper is purely a browser-rendering concern; everything else
+ * (presence, count, is_delimiting fields, MULTIPLICITY name lookup via
+ * multiplicityFromPair, validity via isValidPresence / isValidCount)
+ * comes from `glossarist/models`.
+ */
+
+import {
+  PARTITIVE_PRESENCE,
+  PARTITIVE_COUNT,
+  multiplicityFromPair,
+  isValidPresence,
+  isValidCount,
+  type PartitivePresence,
+  type PartitiveCount,
+} from 'glossarist/models';
+
+// ── Two independent axes (re-exported SSOT) ────────────────────────────
+
+export { PARTITIVE_PRESENCE, PARTITIVE_COUNT };
+export type { PartitivePresence, PartitiveCount };
+export { isValidPresence as isPartitivePresence, isValidCount as isPartitiveCount };
+
+/** ISO 704 name for a (presence, count) pair. Throws on invalid combos. */
+export const partitiveMultiplicityName = multiplicityFromPair;
+
+// ── Render-ready stroke style (rendering-only concern) ─────────────────
+
+export interface RakeStrokeStyle {
+  readonly lineCount: 1 | 2;
+  readonly primaryDashed: boolean;
+  readonly secondaryDashed: boolean;
+  readonly strokeWidth: number;
+}
+
+export const NORMAL_STROKE_WIDTH = 1.5;
+export const DELIMITING_STROKE_WIDTH = 4.5;
+
+/**
+ * Compute the render-ready stroke style.
+ *
+ * Pure function — consumed by both the sidebar rake diagram
+ * (PartitiveRelationDiagram) and the sphere rake bundles
+ * (RelationSphere.drawRakeBundles).
+ *
+ * Derivation:
+ *   presence=required  → primary line is solid
+ *   presence=optional  → primary line is dashed
+ *   count=exactly_one  → 1 line
+ *   count=multiple     → 2 lines, both same style as primary
+ *   count=at_least_one → 2 lines: primary + dashed ("possibly more")
+ */
+export function rakeStrokeStyle(
+  presence: PartitivePresence,
+  count: PartitiveCount,
+  isDelimiting: boolean,
+): RakeStrokeStyle {
+  const primaryDashed = presence === 'optional';
+  const width = isDelimiting ? DELIMITING_STROKE_WIDTH : NORMAL_STROKE_WIDTH;
+
+  if (count === 'exactly_one') {
+    return { lineCount: 1, primaryDashed, secondaryDashed: false, strokeWidth: width };
+  }
+  // multiple or at_least_one
+  const secondaryDashed = count === 'at_least_one' ? true : primaryDashed;
+  return { lineCount: 2, primaryDashed, secondaryDashed, strokeWidth: width };
+}
+
+// ── Human-readable labels (UI concern) ────────────────────────────────
+
+export function presenceLabel(p: PartitivePresence): string {
+  return p === 'optional' ? 'Optional' : 'Required';
+}
+
+export function countLabel(c: PartitiveCount): string {
+  switch (c) {
+    case 'exactly_one': return 'Exactly one';
+    case 'at_least_one': return 'At least one';
+    case 'multiple': return 'Multiple';
+    default: return '';
+  }
+}

package/src/utils/partitive-relation-styling.ts

@@ -1,23 +1,28 @@
 /**
- * Partitive relation styling — colors for one-to-many decompositions.
+ * Partitive relation styling — colors and labels for one-to-many
+ * partitive decompositions.
  *
  * Independent of relationship-categories.ts (which handles binary edges).
- * Partitive relations have their own visual language:
- *   - completeness (complete/partial) affects opacity
- *   - plurality (type-shared, uncertain) adds accent badges
+ * The visual encoding for PartitiveRelation comes from two orthogonal
+ * axes per ISO 704:2022:
  *
- * v2 redesign: replaces v1 hyperedge-styling.ts per
- * concept-model/TODO.partitive-relation-v2.
+ *   1. completeness (complete / partial) — relation-level metadata,
+ *      affects overall opacity. Partial relations have a continued
+ *      backline ("more exist but aren't shown").
+ *   2. multiplicity + is_delimiting (per-member) — see
+ *      partitive-multiplicity.ts for the registry + rakeStrokeStyle().
+ *
+ * This module owns:
+ *   - relation-level color/badge (completeness-driven)
+ *   - human-readable labels for badges
+ *
+ * It does NOT encode multiplicity visuals — those live in
+ * partitive-multiplicity.ts (separated so renderers can consume the
+ * pure rakeStrokeStyle() helper without pulling badge strings).
  */
 
-import type { TypeSharedPluralityWire } from '../adapters/types';
-
 const BASE_LIGHT = '#0d9488';
 const BASE_DARK = '#2dd4bf';
-const ACCENT_SHARED_LIGHT = '#3b82f6';
-const ACCENT_SHARED_DARK = '#60a5fa';
-const ACCENT_UNCERTAIN_LIGHT = '#f59e0b';
-const ACCENT_UNCERTAIN_DARK = '#fbbf24';
 
 export interface PartitiveRelationStyle {
   color: string;
@@ -25,38 +30,24 @@ export interface PartitiveRelationStyle {
   opacity: number;
 }
 
+/**
+ * Relation-level style (color + opacity) driven by completeness.
+ *
+ * Per-member multiplicity + delimiting rendering is via
+ * `rakeStrokeStyle()` from partitive-multiplicity.ts, not here —
+ * this helper is for the relation's overall frame + header badges.
+ */
 export function partitiveRelationStyle(
   completeness: 'complete' | 'partial',
-  plurality: TypeSharedPluralityWire | null,
   isDark: boolean,
 ): PartitiveRelationStyle {
-  const base = isDark ? BASE_DARK : BASE_LIGHT;
-  const opacity = completeness === 'partial' ? 0.6 : 1.0;
-
-  let badgeClass = 'badge-teal';
-  if (plurality?.isShared) {
-    badgeClass = 'badge-blue';
-    if (plurality.isUncertain) {
-      badgeClass = 'badge-yellow';
-    }
-  }
-
-  return { color: base, badgeClass, opacity };
-}
-
-export function pluralityColor(
-  plurality: TypeSharedPluralityWire,
-  isDark: boolean,
-): string {
-  if (plurality.isUncertain) return isDark ? ACCENT_UNCERTAIN_DARK : ACCENT_UNCERTAIN_LIGHT;
-  if (plurality.isShared) return isDark ? ACCENT_SHARED_DARK : ACCENT_SHARED_LIGHT;
-  return isDark ? BASE_DARK : BASE_LIGHT;
+  return {
+    color: isDark ? BASE_DARK : BASE_LIGHT,
+    badgeClass: 'badge-teal',
+    opacity: completeness === 'partial' ? 0.6 : 1.0,
+  };
 }
 
 export function completenessLabel(completeness: 'complete' | 'partial'): string {
   return completeness === 'partial' ? 'Partial' : 'Complete';
 }
-
-export function certaintyLabel(certainty: 'confirmed' | 'possible'): string {
-  return certainty === 'possible' ? 'Possible' : 'Confirmed';
-}

package/src/views/ConceptView.vue

@@ -5,6 +5,8 @@ import { useVocabularyStore } from '../stores/vocabulary';
 import { conceptUri } from '../adapters/model-bridge';
 import { UriRouter } from '../adapters/UriRouter';
 import type { PartitiveRelationWire, PartitiveMemberWire } from '../adapters/types';
+import type { PartitiveMember } from 'glossarist/models';
+import type { PartitivePresence, PartitiveCount } from '../utils/partitive-multiplicity';
 import ConceptDetail from '../components/ConceptDetail.vue';
 import RelationSphere from '../components/RelationSphere.vue';
 import ShortcutsModal from '../components/ShortcutsModal.vue';
@@ -80,15 +82,15 @@ const partitiveRelationsForSphere = computed<PartitiveRelationWire[]>(() => {
       : null;
     if (!compRef.id || !compTarget) continue;
     const partitives: PartitiveMemberWire[] = rel.partitives
-      .map(member => {
+      .map((member): PartitiveMemberWire | null => {
         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);
+        const uri = UriRouter.buildConceptUri(m.uriBase, activeRegisterId.value, ref.id);
         if (uri === sourceUri) return null;
-        return { uri, certainty: member.certainty };
+        const presence: PartitivePresence = member.presence;
+        const count: PartitiveCount = member.count;
+        const isDelimiting = member.isDelimiting;
+        return { uri, presence, count, isDelimiting };
       })
       .filter((x): x is PartitiveMemberWire => x !== null);
     if (partitives.length === 0) continue;
@@ -97,13 +99,6 @@ const partitiveRelationsForSphere = computed<PartitiveRelationWire[]>(() => {
       comprehensive: compTarget,
       partitives,
       completeness: rel.completeness,
-      plurality: rel.plurality
-        ? {
-            isShared: rel.plurality.isShared,
-            isUncertain: rel.plurality.isUncertain,
-            sharedType: null,
-          }
-        : null,
       register: activeRegisterId.value,
     });
   }