@jbrowse/bandage-core 8.1.0 → 9.0.0

package/dist/chunks/{chunk-MP7LXLWV.js → chunk-3C5UXR2U.js}

@@ -1,6 +1,6 @@
 import {
   walkRows
-} from "./chunk-SZNZ2T6D.js";
+} from "./chunk-MAUEPAMG.js";
 import {
   ROW_HEIGHT_PX
 } from "./chunk-CPMHA4W5.js";

package/dist/chunks/{chunk-T4SQ5QGM.js → chunk-AMS3MAFP.js}

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "8.1.0";
+var version = "9.0.0";
 
 export {
   version

package/dist/chunks/{chunk-DRA7733Q.js → chunk-BPRXQ2SS.js}

@@ -6,17 +6,22 @@ import {
 } from "./chunk-FYQWPEEY.js";
 
 // src/tubeMap/axis.ts
-function referenceBoxes(graph, layout) {
+function referenceBoxes({
+  graph,
+  layout
+}) {
   const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
   const byRefName = /* @__PURE__ */ new Map();
-  layout.nodes.forEach((node) => {
+  layout.nodes.forEach((node, index) => {
     const graphNode = nodeById.get(node.name);
     if (node.order >= 0 && graphNode && isBackbone(graphNode)) {
       const { refName, start } = graphNode.stable;
       const boxes = byRefName.get(refName) ?? byRefName.set(refName, []).get(refName);
       boxes.push({
+        name: node.name,
+        index,
         bp0: start,
-        bp1: start + node.sequenceLength,
+        bp1: start + graphNode.length,
         x0: node.x,
         x1: node.x + node.pixelWidth
       });

package/dist/chunks/{chunk-TEDQJPMI.js → chunk-CWFNEKST.js}

@@ -30,16 +30,30 @@ function mismatchesByStep(record, lengths) {
     return byStep;
   }
   const starts = stepStarts(lengths, record.pathLength);
+  const known = starts.flatMap((start, s) => start === void 0 ? [] : [s]);
+  const startOf = (k) => starts[known[k]];
+  const endOf = (k) => startOf(k) + lengths[known[k]];
+  let first = 0;
   const stepAt = (pos2, atEnd = false) => {
-    for (let s = 0; s < starts.length; s++) {
-      const start = starts[s];
-      const length = lengths[s];
-      if (start !== void 0 && length !== void 0 && start <= pos2 && (pos2 < start + length || atEnd && pos2 === start + length)) {
-        return { s, local: pos2 - start, room: start + length - pos2 };
+    while (first < known.length && endOf(first) < pos2) {
+      first++;
+    }
+    for (let k = first; k < known.length && startOf(k) <= pos2; k++) {
+      const end = endOf(k);
+      if (pos2 < end || atEnd && pos2 === end) {
+        return { s: known[k], local: pos2 - startOf(k), room: end - pos2 };
       }
     }
     return void 0;
   };
+  const unplacedFrom = (pos2) => {
+    for (let k = first; k < known.length; k++) {
+      if (startOf(k) > pos2) {
+        return startOf(k) - pos2;
+      }
+    }
+    return Infinity;
+  };
   const add = (s, mismatch) => {
     const list = byStep[s];
     const last = list.at(-1);
@@ -68,7 +82,7 @@ function mismatchesByStep(record, lengths) {
       let left = op.length;
       while (left > 0) {
         const at = stepAt(pos);
-        const take = at ? Math.min(left, at.room) : left;
+        const take = Math.min(left, at ? at.room : unplacedFrom(pos));
         if (at) {
           add(at.s, { type: "deletion", pos: at.local, length: take });
         }
@@ -106,7 +120,8 @@ function tubeMapReads(graph, records, firstId) {
         })),
         firstNodeOffset: first === 0 ? record.pathStart : 0,
         finalNodeCoverLength: last === record.path.length - 1 ? lastLength - (record.pathLength - record.pathEnd) : lastLength,
-        mapping_quality: record.mappingQuality === 255 ? 0 : record.mappingQuality,
+        // 255 is GAF's missing MAPQ
+        mapping_quality: record.mappingQuality === 255 ? void 0 : record.mappingQuality,
         is_secondary: record.secondary,
         is_reverse: record.strand === "-"
       });

package/dist/chunks/chunk-INJ2UVOT.js

@@ -0,0 +1,370 @@
+import {
+  canonicalStrand,
+  stepName,
+  tubeMapReads
+} from "./chunk-CWFNEKST.js";
+import {
+  pathCssColor,
+  pathGreyCssColor
+} from "./chunk-7GBL7SJY.js";
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  ownStrand,
+  strandSides
+} from "./chunk-2CVHXFK7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/tubeMapLayout.ts
+import { forward, isReverse, layoutTubeMap } from "@jbrowse/tubemap-core";
+function pathSteps(graph) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const strands = /* @__PURE__ */ new Map();
+  for (const [segment, visits] of graph.pathVisits ?? []) {
+    for (const visit of visits) {
+      const key = `${visit.path}	${segment}`;
+      const list = strands.get(key);
+      if (list) {
+        list.push(visit.strand);
+      } else {
+        strands.set(key, [visit.strand]);
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  return (graph.paths ?? []).map((path) => {
+    const walk = pathOrigin(path.name).name;
+    return path.nodeIds.flatMap((id) => {
+      const node = nodeById.get(id);
+      if (!node) {
+        return [];
+      }
+      const key = `${walk}	${node.name}`;
+      const k = seen.get(key) ?? 0;
+      seen.set(key, k + 1);
+      return [{ node, strand: strands.get(key)?.[k] ?? canonicalStrand(node) }];
+    });
+  });
+}
+function tubeMapTracks(graph) {
+  const steps = pathSteps(graph);
+  const tracks = (graph.paths ?? []).flatMap((path, index) => {
+    const sequence = steps[index].map((s) => stepName(s.node, s.strand));
+    return sequence.length > 0 ? [
+      {
+        id: index,
+        name: path.name,
+        sequence,
+        sourceTrackID: 0,
+        type: "haplotype"
+      }
+    ] : [];
+  });
+  const reference = tracks.findIndex(
+    (t) => pathOrigin(t.name).name === graph.referencePath
+  );
+  if (reference > 0) {
+    tracks.unshift(...tracks.splice(reference, 1));
+  }
+  return tracks;
+}
+function tubeMapNodes(graph) {
+  return graph.nodes.map((n) => ({
+    name: n.id,
+    seq: "",
+    sequenceLength: Math.max(1, n.length)
+  }));
+}
+function hasTubeMapPaths(graph) {
+  return (graph.paths?.length ?? 0) > 0;
+}
+var STACK_PX = 600;
+var MIN_TUBE_PX = 3;
+var MAX_TUBE_PX = 15;
+function tubeWidth(trackCount) {
+  return Math.max(
+    MIN_TUBE_PX,
+    Math.min(MAX_TUBE_PX, Math.floor(STACK_PX / Math.max(1, trackCount)))
+  );
+}
+function straightened(first) {
+  const flipped = /* @__PURE__ */ new Set();
+  const forwards = /* @__PURE__ */ new Set();
+  for (const step of first?.sequence ?? []) {
+    if (!isReverse(step)) {
+      forwards.add(step);
+    } else if (!forwards.has(forward(step))) {
+      flipped.add(forward(step));
+    }
+  }
+  return flipped;
+}
+function mergedRuns(graph, layout, walks) {
+  const flipped = straightened(walks[0]);
+  const before = /* @__PURE__ */ new Map();
+  for (const { sequence, is_secondary } of walks) {
+    if (!is_secondary) {
+      sequence.forEach((step, i) => {
+        const id = forward(step);
+        const against = isReverse(step) !== flipped.has(id);
+        const neighbour = against ? sequence[i + 1] : sequence[i - 1];
+        if (!layout.nodeMap.has(id) && neighbour !== void 0) {
+          before.set(id, forward(neighbour));
+        }
+      });
+    }
+  }
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, Math.max(1, n.length)]));
+  const after = new Map([...before].map(([node, prev]) => [prev, node]));
+  const members = /* @__PURE__ */ new Map();
+  for (const head of after.keys()) {
+    const index = layout.nodeMap.get(head);
+    if (index !== void 0) {
+      const run = [head];
+      for (let n = after.get(head); n !== void 0; n = after.get(n)) {
+        run.push(n);
+      }
+      const bp = run.reduce((sum, id) => sum + (lengthOf.get(id) ?? 0), 0);
+      if (bp === layout.nodes[index].sequenceLength) {
+        members.set(head, run);
+      }
+    }
+  }
+  return { members, flipped };
+}
+var opposite = { start: "end", end: "start" };
+var otherStrand = { "+": "-", "-": "+" };
+function boxGraph(graph, { members, flipped }) {
+  if (members.size === 0) {
+    return graph;
+  }
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const boxOf = /* @__PURE__ */ new Map();
+  const inner = /* @__PURE__ */ new Set();
+  const drawn = (id, side) => flipped.has(id) ? opposite[side] : side;
+  for (const [box, run] of members) {
+    run.forEach((id, i) => {
+      boxOf.set(id, box);
+      const next = run[i + 1];
+      if (next !== void 0) {
+        inner.add(`${id}:${drawn(id, "end")}	${next}:${drawn(next, "start")}`);
+      }
+    });
+  }
+  const absorbed = new Set(
+    [...boxOf].filter(([id, box]) => id !== box).map(([id]) => id)
+  );
+  const nodes = graph.nodes.flatMap((node) => {
+    const run = members.get(node.id);
+    if (!run) {
+      return absorbed.has(node.id) ? [] : [node];
+    }
+    const parts = run.map((id) => nodeById.get(id));
+    const starts = parts.flatMap((p) => p.stable ? [p.stable.start] : []);
+    return [
+      {
+        ...node,
+        length: parts.reduce((sum, p) => sum + p.length, 0),
+        stable: node.stable && { ...node.stable, start: Math.min(...starts) }
+      }
+    ];
+  });
+  const leaving = (id, box, side) => drawn(box, drawn(id, side)) === "end" ? ownStrand(box) : otherStrand[ownStrand(box)];
+  const edges = graph.edges.flatMap((edge) => {
+    const sides = strandSides(edge);
+    const from = `${edge.from}:${sides.from}`;
+    const to = `${edge.to}:${sides.to}`;
+    if (inner.has(`${from}	${to}`) || inner.has(`${to}	${from}`)) {
+      return [];
+    }
+    const fromBox = boxOf.get(edge.from);
+    const toBox = boxOf.get(edge.to);
+    return [
+      {
+        ...edge,
+        ...fromBox === void 0 ? {} : {
+          from: fromBox,
+          fromStrand: leaving(edge.from, fromBox, sides.from)
+        },
+        ...toBox === void 0 ? {} : {
+          to: toBox,
+          toStrand: otherStrand[leaving(edge.to, toBox, sides.to)]
+        }
+      }
+    ];
+  });
+  const absorbedNames = new Set(
+    [...absorbed].map((id) => nodeById.get(id)?.name ?? id)
+  );
+  return {
+    ...graph,
+    nodes,
+    edges,
+    paths: graph.paths?.map((path) => ({
+      ...path,
+      nodeIds: path.nodeIds.filter((id) => !absorbed.has(id))
+    })),
+    pathVisits: graph.pathVisits && new Map(
+      [...graph.pathVisits].filter(([name]) => !absorbedNames.has(name))
+    )
+  };
+}
+function runTubeMap(graph) {
+  const paths = graph.paths ?? [];
+  const tracks = tubeMapTracks(graph);
+  const reads = graph.reads ? tubeMapReads(graph, graph.reads, paths.length) : [];
+  const tubeColor = reads.length > 0 ? pathGreyCssColor : pathCssColor;
+  const pathColors = paths.map((_, i) => tubeColor(i, paths.length));
+  const layout = layoutTubeMap(tubeMapNodes(graph), tracks, reads, {
+    nodeWidthOption: "compressed",
+    trackWidth: tubeWidth(tracks.length)
+  });
+  if (!layout) {
+    return void 0;
+  }
+  const runs = mergedRuns(graph, layout, [...tracks, ...reads]);
+  return {
+    layout,
+    pathColors,
+    members: runs.members,
+    graph: boxGraph(graph, runs)
+  };
+}
+function drawnNodes(layout) {
+  const nodes = [];
+  layout.nodes.forEach((node) => {
+    if (node.order >= 0) {
+      nodes.push(node);
+    }
+  });
+  return nodes;
+}
+function centreline(node, yOffset, x0, x1) {
+  const y = node.y + node.contentHeight / 2 - yOffset;
+  return [
+    { x: x0, y },
+    { x: x1, y }
+  ];
+}
+function extentOf(layout, yOffset) {
+  return {
+    minY: layout.bounds.minY - yOffset,
+    maxY: layout.bounds.maxY - yOffset
+  };
+}
+function tubeMapLayout(graph) {
+  const run = hasTubeMapPaths(graph) ? runTubeMap(graph) : void 0;
+  if (!run) {
+    return void 0;
+  }
+  const { layout, ...drawing } = run;
+  const yOffset = layout.bounds.minY;
+  const nodePositions = {};
+  for (const node of drawnNodes(layout)) {
+    nodePositions[node.name] = centreline(
+      node,
+      yOffset,
+      node.x,
+      node.x + node.pixelWidth
+    );
+  }
+  const { minY, maxY } = extentOf(layout, yOffset);
+  return {
+    nodePositions,
+    tubeMap: { layout, yOffset, ...drawing },
+    extent: {
+      minX: layout.bounds.minX,
+      maxX: layout.bounds.maxX,
+      minY,
+      maxY
+    }
+  };
+}
+function tubeMapColumns(graph, layout) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const byOrder = /* @__PURE__ */ new Map();
+  for (const node of drawnNodes(layout)) {
+    const list = byOrder.get(node.order);
+    if (list) {
+      list.push(node);
+    } else {
+      byOrder.set(node.order, [node]);
+    }
+  }
+  const columns = [];
+  let end = -Infinity;
+  for (const order of [...byOrder.keys()].sort((a, b) => a - b)) {
+    const nodes = byOrder.get(order);
+    let bp0 = Infinity;
+    let bp1 = -Infinity;
+    for (const node of nodes) {
+      const graphNode = nodeById.get(node.name);
+      if (graphNode && isBackbone(graphNode)) {
+        bp0 = Math.min(bp0, graphNode.stable.start);
+        bp1 = Math.max(bp1, graphNode.stable.start + graphNode.length);
+      }
+    }
+    if (bp0 === Infinity) {
+      bp0 = bp1 = end;
+    }
+    if (bp0 < end) {
+      bp0 = end;
+      bp1 = Math.max(end, bp1);
+    }
+    end = Math.max(end, bp1);
+    columns.push({
+      order,
+      x0: Math.min(...nodes.map((n) => n.x)),
+      x1: Math.max(...nodes.map((n) => n.x + n.pixelWidth)),
+      bp0,
+      bp1
+    });
+  }
+  const first = columns.find((c) => c.bp0 !== -Infinity);
+  for (const column of columns) {
+    if (column.bp0 === -Infinity) {
+      column.bp0 = column.bp1 = first?.bp0 ?? 0;
+    }
+  }
+  return columns;
+}
+function hasTubeMapBackbone(graph) {
+  return hasTubeMapPaths(graph) && graph.nodes.some(isBackbone);
+}
+function tubeMapReferenceLayout(graph) {
+  const run = hasTubeMapBackbone(graph) ? runTubeMap(graph) : void 0;
+  if (!run) {
+    return void 0;
+  }
+  const { layout, ...drawing } = run;
+  const columns = tubeMapColumns(drawing.graph, layout);
+  const byOrder = new Map(columns.map((c) => [c.order, c]));
+  const yOffset = layout.bounds.minY;
+  const nodePositions = {};
+  for (const node of drawnNodes(layout)) {
+    const column = byOrder.get(node.order);
+    nodePositions[node.name] = centreline(node, yOffset, column.bp0, column.bp1);
+  }
+  return {
+    nodePositions,
+    tubeMap: { layout, yOffset, columns, ...drawing },
+    referenceAxis: true,
+    pixelRows: true,
+    extent: extentOf(layout, yOffset)
+  };
+}
+
+export {
+  pathSteps,
+  tubeMapTracks,
+  hasTubeMapPaths,
+  tubeWidth,
+  mergedRuns,
+  boxGraph,
+  tubeMapLayout,
+  hasTubeMapBackbone,
+  tubeMapReferenceLayout
+};

package/dist/chunks/{chunk-KCRL5JB2.js → chunk-LLP3FXPM.js}

@@ -1,9 +1,9 @@
 import {
   tubeMapMismatches
-} from "./chunk-733L2TS6.js";
+} from "./chunk-XXT2JCAC.js";
 import {
   readColor
-} from "./chunk-TEDQJPMI.js";
+} from "./chunk-CWFNEKST.js";
 
 // src/tubeMap/draw.ts
 import { curvePaths, nodeOutlinePath } from "@jbrowse/tubemap-core";
@@ -53,9 +53,9 @@ function extentOf(commands) {
   }
   return { x0, x1 };
 }
-function shapeOf(d, color, track) {
+function shapeOf(d, color, id, haplotype) {
   const commands = parsePath(d);
-  return { commands, color, track, ...extentOf(commands) };
+  return { commands, color, id, haplotype, ...extentOf(commands) };
 }
 function trackColors(layout, pathColors) {
   return new Map(
@@ -67,20 +67,21 @@ function trackColors(layout, pathColors) {
 }
 function layerOf(layout, type, colors) {
   const { shapes } = layout;
+  const haplotype = type === "haplotype";
   const colorOf = (s) => colors.get(s.id);
-  const trackOf = (s) => type === "haplotype" ? s.id : void 0;
   const rects = [...shapes.rectangles, ...shapes.verticalRectangles].filter((r) => r.type === type).map((r) => ({
     color: colorOf(r),
-    track: trackOf(r),
+    id: r.id,
+    haplotype,
     x0: r.xStart,
     x1: r.xEnd + 1,
     y0: r.yStart,
     y1: r.yEnd + 1
   }));
   const curves = curvePaths(shapes.curves, type).map(
-    (c) => shapeOf(c.path, colorOf(c), trackOf(c))
+    (c) => shapeOf(c.path, colorOf(c), c.id, haplotype)
   );
-  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, colorOf(c), trackOf(c)));
+  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, colorOf(c), c.id, haplotype));
   return { rects, shapes: [...curves, ...corners] };
 }
 function tubeMapPicture({
@@ -177,7 +178,7 @@ var NODE_TINT_ALPHA = 0.55;
 function drawTubeMap(ctx, picture, frame) {
   const { x, y, width } = frame;
   const visible = (item) => x(item.x1) >= 0 && x(item.x0) <= width;
-  const colorOf = (item) => item.track !== void 0 && frame.tubeColors?.[item.track] || item.color;
+  const colorOf = (item) => item.haplotype && frame.tubeColors?.[item.id] || item.color;
   ctx.globalAlpha = 1;
   for (const layer of picture.layers) {
     fillByColor(ctx, layer.rects, visible, colorOf, (r) => {
@@ -235,6 +236,7 @@ function drawMismatches(ctx, marks, frame) {
   }
   ctx.fill();
   ctx.font = `${fontPx}px monospace`;
+  ctx.textAlign = "left";
   ctx.textBaseline = "alphabetic";
   ctx.fillStyle = darkMode ? "#ffffff" : "#000000";
   for (const m of marks) {
@@ -248,6 +250,23 @@ function drawMismatches(ctx, marks, frame) {
     }
   }
 }
+function tubeMapTrackAt(picture, { x, y }, sx, sy) {
+  for (let l = picture.layers.length - 1; l >= 0; l--) {
+    for (const r of picture.layers[l].rects) {
+      if (x(r.x0) <= sx && sx <= x(r.x1) && y(r.y0) <= sy && sy <= y(r.y1)) {
+        return r.id;
+      }
+    }
+  }
+  return void 0;
+}
+var INSERTION_SLOP_PX = 4;
+function tubeMapMismatchAt(picture, frame, sx, sy) {
+  const { x, y, yScale } = frame;
+  return mismatchesLegible(yScale) ? picture.mismatches.find(
+    (m) => y(m.y) <= sy && sy <= y(m.y + m.height) && (m.kind === "insertion" ? Math.abs(x(m.x) - sx) <= INSERTION_SLOP_PX : x(m.x0) <= sx && sx <= x(m.x1))
+  ) : void 0;
+}
 
 export {
   parsePath,
@@ -255,5 +274,7 @@ export {
   tubeMapPicture,
   drawTubeMap,
   mismatchesLegible,
-  mismatchOnScreen
+  mismatchOnScreen,
+  tubeMapTrackAt,
+  tubeMapMismatchAt
 };

package/dist/chunks/{chunk-SZNZ2T6D.js → chunk-MAUEPAMG.js}

@@ -53,12 +53,16 @@ function sliceBetween(steps, span, region, flanked = true) {
   if (!region || !flanked) {
     return { ids: steps, complete: true, from: -1, to: -1 };
   }
+  const spanAt = (i) => {
+    const id = steps[i];
+    return typeof id === "string" ? span.get(id) : void 0;
+  };
   let i0 = -1;
   let i1 = -1;
   let bestEnd = -Infinity;
   let bestStart = Infinity;
-  steps.forEach((id, i) => {
-    const s = typeof id === "string" ? span.get(id) : void 0;
+  steps.forEach((_, i) => {
+    const s = spanAt(i);
     if (s) {
       if (s.end <= region.start && s.end > bestEnd) {
         bestEnd = s.end;
@@ -70,15 +74,38 @@ function sliceBetween(steps, span, region, flanked = true) {
       }
     }
   });
-  if (i0 < 0 || i1 < 0) {
+  if (i0 >= 0 && i1 >= 0) {
+    const ids2 = steps.slice(Math.min(i0, i1) + 1, Math.max(i0, i1));
+    return {
+      ids: i0 < i1 ? ids2 : ids2.reverse(),
+      complete: true,
+      from: i0,
+      to: i1
+    };
+  }
+  const flank = i0 >= 0 ? i0 : i1;
+  let near = -1;
+  for (let d = 1; flank >= 0 && near < 0 && d < steps.length; d++) {
+    near = [flank - d, flank + d].find((j) => spanAt(j) !== void 0) ?? -1;
+  }
+  if (near < 0) {
     return { ids: steps, complete: false, from: -1, to: -1 };
   }
-  const ids = steps.slice(Math.min(i0, i1) + 1, Math.max(i0, i1));
+  const forward = near > flank === spanAt(near).start > spanAt(flank).start;
+  const after = forward === (flank === i0);
+  const ids = after ? steps.slice(flank + 1) : steps.slice(0, flank).reverse();
+  const last = ids.length > 0 ? ids.length - 1 : -1;
+  const end = last < 0 ? spanAt(flank) : spanAt(after ? flank + 1 + last : 0);
+  const stop = {
+    contigEnds: end !== void 0,
+    shortBp: !end ? 0 : Math.max(0, region.start - end.end, end.start - region.end)
+  };
   return {
-    ids: i0 < i1 ? ids : ids.reverse(),
-    complete: true,
-    from: i0,
-    to: i1
+    ids,
+    complete: false,
+    from: flank,
+    to: after ? steps.length : -1,
+    stop
   };
 }
 function filterSamples(rows, samples) {
@@ -117,7 +144,7 @@ function walkRows(graph, region, unit) {
   const rowOf = (pieces) => {
     const path = pieces[0];
     const ordered = [...pieces].sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
-    const { ids, complete, from, to } = sliceBetween(
+    const { ids, complete, from, to, stop } = sliceBetween(
       stepsOf(ordered, lengthOf),
       span,
       cut,
@@ -177,6 +204,7 @@ function walkRows(graph, region, unit) {
       offReferenceBp,
       gapBp,
       complete,
+      stop,
       runs,
       axis
     };

package/dist/chunks/{chunk-V3MD3IZB.js → chunk-MIW3HYPE.js}

@@ -34,15 +34,24 @@ function units(bp, unit) {
   return unit ? ` \u2248 ${Math.round(bp / unit)} units` : "";
 }
 function walkRowReadout(row, reference, unit, call) {
-  const { bp, gapBp, complete } = row;
+  const { bp, gapBp, complete, stop } = row;
   if (!reference) {
     return `${kb(bp)}${units(bp, unit)}`;
   }
-  const delta = bp - reference.bp;
-  const against = delta === 0 ? "" : ` (${delta > 0 ? "+" : "\u2212"}${kb(Math.abs(delta))})`;
   const outside = gapBp > 0 ? ` \xB7 ${kb(gapBp)} outside the cut` : "";
   const called = call ? ` \xB7 called ${kb(call.bp)}${call.spanningReads === 0 ? " \xB7 no spanning read" : ""}` : "";
-  return `${kb(bp)}${units(bp, unit)}${against}${outside}${complete ? "" : " \xB7 partial walk"}${called}`;
+  if (complete) {
+    const delta = bp - reference.bp;
+    const against = delta === 0 ? "" : ` (${delta > 0 ? "+" : "\u2212"}${kb(Math.abs(delta))})`;
+    return `${kb(bp)}${units(bp, unit)}${against}${outside}${called}`;
+  }
+  const region = unit ? "repeat" : "window";
+  if (stop?.contigEnds && bp === 0) {
+    const where = stop.shortBp > 0 ? `${kb(stop.shortBp)} before` : "at";
+    return `contig ends ${where} the ${region}${called}`;
+  }
+  const why = !stop ? "partial walk" : stop.contigEnds ? `contig ends inside the ${region}` : "does not rejoin the reference within the cut";
+  return `\u2265 ${kb(bp)}${units(bp, unit)} \xB7 ${why}${outside}${called}`;
 }
 function readoutPlacement(text, endX, width) {
   const x = endX + 6;