@glossarist/concept-browser 0.7.86 → 0.7.88

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,15 +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 { PartitiveMultiplicity } from '../../utils/partitive-multiplicity';
+import type { PartitivePresence, PartitiveCount } from '../../utils/partitive-multiplicity';
 
 declare module 'glossarist' {
   class RegistrableModel extends GlossaristModel {
@@ -137,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' };
@@ -146,51 +147,49 @@ 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[];
   }
 
-  // ── v3 PartitiveRelation (glossarist 0.4.24 — ISO 704:2022 multiplicity + delimiting) ─
   // Re-exposed here so callers importing from the top-level `glossarist`
-  // entry get the v3-augmented shape, not the stale d.ts type.
+  // entry get the MECE-augmented shape, not the stale d.ts type.
   export class PartitiveMember extends GlossaristModel {
     constructor(data?: {
       ref?: ConceptRef;
-      multiplicity?: PartitiveMultiplicity;
+      presence?: PartitivePresence;
+      count?: PartitiveCount;
       is_delimiting?: boolean;
     });
     readonly ref: ConceptRef;
-    readonly multiplicity: PartitiveMultiplicity;
+    readonly presence: PartitivePresence;
+    readonly count: PartitiveCount;
     readonly is_delimiting: boolean;
-    readonly isConfirmed: boolean;
-    readonly isPossible: boolean;
-    readonly isCompulsory: boolean;
+    readonly isRequired: boolean;
     readonly isOptional: boolean;
     get isDelimiting(): boolean;
-    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; multiplicity?: PartitiveMultiplicity; is_delimiting?: 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;
   }
@@ -225,6 +224,12 @@ declare module 'glossarist' {
 // Re-declare the same exports under the 'glossarist/models' subpath so
 // deep-import callers can use them. Upstream's d.ts is stale on this
 // subpath too.
+//
+// The duplication between the 'glossarist' block above and this block
+// is forced by upstream's broken d.ts (PR glossarist/glossarist-js#31).
+// We cannot `export import` from a local namespace because TypeScript
+// requires `declare module` blocks to be self-contained. When upstream
+// ships proper d.ts, DELETE this entire file.
 declare module 'glossarist/models' {
   export type Completeness = 'complete' | 'partial';
   export const COMPLETENESS: { readonly COMPLETE: 'complete'; readonly PARTIAL: 'partial' };
@@ -232,46 +237,47 @@ 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 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;
-  }
+  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 };
+  // (TypeSharedPlurality removed — superseded by presence/count on
+  // PartitiveMember per MECE refactor. Was dead code.)
 
-  // ── v2 PartitiveRelation (glossarist 0.4.24 — ISO 704:2022 multiplicity + delimiting) ─
+  // ── PartitiveRelation (glossarist 0.4.26 — MECE presence × count) ─
 
   export class PartitiveMember extends GlossaristModel {
     constructor(data?: {
       ref?: ConceptRef;
-      multiplicity?: PartitiveMultiplicity;
+      presence?: PartitivePresence;
+      count?: PartitiveCount;
       is_delimiting?: boolean;
     });
     readonly ref: ConceptRef;
-    readonly multiplicity: PartitiveMultiplicity;
+    readonly presence: PartitivePresence;
+    readonly count: PartitiveCount;
     readonly is_delimiting: boolean;
-    readonly isConfirmed: boolean;
-    readonly isPossible: boolean;
-    readonly isCompulsory: boolean;
+    readonly isRequired: boolean;
     readonly isOptional: boolean;
     get isDelimiting(): boolean;
-    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; multiplicity?: PartitiveMultiplicity; is_delimiting?: 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;
   }

package/src/adapters/types.ts

@@ -174,7 +174,8 @@ export interface PartitiveRelationWire {
 
 export interface PartitiveMemberWire {
   uri: string;
-  multiplicity: 'compulsory' | 'optional' | 'compulsory_multiple' | 'optional_multiple' | 'compulsory_at_least_one';
+  presence: 'required' | 'optional';
+  count: 'exactly_one' | 'at_least_one' | 'multiple';
   isDelimiting: boolean;
 }
 

package/src/components/PartitiveRelationDiagram.vue

@@ -40,14 +40,16 @@
 import { computed } from 'vue';
 import {
   rakeStrokeStyle,
-  type PartitiveMultiplicity,
+  type PartitivePresence,
+  type PartitiveCount,
   type RakeStrokeStyle,
 } from '../utils/partitive-multiplicity';
 
 export interface PartitiveMemberLabeled {
   uri: string;
   label: string;
-  multiplicity: PartitiveMultiplicity;
+  presence: PartitivePresence;
+  count: PartitiveCount;
   isDelimiting: boolean;
 }
 
@@ -57,7 +59,7 @@ const props = withDefaults(defineProps<{
   completeness: 'complete' | 'partial';
   criterion?: string | null;
   /** Optional per-member tooltip string. */
-  memberTooltip?: (m: { multiplicity: PartitiveMultiplicity; isDelimiting: boolean }) => string;
+  memberTooltip?: (m: { presence: PartitivePresence; count: PartitiveCount; isDelimiting: boolean }) => string;
 }>(), {
   criterion: null,
 });
@@ -142,7 +144,7 @@ const layout = computed(() => {
       member,
       x,
       labelLines,
-      style: rakeStrokeStyle(member.multiplicity, member.isDelimiting),
+      style: rakeStrokeStyle(member.presence, member.count, member.isDelimiting),
     };
   });
 
@@ -198,7 +200,7 @@ function emitNav(uri: string) {
 }
 
 function tooltipFor(member: PartitiveMemberLabeled): string | undefined {
-  return props.memberTooltip?.({ multiplicity: member.multiplicity, isDelimiting: member.isDelimiting });
+  return props.memberTooltip?.({ presence: member.presence, count: member.count, isDelimiting: member.isDelimiting });
 }
 </script>
 

package/src/components/PartitiveRelationList.vue

@@ -19,7 +19,7 @@ import { useVocabularyStore } from '../stores/vocabulary';
 import { getFactory } from '../adapters/factory';
 import { useI18n, locale } from '../i18n';
 import { completenessLabel } from '../utils/partitive-relation-styling';
-import { multiplicityDefinition } from '../utils/partitive-multiplicity';
+import { presenceLabel, countLabel } from '../utils/partitive-multiplicity';
 import PartitiveRelationDiagram, {
   type PartitiveMemberLabeled,
 } from './PartitiveRelationDiagram.vue';
@@ -85,15 +85,16 @@ function labeledMembers(rel: PartitiveRelationWire): PartitiveMemberLabeled[] {
   return rel.partitives.map(m => ({
     uri: m.uri,
     label: designationFor(m.uri),
-    multiplicity: m.multiplicity,
+    presence: m.presence,
+    count: m.count,
     isDelimiting: m.isDelimiting,
   }));
 }
 
 /** Tooltip text for a member, shown on hover. */
-function memberTooltip(m: { multiplicity: string; isDelimiting: boolean }): string {
-  const def = multiplicityDefinition(m.multiplicity as Parameters<typeof multiplicityDefinition>[0]);
-  return m.isDelimiting ? `Delimiting ${def.label.toLowerCase()}` : def.label;
+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>
 

package/src/components/RelationSphere.vue

@@ -25,8 +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 { rakeStrokeStyle, type PartitiveMultiplicity } from '../utils/partitive-multiplicity';
+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<{
@@ -818,7 +818,7 @@ function drawRakeBundles(
         const p = pos.get(nid);
         return p ? { member, pos: p } : null;
       })
-      .filter((x): x is { member: { uri: string; multiplicity: PartitiveMultiplicity; isDelimiting: boolean }; 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 +850,7 @@ function drawRakeBundles(
         toothX,
         toothY,
         along,
-        style: rakeStrokeStyle(member.multiplicity, member.isDelimiting),
+        style: rakeStrokeStyle(member.presence, member.count, member.isDelimiting),
       };
     });
 

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

@@ -1,8 +1,8 @@
 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).
+// 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 {
   PartitiveRelation as GlsPartitiveRelation,
@@ -23,7 +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';
+import { type PartitivePresence, type PartitiveCount } from '../utils/partitive-multiplicity';
 
 export interface EdgeDisplay {
   uri: string;
@@ -192,7 +192,8 @@ export function useConceptEdges(
             if (!uri || uri === source) return null;
             return {
               uri,
-              multiplicity: readMultiplicity(m),
+              presence: readPresence(m),
+              count: readCount(m),
               isDelimiting: readIsDelimiting(m),
             };
           })
@@ -216,14 +217,18 @@ export function useConceptEdges(
     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;
+  // 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;
+    return m.is_delimiting === true;
   }
 
   function resolveRefUri(ref: { source: string | null; id: string | null } | null): string | null {

package/src/utils/partitive-multiplicity.ts

@@ -1,106 +1,99 @@
 /**
- * ISO 704:2022 §5.5.4.2 — partitive multiplicity + delimiting model.
+ * ISO 704:2022 §5.5.4.2 — partitive multiplicity model (MECE).
  *
- * 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)
+ * Two independent axes:
  *
- * 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).
+ *   presence: 'required' | 'optional'
+ *     Is this part always present?
  *
- * 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.
+ *   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`.
  */
 
-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[];
+import {
+  PARTITIVE_PRESENCE,
+  PARTITIVE_COUNT,
+  multiplicityFromPair,
+  isValidPresence,
+  isValidCount,
+  type PartitivePresence,
+  type PartitiveCount,
+} from 'glossarist/models';
 
-export function isPartitiveMultiplicity(value: unknown): value is PartitiveMultiplicity {
-  return typeof value === 'string' && value in PARTITIVE_MULTIPLICITY;
-}
-
-export type LinePattern = 'solid' | 'dashed' | 'mixed';
+// ── Two independent axes (re-exported SSOT) ────────────────────────────
 
-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 { PARTITIVE_PRESENCE, PARTITIVE_COUNT };
+export type { PartitivePresence, PartitiveCount };
+export { isValidPresence as isPartitivePresence, isValidCount as isPartitiveCount };
 
-export function multiplicityDefinition(m: PartitiveMultiplicity): MultiplicityDefinition {
-  return PARTITIVE_MULTIPLICITY[m];
-}
+/** ISO 704 name for a (presence, count) pair. Throws on invalid combos. */
+export const partitiveMultiplicityName = multiplicityFromPair;
 
-// ── RakeStrokeStyle — the render-ready form consumed by all renderers ────
+// ── Render-ready stroke style (rendering-only concern) ─────────────────
 
 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
+export const DELIMITING_STROKE_WIDTH = 4.5;
 
 /**
- * Compute the render-ready stroke style for a partitive member.
+ * Compute the render-ready stroke style.
  *
- * Pure function — same inputs always yield the same RakeStrokeStyle.
- * Consumed by both the sidebar rake diagram (PartitiveRelationDiagram)
- * and the sphere rake bundles (RelationSphere.drawRakeBundles).
+ * 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(
-  multiplicity: PartitiveMultiplicity,
+  presence: PartitivePresence,
+  count: PartitiveCount,
   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,
-  };
+  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 };
 }
 
-// ── Migration from glossarist 0.4.20 certainty → ISO 704 multiplicity ────
+// ── Human-readable labels (UI concern) ────────────────────────────────
 
-/**
- * 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';
+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/views/ConceptView.vue

@@ -6,7 +6,7 @@ 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 { PartitiveMultiplicity } from '../utils/partitive-multiplicity';
+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';
@@ -87,9 +87,10 @@ const partitiveRelationsForSphere = computed<PartitiveRelationWire[]>(() => {
         if (!ref?.id) return null;
         const uri = UriRouter.buildConceptUri(m.uriBase, activeRegisterId.value, ref.id);
         if (uri === sourceUri) return null;
-        const multiplicity: PartitiveMultiplicity = member.multiplicity;
+        const presence: PartitivePresence = member.presence;
+        const count: PartitiveCount = member.count;
         const isDelimiting = member.isDelimiting;
-        return { uri, multiplicity, isDelimiting };
+        return { uri, presence, count, isDelimiting };
       })
       .filter((x): x is PartitiveMemberWire => x !== null);
     if (partitives.length === 0) continue;