@jbrowse/bandage-core 10.2.2 → 10.2.3

package/dist/chunks/{chunk-TICYLD5F.js → chunk-7CC7N3XC.js}

@@ -1,32 +1,24 @@
 import {
   layoutEngine
-} from "./chunk-DT2GGH4D.js";
+} from "./chunk-JMABOQWL.js";
 import {
   layoutModeByValue
-} from "./chunk-4R6QNG23.js";
+} from "./chunk-WL6ZKUVC.js";
 import {
   parseRegion
-} from "./chunk-FLFBYSJO.js";
-import {
-  layoutGeometryInputs
-} from "./chunk-LOCJN3BZ.js";
+} from "./chunk-VQWHMWLF.js";
 import {
   version
-} from "./chunk-EYK7DJZV.js";
+} from "./chunk-J5FWKGOY.js";
 import {
   axisScaleOf
-} from "./chunk-L5WF4ZPS.js";
-import {
-  facetLifts,
-  walkLift
-} from "./chunk-R456ME6J.js";
+} from "./chunk-BS4UZ44I.js";
 import {
   walkKey
-} from "./chunk-2LQ5BWT7.js";
+} from "./chunk-4ETPXDO6.js";
 import {
-  buildGeometry,
-  computeReferenceRamp
-} from "./chunk-SBMJNRTV.js";
+  figureScene
+} from "./chunk-D5D36ZF6.js";
 import {
   abgrAlpha,
   abgrBlue,
@@ -34,32 +26,16 @@ import {
   abgrRed
 } from "./chunk-G2FD7S3C.js";
 import {
-  pathLegend,
-  walkLabelsOf
-} from "./chunk-TWRLC3KK.js";
-import {
-  drawingBounds,
   engineSettingsOf,
   fitTransform,
   forceLayout,
   loadGraph
-} from "./chunk-XTCNEKO5.js";
-import {
-  referenceLabel
-} from "./chunk-RAKOB6IV.js";
-import {
-  resolveColorScheme
-} from "./chunk-JKJWSY4V.js";
-import {
-  deletionDrawing,
-  deletionEdges
-} from "./chunk-N6FECAXP.js";
+} from "./chunk-2QLLQJ72.js";
 import {
   isBackbone
 } from "./chunk-FYQWPEEY.js";
 import {
-  facetCells,
-  facetSettingOf
+  facetCells
 } from "./chunk-XV4P5KEQ.js";
 
 // src/figureData.ts
@@ -85,39 +61,24 @@ function figureData(graph, layout, o = {}) {
   }
   const width = o.width ?? 1200;
   const height = o.height ?? 800;
-  const region = o.region;
   const pixelRows = layout.pixelRows ?? false;
-  const bounds = drawingBounds(layout, {
-    region: o.fitToDrawing ? void 0 : region
-  });
+  const {
+    bounds,
+    colorScheme,
+    drawnDeletions,
+    lift,
+    facet,
+    panels: facetted,
+    labelOf,
+    referenceName,
+    reference,
+    geometry
+  } = figureScene(graph, layout, o);
   const fit = fitTransform(bounds, width, height, pixelRows);
   if (!fit) {
     throw new Error("the layout drew nothing to fit");
   }
   const axis = axisScaleOf(fit.scale, pixelRows);
-  const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
-  const colorScheme = resolveColorScheme(o.colorScheme ?? "auto", graph);
-  const rampDomain = o.colorDomain ?? region;
-  const referenceRamp = colorScheme === "reference-position" ? computeReferenceRamp(graph, rampDomain) : void 0;
-  const drawnDeletions = deletionDrawing(
-    graph,
-    deletionEdges(graph),
-    o.showDeletionEdges
-  );
-  const layers = o.walks ?? [];
-  const walkRamp = layers.some((l) => l.color?.field === "reference") ? referenceRamp ?? computeReferenceRamp(graph, rampDomain) : void 0;
-  const lift = layers.length > 0 ? walkLift(graph, layers, walkRamp) : void 0;
-  const facet = facetSettingOf(o.facet);
-  const facetted = facet.field && lift && lift.walks.length > 1 ? facetLifts(graph, lift, layers, walkRamp) : void 0;
-  const labels = walkLabelsOf(
-    graph.paths?.length ? pathLegend(graph.paths) : []
-  );
-  const labelOf = (name) => labels.get(name) ?? name;
-  const referenceName = o.referenceName ?? referenceLabel(graph, region);
-  const reference = lift?.referenceDomain && {
-    ...lift.referenceDomain,
-    name: referenceName
-  };
   const panels = [];
   if (facetted) {
     const place = facetCells(
@@ -178,20 +139,7 @@ function figureData(graph, layout, o = {}) {
     "alpha"
   ]);
   for (const { highlight, name: panel } of panels) {
-    const batch = buildGeometry({
-      ...layoutGeometryInputs(layout, drawnDeletions),
-      graph,
-      nodeById,
-      colorScheme,
-      contigThickness: o.contigThickness ?? 6,
-      connectorThickness: o.connectorThickness ?? 2,
-      drawPaths: false,
-      nodeWidth: o.nodeWidth ?? "depth",
-      linearLayout: o.linearLayout,
-      highlight,
-      axis,
-      referenceRamp
-    });
+    const batch = geometry(highlight, axis);
     for (const [node, run] of batch.nodeStrokeRuns) {
       for (let i = run.start; i < run.start + run.count; i++) {
         const s = batch.nodeStrokes[i];
@@ -275,18 +223,27 @@ function figureData(graph, layout, o = {}) {
     }
   };
 }
-async function gfaFigureData(text, name, spec = {}) {
-  const region = spec.region ? parseRegion(spec.region) : void 0;
+async function laidOutGraph(text, name, region, spec) {
   const graph = loadGraph(text, name, { referencePath: spec.referencePath });
   const layout = layoutModeByValue(spec.layout ?? "force").run(graph, region) ?? (await forceLayout(graph, engineSettingsOf(spec), layoutEngine)).result;
+  return { graph, layout };
+}
+function walkLayers(walks) {
+  return walks?.map((w) => typeof w === "string" ? { walk: w } : w);
+}
+async function gfaFigureData(text, name, spec = {}) {
+  const region = spec.region ? parseRegion(spec.region) : void 0;
+  const { graph, layout } = await laidOutGraph(text, name, region, spec);
   return figureData(graph, layout, {
     ...spec,
     region,
-    walks: spec.walks?.map((w) => typeof w === "string" ? { walk: w } : w)
+    walks: walkLayers(spec.walks)
   });
 }
 
 export {
   figureData,
+  laidOutGraph,
+  walkLayers,
   gfaFigureData
 };

package/dist/chunks/{chunk-2CVHXFK7.js → chunk-7SRWJLSC.js}

@@ -206,15 +206,16 @@ function bowAround(p1x, p1y, p2x, p2y, toward, maxBow) {
 function yToXOf({ scaleX, scaleY }) {
   return scaleY / scaleX;
 }
-var PATH_RIBBON_SPACING = 3;
+var PATH_RIBBON_SPACING_PX = 3;
 function drawnDirection(a, b, yToX) {
   const dx = b.x - a.x;
   const dy = (b.y - a.y) * yToX;
   const len = Math.hypot(dx, dy);
   return len === 0 ? void 0 : { x: dx / len, y: dy / len };
 }
-function pathRibbonOffsets(fromSegments, toSegments, count, axis, spacing = PATH_RIBBON_SPACING) {
+function pathRibbonOffsets(fromSegments, toSegments, count, axis) {
   const yToX = yToXOf(axis);
+  const spacing = PATH_RIBBON_SPACING_PX / Math.max(axis.scaleX, 1e-6);
   const dir = drawnDirection(
     fromSegments[fromSegments.length - 1],
     toSegments[0],
@@ -270,15 +271,15 @@ function edgeJoinOf(edge, stranded = false) {
   const sides = strandSides(edge);
   return self === false ? sides : sides.from === sides.to ? sides.from : true;
 }
-function hairpinCurves(attach, reach, offsetX, offsetY) {
+function hairpinCurves(attach, reach) {
   const { at, inward } = attach;
   const dx = inward ? at.x - inward.x : 1;
   const dy = inward ? at.y - inward.y : 0;
   const len = Math.hypot(dx, dy) || 1;
   const ux = dx / len;
   const uy = dy / len;
-  const px = at.x + offsetX;
-  const py = at.y + offsetY;
+  const px = at.x;
+  const py = at.y;
   const nearX = px + ux * reach / 3;
   const nearY = py + uy * reach / 3;
   const apexX = px + ux * reach;
@@ -308,7 +309,7 @@ function hairpinCurves(attach, reach, offsetX, offsetY) {
     }
   ];
 }
-function computeEdgeCurves(fromSegments, toSegments, join, offsetX, offsetY, axis, bypassed = [], maxBowIn) {
+function computeEdgeCurves(fromSegments, toSegments, join, axis, bypassed = [], maxBowIn) {
   const scale = axis.scaleX;
   const yToX = yToXOf(axis);
   const maxBow = maxBowIn ?? (axis.pixelRows ? MAX_ROW_BOW_PX : void 0);
@@ -321,8 +322,6 @@ function computeEdgeCurves(fromSegments, toSegments, join, offsetX, offsetY, axi
         scaleYOf(fromSegments, yToX),
         scaleYOf(toSegments, yToX),
         join,
-        offsetX,
-        offsetY * yToX,
         { scaleX: scale, scaleY: scale },
         scaleYOf(bypassed, yToX),
         // the cap is a y measure and the body works in x units, so it converts
@@ -335,9 +334,7 @@ function computeEdgeCurves(fromSegments, toSegments, join, offsetX, offsetY, axi
   if (typeof join === "string") {
     return hairpinCurves(
       attachment(fromSegments, join),
-      selfLoopReach(fromSegments, scale),
-      offsetX,
-      offsetY
+      selfLoopReach(fromSegments, scale)
     );
   }
   const loop = join === true;
@@ -346,10 +343,10 @@ function computeEdgeCurves(fromSegments, toSegments, join, offsetX, offsetY, axi
   const toAttach = attachment(toSegments, sides.to);
   const fromEnd = fromAttach.at;
   const toStart = toAttach.at;
-  const p1x = fromEnd.x + offsetX;
-  const p1y = fromEnd.y + offsetY;
-  const p2x = toStart.x + offsetX;
-  const p2y = toStart.y + offsetY;
+  const p1x = fromEnd.x;
+  const p1y = fromEnd.y;
+  const p2x = toStart.x;
+  const p2y = toStart.y;
   if (loop) {
     let segDirX = 1;
     let segDirY = 0;
@@ -365,8 +362,8 @@ function computeEdgeCurves(fromSegments, toSegments, join, offsetX, offsetY, axi
     const ext = selfLoopReach(fromSegments, scale);
     const perpX = -segDirY;
     const perpY = segDirX;
-    const midX = (fromEnd.x + toStart.x) / 2 + offsetX + perpX * ext;
-    const midY = (fromEnd.y + toStart.y) / 2 + offsetY + perpY * ext;
+    const midX = (fromEnd.x + toStart.x) / 2 + perpX * ext;
+    const midY = (fromEnd.y + toStart.y) / 2 + perpY * ext;
     const cp1x = p1x + segDirX * ext;
     const cp1y = p1y + segDirY * ext;
     const cp2x = p2x - segDirX * ext;
@@ -441,10 +438,10 @@ function computeEdgeCurves(fromSegments, toSegments, join, offsetX, offsetY, axi
       {
         x0: p1x,
         y0: p1y,
-        cx0: cx1 + offsetX + bulgeX - spreadX,
-        cy0: cy1 + offsetY + bulgeY - spreadY,
-        cx1: cx2 + offsetX + bulgeX + spreadX,
-        cy1: cy2 + offsetY + bulgeY + spreadY,
+        cx0: cx1 + bulgeX - spreadX,
+        cy0: cy1 + bulgeY - spreadY,
+        cx1: cx2 + bulgeX + spreadX,
+        cy1: cy2 + bulgeY + spreadY,
         x1: p2x,
         y1: p2y
       }
@@ -521,7 +518,7 @@ export {
   strandSides,
   bowAround,
   yToXOf,
-  PATH_RIBBON_SPACING,
+  PATH_RIBBON_SPACING_PX,
   pathRibbonOffsets,
   selfLinkOf,
   edgeJoinOf,

package/dist/chunks/{chunk-SBMJNRTV.js → chunk-A4PFFC4Q.js}

@@ -5,17 +5,17 @@ import {
 } from "./chunk-G2FD7S3C.js";
 import {
   baseEdgeCurves
-} from "./chunk-WFB5TXRA.js";
+} from "./chunk-ZY2AFL4Y.js";
 import {
   PATH_LIGHTNESS,
   PATH_SATURATION,
   nameHue,
   pathHueAt
-} from "./chunk-TWRLC3KK.js";
+} from "./chunk-3XSM4OZU.js";
 import {
   meanDepth,
   nodeWidthPx
-} from "./chunk-PBENCR5L.js";
+} from "./chunk-JBCZIBFC.js";
 import {
   referenceMidpoints
 } from "./chunk-ES2N6V56.js";
@@ -25,7 +25,7 @@ import {
   strandSides,
   translateCurves,
   yToXOf
-} from "./chunk-2CVHXFK7.js";
+} from "./chunk-7SRWJLSC.js";
 
 // src/renderer/GeometryBuilder.ts
 var EDGE_DEFAULT_COLOR = packAbgr(119, 119, 119, 217);
@@ -551,25 +551,24 @@ function buildGeometry(options) {
     const edgeColor = !highlight || onWalk ? plainEdgeColor : fadeAbgr(plainEdgeColor, FADED_ALPHA);
     const toNode = nodeById.get(edge.to);
     const intoHalfWidth = (toNode ? nodeWidthPx(toNode, contigThickness, nodeWidth, depthNorm) : contigThickness) / 2;
-    const buildSingleEdge = (offsetX, offsetY, color, arrowColor) => {
-      const curves = offsetX === 0 && offsetY === 0 ? baseCurves : translateCurves(baseCurves, offsetX, offsetY);
-      if (viewportBounds && !isBezierInBounds(curves, viewportBounds)) {
-        return;
-      }
+    const inView = (curves) => !viewportBounds || isBezierInBounds(curves, viewportBounds);
+    const stroke = (curves, thickness, color) => {
       if (isDeletion) {
         for (const dash of dashCurves(curves, DELETION_DASH_PX / scale)) {
-          edgeCurves.push({ curves: dash, thickness: edgeThickness, color });
+          edgeCurves.push({ curves: dash, thickness, color });
         }
       } else {
-        edgeCurves.push({ curves, thickness: edgeThickness, color });
+        edgeCurves.push({ curves, thickness, color });
       }
-      const head = showArrows && arrowColor !== void 0 ? arrowheadFor({
+    };
+    const arrowOn = (curves) => {
+      const head = showArrows ? arrowheadFor({
         curves,
         edgeHalfWidth: connectorThickness / 2,
         nodeHalfWidth: intoHalfWidth,
         scale,
         yToX,
-        color: arrowColor,
+        color: edgeColor,
         fromSegments,
         toSegments
       }) : void 0;
@@ -602,17 +601,22 @@ function buildGeometry(options) {
         }
         const offset = (lane - (laneWalks.length - 1) / 2) * laneWidth * worldPerScreenPx;
         const curves = offset === 0 ? baseCurves : translateCurves(baseCurves, nx * offset, ny * offset / yToX);
-        if (viewportBounds && !isBezierInBounds(curves, viewportBounds)) {
-          return;
+        if (inView(curves)) {
+          stroke(
+            curves,
+            laneWidth / 2,
+            walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor
+          );
         }
-        edgeCurves.push({
-          curves,
-          thickness: laneWidth / 2,
-          color: walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor
-        });
       });
+      if (edgeCurves.length > edgeCurveStart) {
+        arrowOn(baseCurves);
+      }
     } else if (!ribbons) {
-      buildSingleEdge(0, 0, edgeColor, edgeColor);
+      if (inView(baseCurves)) {
+        stroke(baseCurves, edgeThickness, edgeColor);
+        arrowOn(baseCurves);
+      }
     } else {
       const offsets = pathRibbonOffsets(
         fromSegments,
@@ -622,14 +626,20 @@ function buildGeometry(options) {
       );
       const arrowRibbon = Math.floor((numPaths - 1) / 2);
       for (let pathIdx = 0; pathIdx < numPaths; pathIdx++) {
-        const offset = offsets[pathIdx];
+        const { x, y } = offsets[pathIdx];
+        const curves = x === 0 && y === 0 ? baseCurves : translateCurves(baseCurves, x, y);
+        if (!inView(curves)) {
+          continue;
+        }
         const ribbonColor = pathColorByName(edge.pathIds[pathIdx]);
-        buildSingleEdge(
-          offset.x,
-          offset.y,
-          highlight && (highlight.walks.length ? !highlight.names.has(edge.pathIds[pathIdx]) : !onWalk) ? fadeAbgr(ribbonColor, FADED_ALPHA) : ribbonColor,
-          pathIdx === arrowRibbon ? edgeColor : void 0
+        stroke(
+          curves,
+          edgeThickness,
+          highlight && (highlight.walks.length ? !highlight.names.has(edge.pathIds[pathIdx]) : !onWalk) ? fadeAbgr(ribbonColor, FADED_ALPHA) : ribbonColor
         );
+        if (pathIdx === arrowRibbon) {
+          arrowOn(curves);
+        }
       }
     }
     const edgeCurveCount = edgeCurves.length - edgeCurveStart;

package/dist/chunks/{chunk-IW6CYVX2.js → chunk-AR4BUBMU.js}

@@ -1,6 +1,6 @@
 import {
   stableCoordinate
-} from "./chunk-CDLPYR5O.js";
+} from "./chunk-5I3K4R2G.js";
 import {
   pathOrigin,
   surveyPaths
@@ -95,7 +95,12 @@ function convertGFAToGraph(gfaGraph, name = "Imported GFA") {
     }
     return id;
   };
+  const declared = /* @__PURE__ */ new Set();
   for (const gfaNode of gfaGraph.nodes) {
+    if (declared.has(gfaNode.id)) {
+      continue;
+    }
+    declared.add(gfaNode.id);
     const depth = statedDepth(gfaNode) ?? Math.max(traversals.get(gfaNode.id) ?? 1, 1);
     nodes.push(makeNode(gfaNode, canonical.get(gfaNode.id) ?? "+", depth));
   }

package/dist/chunks/{chunk-IUDJKOLB.js → chunk-B6IW3IRE.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-M6LK4GII.js";
 
 // src/tubeMap/draw.ts
-import { curvePaths, nodeOutlinePath } from "@jbrowse/tubemap-core";
+import { curvePaths, flattenPath, nodeOutlinePath } from "@jbrowse/tubemap-core";
 function parsePath(d) {
   const tokens = d.trim().split(/[\s,]+/);
   const commands = [];
@@ -61,7 +61,15 @@ function extentOf(commands) {
 }
 function shapeOf(d, color, id, haplotype, reference) {
   const commands = parsePath(d);
-  return { commands, color, id, haplotype, reference, ...extentOf(commands) };
+  return {
+    commands,
+    outline: flattenPath(d, 12),
+    color,
+    id,
+    haplotype,
+    reference,
+    ...extentOf(commands)
+  };
 }
 function trackColors(layout, pathColors) {
   return new Map(
@@ -302,36 +310,6 @@ function drawMismatches(ctx, marks, frame) {
     }
   }
 }
-function outline(commands, x, y) {
-  const points = [];
-  let cx = 0;
-  let cy = 0;
-  const STEPS = 12;
-  for (const c of commands) {
-    if (c.op === "C" || c.op === "Q") {
-      for (let i = 1; i <= STEPS; i++) {
-        const t = i / STEPS;
-        const u = 1 - t;
-        const [px, py] = c.op === "C" ? [
-          u * u * u * cx + 3 * u * u * t * c.x1 + 3 * u * t * t * c.x2 + t * t * t * c.x,
-          u * u * u * cy + 3 * u * u * t * c.y1 + 3 * u * t * t * c.y2 + t * t * t * c.y
-        ] : [
-          u * u * cx + 2 * u * t * c.x1 + t * t * c.x,
-          u * u * cy + 2 * u * t * c.y1 + t * t * c.y
-        ];
-        points.push([x(px), y(py)]);
-      }
-    }
-    if (c.op !== "Z") {
-      cx = "x" in c ? c.x : cx;
-      cy = "y" in c ? c.y : cy;
-      if (c.op !== "C" && c.op !== "Q") {
-        points.push([x(cx), y(cy)]);
-      }
-    }
-  }
-  return points;
-}
 function inside(points, sx, sy) {
   let hit = false;
   for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
@@ -353,7 +331,11 @@ function tubeMapTrackAt(picture, { x, y }, sx, sy) {
         }
       }
       for (const s of shapes) {
-        if (s.reference === reference && x(s.x0) <= sx && sx <= x(s.x1) && inside(outline(s.commands, x, y), sx, sy)) {
+        if (s.reference === reference && x(s.x0) <= sx && sx <= x(s.x1) && inside(
+          s.outline.map(([px, py]) => [x(px), y(py)]),
+          sx,
+          sy
+        )) {
           return s.id;
         }
       }

package/dist/chunks/{chunk-JUIJI7RC.js → chunk-BAETMD3J.js}

@@ -2,10 +2,13 @@ import {
   alongRow,
   boxesGenes,
   rowPitch
-} from "./chunk-NRV7R36Q.js";
+} from "./chunk-EFQLEGWM.js";
 import {
   el
-} from "./chunk-NNODIW4U.js";
+} from "./chunk-H2H4Y3TV.js";
+import {
+  READOUT_ROOM
+} from "./chunk-54POIBVC.js";
 import {
   pathOrigin
 } from "./chunk-M6LK4GII.js";
@@ -24,7 +27,6 @@ var PAD_PX = 6;
 var WALK_STRIP_CEILING_PX = 260;
 var LABEL_FONT_PX = 11;
 var MIN_ROW_PX = 3;
-var READOUT_ROOM = 1.3;
 var MARK_INK = "#111";
 var TICK_PX = 3;
 function stripMarks(graph, rows, node) {
@@ -59,7 +61,10 @@ function spansOf(graph, name) {
     return byName.get(name);
   }
   const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
-  const pieces = (graph.paths ?? []).filter((p) => p.name === name);
+  const origin = pathOrigin(name).name;
+  const pieces = (graph.paths ?? []).filter(
+    (p) => origin === graph.referencePath ? pathOrigin(p.name).name === origin : p.name === name
+  );
   let spans;
   if (pieces.every((p) => p.start !== void 0)) {
     spans = { ids: [], starts: [], ends: [] };

package/dist/chunks/{chunk-L5WF4ZPS.js → chunk-BS4UZ44I.js}

@@ -1,6 +1,6 @@
 import {
   clampZoom
-} from "./chunk-XTCNEKO5.js";
+} from "./chunk-2QLLQJ72.js";
 
 // src/viewport.ts
 function axisScaleOf(scale, pixelRows) {

package/dist/chunks/{chunk-HNQPEMYE.js → chunk-CM6LO6OC.js}

@@ -292,6 +292,5 @@ function orderedLayout(graph) {
 
 export {
   referenceOrder,
-  layerGraph,
   orderedLayout
 };

package/dist/chunks/{chunk-CLOP7UVD.js → chunk-CQHUZHET.js}

@@ -3,12 +3,20 @@ import {
 } from "./chunk-FX4RDMDN.js";
 import {
   referenceOrder
-} from "./chunk-HNQPEMYE.js";
+} from "./chunk-CM6LO6OC.js";
 import {
   isBackbone
 } from "./chunk-FYQWPEEY.js";
 
 // src/bubbles/bubblesFromGraph.ts
+function relax(best, to, cur, add) {
+  const prev = best.get(to);
+  best.set(to, {
+    min: Math.min(prev?.min ?? Infinity, cur.min + add),
+    max: Math.max(prev?.max ?? -Infinity, cur.max + add),
+    n: Math.min(SATURATED_PATH_COUNT, cur.n + (prev?.n ?? 0))
+  });
+}
 function bubblesFromGraph(graph) {
   if (!graph.nodes.some(isBackbone)) {
     return [];
@@ -61,13 +69,7 @@ function bubblesFromGraph(graph) {
         if (ti > i1) {
           continue;
         }
-        const add = t === end.id ? 0 : byId.get(t).length;
-        const prev = best.get(t);
-        best.set(t, {
-          min: Math.min(prev?.min ?? Infinity, cur.min + add),
-          max: Math.max(prev?.max ?? -Infinity, cur.max + add),
-          n: Math.min(SATURATED_PATH_COUNT, cur.n + (prev?.n ?? 0))
-        });
+        relax(best, t, cur, t === end.id ? 0 : byId.get(t).length);
       }
     }
     const walked = walkIndex && walkRoutes(graph, byId, walkIndex, start.id, end.id);
@@ -167,6 +169,7 @@ function walkRoutes(graph, byId, walkIndex, startId, endId) {
 }
 
 export {
+  relax,
   bubblesFromGraph,
   walkIndexOf,
   walkRoutes

package/dist/chunks/{chunk-R456ME6J.js → chunk-CU6P5RUG.js}

@@ -1,7 +1,7 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-ALDGONEI.js";
+} from "./chunk-VQC7KELB.js";
 import {
   pathOrigin
 } from "./chunk-M6LK4GII.js";
@@ -28,10 +28,14 @@ function walkHighlight(graph, name) {
   const lengthOf = (id) => byId.get(id)?.length ?? 0;
   const bpOf = (path) => path.nodeIds.reduce((sum, id) => sum + lengthOf(id), 0);
   const bp = pieces.reduce((sum, piece) => sum + bpOf(piece), 0);
-  const range = first.start === void 0 ? void 0 : {
+  const extentOf = (ps) => {
+    const start = Math.min(...ps.map((p) => p.start ?? Infinity));
+    return Number.isFinite(start) ? { start, end: Math.max(...ps.map((p) => (p.start ?? 0) + bpOf(p))) } : void 0;
+  };
+  const extent = extentOf(pieces);
+  const range = extent && {
     contig: first.contig ?? panSNContig(pathOrigin(name).name),
-    start: first.start,
-    end: Math.max(...pieces.map((p) => (p.start ?? 0) + bpOf(p)))
+    ...extent
   };
   const span = range ? range.end - range.start : bp;
   const nodeIds = /* @__PURE__ */ new Set();
@@ -59,7 +63,14 @@ function walkHighlight(graph, name) {
     });
   }
   const reference = isReference(graph, name);
-  const referencePieces = reference ? [] : (graph.paths ?? []).filter((p) => isReference(graph, p.name));
+  const referenceSpan = () => {
+    const referencePieces = reference ? [] : (graph.paths ?? []).filter((p) => isReference(graph, p.name));
+    if (referencePieces.length === 0) {
+      return void 0;
+    }
+    const e = extentOf(referencePieces);
+    return e ? e.end - e.start : referencePieces.reduce((sum, piece) => sum + bpOf(piece), 0);
+  };
   return {
     name,
     reference,
@@ -69,7 +80,7 @@ function walkHighlight(graph, name) {
     progress,
     steps: pieces.reduce((sum, piece) => sum + piece.nodeIds.length, 0),
     bp,
-    referenceBp: referencePieces.length > 0 ? referencePieces.reduce((sum, piece) => sum + bpOf(piece), 0) : void 0
+    referenceBp: referenceSpan()
   };
 }
 function laneColors(graph, walk, encoding, ramp) {