@diagrammo/dgmo 0.48.2 → 0.50.0

package/dist/{chunk-WVAJFAIA.js → chunk-WWN566I7.js}

@@ -4,12 +4,12 @@ import {
   matchTagBlockHeading,
   stripDefaultModifier,
   tagAttrKey
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-WCUHAQKB.js";
 import {
   extractColor,
   measureIndent,
   parseFirstLine
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-OTAL43EH.js";
 import {
   emit
 } from "./chunk-CXK4DZH3.js";
@@ -22,10 +22,9 @@ var SWIMLANE_DX = {
     chartType: "swimlane",
     title: "Duplicate node",
     message: (p) => `Duplicate node name '${p.name ?? "Foo"}'`,
-    hint: "Every node name must be unique across the diagram \u2014 rename or remove the second declaration.",
+    hint: "Within a lane a node name must be unique \u2014 rename or remove the second declaration (different lanes may reuse a name).",
     example: `swimlane T
 lane L
-L
   Foo
   Foo`
   },
@@ -35,12 +34,23 @@ L
     chartType: "swimlane",
     title: "Unknown node in edge",
     message: (p) => `Edge references unknown node '${p.node ?? "Bar"}'`,
-    hint: "Declare the node under a lane before referencing it in a flow arrow.",
+    hint: "A bare-task target must be declared as a line-head in some lane; delimited endpoints ((\u2026)/<\u2026>/[[\u2026]]) auto-create. Check for a typo, or qualify a cross-lane name as Lane.Node.",
     example: `swimlane T
 lane L
-L
-  Foo
-Foo -> Bar`
+  Foo -> Bar`
+  },
+  AMBIGUOUS_NODE: {
+    code: "E_SWIMLANE_AMBIGUOUS_NODE",
+    severity: "warning",
+    chartType: "swimlane",
+    title: "Ambiguous node reference",
+    message: (p) => `Node '${p.node ?? "Review"}' is declared in more than one lane${p.lanes ? ` (${p.lanes})` : ""} \u2014 qualify it as Lane.${p.node ?? "Review"}`,
+    hint: "Two lanes hold a node with this name. Prefix the reference with its lane (`Customs.Inspect`) to pick one; resolved to the first match otherwise.",
+    example: `swimlane T
+lane Customs
+  Customs.Inspect -> Harbor.Inspect
+lane Harbor
+  Harbor.Inspect`
   },
   UNKNOWN_LANE: {
     code: "E_SWIMLANE_UNKNOWN_LANE",
@@ -205,7 +215,6 @@ function parseSwimlane(content, palette) {
   const tagGroups = [];
   const laneByKey = /* @__PURE__ */ new Map();
   const phaseByKey = /* @__PURE__ */ new Map();
-  const nodeByKey = /* @__PURE__ */ new Map();
   const metaAliasMap = /* @__PURE__ */ new Map();
   const options = {};
   let direction = "LR";
@@ -299,7 +308,7 @@ function parseSwimlane(content, palette) {
       }
       continue;
     }
-    if (indent === 0 && /^lane\s+/i.test(trimmed)) {
+    if (/^lane\s+/i.test(trimmed)) {
       const rest = trimmed.replace(/^lane\s+/i, "").trim();
       const { label, color } = extractColor(
         rest,
@@ -321,39 +330,22 @@ function parseSwimlane(content, palette) {
     }
     if (indent === 0 && !trimmed.startsWith("tag ")) sawContent = true;
   }
-  let currentPhase = null;
-  let currentLane = null;
-  let laneIndent = -1;
-  let currentFlowSource = null;
-  const declareNode = (token, meta, lineNum) => {
-    const parsed = parseNodeToken(token);
-    if (parsed.unsupported) {
-      diagnostics.push(
-        emit(SWIMLANE_DX.UNSUPPORTED, lineNum, { reason: parsed.unsupported })
-      );
-      return;
-    }
-    if (!parsed.label) return;
-    if (!currentLane) {
-      diagnostics.push(
-        emit(SWIMLANE_DX.UNKNOWN_LANE, lineNum, { node: parsed.label })
-      );
-      return;
+  const drafts = [];
+  const draftByKey = /* @__PURE__ */ new Map();
+  const draftsByLabel = /* @__PURE__ */ new Map();
+  const rawEdges = [];
+  const laneKey = (laneId, label) => `${normKey(laneId)}\0${normKey(label)}`;
+  const splitQualifier = (token) => {
+    const t = token.trim();
+    if (/^[<([]/.test(t)) return { rest: t };
+    const dot = t.indexOf(".");
+    if (dot > 0) {
+      const lane = laneByKey.get(normKey(t.slice(0, dot)));
+      if (lane) return { laneId: lane.id, rest: t.slice(dot + 1).trim() };
     }
-    const { label: cleanLabel, color } = extractColor(
-      parsed.label,
-      palette,
-      diagnostics,
-      lineNum
-    );
-    const key = normKey(cleanLabel);
-    if (nodeByKey.has(key)) {
-      diagnostics.push(
-        emit(SWIMLANE_DX.DUPLICATE_NODE, lineNum, { name: cleanLabel })
-      );
-      return;
-    }
-    const tags = {};
+    return { rest: t };
+  };
+  const applyMeta = (draft, meta, lineNum) => {
     for (const [k, v] of Object.entries(meta)) {
       if (k === "note") {
         diagnostics.push(
@@ -380,75 +372,147 @@ function parseSwimlane(content, palette) {
         continue;
       }
       const canonical = metaAliasMap.get(k) ?? k;
-      tags[canonical] = v;
+      draft.tags[canonical] = v;
     }
-    const node = {
+  };
+  const registerDraft = (draft) => {
+    draftByKey.set(laneKey(draft.laneId, draft.label), draft);
+    const nk = normKey(draft.label);
+    (draftsByLabel.get(nk) ?? draftsByLabel.set(nk, []).get(nk)).push(draft);
+    drafts.push(draft);
+  };
+  const mergeDraft = (draft, parsed, color) => {
+    if (draft.shape === "task" && parsed.shape !== "task")
+      draft.shape = parsed.shape;
+    if (draft.event === "none" && parsed.event !== "none")
+      draft.event = parsed.event;
+    if (draft.color === void 0 && color !== void 0) draft.color = color;
+  };
+  const declareInLane = (rawText, laneId, phaseId, bare, lineNum) => {
+    const { token, meta } = splitNodeMeta(rawText);
+    const { rest } = splitQualifier(token);
+    const parsed = parseNodeToken(rest);
+    if (parsed.unsupported) {
+      diagnostics.push(
+        emit(SWIMLANE_DX.UNSUPPORTED, lineNum, { reason: parsed.unsupported })
+      );
+      return null;
+    }
+    if (!parsed.label) return null;
+    const { label: cleanLabel, color } = extractColor(
+      parsed.label,
+      palette,
+      diagnostics,
+      lineNum
+    );
+    const key = laneKey(laneId, cleanLabel);
+    const existing = draftByKey.get(key);
+    if (existing) {
+      if (bare && existing.hasBareDecl) {
+        diagnostics.push(
+          emit(SWIMLANE_DX.DUPLICATE_NODE, lineNum, { name: cleanLabel })
+        );
+        return existing;
+      }
+      mergeDraft(existing, parsed, color);
+      if (bare) existing.hasBareDecl = true;
+      if (existing.phaseId === void 0 && phaseId !== void 0)
+        existing.phaseId = phaseId;
+      applyMeta(existing, meta, lineNum);
+      return existing;
+    }
+    const draft = {
       id: cleanLabel,
       label: cleanLabel,
+      laneId,
+      ...phaseId !== void 0 && { phaseId },
       shape: parsed.shape,
       event: parsed.event,
-      lane: currentLane.id,
-      ...currentPhase && { phase: currentPhase.id },
       ...color !== void 0 && { color },
-      tags,
-      lineNumber: lineNum
+      tags: {},
+      lineNumber: lineNum,
+      hasBareDecl: bare
     };
-    nodes.push(node);
-    nodeByKey.set(key, node);
+    applyMeta(draft, meta, lineNum);
+    registerDraft(draft);
+    return draft;
   };
-  const resolveRef = (token, lineNum) => {
-    const parsed = parseNodeToken(token);
+  const resolveEndpoint = (rawText, laneId, phaseId, lineNum) => {
+    const { token, meta } = splitNodeMeta(rawText);
+    const { laneId: qLane, rest } = splitQualifier(token);
+    const parsed = parseNodeToken(rest);
     if (parsed.unsupported) {
       diagnostics.push(
         emit(SWIMLANE_DX.UNSUPPORTED, lineNum, { reason: parsed.unsupported })
       );
       return null;
     }
-    const { label } = extractColor(parsed.label, palette);
-    const key = normKey(label);
-    const node = nodeByKey.get(key);
-    if (!node) {
+    const { label: cleanLabel } = extractColor(parsed.label, palette);
+    const nk = normKey(cleanLabel);
+    const delimited = parsed.shape !== "task";
+    const finish = (d) => {
+      applyMeta(d, meta, lineNum);
+      return d;
+    };
+    const implicit = (owner) => {
+      const draft = {
+        id: cleanLabel,
+        label: cleanLabel,
+        laneId: owner,
+        ...phaseId !== void 0 && { phaseId },
+        shape: parsed.shape,
+        event: parsed.event,
+        tags: {},
+        lineNumber: lineNum,
+        hasBareDecl: false
+      };
+      applyMeta(draft, meta, lineNum);
+      registerDraft(draft);
+      return draft;
+    };
+    if (qLane) {
+      const hit = draftByKey.get(laneKey(qLane, cleanLabel));
+      if (hit) return finish(hit);
+      if (delimited) return implicit(qLane);
       diagnostics.push(
-        emit(SWIMLANE_DX.UNKNOWN_NODE, lineNum, { node: parsed.label })
+        emit(SWIMLANE_DX.UNKNOWN_NODE, lineNum, {
+          node: `${qLane}.${cleanLabel}`
+        })
       );
       return null;
     }
-    return node.id;
-  };
-  const addChain = (line, lineNum) => {
-    if (line.includes("~>")) {
+    if (laneId) {
+      const own = draftByKey.get(laneKey(laneId, cleanLabel));
+      if (own) return finish(own);
+    }
+    const cands = draftsByLabel.get(nk) ?? [];
+    if (cands.length === 1) return finish(cands[0]);
+    if (cands.length > 1) {
       diagnostics.push(
-        emit(SWIMLANE_DX.UNSUPPORTED, lineNum, {
-          reason: "message flow (~>) is fast-follow"
+        emit(SWIMLANE_DX.AMBIGUOUS_NODE, lineNum, {
+          node: cleanLabel,
+          lanes: cands.map((c) => c.laneId).join(", ")
         })
       );
-      return;
-    }
-    const parts = splitChain(line);
-    if (parts.length < 2) return;
-    const resolved = [];
-    for (let p = 0; p < parts.length; p++) {
-      const text = parts[p].text;
-      if (p === 0 && text === "") {
-        resolved.push(currentFlowSource);
-        continue;
-      }
-      resolved.push(resolveRef(text, lineNum));
-    }
-    for (let p = 0; p < parts.length - 1; p++) {
-      const src = resolved[p];
-      const tgt = resolved[p + 1];
-      const label = parts[p].labelAfter;
-      if (!src || !tgt) continue;
-      edges.push({
-        source: src,
-        target: tgt,
-        ...label !== void 0 && { label },
-        lineNumber: lineNum
-      });
+      return finish(cands[0]);
     }
+    if (delimited && laneId) return implicit(laneId);
+    diagnostics.push(
+      emit(SWIMLANE_DX.UNKNOWN_NODE, lineNum, { node: parsed.label })
+    );
+    return null;
   };
+  let currentPhase = null;
+  let currentLane = null;
+  let laneIndent = -1;
+  let flowSource = null;
   let inTagBlock = false;
+  const openLane = (lane, indent, phased) => {
+    currentLane = lane;
+    laneIndent = indent;
+    if (!phased) currentPhase = null;
+    flowSource = null;
+  };
   for (let i = startIdx; i < rawLines.length; i++) {
     const raw = rawLines[i];
     const lineNum = i + 1;
@@ -458,10 +522,7 @@ function parseSwimlane(content, palette) {
     if (cIdx > 0) trimmed = trimmed.slice(0, cIdx).trim();
     if (!trimmed) continue;
     const indent = measureIndent(raw);
-    if (indent === 0 && /^(lane|direction|tag)\s+/i.test(trimmed)) {
-      inTagBlock = /^tag\s+/i.test(trimmed);
-      continue;
-    }
+    if (indent === 0 && /^direction\s+/i.test(trimmed)) continue;
     if (indent === 0 && /^solid-fill\s*$/i.test(trimmed)) continue;
     if (matchTagBlockHeading(trimmed) && indent === 0) {
       inTagBlock = true;
@@ -469,6 +530,13 @@ function parseSwimlane(content, palette) {
     }
     if (indent === 0) inTagBlock = false;
     if (inTagBlock && indent > 0) continue;
+    if (/^lane\s+/i.test(trimmed)) {
+      const rest = trimmed.replace(/^lane\s+/i, "").trim();
+      const { label } = extractColor(rest, palette);
+      const lane = laneByKey.get(normKey(label));
+      if (lane) openLane(lane, indent, indent > 0);
+      continue;
+    }
     if (indent === 0 && trimmed.startsWith("[") && trimmed.endsWith("]") && !trimmed.startsWith("[[")) {
       const label = trimmed.slice(1, -1).trim();
       if (lanes.length === 0) {
@@ -484,27 +552,115 @@ function parseSwimlane(content, palette) {
       currentPhase = phase;
       currentLane = null;
       laneIndent = -1;
-      currentFlowSource = null;
+      flowSource = null;
       continue;
     }
+    const cl = currentLane;
+    const cp = currentPhase;
+    const laneCtx = cl?.id ?? null;
+    const phaseCtx = cp?.id;
+    const inLane = cl !== null && indent > laneIndent;
     if (trimmed.includes("->") || trimmed.includes("~>")) {
-      addChain(trimmed, lineNum);
+      if (trimmed.includes("~>")) {
+        diagnostics.push(
+          emit(SWIMLANE_DX.UNSUPPORTED, lineNum, {
+            reason: "message flow (~>) is fast-follow"
+          })
+        );
+        continue;
+      }
+      const parts = splitChain(trimmed);
+      if (parts.length < 2) continue;
+      let headText;
+      if (parts[0].text === "") {
+        headText = flowSource;
+      } else {
+        headText = parts[0].text;
+        if (inLane) declareInLane(headText, laneCtx, phaseCtx, false, lineNum);
+      }
+      for (let p = 0; p < parts.length - 1; p++) {
+        const srcText = p === 0 ? headText : parts[p].text;
+        rawEdges.push({
+          srcText,
+          tgtText: parts[p + 1].text,
+          ...parts[p].labelAfter !== void 0 && {
+            label: parts[p].labelAfter
+          },
+          laneId: laneCtx,
+          ...phaseCtx !== void 0 && { phaseId: phaseCtx },
+          inLane,
+          lineNumber: lineNum
+        });
+      }
       continue;
     }
     const laneRef = laneByKey.get(normKey(trimmed));
     if (laneRef && (laneIndent < 0 || indent <= laneIndent)) {
-      currentLane = laneRef;
-      laneIndent = indent;
-      currentFlowSource = null;
+      openLane(laneRef, indent, currentPhase !== null && indent > 0);
+      continue;
+    }
+    if (inLane) {
+      declareInLane(trimmed, laneCtx, phaseCtx, true, lineNum);
+      flowSource = trimmed;
       continue;
     }
     if (indent === 0) {
-      const ref = resolveRef(trimmed, lineNum);
-      if (ref) currentFlowSource = ref;
+      flowSource = trimmed;
       continue;
     }
-    const { token, meta } = splitNodeMeta(trimmed);
-    declareNode(token, meta, lineNum);
+    const { token } = splitNodeMeta(trimmed);
+    const nodeLabel = parseNodeToken(splitQualifier(token).rest).label;
+    diagnostics.push(
+      emit(SWIMLANE_DX.UNKNOWN_LANE, lineNum, { node: nodeLabel })
+    );
+  }
+  const resolvedPairs = [];
+  for (const e of rawEdges) {
+    if (e.srcText === null) continue;
+    const s = resolveEndpoint(e.srcText, e.laneId, e.phaseId, e.lineNumber);
+    const t = resolveEndpoint(e.tgtText, e.laneId, e.phaseId, e.lineNumber);
+    if (!s || !t) continue;
+    resolvedPairs.push({
+      s,
+      t,
+      ...e.label !== void 0 && { label: e.label },
+      lineNumber: e.lineNumber
+    });
+  }
+  const labelCounts = /* @__PURE__ */ new Map();
+  for (const d of drafts)
+    labelCounts.set(
+      normKey(d.label),
+      (labelCounts.get(normKey(d.label)) ?? 0) + 1
+    );
+  const usedIds = /* @__PURE__ */ new Set();
+  for (const d of drafts) {
+    let id = d.label;
+    if ((labelCounts.get(normKey(d.label)) ?? 0) > 1)
+      id = `${d.label}\u241F${d.laneId}`;
+    while (usedIds.has(id)) id = `${id}\u241F`;
+    usedIds.add(id);
+    d.id = id;
+    nodes.push({
+      id,
+      label: d.label,
+      shape: d.shape,
+      event: d.event,
+      lane: d.laneId,
+      ...d.phaseId !== void 0 && { phase: d.phaseId },
+      ...d.color !== void 0 && { color: d.color },
+      tags: d.tags,
+      lineNumber: d.lineNumber
+    });
+  }
+  for (const p of resolvedPairs) {
+    if (p.s.id === p.t.id) continue;
+    edges.push({
+      source: p.s.id,
+      target: p.t.id,
+      ...p.label !== void 0 && { label: p.label },
+      lineNumber: p.lineNumber
+    });
   }
   finalizeAutoTagColors(tagGroups, palette);
   return {
@@ -526,4 +682,4 @@ export {
   SWIMLANE_DIAGNOSTICS,
   parseSwimlane
 };
-//# sourceMappingURL=chunk-WVAJFAIA.js.map
+//# sourceMappingURL=chunk-WWN566I7.js.map

package/dist/{chunk-IPWPWM6R.js → chunk-X2NMFTG3.js}

@@ -8,18 +8,18 @@ import {
   rectsOverlap,
   segmentRectOverlap,
   segmentsCross
-} from "./chunk-PBAHEPLQ.js";
+} from "./chunk-HGN652MU.js";
 import {
   compactNumber,
   computeLegendLayout
-} from "./chunk-YAA6IID3.js";
+} from "./chunk-7UEMZREK.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_Y
 } from "./chunk-A4GOY3PE.js";
 import {
   measureLegendText
-} from "./chunk-QOOUC2J5.js";
+} from "./chunk-HQCHYB5F.js";
 import {
   contrastRatio,
   mix,
@@ -29,7 +29,7 @@ import {
 } from "./chunk-P6T66CCZ.js";
 import {
   tagAttrKey
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-WCUHAQKB.js";
 import {
   resolveColor
 } from "./chunk-TLVIHFRO.js";
@@ -1820,6 +1820,94 @@ function layoutMap(resolvedIn, data, size, opts) {
     const off = bow * 0.5 + Math.sign(bow || 1) * 8;
     return { x: mx + nx * off, y: my + ny * off };
   };
+  const LEG_SAMPLES = 25;
+  const POI_CLEARANCE = 10;
+  const LEG_CLEARANCE = 7;
+  const SHARED_END_RADIUS = 36;
+  const placedLegSamples = [];
+  const sampleLeg = (a, b, curved, bow) => {
+    const pts = [];
+    const dx = b.cx - a.cx;
+    const dy = b.cy - a.cy;
+    const len = Math.hypot(dx, dy) || 1;
+    const px = (a.cx + b.cx) / 2 + -dy / len * bow;
+    const py = (a.cy + b.cy) / 2 + dx / len * bow;
+    for (let i = 0; i < LEG_SAMPLES; i++) {
+      const t = i / (LEG_SAMPLES - 1);
+      if (!curved && bow === 0) {
+        pts.push({ x: a.cx + dx * t, y: a.cy + dy * t });
+      } else {
+        const u = 1 - t;
+        pts.push({
+          x: u * u * a.cx + 2 * u * t * px + t * t * b.cx,
+          y: u * u * a.cy + 2 * u * t * py + t * t * b.cy
+        });
+      }
+    }
+    return pts;
+  };
+  const legPenalty = (pts, fromId, toId) => {
+    let pen = 0;
+    for (const [id, p] of poiScreen) {
+      if (id === fromId || id === toId) continue;
+      let dmin = Infinity;
+      for (const s of pts) {
+        const d = Math.hypot(s.x - p.cx, s.y - p.cy);
+        if (d < dmin) dmin = d;
+      }
+      const clear = p.r + POI_CLEARANCE;
+      if (dmin < clear) pen += (clear - dmin) * 12;
+    }
+    for (const other of placedLegSamples) {
+      const shared = [fromId, toId].filter((id) => id === other.fromId || id === other.toId).map((id) => poiScreen.get(id)).filter((p) => !!p);
+      for (const s of pts) {
+        if (shared.some(
+          (sp) => Math.hypot(s.x - sp.cx, s.y - sp.cy) < SHARED_END_RADIUS
+        )) {
+          continue;
+        }
+        let dmin = Infinity;
+        for (const o of other.pts) {
+          const d = Math.hypot(s.x - o.x, s.y - o.y);
+          if (d < dmin) dmin = d;
+        }
+        if (dmin < LEG_CLEARANCE) pen += 6;
+      }
+    }
+    for (const s of pts) {
+      if (s.x < 0 || s.x > width || s.y < 0 || s.y > height) pen += 20;
+    }
+    return pen;
+  };
+  const chooseArcBow = (a, b, fromId, toId, away) => {
+    const mx = (a.cx + b.cx) / 2;
+    const my = (a.cy + b.cy) / 2;
+    const dx = b.cx - a.cx;
+    const dy = b.cy - a.cy;
+    const len = Math.hypot(dx, dy) || 1;
+    const nx = -dy / len;
+    const ny = dx / len;
+    const def = bowMagnitude(mx, my, nx, ny, 0, len, away);
+    const candidates = [
+      def,
+      -def,
+      def * 1.6,
+      -def * 1.6,
+      def * 2.2,
+      -def * 2.2
+    ];
+    let best = def;
+    let bestPen = Infinity;
+    for (const c of candidates) {
+      const pen = legPenalty(sampleLeg(a, b, true, c), fromId, toId);
+      if (pen < bestPen - 1e-6) {
+        best = c;
+        bestPen = pen;
+      }
+      if (bestPen === 0) break;
+    }
+    return best;
+  };
   const routeLegVals = resolved.routes.flatMap((rt) => rt.legs).map((l) => Number(l.value)).filter((n) => Number.isFinite(n) && n > 0);
   const rlMin = routeLegVals.length ? Math.min(...routeLegVals) : 0;
   const rlMax = routeLegVals.length ? Math.max(...routeLegVals) : 0;
@@ -1838,14 +1926,21 @@ function layoutMap(resolvedIn, data, size, opts) {
       const a = poiScreen.get(leg.fromId);
       const b = poiScreen.get(leg.toId);
       if (!a || !b) continue;
-      const lp = legLabelPoint(a, b, leg.style === "arc", 0, center);
+      const curvedLeg = leg.style === "arc";
+      const chosenBow = curvedLeg ? chooseArcBow(a, b, leg.fromId, leg.toId, center) : 0;
+      const lp = legLabelPoint(a, b, curvedLeg, chosenBow, center);
       const bow = {
-        curved: leg.style === "arc",
-        offset: 0,
+        curved: curvedLeg,
+        offset: chosenBow,
         center,
         labelX: lp.x,
         labelY: lp.y
       };
+      placedLegSamples.push({
+        fromId: leg.fromId,
+        toId: leg.toId,
+        pts: sampleLeg(a, b, curvedLeg, chosenBow)
+      });
       const routeLabelStyle = leg.label !== void 0 ? labelOnFill(fillAt(bow.labelX, bow.labelY)) : void 0;
       const routeVal = Number(leg.value);
       legs.push({
@@ -1894,13 +1989,19 @@ function layoutMap(resolvedIn, data, size, opts) {
       if (!a || !b) return;
       const fanOffset = n > 1 ? (i - (n - 1) / 2) * FAN_STEP : 0;
       const curved = e.style === "arc" || n > 1;
-      const lp = legLabelPoint(a, b, curved, fanOffset);
+      const edgeBow = curved && n === 1 ? chooseArcBow(a, b, e.fromId, e.toId) : fanOffset;
+      const lp = legLabelPoint(a, b, curved, edgeBow);
       const bow = {
         curved,
-        offset: fanOffset,
+        offset: edgeBow,
         labelX: lp.x,
         labelY: lp.y
       };
+      placedLegSamples.push({
+        fromId: e.fromId,
+        toId: e.toId,
+        pts: sampleLeg(a, b, curved, edgeBow)
+      });
       const edgeLabelStyle = e.label !== void 0 ? labelOnFill(fillAt(bow.labelX, bow.labelY)) : void 0;
       const edgeVal = Number(e.meta["width"]);
       legs.push({
@@ -3076,4 +3177,4 @@ export {
   albersSkewFallback,
   layoutMap
 };
-//# sourceMappingURL=chunk-IPWPWM6R.js.map
+//# sourceMappingURL=chunk-X2NMFTG3.js.map