@jbrowse/bandage-core 5.0.1 → 5.2.0

package/dist/chunks/{chunk-RS23442A.js → chunk-ZMVFSZI5.js}

@@ -297,6 +297,16 @@ function attachment(segments, side) {
 }
 var TANGENT_SPAN_FACTOR = 0.5;
 var MAX_TANGENT = 80;
+function ownStrand(id) {
+  return id.endsWith("-") ? "-" : "+";
+}
+function strandSides(edge) {
+  const own = (id, strand) => (strand ?? ownStrand(id)) === ownStrand(id);
+  return {
+    from: own(edge.from, edge.fromStrand) ? "end" : "start",
+    to: own(edge.to, edge.toStrand) ? "start" : "end"
+  };
+}
 function spanOf(segments) {
   let min = Infinity;
   let max = -Infinity;
@@ -409,6 +419,14 @@ function selfLinkOf(edge) {
   }
   return edge.fromStrand && edge.toStrand && edge.fromStrand !== edge.toStrand ? edge.fromStrand === "+" ? "end" : "start" : true;
 }
+function edgeJoinOf(edge, stranded = false) {
+  const self = selfLinkOf(edge);
+  if (!stranded) {
+    return self;
+  }
+  const sides = strandSides(edge);
+  return self === false ? sides : sides.from === sides.to ? sides.from : true;
+}
 function hairpinCurves(attach, reach, offsetX, offsetY) {
   const { at, inward } = attach;
   const dx = inward ? at.x - inward.x : 1;
@@ -447,7 +465,7 @@ function hairpinCurves(attach, reach, offsetX, offsetY) {
     }
   ];
 }
-function computeEdgeCurves(fromSegments, toSegments, selfLink, offsetX, offsetY, axis, bypassed = [], maxBowIn) {
+function computeEdgeCurves(fromSegments, toSegments, join, offsetX, offsetY, axis, bypassed = [], maxBowIn) {
   const scale = axis.scaleX;
   const yToX = yToXOf(axis);
   const maxBow = maxBowIn ?? (axis.pixelRows ? MAX_ROW_BOW_PX : void 0);
@@ -456,7 +474,7 @@ function computeEdgeCurves(fromSegments, toSegments, selfLink, offsetX, offsetY,
       computeEdgeCurves(
         scaleYOf(fromSegments, yToX),
         scaleYOf(toSegments, yToX),
-        selfLink,
+        join,
         offsetX,
         offsetY * yToX,
         { scaleX: scale, scaleY: scale },
@@ -468,15 +486,16 @@ function computeEdgeCurves(fromSegments, toSegments, selfLink, offsetX, offsetY,
       yToX
     );
   }
-  if (typeof selfLink === "string") {
+  if (typeof join === "string") {
     return hairpinCurves(
-      attachment(fromSegments, selfLink),
+      attachment(fromSegments, join),
       selfLoopReach(fromSegments, scale),
       offsetX,
       offsetY
     );
   }
-  const sides = selfLink ? { from: "end", to: "start" } : facingSides(fromSegments, toSegments);
+  const loop = join === true;
+  const sides = loop ? { from: "end", to: "start" } : join || facingSides(fromSegments, toSegments);
   const fromAttach = attachment(fromSegments, sides.from);
   const toAttach = attachment(toSegments, sides.to);
   const fromEnd = fromAttach.at;
@@ -485,7 +504,7 @@ function computeEdgeCurves(fromSegments, toSegments, selfLink, offsetX, offsetY,
   const p1y = fromEnd.y + offsetY;
   const p2x = toStart.x + offsetX;
   const p2y = toStart.y + offsetY;
-  if (selfLink) {
+  if (loop) {
     let segDirX = 1;
     let segDirY = 0;
     if (fromAttach.inward) {
@@ -591,12 +610,15 @@ function nearerEnd(segments, to) {
   const end = segments.at(-1);
   return Math.hypot(start.x - to.x, start.y - to.y) < Math.hypot(end.x - to.x, end.y - to.y) ? "start" : "end";
 }
-function routedEdgeCurves(fromSegments, toSegments, route) {
+function routedEdgeCurves(fromSegments, toSegments, route, sides) {
   const fromAttach = attachment(
     fromSegments,
-    nearerEnd(fromSegments, route[0])
+    sides?.from ?? nearerEnd(fromSegments, route[0])
+  );
+  const toAttach = attachment(
+    toSegments,
+    sides?.to ?? nearerEnd(toSegments, route.at(-1))
   );
-  const toAttach = attachment(toSegments, nearerEnd(toSegments, route.at(-1)));
   const points = [fromAttach.at, ...route, toAttach.at];
   const tangent = (i) => {
     const p = points[i];
@@ -646,16 +668,21 @@ var MIN_DELETION_BP = 1;
 function bypassedPoints(nodePositions, bypassed) {
   return bypassed.flatMap((id) => nodePositions[id] ?? []);
 }
-function deletionArcCurves(nodePositions, deletion, axis, route) {
+function deletionArcCurves(nodePositions, deletion, axis, route, stranded = false) {
   const from = nodePositions[deletion.from];
   const to = nodePositions[deletion.to];
   if (!from?.length || !to?.length) {
     return void 0;
   }
-  return route ? routedEdgeCurves(from, to, route) : computeEdgeCurves(
+  return route ? routedEdgeCurves(
+    from,
+    to,
+    route,
+    stranded ? strandSides(deletion) : void 0
+  ) : computeEdgeCurves(
     from,
     to,
-    deletion.from === deletion.to,
+    edgeJoinOf(deletion, stranded),
     0,
     0,
     axis,
@@ -723,6 +750,8 @@ function deletionEdges(graph) {
           edgeIndex,
           from: edge.from,
           to: edge.to,
+          ...edge.fromStrand ? { fromStrand: edge.fromStrand } : {},
+          ...edge.toStrand ? { toStrand: edge.toStrand } : {},
           refName,
           start,
           end,
@@ -1207,19 +1236,11 @@ function takeRoutes(positions, routes) {
 }
 
 // src/layout/mergeRuns.ts
-function ownStrand(id) {
-  return id.endsWith("-") ? "-" : "+";
-}
 function flip(strand) {
   return strand === "+" ? "-" : "+";
 }
-function sidesOf(edge) {
-  const from = (edge.fromStrand ?? ownStrand(edge.from)) === ownStrand(edge.from) ? "end" : "start";
-  const to = (edge.toStrand ?? ownStrand(edge.to)) === ownStrand(edge.to) ? "start" : "end";
-  return { from, to };
-}
 function mergeRuns(graph, alone = /* @__PURE__ */ new Set()) {
-  const sides = graph.edges.map(sidesOf);
+  const sides = graph.edges.map(strandSides);
   const at = /* @__PURE__ */ new Map();
   const attach = (id, side, ei) => {
     const key = `${id}|${side}`;
@@ -1589,24 +1610,33 @@ function loadGraph(text, name, opts = {}) {
   }
   return graph;
 }
+var COMPONENT_SEPARATION = 15;
 function engineRequest(graph, scaling, settings) {
   const anchored = graph.nodes.some(isBackbone);
+  const spaced = {
+    ...scaling,
+    opts: {
+      ...scaling.opts,
+      edgeLength: scaling.opts.edgeLength * (settings.spacing ?? 1)
+    }
+  };
   return {
     graph: {
-      nodes: anchored ? seededNodes(graph, scaling) : scaling.nodes,
+      nodes: anchored ? seededNodes(graph, spaced) : spaced.nodes,
       edges: graph.edges
     },
     options: {
       quality: settings.quality,
       linearLayout: settings.linearLayout,
-      ...scaling.opts,
+      ...spaced.opts,
+      componentSeparation: COMPONENT_SEPARATION * (settings.componentSeparation ?? 1),
       ...anchored ? { rotateComponents: false } : {}
     }
   };
 }
 function engineKey(graph, settings) {
   const anchored = graph.nodes.some(isBackbone);
-  return `${settings.quality}|${settings.linearLayout}|${settings.bubbleSpread}|${anchored}|${graph.referencePath ?? ""}`;
+  return `${settings.quality}|${settings.linearLayout}|${settings.bubbleSpread}|${settings.spacing ?? 1}|${settings.componentSeparation ?? 1}|${anchored}|${graph.referencePath ?? ""}`;
 }
 async function forceLayout(graph, settings, engine) {
   const spread = spreadFor(settings.bubbleSpread);
@@ -1654,6 +1684,7 @@ async function forceLayout(graph, settings, engine) {
     result: {
       ...result,
       nodePositions,
+      stranded: true,
       ...deletions.length ? { deletionRoutes, extent: layoutExtent(deletionRoutes) } : {}
     },
     duration
@@ -1773,7 +1804,7 @@ function placeLabels(candidates, frame, take) {
       if (offFrame(box, frame)) {
         return void 0;
       }
-      if (insideFrame(box, frame) && take(box)) {
+      if (insideFrame(box, frame) && (c.fits?.(box) ?? true) && take(box)) {
         return { ...c, text, y, w };
       }
     }
@@ -1888,10 +1919,10 @@ function labelOrder(nodePositions, nodeLengths) {
   return order;
 }
 var arcCache = /* @__PURE__ */ new WeakMap();
-function arcPlacements(nodePositions, deletions, axis, version2, routes) {
+function arcPlacements(nodePositions, deletions, axis, version2, routes, stranded) {
   const { scaleX, scaleY } = axis;
   const cached2 = arcCache.get(nodePositions);
-  if (cached2?.deletions === deletions && cached2.routes === routes && cached2.scaleX === scaleX && cached2.scaleY === scaleY && cached2.version === version2) {
+  if (cached2?.deletions === deletions && cached2.routes === routes && cached2.stranded === stranded && cached2.scaleX === scaleX && cached2.scaleY === scaleY && cached2.version === version2) {
     return cached2.arcs;
   }
   const arcs = [];
@@ -1900,7 +1931,8 @@ function arcPlacements(nodePositions, deletions, axis, version2, routes) {
       nodePositions,
       deletion,
       axis,
-      routes?.[deletion.edgeIndex]
+      routes?.[deletion.edgeIndex],
+      stranded
     );
     const apex = curves ? curveMidpoint(curves) : void 0;
     if (curves && apex) {
@@ -1917,6 +1949,7 @@ function arcPlacements(nodePositions, deletions, axis, version2, routes) {
   arcCache.set(nodePositions, {
     deletions,
     routes,
+    stranded,
     scaleX,
     scaleY,
     version: version2,
@@ -1929,6 +1962,7 @@ function sizeLabelCandidates({
   nodeLengths,
   deletions,
   deletionRoutes,
+  stranded = false,
   alleleDeletions,
   axis,
   translateX,
@@ -1945,7 +1979,8 @@ function sizeLabelCandidates({
     deletions,
     axis,
     version2,
-    deletionRoutes
+    deletionRoutes,
+    stranded
   )) {
     if (extent >= MIN_DELETION_LABEL_PX) {
       const text = deletionText(deletion.bp);
@@ -3374,7 +3409,7 @@ var COLOR_SCHEMES = [
   { value: "random", label: "Random" },
   { value: "rainbow", label: "Rainbow" },
   { value: "depth", label: "Depth" },
-  { value: "node-length", label: "Node Length" },
+  { value: "node-length", label: "Node length" },
   { value: "stable-rank", label: "Stable rank" },
   { value: "reference-position", label: "Reference position" },
   { value: "grey", label: "Grey" }
@@ -3465,10 +3500,10 @@ function brightenAbgr(c, factor) {
 
 // src/util/edgeCurves.ts
 var cache = /* @__PURE__ */ new WeakMap();
-function baseEdgeCurves(nodePositions, graph, axis, deletions, version2, routes) {
+function baseEdgeCurves(nodePositions, graph, axis, deletions, version2, routes, stranded = false) {
   const { scaleX, scaleY } = axis;
   const cached2 = cache.get(nodePositions);
-  if (cached2?.graph === graph && cached2.scaleX === scaleX && cached2.scaleY === scaleY && cached2.deletions === deletions && cached2.routes === routes && cached2.version === version2) {
+  if (cached2?.graph === graph && cached2.scaleX === scaleX && cached2.scaleY === scaleY && cached2.deletions === deletions && cached2.routes === routes && cached2.stranded === stranded && cached2.version === version2) {
     return cached2.curves;
   }
   const curves = /* @__PURE__ */ new Map();
@@ -3481,10 +3516,15 @@ function baseEdgeCurves(nodePositions, graph, axis, deletions, version2, routes)
       const route = bypassed && routes?.[ei];
       curves.set(
         ei,
-        route ? routedEdgeCurves(from, to, route) : computeEdgeCurves(
+        route ? routedEdgeCurves(
+          from,
+          to,
+          route,
+          stranded ? strandSides(edge) : void 0
+        ) : computeEdgeCurves(
           from,
           to,
-          selfLinkOf(edge),
+          edgeJoinOf(edge, stranded),
           0,
           0,
           axis,
@@ -3499,6 +3539,7 @@ function baseEdgeCurves(nodePositions, graph, axis, deletions, version2, routes)
     scaleY,
     deletions,
     routes,
+    stranded,
     version: version2,
     curves
   });
@@ -3523,6 +3564,7 @@ var ARROW_LENGTH_BASE_PX = 7;
 var ARROW_LENGTH_PER_EDGE_PX = 3;
 var ARROW_HALF_WIDTH_BASE_PX = 3;
 var ARROW_HALF_WIDTH_PER_EDGE_PX = 1.5;
+var MIN_LINK_HEADS = 3;
 var MIN_ARROW_FIT = 0.5;
 var MIN_ARROW_SCALE = 0.45;
 var ARROW_CURVE_STEPS = 12;
@@ -3587,12 +3629,17 @@ function arrowheadFor({
   toSegments
 }) {
   const length = ARROW_LENGTH_BASE_PX + ARROW_LENGTH_PER_EDGE_PX * edgeHalfWidth;
-  const n2 = backFromEnd(curves, scale, yToX, nodeHalfWidth + length);
+  const n2 = backFromEnd(
+    curves,
+    scale,
+    yToX,
+    nodeHalfWidth + MIN_LINK_HEADS * length
+  );
   const lengthPx = walkPx[n2 - 1];
+  const abutting = lengthPx < ABUTTING_PX;
   const inset = Math.min(nodeHalfWidth, lengthPx);
-  const room = lengthPx < ABUTTING_PX ? polylinePx(fromSegments, scale, yToX) : lengthPx - inset;
-  const fit = Math.min(1, room / length);
-  if (fit < MIN_ARROW_FIT) {
+  const fit = abutting ? Math.min(1, polylinePx(fromSegments, scale, yToX) / length) : 1;
+  if (abutting ? fit < MIN_ARROW_FIT : lengthPx < MIN_LINK_HEADS * length) {
     return void 0;
   }
   const tip = walkPointAt(n2, inset);
@@ -3619,6 +3666,13 @@ function polylinePx(segments, scale, yToX) {
   }
   return length * scale;
 }
+function leavesStart(edge, segments, first, stranded, yToX) {
+  if (stranded) {
+    return strandSides(edge).from === "start";
+  }
+  const gap = (p) => Math.hypot(p.x - first.x0, (p.y - first.y0) * yToX);
+  return gap(segments[0]) < gap(segments.at(-1));
+}
 function intoDirection(last, toSegments) {
   if (toSegments.length < 2) {
     return void 0;
@@ -3964,6 +4018,7 @@ function buildGeometry(options) {
     referenceRamp,
     deletions,
     deletionRoutes,
+    stranded,
     hiddenEdges,
     version: version2 = 0
   } = options;
@@ -3976,7 +4031,8 @@ function buildGeometry(options) {
     axis,
     deletions,
     version2,
-    deletionRoutes
+    deletionRoutes,
+    stranded
   );
   const nodeStrokes = [];
   const nodeStrokeRuns = /* @__PURE__ */ new Map();
@@ -4028,7 +4084,7 @@ function buildGeometry(options) {
       }
       const head = showArrows && arrowColor !== void 0 ? arrowheadFor({
         curves,
-        edgeHalfWidth: edgeThickness,
+        edgeHalfWidth: connectorThickness / 2,
         nodeHalfWidth: intoHalfWidth,
         scale,
         yToX,
@@ -4048,7 +4104,13 @@ function buildGeometry(options) {
       const width = fromNode ? nodeWidthPx(fromNode, contigThickness, nodeWidth2, depthNorm) : contigThickness;
       const laneWidth = Math.max(width / laneWalks.length, MIN_WALK_LANE_PX);
       const normals = pointNormalsOf(fromSegments, yToX);
-      const { nx, ny } = (edge.fromStrand === "-" ? normals[0] : normals.at(-1)) ?? {
+      const { nx, ny } = (leavesStart(
+        edge,
+        fromSegments,
+        baseCurves[0],
+        stranded,
+        yToX
+      ) ? normals[0] : normals.at(-1)) ?? {
         nx: 0,
         ny: 0
       };
@@ -4370,6 +4432,415 @@ function groupByPaint(items, paintOf) {
   return [...groups.values(), ...deferred.values()];
 }
 
+// src/util/SpatialIndex.ts
+var FALLBACK_CELL_SIZE = 50;
+function meanExtentCellSize(extentTotal, count) {
+  return count > 0 ? Math.max(1, extentTotal / count) : FALLBACK_CELL_SIZE;
+}
+function rowPitchOf(boxes) {
+  const distinct = /* @__PURE__ */ new Set();
+  let min = Infinity;
+  let max = -Infinity;
+  for (const box of boxes) {
+    distinct.add(box.minY);
+    min = Math.min(min, box.minY);
+    max = Math.max(max, box.minY);
+  }
+  return distinct.size > 1 ? (max - min) / (distinct.size - 1) : void 0;
+}
+function cellSizeFrom(boxes, extentX, extentY) {
+  const x = meanExtentCellSize(extentX, boxes.length);
+  return {
+    x,
+    y: extentY > 0 ? meanExtentCellSize(extentY, boxes.length) : rowPitchOf(boxes) ?? x
+  };
+}
+function resolveCellSize(given, boxes, extentX, extentY) {
+  return given === void 0 ? cellSizeFrom(boxes, extentX, extentY) : typeof given === "number" ? { x: given, y: given } : given;
+}
+function getOrCreateCell(cells, cx, cy) {
+  let row = cells.get(cx);
+  if (!row) {
+    row = /* @__PURE__ */ new Map();
+    cells.set(cx, row);
+  }
+  let cell = row.get(cy);
+  if (!cell) {
+    cell = [];
+    row.set(cy, cell);
+  }
+  return cell;
+}
+function addToGrid(cells, cellSize, minX, minY, maxX, maxY, entry) {
+  const cx0 = Math.floor(minX / cellSize.x);
+  const cx1 = Math.floor(maxX / cellSize.x);
+  const cy0 = Math.floor(minY / cellSize.y);
+  const cy1 = Math.floor(maxY / cellSize.y);
+  for (let cx = cx0; cx <= cx1; cx++) {
+    for (let cy = cy0; cy <= cy1; cy++) {
+      getOrCreateCell(cells, cx, cy).push(entry);
+    }
+  }
+}
+function queryGrid(cells, cellSize, x, y, radiusX, radiusY) {
+  const cx0 = Math.floor((x - radiusX) / cellSize.x);
+  const cx1 = Math.floor((x + radiusX) / cellSize.x);
+  const cy0 = Math.floor((y - radiusY) / cellSize.y);
+  const cy1 = Math.floor((y + radiusY) / cellSize.y);
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let cx = cx0; cx <= cx1; cx++) {
+    const row = cells.get(cx);
+    if (row) {
+      for (let cy = cy0; cy <= cy1; cy++) {
+        const cell = row.get(cy);
+        if (cell) {
+          for (const entry of cell) {
+            if (!seen.has(entry)) {
+              seen.add(entry);
+              results.push(entry);
+            }
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+var SpatialIndex = class {
+  constructor(nodePositions, cellSize) {
+    this.cells = /* @__PURE__ */ new Map();
+    const boxes = [];
+    let extentX = 0;
+    let extentY = 0;
+    for (const [nodeId, segments] of Object.entries(nodePositions)) {
+      for (let i = 0; i < segments.length - 1; i++) {
+        const seg = segments[i];
+        const next = segments[i + 1];
+        const minX = Math.min(seg.x, next.x);
+        const minY = Math.min(seg.y, next.y);
+        const maxX = Math.max(seg.x, next.x);
+        const maxY = Math.max(seg.y, next.y);
+        extentX += maxX - minX;
+        extentY += maxY - minY;
+        boxes.push({ entry: { nodeId, segmentIdx: i }, minX, minY, maxX, maxY });
+      }
+    }
+    this.cellSize = resolveCellSize(cellSize, boxes, extentX, extentY);
+    for (const b of boxes) {
+      addToGrid(
+        this.cells,
+        this.cellSize,
+        b.minX,
+        b.minY,
+        b.maxX,
+        b.maxY,
+        b.entry
+      );
+    }
+  }
+  query(x, y, radiusX, radiusY = radiusX) {
+    return queryGrid(this.cells, this.cellSize, x, y, radiusX, radiusY);
+  }
+};
+var EdgeSpatialIndex = class {
+  constructor(nodePositions, graph, drawPaths, axis, cellSize, deletions, version2 = 0, routes, stranded = false) {
+    this.cells = /* @__PURE__ */ new Map();
+    this.edgeCurves = baseEdgeCurves(
+      nodePositions,
+      graph,
+      axis,
+      deletions,
+      version2,
+      routes,
+      stranded
+    );
+    const boxes = [];
+    let extentX = 0;
+    let extentY = 0;
+    for (let ei = 0; ei < graph.edges.length; ei++) {
+      const edge = graph.edges[ei];
+      const fromSegments = nodePositions[edge.from];
+      const toSegments = nodePositions[edge.to];
+      const curves = this.edgeCurves.get(ei);
+      if (fromSegments?.length && toSegments?.length && curves) {
+        let { minX, minY, maxX, maxY } = curveBounds(curves);
+        const numPaths = edge.pathIds?.length ?? 0;
+        if (drawPaths && numPaths > 0) {
+          let padX = 0;
+          let padY = 0;
+          for (const o of pathRibbonOffsets(
+            fromSegments,
+            toSegments,
+            numPaths,
+            axis
+          )) {
+            padX = Math.max(padX, Math.abs(o.x));
+            padY = Math.max(padY, Math.abs(o.y));
+          }
+          minX -= padX;
+          minY -= padY;
+          maxX += padX;
+          maxY += padY;
+        }
+        extentX += maxX - minX;
+        extentY += maxY - minY;
+        boxes.push({ ei, minX, minY, maxX, maxY });
+      }
+    }
+    this.cellSize = resolveCellSize(cellSize, boxes, extentX, extentY);
+    for (const b of boxes) {
+      addToGrid(this.cells, this.cellSize, b.minX, b.minY, b.maxX, b.maxY, b.ei);
+    }
+  }
+  getCurves(ei) {
+    return this.edgeCurves.get(ei);
+  }
+  query(x, y, radiusX, radiusY = radiusX) {
+    return queryGrid(this.cells, this.cellSize, x, y, radiusX, radiusY);
+  }
+};
+
+// src/util/hitDetection.ts
+function distanceToSegment(px, py, x1, y1, x2, y2) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) {
+    return Math.hypot(px - x1, py - y1);
+  }
+  const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / lenSq));
+  return Math.hypot(px - (x1 + t * dx), py - (y1 + t * dy));
+}
+function distanceToCubicBezier(px, py, x1, y1, cx1, cy1, cx2, cy2, x2, y2) {
+  let minDist = Infinity;
+  const samples = 20;
+  let lastX = x1;
+  let lastY = y1;
+  for (let i = 1; i <= samples; i++) {
+    const t = i / samples;
+    const u = 1 - t;
+    const bx = u * u * u * x1 + 3 * u * u * t * cx1 + 3 * u * t * t * cx2 + t * t * t * x2;
+    const by = u * u * u * y1 + 3 * u * u * t * cy1 + 3 * u * t * t * cy2 + t * t * t * y2;
+    minDist = Math.min(minDist, distanceToSegment(px, py, lastX, lastY, bx, by));
+    lastX = bx;
+    lastY = by;
+  }
+  return minDist;
+}
+function distanceToBezierCurve(px, py, c) {
+  return distanceToCubicBezier(
+    px,
+    py,
+    c.x0,
+    c.y0,
+    c.cx0,
+    c.cy0,
+    c.cx1,
+    c.cy1,
+    c.x1,
+    c.y1
+  );
+}
+function distanceToEdgeCurves(px, py, curves, yToX = 1) {
+  let minDist = Infinity;
+  for (const c of curves) {
+    const d = distanceToBezierCurve(
+      px,
+      py,
+      yToX === 1 ? c : {
+        x0: c.x0,
+        y0: c.y0 * yToX,
+        cx0: c.cx0,
+        cy0: c.cy0 * yToX,
+        cx1: c.cx1,
+        cy1: c.cy1 * yToX,
+        x1: c.x1,
+        y1: c.y1 * yToX
+      }
+    );
+    if (d < minDist) {
+      minDist = d;
+    }
+  }
+  return minDist;
+}
+var nodeCache = /* @__PURE__ */ new WeakMap();
+function getSpatialIndex(nodePositions, version2) {
+  const cached2 = nodeCache.get(nodePositions);
+  if (cached2?.version === version2) {
+    return cached2.index;
+  }
+  const index = new SpatialIndex(nodePositions);
+  nodeCache.set(nodePositions, { version: version2, index });
+  return index;
+}
+var edgeCache = /* @__PURE__ */ new WeakMap();
+function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version2, deletions, routes, stranded = false) {
+  const cached2 = edgeCache.get(nodePositions);
+  if (cached2?.graph === graph && cached2.drawPaths === drawPaths && cached2.scaleX === axis.scaleX && cached2.scaleY === axis.scaleY && cached2.version === version2 && cached2.deletions === deletions && cached2.routes === routes && cached2.stranded === stranded) {
+    return cached2.index;
+  }
+  const index = new EdgeSpatialIndex(
+    nodePositions,
+    graph,
+    drawPaths,
+    axis,
+    void 0,
+    deletions,
+    version2,
+    routes,
+    stranded
+  );
+  edgeCache.set(nodePositions, {
+    graph,
+    drawPaths,
+    scaleX: axis.scaleX,
+    scaleY: axis.scaleY,
+    version: version2,
+    index,
+    deletions,
+    routes,
+    stranded
+  });
+  return index;
+}
+var MIN_NODE_REACH_PX = 5;
+function findHoveredNode(nodePositions, graphX, graphY, axis, version2 = 0, ink) {
+  const yToX = yToXOf(axis);
+  const index = getSpatialIndex(nodePositions, version2);
+  const reach = (px) => Math.max(MIN_NODE_REACH_PX, px) / axis.scaleX;
+  const queryReach = reach(ink?.maxHalfWidthPx ?? 0);
+  const candidates = index.query(graphX, graphY, queryReach, queryReach / yToX);
+  let hovered = null;
+  let best = Infinity;
+  for (const { nodeId, segmentIdx } of candidates) {
+    const segments = nodePositions[nodeId];
+    const dist = distanceToSegment(
+      graphX,
+      graphY * yToX,
+      segments[segmentIdx].x,
+      segments[segmentIdx].y * yToX,
+      segments[segmentIdx + 1].x,
+      segments[segmentIdx + 1].y * yToX
+    );
+    if (dist < best && dist < reach(ink?.halfWidthPx(nodeId) ?? 0)) {
+      best = dist;
+      hovered = nodeId;
+    }
+  }
+  return hovered;
+}
+function segmentMeetsBox(a, b, box) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  let t0 = 0;
+  let t1 = 1;
+  for (const [p, q] of [
+    [-dx, a.x - box.x0],
+    [dx, box.x1 - a.x],
+    [-dy, a.y - box.y0],
+    [dy, box.y1 - a.y]
+  ]) {
+    if (p === 0) {
+      if (q < 0) {
+        return false;
+      }
+    } else if (p < 0) {
+      t0 = Math.max(t0, q / p);
+    } else {
+      t1 = Math.min(t1, q / p);
+    }
+  }
+  return t0 <= t1;
+}
+function nodesUnderBox(nodePositions, t, version2 = 0) {
+  const index = getSpatialIndex(nodePositions, version2);
+  const screen = (p) => ({
+    x: p.x * t.scaleX + t.translateX,
+    y: p.y * t.scaleY + t.translateY
+  });
+  return (box) => {
+    const hits = /* @__PURE__ */ new Set();
+    const candidates = index.query(
+      ((box.x0 + box.x1) / 2 - t.translateX) / t.scaleX,
+      ((box.y0 + box.y1) / 2 - t.translateY) / t.scaleY,
+      Math.abs((box.x1 - box.x0) / 2 / t.scaleX),
+      Math.abs((box.y1 - box.y0) / 2 / t.scaleY)
+    );
+    for (const { nodeId, segmentIdx } of candidates) {
+      const line = nodePositions[nodeId];
+      if (!hits.has(nodeId) && segmentMeetsBox(
+        screen(line[segmentIdx]),
+        screen(line[segmentIdx + 1]),
+        box
+      )) {
+        hits.add(nodeId);
+      }
+    }
+    return hits;
+  };
+}
+function findHoveredEdge(nodePositions, graph, graphX, graphY, axis, drawPaths, version2 = 0, deletions, hiddenEdges, deletionRoutes, stranded = false) {
+  const yToX = yToXOf(axis);
+  const edgeThreshold = 10 / axis.scaleX;
+  const edgeIndex = getEdgeSpatialIndex(
+    nodePositions,
+    graph,
+    drawPaths,
+    axis,
+    version2,
+    deletions,
+    deletionRoutes,
+    stranded
+  );
+  const candidates = edgeIndex.query(
+    graphX,
+    graphY,
+    edgeThreshold,
+    edgeThreshold / yToX
+  );
+  let hovered = null;
+  let best = edgeThreshold;
+  for (const edgeIdx of candidates) {
+    const edge = graph.edges[edgeIdx];
+    const fromSegments = nodePositions[edge.from];
+    const toSegments = nodePositions[edge.to];
+    if (!fromSegments?.length || !toSegments?.length || hiddenEdges?.has(edgeIdx)) {
+      continue;
+    }
+    const numPaths = edge.pathIds?.length ?? 0;
+    const baseCurves = edgeIndex.getCurves(edgeIdx);
+    if (!baseCurves) {
+      continue;
+    }
+    let dist;
+    if (!drawPaths || numPaths === 0) {
+      dist = distanceToEdgeCurves(graphX, graphY * yToX, baseCurves, yToX);
+    } else {
+      let minDist = Infinity;
+      for (const offset of pathRibbonOffsets(
+        fromSegments,
+        toSegments,
+        numPaths,
+        axis
+      )) {
+        const curves = offset.x === 0 && offset.y === 0 ? baseCurves : translateCurves(baseCurves, offset.x, offset.y);
+        const d = distanceToEdgeCurves(graphX, graphY * yToX, curves, yToX);
+        if (d < minDist) {
+          minDist = d;
+        }
+      }
+      dist = minDist;
+    }
+    if (dist < best) {
+      best = dist;
+      hovered = edgeIdx;
+    }
+  }
+  return hovered;
+}
+
 // src/walkEncoding.ts
 import { packAbgr as packAbgr3 } from "@jbrowse/core/util/colorBits";
 var WALK_FIELDS = [
@@ -4752,11 +5223,71 @@ function facetCells(names, by, domain = []) {
   return cells.includes(-1) || new Set(cells).size < cells.length ? wrap : { columns, count: rows.length * columns, cells };
 }
 
+// src/genes/exonOutline.ts
+var EXON_COLOR = "#daa520";
+var EXON_GAP_PX = 1;
+var EXON_LINE_PX = 2;
+var MIN_LANE_PX = 4;
+function exonStretches(pins, halfWidthPx, lift, pathOf = (d) => d) {
+  const inkPx = (nodeId) => {
+    const own = halfWidthPx(nodeId) * 2;
+    return lift?.nodeIds.has(nodeId) ? Math.max(own, lift.walks.length * MIN_LANE_PX) : own;
+  };
+  return pins.flatMap(
+    (pin) => pin.exonsByNode.map(({ nodeId, d }) => ({
+      key: `${pin.gene.name}-${pin.gene.start}-${nodeId}`,
+      d: pathOf(d),
+      inner: inkPx(nodeId) + 2 * EXON_GAP_PX
+    }))
+  );
+}
+function exonOutlineTree(stretches, o) {
+  if (stretches.length === 0) {
+    return void 0;
+  }
+  const stroke = (s, color, width) => el("path", {
+    d: s.d,
+    fill: "none",
+    stroke: color,
+    "stroke-width": width,
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round",
+    "vector-effect": o.transform ? "non-scaling-stroke" : void 0
+  });
+  return el(
+    "g",
+    {},
+    el(
+      "mask",
+      {
+        id: o.id,
+        maskUnits: "userSpaceOnUse",
+        x: 0,
+        y: 0,
+        width: o.width,
+        height: o.height
+      },
+      el(
+        "g",
+        { transform: o.transform },
+        ...stretches.map((s) => stroke(s, "#fff", s.inner + 2 * EXON_LINE_PX)),
+        ...stretches.map((s) => stroke(s, "#000", s.inner))
+      )
+    ),
+    el("rect", {
+      width: o.width,
+      height: o.height,
+      fill: EXON_COLOR,
+      mask: `url(#${o.id})`
+    })
+  );
+}
+
 // src/genes/genePins.ts
 function genePins(graph, genes, positions) {
   const byRefName = /* @__PURE__ */ new Map();
   for (const node of graph.nodes) {
-    if (isBackbone(node)) {
+    if (isAnchored(node)) {
       const { refName } = node.stable;
       if (positions[node.id]?.length) {
         const entry = byRefName.get(refName) ?? byRefName.set(refName, { nodes: [], reach: 0 }).get(refName);
@@ -4770,17 +5301,18 @@ function genePins(graph, genes, positions) {
   }
   const pins = [];
   for (const gene of genes) {
-    const backbone = byRefName.get(gene.refName);
-    if (!backbone) {
+    const onRefName = byRefName.get(gene.refName);
+    if (!onRefName) {
       continue;
     }
     const parts = [];
     const exonsByNode = [];
+    const nodeIds = /* @__PURE__ */ new Set();
     let at;
     let atDistance = Infinity;
     let covered = 0;
     const mid = (gene.start + gene.end) / 2;
-    const { nodes, reach } = backbone;
+    const { nodes, reach } = onRefName;
     for (let i = firstNodeAtOrAfter(nodes, gene.start - reach); i < nodes.length && nodes[i].stable.start < gene.end; i++) {
       const node = nodes[i];
       const nodeStart = node.stable.start;
@@ -4789,6 +5321,7 @@ function genePins(graph, genes, positions) {
         continue;
       }
       const line = positions[node.id];
+      nodeIds.add(node.id);
       covered += Math.min(nodeEnd, gene.end) - Math.max(nodeStart, gene.start);
       const nodeParts = [];
       for (const exon of gene.exons) {
@@ -4828,6 +5361,7 @@ function genePins(graph, genes, positions) {
         gene,
         exons: parts.join(""),
         exonsByNode,
+        nodeIds,
         at,
         covered: covered / (gene.end - gene.start)
       });
@@ -4852,7 +5386,8 @@ function geneCoverageNote(pin) {
   const amount = (bp) => +(bp / per).toFixed(per === 1 ? 0 : 1);
   return `${amount(pin.covered * length)} of ${amount(length)} ${unit}`;
 }
-function geneLabelCandidates(pins, screen, contigThickness) {
+function geneLabelCandidates(pins, screen, contigThickness, nodesUnder) {
+  const ink = contigThickness / 2;
   return byExtent(pins, (pin) => pin.gene.end - pin.gene.start).map((pin) => {
     const { x, y } = screen(pin.at);
     const note = geneCoverageNote(pin);
@@ -4862,7 +5397,15 @@ function geneLabelCandidates(pins, screen, contigThickness) {
       y: y + contigThickness + GENE_PIN_DROP_PX,
       text: note ? `${pin.gene.name} \xB7 ${note}` : pin.gene.name,
       fallback: note ? `${pin.gene.name} \u2026` : void 0,
-      stack: GENE_STACK
+      stack: GENE_STACK,
+      fits: (box) => [
+        ...nodesUnder({
+          x0: box.x0 - ink,
+          x1: box.x1 + ink,
+          y0: box.y0 - ink,
+          y1: box.y1 + ink
+        })
+      ].every((id) => pin.nodeIds.has(id))
     };
   });
 }
@@ -4923,7 +5466,16 @@ function layoutLabels(m) {
     take
   );
   const genes = placeLabels(
-    geneLabelCandidates(m.genePins, screen, m.contigThickness),
+    geneLabelCandidates(
+      m.genePins,
+      screen,
+      m.contigThickness,
+      nodesUnderBox(
+        m.nodePositions ?? {},
+        { scaleX, scaleY, translateX, translateY },
+        m.positionsVersion
+      )
+    ),
     frame,
     take
   );
@@ -4932,6 +5484,7 @@ function layoutLabels(m) {
     nodeLengths: m.nodeLengths,
     deletions: m.showDeletionEdges ? m.deletions : [],
     deletionRoutes: m.deletionRoutes,
+    stranded: m.stranded,
     alleleDeletions: m.alleleDeletions,
     axis: m.axisScale,
     translateX,
@@ -5609,6 +6162,154 @@ function stripGeneGaps(frame, rowGenes, gaps) {
   return frame.boxesGenes ? gaps : { untracked: 0, unread: 0, ...gaps, crowded: true };
 }
 
+// src/reference.ts
+var WELL_KNOWN_SAMPLES = /* @__PURE__ */ new Map([
+  ["hg38", "GRCh38"],
+  ["hg19", "GRCh37"],
+  ["hs1", "CHM13"],
+  ["t2t-chm13", "CHM13"],
+  ["chm13v2", "CHM13"]
+]);
+function wellKnownSample(assemblyName) {
+  return WELL_KNOWN_SAMPLES.get(assemblyName.toLowerCase());
+}
+function sampleOf2(refName) {
+  const sample = refName.includes("#") ? panSNSample(refName) : void 0;
+  return sample === void 0 || isGenericSample(sample) ? void 0 : sample;
+}
+function haplotypeOf(refName) {
+  return panSNHaplotype(refName) ?? panSNSample(refName);
+}
+function graphHaplotypes(graph) {
+  const refNames = new Set((graph.anchorPaths ?? []).map((p) => p.name));
+  for (const node of graph.nodes) {
+    if (node.stable) {
+      refNames.add(node.stable.refName);
+    }
+  }
+  const bySample = /* @__PURE__ */ new Map();
+  for (const refName of refNames) {
+    const sample = sampleOf2(refName);
+    if (sample !== void 0) {
+      const haplotypes = bySample.get(sample) ?? bySample.set(sample, /* @__PURE__ */ new Set()).get(sample);
+      haplotypes.add(haplotypeOf(refName));
+    }
+  }
+  return bySample;
+}
+function backboneFrom(contigs, haplotypes) {
+  const samples = new Set(contigs.map((c) => sampleOf2(c.refName)));
+  const [sample] = samples;
+  if (samples.size !== 1 || sample === void 0) {
+    return { contigs, prefixes: [], named: false };
+  }
+  const own = new Set(contigs.map((c) => haplotypeOf(c.refName)));
+  const unique = [...haplotypes.get(sample) ?? []].every((h) => own.has(h));
+  const shared = new Set(contigs.map((c) => panSNHaplotype(c.refName)));
+  const [haplotype] = shared;
+  return {
+    contigs,
+    prefixes: [
+      ...unique ? [sample] : [],
+      ...shared.size === 1 && haplotype ? [haplotype] : []
+    ],
+    named: true
+  };
+}
+function graphBackbone(graph) {
+  const spans = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isBackbone(node)) {
+      const { refName, start } = node.stable;
+      const end = start + node.length;
+      const span = spans.get(refName);
+      if (span) {
+        span.start = Math.min(span.start, start);
+        span.end = Math.max(span.end, end);
+      } else {
+        spans.set(refName, {
+          refName,
+          contig: panSNContig(refName),
+          start,
+          end
+        });
+      }
+    }
+  }
+  const contigs = [...spans.values()];
+  return contigs.length ? backboneFrom(contigs, graphHaplotypes(graph)) : void 0;
+}
+function referenceLabel(graph, region) {
+  const backbone = graphBackbone(graph);
+  const contig = region ? panSNContig(region.refName) : backbone?.contigs.length === 1 ? backbone.contigs[0].contig : void 0;
+  const sample = backbone?.named ? panSNSample(backbone.contigs[0].refName) : void 0;
+  return contig && (sample ? `${sample} ${contig}` : contig);
+}
+function backboneAssembly(backbone, assemblies) {
+  const names = (a) => [a.name, ...a.aliases ?? []];
+  const naming = (prefix) => (a) => names(a).some((n2) => n2.toLowerCase() === prefix.toLowerCase());
+  const prefixes = [...backbone?.prefixes ?? []].reverse();
+  const sample = backbone?.prefixes.find((p) => !p.includes("#"))?.toLowerCase();
+  for (const prefix of prefixes) {
+    const assembly = assemblies.find(naming(prefix));
+    if (assembly) {
+      return assembly;
+    }
+  }
+  return sample === void 0 ? void 0 : assemblies.find(
+    (a) => names(a).some((n2) => wellKnownSample(n2)?.toLowerCase() === sample)
+  );
+}
+function assemblyWalk(graph, assembly) {
+  const haplotypes = graphHaplotypes(graph);
+  return graph.anchorPaths?.find(
+    (walk) => backboneAssembly(
+      backboneFrom(
+        [
+          {
+            refName: walk.name,
+            contig: panSNContig(walk.name),
+            start: walk.start,
+            end: walk.start + walk.length
+          }
+        ],
+        haplotypes
+      ),
+      [assembly]
+    )
+  );
+}
+function contigNames(contig) {
+  const bare = contig.replace(/^chr/i, "");
+  const forms = !bare ? [] : /^(M|MT)$/i.test(bare) ? ["M", "MT"] : [bare];
+  return [.../* @__PURE__ */ new Set([contig, ...forms.flatMap((f) => [f, `chr${f}`])])];
+}
+function refNameBinding(refNames, aliases = {}) {
+  const exact = new Set(refNames);
+  const byName = /* @__PURE__ */ new Map();
+  for (const refName of exact) {
+    const contig = panSNContig(refName);
+    const alias = aliases[contig];
+    for (const name of /* @__PURE__ */ new Set([
+      ...contigNames(contig),
+      ...alias ? [alias] : []
+    ])) {
+      byName.set(name, byName.has(name) ? void 0 : refName);
+    }
+  }
+  return (name) => exact.has(name) ? name : byName.get(name);
+}
+function featuresOnBackbone(features, backbone, aliases) {
+  const bind = refNameBinding(
+    backbone.contigs.map((c) => c.refName),
+    aliases
+  );
+  return features.flatMap((f) => {
+    const refName = bind(f.refName);
+    return refName === void 0 ? [] : [refName === f.refName ? f : { ...f, refName }];
+  });
+}
+
 // src/renderer/svgCanvas.ts
 var n = (v) => +v.toFixed(1);
 function paint(css) {
@@ -5722,7 +6423,7 @@ function svgCanvas(width, height) {
 }
 
 // src/version.ts
-var version = "5.0.1";
+var version = "5.2.0";
 
 // src/viewport.ts
 function axisScaleOf(scale, pixelRows) {
@@ -5772,11 +6473,7 @@ var SWATCH_PX = 18;
 var KEY_GAP_PX = 16;
 var STRIP_KEY_PX = 22;
 var FADED = "rgb(160,160,160)";
-var EXON_COLOR = "#daa520";
 var GENE_INK2 = "#1c1c22";
-var MIN_LANE_PX = 4;
-var EXON_GAP_PX = 1;
-var EXON_LINE_PX = 2;
 function esc(s) {
   return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
@@ -5793,6 +6490,12 @@ function keySvg(id, x, y, stops, label, after, under, opacity = 1) {
     markup: `${defs}<g transform="translate(${x} ${y})" ${FONT}><rect y="5" width="${bar}" height="8" rx="2" ${fill}/><text x="${bar + 5}" y="13"><tspan font-weight="bold">${esc(label)}</tspan>${esc(after)}</text>${under ? `<text y="28">${esc(under)}</text>` : ""}</g>`
   };
 }
+function exonKeySvg(x, y) {
+  return {
+    width: SWATCH_PX + 5 + 4 * LABEL_CHAR_PX,
+    markup: `<g transform="translate(${x} ${y})" ${FONT}><rect x="1" y="4" width="${SWATCH_PX - 2}" height="10" rx="4" fill="none" stroke="${EXON_COLOR}" stroke-width="2"/><text x="${SWATCH_PX + 5}" y="13">exon</text></g>`
+  };
+}
 function walkKeySvg(id, x, y, walk, label, reference) {
   const key = walkKey(walk, reference);
   return keySvg(
@@ -5845,9 +6548,10 @@ function figureSvg(graph, layout, o = {}) {
     ])
   );
   const labelOf2 = (name) => labels.get(name) ?? name;
+  const referenceName = o.referenceName ?? referenceLabel(graph, region);
   const reference = lift?.referenceDomain && {
     ...lift.referenceDomain,
-    name: region?.refName
+    name: referenceName
   };
   const contigThickness = o.contigThickness ?? 6;
   const nodeWidth2 = o.nodeWidth ?? "depth";
@@ -5856,24 +6560,12 @@ function figureSvg(graph, layout, o = {}) {
   let masks = 0;
   function overlays(highlight, t, w, h) {
     const out = [];
-    const inkPx = (nodeId) => {
-      const own = ink.halfWidthPx(nodeId) * 2;
-      return highlight?.nodeIds.has(nodeId) ? Math.max(own, highlight.walks.length * MIN_LANE_PX) : own;
-    };
-    const stretches = pins.flatMap(
-      (pin) => pin.exonsByNode.map(({ nodeId, d }) => ({
-        d: screenPath(d, t),
-        inner: inkPx(nodeId) + 2 * EXON_GAP_PX
-      }))
+    const outlines = exonOutlineTree(
+      exonStretches(pins, ink.halfWidthPx, highlight, (d) => screenPath(d, t)),
+      { id: `exons${masks++}`, width: w, height: h }
     );
-    if (stretches.length > 0) {
-      const id = `exons${masks++}`;
-      const stroke = (color, width2, d) => `<path d="${d}" fill="none" stroke="${color}" stroke-width="${width2}" stroke-linecap="round" stroke-linejoin="round"/>`;
-      out.push(
-        `<mask id="${id}" maskUnits="userSpaceOnUse" x="0" y="0" width="${w}" height="${h}">${stretches.map((s) => stroke("#fff", s.inner + 2 * EXON_LINE_PX, s.d)).join("")}${stretches.map((s) => stroke("#000", s.inner, s.d)).join(
-          ""
-        )}</mask><rect width="${w}" height="${h}" fill="${EXON_COLOR}" mask="url(#${id})"/>`
-      );
+    if (outlines) {
+      out.push(serializeEl(outlines));
     }
     const screen = (p) => ({
       x: p.x * t.scaleX + t.translateX,
@@ -5881,7 +6573,12 @@ function figureSvg(graph, layout, o = {}) {
     });
     const frame = { width: w, height: h };
     for (const { item: pin, x, y, w: cw, text } of placeLabels(
-      geneLabelCandidates(pins, screen, contigThickness),
+      geneLabelCandidates(
+        pins,
+        screen,
+        contigThickness,
+        nodesUnderBox(layout.nodePositions, t)
+      ),
       frame,
       occupancy(frame)
     )) {
@@ -5953,6 +6650,7 @@ function figureSvg(graph, layout, o = {}) {
         referenceRamp,
         deletions: new Map(deletions.map((d) => [d.edgeIndex, d.bypassed])),
         deletionRoutes: layout.deletionRoutes,
+        stranded: layout.stranded,
         hiddenEdges: new Set(
           o.showDeletionEdges ? [] : deletions.map((d) => d.edgeIndex)
         )
@@ -6036,16 +6734,19 @@ function figureSvg(graph, layout, o = {}) {
           x,
           2,
           encodingStops({ field: "reference", scheme: "rainbow" }),
-          "Reference position",
+          referenceName ? `${referenceName} position` : "Reference position",
           "",
           rangeText(
-            region?.refName,
+            referenceName,
             referenceRamp.start,
             referenceRamp.start + referenceRamp.span
           )
         )
       );
     }
+    if (pins.some((pin) => pin.exonsByNode.length > 0)) {
+      push(exonKeySvg(x, 2));
+    }
     const header = parts.length > 0 ? FACET_TITLE_PX : 0;
     const usable = width - 2 * FIT_PADDING;
     const drawn = pixelRows || !(bounds.w > 0) ? bounds.h : bounds.h * usable / bounds.w;
@@ -6198,14 +6899,22 @@ function genesFromGff3Lines(lines) {
     const start = top?.start ?? Math.min(...rows2.map((r) => r.start));
     const end = top?.end ?? Math.max(...rows2.map((r) => r.end));
     const a = first.attrs;
-    const exons = rows2.filter((r) => r.type === "exon").map((r) => ({ start: r.start, end: r.end }));
+    const spans = (type) => rows2.filter((r) => r.type === type).map((r) => ({ start: r.start, end: r.end }));
+    const exons = spans("exon");
+    const coding = spans("CDS");
+    const transcribed = rows2.some(
+      (r) => r !== top && r.type !== "exon" && r.type !== "CDS"
+    );
     genes.push({
       name: a.get("Name") ?? a.get("gene_name") ?? a.get("gene") ?? a.get("gene_id") ?? key.split("	")[1],
       refName: first.refName,
       start,
       end,
       strand: first.strand,
-      exons: exons.length ? mergedIntervals(exons) : [{ start, end }]
+      // A range read holds only the rows over its window, so a gene with
+      // transcripts but no exon or CDS there is intronic in it. Only a gene
+      // with no transcripts, as a bacterium's gene and CDS, is one exon.
+      exons: exons.length ? mergedIntervals(exons) : transcribed ? mergedIntervals(coding) : [{ start, end }]
     });
   }
   return genes;
@@ -6261,148 +6970,6 @@ function genesFromText(text) {
   return /^\d+$/.test(cols[1] ?? "") && /^\d+$/.test(cols[2] ?? "") ? genesFromBed(text) : genesFromGff3Lines(text.split(/\r?\n/));
 }
 
-// src/reference.ts
-var WELL_KNOWN_SAMPLES = /* @__PURE__ */ new Map([
-  ["hg38", "GRCh38"],
-  ["hg19", "GRCh37"],
-  ["hs1", "CHM13"],
-  ["t2t-chm13", "CHM13"],
-  ["chm13v2", "CHM13"]
-]);
-function wellKnownSample(assemblyName) {
-  return WELL_KNOWN_SAMPLES.get(assemblyName.toLowerCase());
-}
-function sampleOf2(refName) {
-  const sample = refName.includes("#") ? panSNSample(refName) : void 0;
-  return sample === void 0 || isGenericSample(sample) ? void 0 : sample;
-}
-function haplotypeOf(refName) {
-  return panSNHaplotype(refName) ?? panSNSample(refName);
-}
-function graphHaplotypes(graph) {
-  const refNames = new Set((graph.anchorPaths ?? []).map((p) => p.name));
-  for (const node of graph.nodes) {
-    if (node.stable) {
-      refNames.add(node.stable.refName);
-    }
-  }
-  const bySample = /* @__PURE__ */ new Map();
-  for (const refName of refNames) {
-    const sample = sampleOf2(refName);
-    if (sample !== void 0) {
-      const haplotypes = bySample.get(sample) ?? bySample.set(sample, /* @__PURE__ */ new Set()).get(sample);
-      haplotypes.add(haplotypeOf(refName));
-    }
-  }
-  return bySample;
-}
-function backboneFrom(contigs, haplotypes) {
-  const samples = new Set(contigs.map((c) => sampleOf2(c.refName)));
-  const [sample] = samples;
-  if (samples.size !== 1 || sample === void 0) {
-    return { contigs, prefixes: [], named: false };
-  }
-  const own = new Set(contigs.map((c) => haplotypeOf(c.refName)));
-  const unique = [...haplotypes.get(sample) ?? []].every((h) => own.has(h));
-  const shared = new Set(contigs.map((c) => panSNHaplotype(c.refName)));
-  const [haplotype] = shared;
-  return {
-    contigs,
-    prefixes: [
-      ...unique ? [sample] : [],
-      ...shared.size === 1 && haplotype ? [haplotype] : []
-    ],
-    named: true
-  };
-}
-function graphBackbone(graph) {
-  const spans = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    if (isBackbone(node)) {
-      const { refName, start } = node.stable;
-      const end = start + node.length;
-      const span = spans.get(refName);
-      if (span) {
-        span.start = Math.min(span.start, start);
-        span.end = Math.max(span.end, end);
-      } else {
-        spans.set(refName, {
-          refName,
-          contig: panSNContig(refName),
-          start,
-          end
-        });
-      }
-    }
-  }
-  const contigs = [...spans.values()];
-  return contigs.length ? backboneFrom(contigs, graphHaplotypes(graph)) : void 0;
-}
-function backboneAssembly(backbone, assemblies) {
-  const names = (a) => [a.name, ...a.aliases ?? []];
-  const naming = (prefix) => (a) => names(a).some((n2) => n2.toLowerCase() === prefix.toLowerCase());
-  const prefixes = [...backbone?.prefixes ?? []].reverse();
-  const sample = backbone?.prefixes.find((p) => !p.includes("#"))?.toLowerCase();
-  for (const prefix of prefixes) {
-    const assembly = assemblies.find(naming(prefix));
-    if (assembly) {
-      return assembly;
-    }
-  }
-  return sample === void 0 ? void 0 : assemblies.find(
-    (a) => names(a).some((n2) => wellKnownSample(n2)?.toLowerCase() === sample)
-  );
-}
-function assemblyWalk(graph, assembly) {
-  const haplotypes = graphHaplotypes(graph);
-  return graph.anchorPaths?.find(
-    (walk) => backboneAssembly(
-      backboneFrom(
-        [
-          {
-            refName: walk.name,
-            contig: panSNContig(walk.name),
-            start: walk.start,
-            end: walk.start + walk.length
-          }
-        ],
-        haplotypes
-      ),
-      [assembly]
-    )
-  );
-}
-function contigNames(contig) {
-  const bare = contig.replace(/^chr/i, "");
-  const forms = !bare ? [] : /^(M|MT)$/i.test(bare) ? ["M", "MT"] : [bare];
-  return [.../* @__PURE__ */ new Set([contig, ...forms.flatMap((f) => [f, `chr${f}`])])];
-}
-function refNameBinding(refNames, aliases = {}) {
-  const exact = new Set(refNames);
-  const byName = /* @__PURE__ */ new Map();
-  for (const refName of exact) {
-    const contig = panSNContig(refName);
-    const alias = aliases[contig];
-    for (const name of /* @__PURE__ */ new Set([
-      ...contigNames(contig),
-      ...alias ? [alias] : []
-    ])) {
-      byName.set(name, byName.has(name) ? void 0 : refName);
-    }
-  }
-  return (name) => exact.has(name) ? name : byName.get(name);
-}
-function featuresOnBackbone(features, backbone, aliases) {
-  const bind = refNameBinding(
-    backbone.contigs.map((c) => c.refName),
-    aliases
-  );
-  return features.flatMap((f) => {
-    const refName = bind(f.refName);
-    return refName === void 0 ? [] : [refName === f.refName ? f : { ...f, refName }];
-  });
-}
-
 // src/gbzJoin.ts
 var UNKNOWN_SAMPLE = "unknown";
 function parseWalk(line) {
@@ -6546,7 +7113,9 @@ var NodeLimitError = class extends Error {
     super(
       `this ${windowBp.toLocaleString()} bp window reads more than nodeLimit (${limit.toLocaleString()}) graph nodes; zoom in to about ${fitsBp.toLocaleString()} bp or raise nodeLimit`
     );
+    this.fitsBp = fitsBp;
     this.name = "NodeLimitError";
+    this.regionTooLarge = true;
   }
 };
 function haplotypePrefix(name) {
@@ -6691,10 +7260,6 @@ export {
   BUBBLE_SPREADS,
   ROW_HEIGHT_PX,
   svgPath,
-  curveBounds,
-  translateCurves,
-  yToXOf,
-  pathRibbonOffsets,
   deletionEdges,
   panSNSample,
   panSNHaplotype,
@@ -6730,7 +7295,6 @@ export {
   nodeWidthPx,
   maxNodeWidthPx,
   nodeInk,
-  baseEdgeCurves,
   LIFT_BACKDROP_CSS,
   REFERENCE_RAMP_MAX_HUE,
   computeReferenceRamp,
@@ -6738,6 +7302,8 @@ export {
   getNodeColor,
   buildGeometry,
   Canvas2DRenderer,
+  findHoveredNode,
+  findHoveredEdge,
   WALK_FIELDS,
   WALK_SCHEMES,
   resolveEncoding,
@@ -6758,6 +7324,9 @@ export {
   facetGrid,
   facetSettingOf,
   facetCells,
+  EXON_COLOR,
+  exonStretches,
+  exonOutlineTree,
   genePins,
   HALO_FACTOR,
   LEGEND_INSET_PX,
@@ -6796,6 +7365,14 @@ export {
   walkMarksTree,
   walkStripLabelsTree,
   stripGeneGaps,
+  WELL_KNOWN_SAMPLES,
+  wellKnownSample,
+  graphBackbone,
+  referenceLabel,
+  backboneAssembly,
+  assemblyWalk,
+  refNameBinding,
+  featuresOnBackbone,
   svgCanvas,
   version,
   axisScaleOf,
@@ -6809,13 +7386,6 @@ export {
   mergeOverlappingByName,
   genesFromBed,
   genesFromText,
-  WELL_KNOWN_SAMPLES,
-  wellKnownSample,
-  graphBackbone,
-  backboneAssembly,
-  assemblyWalk,
-  refNameBinding,
-  featuresOnBackbone,
   haplotypeWanted,
   referenceSamplesOf,
   resolveReferenceSample,