@glossarist/concept-browser 0.7.85 → 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<{
@@ -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: { uri: string; multiplicity: PartitiveMultiplicity; isDelimiting: boolean }; 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.multiplicity, 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 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';
+}

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 { PartitiveMultiplicity } 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,14 @@ 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 multiplicity: PartitiveMultiplicity = member.multiplicity;
+        const isDelimiting = member.isDelimiting;
+        return { uri, multiplicity, isDelimiting };
       })
       .filter((x): x is PartitiveMemberWire => x !== null);
     if (partitives.length === 0) continue;
@@ -97,13 +98,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,
     });
   }