@glossarist/concept-browser 0.7.85 → 0.7.87

package/src/adapters/model-bridge.ts

@@ -25,6 +25,10 @@ import {
   DATE_TYPES,
   ConceptRef,
 } from 'glossarist';
+import {
+  isPartitivePresence,
+  isPartitiveCount,
+} from '../utils/partitive-multiplicity';
 import {
   LetterSymbol,
   GrammarInfo,
@@ -166,20 +170,22 @@ interface JsonLdLocalizedConcept {
 
 interface JsonLdPartitiveMember {
   'gl:ref'?: JsonLdRef;
+  /** ISO 704:2022 MECE: presence (required | optional) */
+  'gl:presence'?: string;
+  /** ISO 704:2022 MECE: count (exactly_one | at_least_one | multiple) */
+  'gl:count'?: string;
+  /** ISO 704:2022: delimiting part (3× stroke width in diagrams) */
+  'gl:isDelimiting'?: boolean;
+  /** Legacy v3 field — one-string multiplicity, split into presence+count */
+  'gl:multiplicity'?: string;
+  /** Legacy v2 field — migrated to presence+count */
   '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;
 }
 
@@ -592,7 +598,23 @@ function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<stri
       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'];
+      // ISO 704:2022 MECE: prefer presence × count from JSON-LD. Fall back
+      // to migrating the legacy one-string `multiplicity` or v2 `certainty`
+      // so data in transit from older glossarist versions still loads.
+      const presence = m['gl:presence'];
+      const count = m['gl:count'];
+      if (isPartitivePresence(presence) && isPartitiveCount(count)) {
+        out.presence = presence;
+        out.count = count;
+      } else {
+        const raw = m['gl:multiplicity'] ?? splitLegacyCertainty(m['gl:certainty']);
+        if (raw) {
+          const parts = splitMultiplicity(raw);
+          out.presence = parts.presence;
+          out.count = parts.count;
+        }
+      }
+      if (m['gl:isDelimiting'] === true) out.is_delimiting = true;
       return out;
     })
     .filter((m): m is Record<string, unknown> => m !== null);
@@ -608,17 +630,6 @@ function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<stri
 
   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'] }
@@ -628,6 +639,24 @@ function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<stri
   return out;
 }
 
+/** Migrate legacy v2 certainty → old v3 multiplicity string. */
+function splitLegacyCertainty(certainty: string | undefined): string | null {
+  if (!certainty) return null;
+  return certainty === 'possible' ? 'optional' : 'compulsory';
+}
+
+/** Split the legacy one-string multiplicity into MECE presence × count. */
+function splitMultiplicity(m: string): { presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple' } {
+  const LEGACY_MAP: Record<string, { presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple' }> = {
+    compulsory:               { presence: 'required', count: 'exactly_one' },
+    optional:                 { presence: 'optional', count: 'exactly_one' },
+    compulsory_multiple:      { presence: 'required', count: 'multiple' },
+    optional_multiple:        { presence: 'optional', count: 'multiple' },
+    compulsory_at_least_one:  { presence: 'required', count: 'at_least_one' },
+  };
+  return LEGACY_MAP[m] ?? { presence: 'required', count: 'exactly_one' };
+}
+
 function conceptFromJsonLd(doc: JsonLdConcept): Concept {
   const id = String(doc['gl:identifier'] ?? doc['@id']?.split('/').pop() ?? '');
   const localizations: Record<string, unknown> = {};

package/src/adapters/non-verbal/glossarist-augment.d.ts

@@ -1,4 +1,4 @@
-// Local module augmentation for glossarist 0.4.2.
+// Local module augmentation for glossarist 0.4.26.
 //
 // Upstream's published src/models/index.d.ts declares ZERO classes for the
 // non-verbal hierarchy (Figure, Table, Formula, FigureImage, NonVerbalEntity,
@@ -9,14 +9,15 @@
 //
 // This file declares the runtime shape so consumer code can be type-checked.
 // DELETE this file when upstream ships proper declarations — tracked by
-// PR glossarist/glossarist-js#31 (targets v0.4.3+).
+// PR glossarist/glossarist-js#31.
 //
-// v2 PartitiveRelation block (below) tracks glossarist 0.4.20 — the runtime
-// exports PartitiveRelation/PartitiveMember/TypeSharedPlurality from
-// src/models/index.js, but the d.ts has not been updated. Remove the v2
-// block when upstream PRs the d.ts changes.
+// v2 PartitiveRelation block (below) tracks glossarist 0.4.26 — the runtime
+// exports PartitiveRelation/PartitiveMember from src/models/index.js, but
+// the d.ts has not been updated. Remove the v2 block when upstream PRs the
+// d.ts changes.
 
 import type { ConceptSource, Citation, GlossaristModel } from 'glossarist';
+import type { PartitivePresence, PartitiveCount } from '../../utils/partitive-multiplicity';
 
 declare module 'glossarist' {
   class RegistrableModel extends GlossaristModel {
@@ -136,8 +137,9 @@ declare module 'glossarist' {
     static fromJSON(data: Record<string, unknown>): BibliographyData;
   }
 
-  // ── v2 PartitiveRelation (glossarist 0.4.20) ────────────────────────────
+  // ── PartitiveRelation (glossarist 0.4.26 — MECE presence × count) ─
   // Runtime exports these from src/models/index.js; d.ts is stale.
+  // (Tracked by PR glossarist/glossarist-js#31.)
 
   type Completeness = 'complete' | 'partial';
   const COMPLETENESS: { readonly COMPLETE: 'complete'; readonly PARTIAL: 'partial' };
@@ -145,52 +147,63 @@ declare module 'glossarist' {
   const DEFAULT_COMPLETENESS: Completeness;
   function isValidCompleteness(value: unknown): value is Completeness;
 
-  type MemberCertainty = 'confirmed' | 'possible';
-  const MEMBER_CERTAINTY: { readonly CONFIRMED: 'confirmed'; readonly POSSIBLE: 'possible' };
-  const MEMBER_CERTAINTY_VALUES: readonly MemberCertainty[];
-  const DEFAULT_MEMBER_CERTAINTY: MemberCertainty;
-  function isValidMemberCertainty(value: unknown): value is MemberCertainty;
+  const PARTITIVE_PRESENCE: { readonly REQUIRED: 'required'; readonly OPTIONAL: 'optional' } & { readonly VALUES: readonly ['required', 'optional'] };
+  type PartitivePresence = (typeof PARTITIVE_PRESENCE.VALUES)[number];
+  const PARTITIVE_PRESENCE_VALUES: readonly PartitivePresence[];
+  const DEFAULT_PRESENCE: PartitivePresence;
+  function isValidPresence(value: unknown): value is PartitivePresence;
 
-  class TypeSharedPlurality extends GlossaristModel {
-    constructor(data?: {
-      isShared?: boolean;
-      is_shared?: boolean;
-      isUncertain?: boolean;
-      is_uncertain?: boolean;
-      sharedType?: ConceptRef;
-      shared_type?: ConceptRef;
-    });
-    readonly isShared: boolean;
-    readonly isUncertain: boolean;
-    readonly sharedType: ConceptRef | null;
-    hasSharedType(): boolean;
-    toJSON(): { is_shared: boolean; is_uncertain?: boolean; shared_type?: ReturnType<ConceptRef['toJSON']> };
-    static fromJSON(data: Record<string, unknown>): TypeSharedPlurality;
+  const PARTITIVE_COUNT: { readonly EXACTLY_ONE: 'exactly_one'; readonly AT_LEAST_ONE: 'at_least_one'; readonly MULTIPLE: 'multiple' } & { readonly VALUES: readonly ['exactly_one', 'at_least_one', 'multiple'] };
+  type PartitiveCount = (typeof PARTITIVE_COUNT.VALUES)[number];
+  const PARTITIVE_COUNT_VALUES: readonly PartitiveCount[];
+  const DEFAULT_COUNT: PartitiveCount;
+  function isValidCount(value: unknown): value is PartitiveCount;
+
+  type Multiplicity =
+    | 'compulsory' | 'optional' | 'compulsory_multiple'
+    | 'optional_multiple' | 'compulsory_at_least_one';
+  const MULTIPLICITY: Record<string, Multiplicity>;
+  const MULTIPLICITY_VALUES: readonly Multiplicity[];
+  const DEFAULT_MULTIPLICITY: Multiplicity;
+  function isValidMultiplicity(value: unknown): value is Multiplicity;
+  function multiplicityFromPair(presence: PartitivePresence, count: PartitiveCount): Multiplicity;
+  function pairFromMultiplicity(name: Multiplicity): { presence: PartitivePresence; count: PartitiveCount };
+
+  interface Concept {
+    readonly partitiveRelations: PartitiveRelation[];
   }
 
-  class PartitiveMember extends GlossaristModel {
-    constructor(data?: { ref?: ConceptRef; certainty?: MemberCertainty });
+  // Re-exposed here so callers importing from the top-level `glossarist`
+  // entry get the MECE-augmented shape, not the stale d.ts type.
+  export class PartitiveMember extends GlossaristModel {
+    constructor(data?: {
+      ref?: ConceptRef;
+      presence?: PartitivePresence;
+      count?: PartitiveCount;
+      is_delimiting?: boolean;
+    });
     readonly ref: ConceptRef;
-    readonly certainty: MemberCertainty;
-    readonly isConfirmed: boolean;
-    readonly isPossible: boolean;
-    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; certainty?: MemberCertainty };
+    readonly presence: PartitivePresence;
+    readonly count: PartitiveCount;
+    readonly is_delimiting: boolean;
+    readonly isRequired: boolean;
+    readonly isOptional: boolean;
+    get isDelimiting(): boolean;
+    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; presence?: PartitivePresence; count?: PartitiveCount; is_delimiting?: boolean };
     static fromJSON(data: Record<string, unknown>): PartitiveMember;
     static identityOf(value: unknown): string;
   }
 
-  class PartitiveRelation extends GlossaristModel {
+  export class PartitiveRelation extends GlossaristModel {
     constructor(data?: {
       comprehensive?: ConceptRef;
       partitives?: PartitiveMember[];
       completeness?: Completeness;
-      plurality?: TypeSharedPlurality;
       criterion?: Record<string, string> | string;
     });
     readonly comprehensive: ConceptRef;
     readonly partitives: PartitiveMember[];
     readonly completeness: Completeness;
-    readonly plurality: TypeSharedPlurality | null;
     readonly criterion: Record<string, string> | null;
     readonly isComplete: boolean;
     readonly isPartial: boolean;
@@ -201,16 +214,11 @@ declare module 'glossarist' {
       comprehensive: ReturnType<ConceptRef['toJSON']>;
       partitives: ReturnType<PartitiveMember['toJSON']>[];
       completeness: Completeness;
-      plurality?: ReturnType<TypeSharedPlurality['toJSON']>;
       criterion?: Record<string, string>;
     };
     static fromJSON(data: Record<string, unknown>): PartitiveRelation;
     static identityOf(value: unknown): string;
   }
-
-  interface Concept {
-    readonly partitiveRelations: PartitiveRelation[];
-  }
 }
 
 // Re-declare the same exports under the 'glossarist/models' subpath so
@@ -223,11 +231,27 @@ declare module 'glossarist/models' {
   export const DEFAULT_COMPLETENESS: Completeness;
   export function isValidCompleteness(value: unknown): value is Completeness;
 
-  export type MemberCertainty = 'confirmed' | 'possible';
-  export const MEMBER_CERTAINTY: { readonly CONFIRMED: 'confirmed'; readonly POSSIBLE: 'possible' };
-  export const MEMBER_CERTAINTY_VALUES: readonly MemberCertainty[];
-  export const DEFAULT_MEMBER_CERTAINTY: MemberCertainty;
-  export function isValidMemberCertainty(value: unknown): value is MemberCertainty;
+  export const PARTITIVE_PRESENCE: { readonly REQUIRED: 'required'; readonly OPTIONAL: 'optional' } & { readonly VALUES: readonly ['required', 'optional'] };
+  export type PartitivePresence = (typeof PARTITIVE_PRESENCE.VALUES)[number];
+  export const PARTITIVE_PRESENCE_VALUES: readonly PartitivePresence[];
+  export const DEFAULT_PRESENCE: PartitivePresence;
+  export function isValidPresence(value: unknown): value is PartitivePresence;
+
+  export const PARTITIVE_COUNT: { readonly EXACTLY_ONE: 'exactly_one'; readonly AT_LEAST_ONE: 'at_least_one'; readonly MULTIPLE: 'multiple' } & { readonly VALUES: readonly ['exactly_one', 'at_least_one', 'multiple'] };
+  export type PartitiveCount = (typeof PARTITIVE_COUNT.VALUES)[number];
+  export const PARTITIVE_COUNT_VALUES: readonly PartitiveCount[];
+  export const DEFAULT_COUNT: PartitiveCount;
+  export function isValidCount(value: unknown): value is PartitiveCount;
+
+  export type Multiplicity =
+    | 'compulsory' | 'optional' | 'compulsory_multiple'
+    | 'optional_multiple' | 'compulsory_at_least_one';
+  export const MULTIPLICITY: Record<string, Multiplicity>;
+  export const MULTIPLICITY_VALUES: readonly Multiplicity[];
+  export const DEFAULT_MULTIPLICITY: Multiplicity;
+  export function isValidMultiplicity(value: unknown): value is Multiplicity;
+  export function multiplicityFromPair(presence: PartitivePresence, count: PartitiveCount): Multiplicity;
+  export function pairFromMultiplicity(name: Multiplicity): { presence: PartitivePresence; count: PartitiveCount };
 
   export class TypeSharedPlurality extends GlossaristModel {
     constructor(data?: {
@@ -246,13 +270,23 @@ declare module 'glossarist/models' {
     static fromJSON(data: Record<string, unknown>): TypeSharedPlurality;
   }
 
+  // ── PartitiveRelation (glossarist 0.4.26 — MECE presence × count) ─
+
   export class PartitiveMember extends GlossaristModel {
-    constructor(data?: { ref?: ConceptRef; certainty?: MemberCertainty });
+    constructor(data?: {
+      ref?: ConceptRef;
+      presence?: PartitivePresence;
+      count?: PartitiveCount;
+      is_delimiting?: boolean;
+    });
     readonly ref: ConceptRef;
-    readonly certainty: MemberCertainty;
-    readonly isConfirmed: boolean;
-    readonly isPossible: boolean;
-    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; certainty?: MemberCertainty };
+    readonly presence: PartitivePresence;
+    readonly count: PartitiveCount;
+    readonly is_delimiting: boolean;
+    readonly isRequired: boolean;
+    readonly isOptional: boolean;
+    get isDelimiting(): boolean;
+    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; presence?: PartitivePresence; count?: PartitiveCount; is_delimiting?: boolean };
     static fromJSON(data: Record<string, unknown>): PartitiveMember;
     static identityOf(value: unknown): string;
   }
@@ -262,13 +296,11 @@ declare module 'glossarist/models' {
       comprehensive?: ConceptRef;
       partitives?: PartitiveMember[];
       completeness?: Completeness;
-      plurality?: TypeSharedPlurality;
       criterion?: Record<string, string> | string;
     });
     readonly comprehensive: ConceptRef;
     readonly partitives: PartitiveMember[];
     readonly completeness: Completeness;
-    readonly plurality: TypeSharedPlurality | null;
     readonly criterion: Record<string, string> | null;
     readonly isComplete: boolean;
     readonly isPartial: boolean;
@@ -279,7 +311,6 @@ declare module 'glossarist/models' {
       comprehensive: ReturnType<ConceptRef['toJSON']>;
       partitives: ReturnType<PartitiveMember['toJSON']>[];
       completeness: Completeness;
-      plurality?: ReturnType<TypeSharedPlurality['toJSON']>;
       criterion?: Record<string, string>;
     };
     static fromJSON(data: Record<string, unknown>): PartitiveRelation;

package/src/adapters/types.ts

@@ -168,20 +168,15 @@ export interface PartitiveRelationWire {
   comprehensive: string;
   partitives: PartitiveMemberWire[];
   completeness: 'complete' | 'partial';
-  plurality: TypeSharedPluralityWire | null;
   criterion?: Record<string, string>;
   register: string;
 }
 
 export interface PartitiveMemberWire {
   uri: string;
-  certainty: 'confirmed' | 'possible';
-}
-
-export interface TypeSharedPluralityWire {
-  isShared: boolean;
-  isUncertain: boolean;
-  sharedType?: string | null;
+  presence: 'required' | 'optional';
+  count: 'exactly_one' | 'at_least_one' | 'multiple';
+  isDelimiting: boolean;
 }
 
 export interface GraphNode {

package/src/components/PartitiveRelationDiagram.vue

@@ -1,46 +1,65 @@
 <script setup lang="ts">
 /**
  * PartitiveRelationDiagram — renders a single PartitiveRelation as an
- * ISO 704 rake/bracket diagram in SVG.
+ * ISO 704:2022 rake/bracket diagram in SVG.
  *
- * Layout (looking top-down):
+ * Layout:
  *
  *            [comprehensive]
  *                   │
- *                   │   ← vertical stem
- *   ┌───────────────┴───────────────┐   ← horizontal spine
+ *                   │   ← stem (always single solid — relation frame)
+ *   ┌───────────────┴───────────────┐   ← spine (always single solid — relation frame)
  *   │               │               │
- *   │               │               │   ← perpendicular drops
+ *   │               │               │   ← drops (per-member multiplicity + delimiting)
  * [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)
+ * Per ISO 704:2022, each drop's line style encodes its multiplicity +
+ * is_delimiting (see utils/partitive-multiplicity.ts for the registry):
+ *
+ *   multiplicity         is_delimiting  visual
+ *   -------------------  --------------  --------------------------------
+ *   compulsory           false           1 solid  @ 1.5px
+ *   compulsory           true            1 solid  @ 4.5px (bold, 3× width)
+ *   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
+ *
+ * completeness === 'partial'  : spine extends past the last tooth
+ *                               (continued backline — "more exist but
+ *                               not shown")
  *
  * 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').
+ * wrap to a second line via tspan.
  */
 import { computed } from 'vue';
-import type { TypeSharedPluralityWire } from '../adapters/types';
+import {
+  rakeStrokeStyle,
+  type PartitivePresence,
+  type PartitiveCount,
+  type RakeStrokeStyle,
+} from '../utils/partitive-multiplicity';
 
 export interface PartitiveMemberLabeled {
   uri: string;
   label: string;
-  certainty: 'confirmed' | 'possible';
+  presence: PartitivePresence;
+  count: PartitiveCount;
+  isDelimiting: boolean;
 }
 
 const props = withDefaults(defineProps<{
   comprehensiveLabel: string;
   partitives: PartitiveMemberLabeled[];
   completeness: 'complete' | 'partial';
-  plurality: TypeSharedPluralityWire | null;
   criterion?: string | null;
+  /** Optional per-member tooltip string. */
+  memberTooltip?: (m: { presence: PartitivePresence; count: PartitiveCount; isDelimiting: boolean }) => string;
 }>(), {
   criterion: null,
 });
@@ -59,29 +78,19 @@ const SPINE_TO_NODE = 32;
 const GAP_X = 16;
 const PADDING_X = 20;
 const PADDING_Y = 14;
-const DOUBLE_GAP = 3;
+const DOUBLE_GAP = 3;             // gap between the two lines of a close-set double
 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';
-});
+const CHAR_W = 6.2;               // approx for 11px sans-serif
+const NODE_TEXT_PAD = 16;
+const FRAME_STROKE_WIDTH = 1.4;   // stem + spine use this width always
 
 /** 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.
- */
+/** Wrap a label to at most 2 lines, breaking on word boundaries. */
 function wrapLabel(text: string, maxCharsPerLine: number): string[] {
   if (text.length <= maxCharsPerLine) return [text];
   const words = text.split(/\s+/);
@@ -89,7 +98,6 @@ function wrapLabel(text: string, maxCharsPerLine: number): 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;
@@ -132,7 +140,12 @@ const layout = computed(() => {
   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 };
+    return {
+      member,
+      x,
+      labelLines,
+      style: rakeStrokeStyle(member.presence, member.count, member.isDelimiting),
+    };
   });
 
   const leftX = partitiveSlots[0]?.x ?? centerX;
@@ -157,19 +170,38 @@ const layout = computed(() => {
   };
 });
 
-function strokeAttr(variant: LineVariant, opacity = 1, override?: 'dash') {
-  const useDash = override === 'dash' || variant === 'solid-plus-dashed';
+/**
+ * Build SVG stroke attributes for the relation frame (stem + spine).
+ *
+ * The frame is structural — always a single solid line at standard
+ * width. Per-member multiplicity + delimiting are encoded on the drops
+ * only (MECE: frame vs drops).
+ */
+const frameStrokeAttrs = computed(() => ({
+  stroke: 'currentColor',
+  'stroke-width': FRAME_STROKE_WIDTH,
+}));
+
+/**
+ * Build SVG stroke attributes for one of a drop's parallel lines.
+ * The drop may have 1 or 2 parallel lines per its multiplicity.
+ */
+function dropStrokeAttrs(style: RakeStrokeStyle, dashed: boolean, opacity = 1) {
   return {
     stroke: 'currentColor',
-    'stroke-width': 1.4,
+    'stroke-width': style.strokeWidth,
     opacity,
-    ...(useDash ? { 'stroke-dasharray': DASH_PATTERN } : {}),
+    ...(dashed ? { 'stroke-dasharray': DASH_PATTERN } : {}),
   };
 }
 
 function emitNav(uri: string) {
   emit('navigate', uri);
 }
+
+function tooltipFor(member: PartitiveMemberLabeled): string | undefined {
+  return props.memberTooltip?.({ presence: member.presence, count: member.count, isDelimiting: member.isDelimiting });
+}
 </script>
 
 <template>
@@ -212,71 +244,53 @@ function emitNav(uri: string) {
       class="text-[9px] italic fill-emerald-800 dark:fill-emerald-200/80"
     >{{ criterion }}</text>
 
-    <!-- Stem (vertical from comprehensive to spine) -->
+    <!-- Stem: comprehensive → spine (single solid frame) -->
     <line
-      v-if="lineVariant === 'single'"
       :x1="layout.centerX" :y1="layout.compY + layout.nodeH / 2"
       :x2="layout.centerX" :y2="layout.spineY"
-      v-bind="strokeAttr('single')"
+      v-bind="frameStrokeAttrs"
     />
-    <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) -->
+    <!-- Spine: leftmost tooth → rightmost tooth (single solid frame;
+         extended for completeness: 'partial') -->
     <line
-      v-if="lineVariant === 'single'"
       :x1="layout.leftX" :y1="layout.spineY"
       :x2="layout.spineEndX" :y2="layout.spineY"
-      v-bind="strokeAttr('single')"
+      v-bind="frameStrokeAttrs"
     />
-    <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">
+      <!-- Primary drop line -->
       <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)"
+        v-bind="dropStrokeAttrs(slot.style, slot.style.primaryDashed)"
+      />
+      <!-- Secondary drop line (only for lineCount === 2; e.g. *_multiple, compulsory_at_least_one) -->
+      <line
+        v-if="slot.style.lineCount === 2"
+        :x1="slot.x + DOUBLE_GAP" :y1="layout.spineY"
+        :x2="slot.x + DOUBLE_GAP" :y2="layout.partY - layout.nodeH / 2"
+        v-bind="dropStrokeAttrs(slot.style, slot.style.secondaryDashed)"
       />
-      <g class="cursor-pointer" @click="emitNav(slot.member.uri)">
+      <g class="cursor-pointer" :title="tooltipFor(slot.member)" @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'
+          :class="slot.style.strokeWidth > 2
+            ? 'fill-emerald-100 dark:fill-emerald-900/50 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"
+          :stroke-width="slot.style.strokeWidth > 2 ? 2.4 : 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'
+          :class="slot.style.strokeWidth > 2
+            ? 'text-[11px] fill-emerald-900 dark:fill-emerald-50 font-medium'
             : 'text-[11px] fill-emerald-900 dark:fill-emerald-100'"
         >
           <tspan