@jbrowse/bandage-core 11.4.0 → 11.6.1

package/dist/chunks/{chunk-JQ52XYD2.js → chunk-BVWMVWLJ.js}

@@ -4,41 +4,41 @@ import {
 import {
   facetLifts,
   walkLift
-} from "./chunk-FRTYQQDI.js";
-import {
-  walkKey
-} from "./chunk-D4ZFRBB4.js";
+} from "./chunk-EVXXFMZ7.js";
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-XSF4RQRP.js";
+} from "./chunk-JGHZ3N34.js";
+import {
+  walkKey
+} from "./chunk-JGQQAUVL.js";
 import {
   walkRowsExtent
-} from "./chunk-TZLEHZVC.js";
+} from "./chunk-P5PBJONQ.js";
 import {
   pathLegend,
   walkLabelsOf
-} from "./chunk-3GP3KT5L.js";
+} from "./chunk-BW2NMXRV.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-EFD753MS.js";
+} from "./chunk-3FWNQNF7.js";
 import {
   drawingBounds
-} from "./chunk-REOWLPH4.js";
+} from "./chunk-7OTWJQGA.js";
 import {
   referenceLabel
-} from "./chunk-234NFZS4.js";
+} from "./chunk-5ORP7EFJ.js";
 import {
   resolveColorScheme
 } from "./chunk-JKJWSY4V.js";
 import {
   deletionDrawing,
   deletionEdges
-} from "./chunk-CGMSKIEO.js";
+} from "./chunk-DV5B5UU7.js";
 import {
   facetCells,
   facetSettingOf
-} from "./chunk-TGUFT6KK.js";
+} from "./chunk-BLUEFYIR.js";
 
 // src/figureScene.ts
 function figureScene(graph, layout, o) {

package/dist/chunks/{chunk-3GP3KT5L.js → chunk-BW2NMXRV.js}

@@ -1,12 +1,12 @@
-import {
-  pathOrigin
-} from "./chunk-B5X2RLJG.js";
 import {
   groupDigits
-} from "./chunk-PFRQBCGC.js";
+} from "./chunk-T3H5ELLA.js";
+import {
+  pathOrigin
+} from "./chunk-3YBP46PB.js";
 import {
   isGenericSample
-} from "./chunk-4XWZNPQ2.js";
+} from "./chunk-2JL2JVZ2.js";
 
 // src/pathColors.ts
 function nameHue(name) {

package/dist/chunks/{chunk-2Q22S52W.js → chunk-C6E6HXP5.js}

@@ -1,3 +1,6 @@
+import {
+  coversGraph
+} from "./chunk-KZMSSPS6.js";
 import {
   bubblesFromGraph,
   derivedBubble,
@@ -5,18 +8,15 @@ import {
   walkIndexOf,
   walkRoutes
 } from "./chunk-RFG42VIO.js";
-import {
-  bubbleSubgraph
-} from "./chunk-PNMJFFNB.js";
-import {
-  coversGraph
-} from "./chunk-E4ZM4OOJ.js";
 import {
   bubbleSegmentIds
-} from "./chunk-A4JDEUAI.js";
+} from "./chunk-SNF2MIEF.js";
+import {
+  bubbleSubgraph
+} from "./chunk-MHZTTLBU.js";
 import {
   strandSides
-} from "./chunk-UBQSRCWR.js";
+} from "./chunk-VACK24HF.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-5I3K4R2G.js → chunk-CFXXFHRK.js}

@@ -57,7 +57,8 @@ function parseGFA(file) {
   };
   for (const rawLine of file.split("\n")) {
     const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-    const type = line.split("	", 1)[0];
+    const tab = line.indexOf("	");
+    const type = tab === -1 ? line : line.slice(0, tab);
     if (type === "H") {
       const [, ...rest] = line.split("	");
       graph.header.push(parseTags(rest));

package/dist/chunks/{chunk-JMABOQWL.js → chunk-CO6RGQAD.js}

@@ -18,13 +18,8 @@ function isLayoutEngineKind(value) {
   return LAYOUT_ENGINE_VALUES.includes(value);
 }
 var layoutEngine = async (request) => {
-  if (request.options.engine === "stress") {
-    const start2 = performance.now();
-    const result2 = stressLayout(request);
-    return { result: result2, duration: performance.now() - start2 };
-  }
   const start = performance.now();
-  const result = await fmmmLayout(request);
+  const result = request.options.engine === "stress" ? stressLayout(request) : await fmmmLayout(request);
   return { result, duration: performance.now() - start };
 };
 

package/dist/chunks/{chunk-M75QPZNJ.js → chunk-D3E7AXBB.js}

@@ -1,20 +1,20 @@
 import {
   tableNodeIds,
   tablePath
-} from "./chunk-B5ARSBOH.js";
-import {
-  pathOrigin
-} from "./chunk-B5X2RLJG.js";
+} from "./chunk-W2YAW36J.js";
 import {
   gapParts
 } from "./chunk-EIY2SKD3.js";
+import {
+  pathOrigin
+} from "./chunk-3YBP46PB.js";
 import {
   groupBy
 } from "./chunk-BSOZW3FC.js";
 import {
   panSNContig,
   panSNSample
-} from "./chunk-4XWZNPQ2.js";
+} from "./chunk-2JL2JVZ2.js";
 
 // src/layout/walkRowRuns.ts
 var RUN_ON_REFERENCE = 1;
@@ -69,8 +69,8 @@ function graphPieces(graph) {
     heads,
     from,
     to,
-    steps,
-    lengths,
+    steps: Int32Array.from(steps),
+    lengths: Int32Array.from(lengths),
     names,
     reference: referenceWalkName(graph)
   };
@@ -92,8 +92,8 @@ function tablePieces(tables, referencePath, visits) {
   }
   return {
     heads,
-    from: kept.map((p) => w.offsets[p]),
-    to: kept.map((p) => w.offsets[p + 1]),
+    from: Int32Array.from(kept, (p) => w.offsets[p]),
+    to: Int32Array.from(kept, (p) => w.offsets[p + 1]),
     steps: w.steps,
     lengths: n.lengths,
     // a visit names its node as the Graph does, which costs a pass over the
@@ -120,24 +120,35 @@ var Columns = class {
   get length() {
     return this.values[0].length;
   }
-  push(...row) {
-    row.forEach((v, i) => this.values[i].push(v));
+  push(a, b, c, d, e) {
+    const v = this.values;
+    v[0].push(a);
+    v[1].push(b);
+    v[2].push(c);
+    v[3].push(d);
+    if (e !== void 0) {
+      v[4].push(e);
+    }
   }
   endRow() {
     this.offsets.push(this.length);
   }
   // the rows in `order`, column i in the array `make[i]` makes
   reorder(order, make) {
-    const columns = make.map((m) => m(this.length));
     const offsets = new Uint32Array(order.length + 1);
-    let at = 0;
     order.forEach((row, i) => {
-      for (let k = this.offsets[row]; k < this.offsets[row + 1]; k++, at++) {
-        columns.forEach((column, c) => {
-          column[at] = this.values[c][k];
-        });
+      offsets[i + 1] = offsets[i] + this.offsets[row + 1] - this.offsets[row];
+    });
+    const columns = make.map((m, c) => {
+      const from = this.values[c];
+      const out = m(this.length);
+      let at = 0;
+      for (const row of order) {
+        for (let k = this.offsets[row]; k < this.offsets[row + 1]; k++) {
+          out[at++] = from[k];
+        }
       }
-      offsets[i + 1] = at;
+      return out;
     });
     return { offsets, columns };
   }
@@ -168,15 +179,23 @@ function walkRowRuns(source, region, o = {}) {
   const walks = groupBy(others, nameOf);
   const spanStart = new Float64Array(names.length).fill(Number.NaN);
   const spanEnd = new Float64Array(names.length);
+  const revisits = /* @__PURE__ */ new Map();
   let reachesBefore = false;
   let reachesAfter = false;
   const cut = region && region.end > region.start ? region : void 0;
   for (const piece of referencePieces) {
     let pos = startOf(piece) ?? 0;
-    for (let s = from[piece]; s < to[piece]; s++) {
+    for (let s = from[piece], stop = to[piece]; s < stop; s++) {
       const node = all[s];
       const len = lengthOf(node);
-      if (Number.isNaN(spanStart[node])) {
+      if (!Number.isNaN(spanStart[node])) {
+        const starts = revisits.get(node);
+        if (starts) {
+          starts.push(pos);
+        } else {
+          revisits.set(node, [spanStart[node], pos]);
+        }
+      } else {
         spanStart[node] = pos;
         spanEnd[node] = pos + len;
         if (cut) {
@@ -241,7 +260,7 @@ function walkRowRuns(source, region, o = {}) {
         stepStart[length++] = end;
       }
       let pos = start2 ?? 0;
-      for (let s = from[piece]; s < to[piece]; s++) {
+      for (let s = from[piece], stop2 = to[piece]; s < stop2; s++) {
         const node = all[s];
         steps[length] = node;
         stepStart[length++] = pos;
@@ -298,8 +317,8 @@ function walkRowRuns(source, region, o = {}) {
       let bestEnd = -Infinity;
       let bestStart = Infinity;
       for (let i = 0; i < length; i++) {
-        if (onReference(i)) {
-          const id = steps[i];
+        const id = steps[i];
+        if (id >= 0 && !Number.isNaN(spanStart[id])) {
           if (spanEnd[id] <= cut.start && spanEnd[id] > bestEnd) {
             bestEnd = spanEnd[id];
             i0 = i;
@@ -334,6 +353,27 @@ function walkRowRuns(source, region, o = {}) {
     let last = -1;
     let lastFlags = 0;
     let lastRef = Number.NaN;
+    let cursor = Number.NaN;
+    const placeOf = (id) => {
+      const starts = revisits.get(id);
+      if (!starts || Number.isNaN(cursor)) {
+        return spanStart[id];
+      }
+      const len = lengthOf(id);
+      let best = starts[0];
+      let bestGap = Infinity;
+      for (const start2 of starts) {
+        const gap = Math.min(
+          Math.abs(start2 - cursor),
+          Math.abs(start2 + len - cursor)
+        );
+        if (gap < bestGap) {
+          best = start2;
+          bestGap = gap;
+        }
+      }
+      return best;
+    };
     const [, runBp, runRef, runFlags] = runs.values;
     for (let k = lo; k < hi; k++) {
       const index = backward ? hi - 1 - (k - lo) : k;
@@ -358,12 +398,12 @@ function walkRowRuns(source, region, o = {}) {
         continue;
       }
       const len = lengthOf(id);
-      const at = spanStart[id];
+      const at = placeOf(id);
       const on = !Number.isNaN(at);
       visits?.push(id, bp2, len, on ? 1 : 0);
       const placed = last >= 0 && !Number.isNaN(lastRef);
       const forward = on && placed && step >= 0 && lastRef + (runBp[last] ?? 0) === at;
-      const back = on && placed && step <= 0 && spanEnd[id] === lastRef;
+      const back = on && placed && step <= 0 && at + len === lastRef;
       if (!on && last >= 0 && !(lastFlags & (RUN_ON_REFERENCE | RUN_GAP))) {
         runBp[last] += len;
       } else if (forward || back) {
@@ -383,7 +423,9 @@ function walkRowRuns(source, region, o = {}) {
         step = 0;
       }
       bp2 += len;
-      if (!on) {
+      if (on) {
+        cursor = step < 0 ? at : at + len;
+      } else {
         offReferenceBp += len;
       }
     }

package/dist/chunks/{chunk-CGMSKIEO.js → chunk-DV5B5UU7.js}

@@ -1,9 +1,12 @@
+import {
+  referenceVisitStarts
+} from "./chunk-3YBP46PB.js";
 import {
   computeEdgeCurves,
   edgeJoinOf,
   routedEdgeCurves,
   strandSides
-} from "./chunk-UBQSRCWR.js";
+} from "./chunk-VACK24HF.js";
 import {
   groupBy
 } from "./chunk-BSOZW3FC.js";
@@ -11,6 +14,9 @@ import {
   firstNodeAtOrAfter,
   isBackbone
 } from "./chunk-RJWPJCIB.js";
+import {
+  partitionPoint
+} from "./chunk-HOAIOEI7.js";
 
 // src/deletionEdges.ts
 var MIN_DELETION_BP = 1;
@@ -70,22 +76,63 @@ function skipsBetween(edge, from, to, forwards) {
   const arrivesLeft = toStrand === (to.stable.strand ?? "+");
   return forwards ? leavesRight && arrivesLeft : !leavesRight && !arrivesLeft;
 }
+function skippedSpan(edge, from, to, startsOf) {
+  let best;
+  for (const a of startsOf(from)) {
+    for (const b of startsOf(to)) {
+      const forwards = a <= b;
+      const span = forwards ? { start: a + from.length, end: b } : { start: b + to.length, end: a };
+      if (skipsBetween(edge, from, to, forwards) && (!best || Math.abs(span.end - span.start) < Math.abs(best.end - best.start))) {
+        best = span;
+      }
+    }
+  }
+  return best;
+}
+var COPY_SWITCH_SHARE = 0.01;
+function repeatCopies(backbone, startsOf) {
+  const bySequence = /* @__PURE__ */ new Map();
+  for (const [refName, nodes] of backbone) {
+    const copies = nodes.flatMap((node) => {
+      const starts = startsOf(node);
+      return starts.slice(1).map((next, i) => ({
+        at: starts[i],
+        copy: next - starts[i]
+      }));
+    });
+    if (copies.length) {
+      bySequence.set(
+        refName,
+        copies.sort((a, b) => a.at - b.at)
+      );
+    }
+  }
+  return bySequence;
+}
+function switchesCopy(copies, start, bp) {
+  if (!copies) {
+    return false;
+  }
+  const i = partitionPoint(copies.length, (k) => copies[k].at < start);
+  const near = [copies[i - 1], copies[i]].filter((c) => c !== void 0).sort((a, b) => Math.abs(a.at - start) - Math.abs(b.at - start))[0];
+  return near !== void 0 && Math.abs(near.at - start) <= near.copy && Math.abs(bp - near.copy) <= near.copy * COPY_SWITCH_SHARE;
+}
 function deletionEdges(graph) {
   const byId = new Map(graph.nodes.map((n) => [n.id, n]));
   const backbone = backboneBySequence(graph);
+  const startsOf = referenceVisitStarts(graph);
+  const copies = repeatCopies(backbone, startsOf);
   const found = [];
   for (let edgeIndex = 0; edgeIndex < graph.edges.length; edgeIndex++) {
     const edge = graph.edges[edgeIndex];
     const from = byId.get(edge.from);
     const to = byId.get(edge.to);
     if (from !== void 0 && to !== void 0 && isBackbone(from) && isBackbone(to) && from.stable.refName === to.stable.refName) {
-      const forwards = from.stable.start <= to.stable.start;
-      const [left, right] = forwards ? [from, to] : [to, from];
-      const start = left.stable.start + left.length;
-      const end = right.stable.start;
-      const bp = end - start;
-      if (bp >= MIN_DELETION_BP && skipsBetween(edge, from, to, forwards)) {
-        const refName = left.stable.refName;
+      const span = skippedSpan(edge, from, to, startsOf);
+      const refName = from.stable.refName;
+      const bp = span ? span.end - span.start : 0;
+      if (span && bp >= MIN_DELETION_BP && !switchesCopy(copies.get(refName), span.start, bp)) {
+        const { start, end } = span;
         found.push({
           edgeIndex,
           from: edge.from,

package/dist/chunks/{chunk-G6UIYQZR.js → chunk-EQDQ7P4Y.js}

@@ -136,13 +136,14 @@ function mergeOverlappingByName(genes) {
   }
   return out;
 }
+var BED_HEADER = /^(#|track\s|browser\s)/;
 function genesFromBed(text) {
   const rows = [];
   for (const line of text.split("\n")) {
     const cols = line.replace(/\r$/, "").split("	");
     const start = Number(cols[1]);
     const end = Number(cols[2]);
-    if (/^(#|track|browser)/.test(line) || cols.length < 3 || !Number.isInteger(start) || !(end > start)) {
+    if (BED_HEADER.test(line) || cols.length < 3 || !Number.isInteger(start) || !(end > start)) {
       continue;
     }
     const refName = cols[0];
@@ -165,7 +166,7 @@ function genesFromBed(text) {
   return mergeOverlappingByName(rows);
 }
 function sniffedFormat(text) {
-  const first = text.split("\n", 1e3).find((l) => l.trim() !== "" && !/^(#|track|browser)/.test(l));
+  const first = text.split("\n", 1e3).find((l) => l.trim() !== "" && !BED_HEADER.test(l));
   const cols = first?.split("	") ?? [];
   return /^\d+$/.test(cols[1] ?? "") && /^\d+$/.test(cols[2] ?? "") ? "bed" : "gff3";
 }

package/dist/chunks/{chunk-FRTYQQDI.js → chunk-EVXXFMZ7.js}

@@ -1,24 +1,25 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-GM7M25NW.js";
+} from "./chunk-2XEAITWM.js";
 import {
-  pathOrigin
-} from "./chunk-B5X2RLJG.js";
+  rampFraction
+} from "./chunk-JGHZ3N34.js";
 import {
   gapParts
 } from "./chunk-EIY2SKD3.js";
 import {
-  isBackbone
-} from "./chunk-RJWPJCIB.js";
+  pathOrigin
+} from "./chunk-3YBP46PB.js";
 import {
   panSNContig
-} from "./chunk-4XWZNPQ2.js";
+} from "./chunk-2JL2JVZ2.js";
 
 // src/walkHighlight.ts
 var isReference = (graph, name) => !!graph.referencePath && pathOrigin(name).name === graph.referencePath;
 function piecesOf(graph, name) {
-  return (graph.paths ?? []).filter((p) => p.name === name).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
+  const origin = pathOrigin(name).name;
+  return (graph.paths ?? []).filter((p) => pathOrigin(p.name).name === origin).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
 }
 var nodesById = (graph) => new Map(graph.nodes.map((n) => [n.id, n]));
 function graphIndex(graph) {
@@ -117,8 +118,7 @@ function laneColors(byId, walk, encoding, ramp) {
   const colors = /* @__PURE__ */ new Map();
   for (const [id, progress] of walk.progress) {
     const node = byId.get(id);
-    const mid = ramp?.midpoints.get(id);
-    const t = encoding.field === "progress" ? progress : ramp && mid !== void 0 && node && isBackbone(node) ? (mid - ramp.start) / ramp.span : void 0;
+    const t = encoding.field === "progress" ? progress : ramp && node ? rampFraction(node, ramp) : void 0;
     colors.set(id, encodedColor(encoding, t));
   }
   return colors;

package/dist/chunks/{chunk-BXLLMWC3.js → chunk-F3KQQDKP.js}

@@ -1,7 +1,7 @@
 import {
   engineKey,
   forceLayout
-} from "./chunk-REOWLPH4.js";
+} from "./chunk-7OTWJQGA.js";
 
 // src/layout/forceCache.ts
 var DEFAULT_SIZE = 4;

package/dist/chunks/{chunk-6EOB6ANX.js → chunk-GZ36HNPJ.js}

@@ -1,6 +1,6 @@
 import {
   tubeSpan
-} from "./chunk-HSVFCA2J.js";
+} from "./chunk-VO6FKNZE.js";
 
 // src/tubeMap/genes.ts
 function tubeMapGenes(byRefName, genes) {

package/dist/chunks/{chunk-3HGYGISG.js → chunk-HV35LDYH.js}

@@ -6,13 +6,13 @@ import {
 } from "./chunk-MYDHU2UV.js";
 import {
   readColor
-} from "./chunk-A7H753BA.js";
+} from "./chunk-SDI6BVG7.js";
 import {
   referenceWalkName
-} from "./chunk-M75QPZNJ.js";
+} from "./chunk-D3E7AXBB.js";
 import {
   pathOrigin
-} from "./chunk-B5X2RLJG.js";
+} from "./chunk-3YBP46PB.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-XSF4RQRP.js → chunk-JGHZ3N34.js}

@@ -10,17 +10,18 @@ import {
 } from "./chunk-GQZVR5DW.js";
 import {
   baseEdgeCurves
-} from "./chunk-WA5WNP6V.js";
+} from "./chunk-OYCQVJYY.js";
 import {
   PATH_LIGHTNESS,
   PATH_SATURATION,
   nameHue,
   pathHueAt
-} from "./chunk-3GP3KT5L.js";
+} from "./chunk-BW2NMXRV.js";
 import {
   meanDepth,
-  nodeWidthPx
-} from "./chunk-CRCD3ODN.js";
+  nodeWidthPx,
+  walkLaneWidthPx
+} from "./chunk-ZANALBSX.js";
 import {
   referenceMidpoints
 } from "./chunk-VX656OAZ.js";
@@ -31,7 +32,7 @@ import {
   strandSides,
   translateCurves,
   yToXOf
-} from "./chunk-UBQSRCWR.js";
+} from "./chunk-VACK24HF.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";
@@ -51,7 +52,6 @@ var LIFT_BACKDROP_CSS = abgrToCssRgba(
 );
 var DELETION_DASH_PX = 11;
 var MIN_PATH_STRIPE_PX = 1.2;
-var MIN_WALK_LANE_PX = 4;
 var MIN_SCALE_FOR_OFFSET = 1e-6;
 var ARROW_LENGTH_BASE_PX = 7;
 var ARROW_LENGTH_PER_EDGE_PX = 3;
@@ -265,6 +265,10 @@ function hashColor(str, alpha) {
 var REFERENCE_RAMP_ALT_RGB = [60, 65, 72];
 var REFERENCE_RAMP_ALT_COLOR = packAbgr(...REFERENCE_RAMP_ALT_RGB, 255);
 var REFERENCE_RAMP_ALT_CSS = `rgb(${REFERENCE_RAMP_ALT_RGB.join(", ")})`;
+function rampFraction(node, ramp) {
+  const mid = ramp.midpoints.get(node.id);
+  return isBackbone(node) && mid !== void 0 ? (mid - ramp.start) / ramp.span : void 0;
+}
 function computeReferenceRamp(graph, domain) {
   const midpoints = referenceMidpoints(graph);
   if (domain && domain.end > domain.start) {
@@ -348,12 +352,9 @@ function getNodeColor(node, nodeIndex, colorScheme, range) {
       if (ramp === void 0) {
         return packAbgr(160, 160, 160, 255);
       }
-      const mid = ramp.midpoints.get(node.id);
-      if (!isBackbone(node) || mid === void 0) {
-        return REFERENCE_RAMP_ALT_COLOR;
-      }
-      return packHsl(
-        rampHueAt((mid - ramp.start) / ramp.span),
+      const t = rampFraction(node, ramp);
+      return t === void 0 ? REFERENCE_RAMP_ALT_COLOR : packHsl(
+        rampHueAt(t),
         REFERENCE_RAMP_SATURATION,
         REFERENCE_RAMP_LIGHTNESS
       );
@@ -517,7 +518,12 @@ function buildGeometry(options) {
     const inView = (curves) => !viewportBounds || isBezierInBounds(curves, viewportBounds);
     const stroke = (curves, thickness, color) => {
       if (isDeletion) {
-        for (const dash of dashCurves(curves, DELETION_DASH_PX / scale)) {
+        for (const dash of dashCurves(
+          curves,
+          DELETION_DASH_PX / scale,
+          yToX,
+          viewportBounds
+        )) {
           edgeCurves.push({ curves: dash, thickness, color });
         }
       } else {
@@ -545,7 +551,7 @@ function buildGeometry(options) {
     if (laneWalks) {
       const fromNode = nodeById.get(edge.from);
       const width = fromNode ? nodeWidthPx(fromNode, contigThickness, nodeWidth, depthNorm) : contigThickness;
-      const laneWidth = Math.max(width / laneWalks.length, MIN_WALK_LANE_PX);
+      const laneWidth = walkLaneWidthPx(width, laneWalks.length);
       const normals = pointNormalsOf(fromSegments, yToX);
       const { nx, ny } = (leavesStart(
         edge,
@@ -637,7 +643,7 @@ function buildGeometry(options) {
     const drawable = segments.length >= 2;
     const lanes = highlight?.walks.length && !faded && !slots?.length ? highlight.walks : void 0;
     if (drawable && lanes) {
-      const laneWidth = Math.max(width / lanes.length, MIN_WALK_LANE_PX);
+      const laneWidth = walkLaneWidthPx(width, lanes.length);
       const normals = pointNormalsOf(segments, yToX);
       lanes.forEach((walk, lane) => {
         const laneColor = walk.colors.get(nodeId);
@@ -688,6 +694,7 @@ export {
   hslToRgb,
   REFERENCE_RAMP_ALT_COLOR,
   REFERENCE_RAMP_ALT_CSS,
+  rampFraction,
   computeReferenceRamp,
   computeColorSchemeRange,
   getNodeColor,

package/dist/chunks/{chunk-D4ZFRBB4.js → chunk-JGQQAUVL.js}

@@ -5,13 +5,13 @@ import {
 import {
   formatBp,
   groupDigits
-} from "./chunk-PFRQBCGC.js";
+} from "./chunk-T3H5ELLA.js";
 
 // src/walkKey.ts
 function rangeText(contig, start, end) {
   const s = Math.round(start);
   const e = Math.round(end);
-  return `${contig ? `${contig}:` : ""}${groupDigits(s)}-${groupDigits(e)} (${formatBp(e - s)})`;
+  return `${contig ? `${contig}:` : ""}${groupDigits(s + 1)}-${groupDigits(e)} (${formatBp(e - s)})`;
 }
 function walkKey(walk, reference) {
   const { field } = walk.encoding;
@@ -42,7 +42,7 @@ function walkPosition(walk, nodeId, length) {
   const start = Math.round(
     range.start + progress * (range.end - range.start) - length / 2
   );
-  return `${range.contig}:${groupDigits(start)}-${groupDigits(start + length)}`;
+  return `${range.contig}:${groupDigits(start + 1)}-${groupDigits(start + length)}`;
 }
 
 export {