@jbrowse/bandage-core 11.7.3 → 11.8.0

package/README.md

@@ -43,7 +43,7 @@ npm install @jbrowse/bandage-core
   backbone lies on. `featuresOnBackbone` renames that assembly's genes onto the
   backbone's refNames, and `genePins` pins only those
 
-## Figures and the coarse tier
+## Figures
 
 - `figureSvg` draws a graph and its lifted walks to a standalone SVG. The
   `bandage-figure` CLI makes one from a JSON spec with no browser:
@@ -52,9 +52,43 @@ npm install @jbrowse/bandage-core
 - `figureData` returns what `figureSvg` would draw as columnar tables, for
   another graphics system to draw;
   [ggbandage](https://github.com/GMOD/ggbandage) draws them in ggplot2
-- The `bandage-fold` CLI folds every variant under a size into the reference, so
-  a graph track can draw a whole chromosome. See
-  [docs/coarse-tier.md](docs/coarse-tier.md)
+
+## Coarse tier: `bandage-fold`
+
+`bandage-fold` writes an rGFA with every variant under `--below` bp folded into
+the reference. Indexed by gfa-to-tabix, the output is the coarse tier a graph
+track draws once zoomed out past the fine index, so a whole chromosome fits.
+[`gfa-to-tabix fold`](https://github.com/GMOD/gfa-to-tabix/blob/main/docs/subcommands.md#fold)
+documents the fold and the handover from the fine index.
+
+```console
+npx -p @jbrowse/bandage-core bandage-fold graph.rgfa.gz --below 10000 \
+  | gfa-to-tabix - -o graph.fold10000
+```
+
+- The input is a GFA or rGFA, plain or gzipped, or `-` for stdin. `-o out.gfa`
+  writes a file in place of stdout
+- `--reference PATH` names a plain GFA's backbone path. In an rGFA, the segments
+  tagged `SR:i:0` form the backbone
+- The fold keeps the backbone, every allele whose own length or the reference it
+  replaces reaches `--below`, and the shortest way from each one's ends back to
+  the backbone. It joins the reference between kept alleles into one segment
+- `bandage-fold` drops paths and walks from the output. It writes forward a
+  segment that a plain GFA's path reads reversed, and flips its links to match,
+  so the output re-reads as the graph that was folded
+- gfa-to-tabix's `--layout anchored|contig` should match the fine index's. An
+  anchored window inside a large bubble then returns the whole bubble in both
+  tiers, and a contig one only what links reach from it
+- The graph track folds each cut it draws at ten pixels (`FOLD_PX` in
+  jbrowse-plugin-graphgenomeviewer), and folding a fold again at a larger size
+  closely matches folding the original at that size. A tier folded at N and
+  handed over at N / 10 bp per pixel, such as
+  `coarse: { uri: "graph.fold10000", aboveBpPerPx: 1000 }`, therefore draws
+  nearly what the fine cut drew
+- Node caps a string at 512 MB, and `bandage-fold` reads the whole graph into
+  one, so it cannot fold a whole human pangenome. `gfa-to-tabix fold`, a port of
+  the same fold, writes the index in one pass:
+  `gfa-to-tabix fold graph.rgfa.gz --below 10000 -o graph.fold10000`
 
 ## Developing
 
@@ -64,21 +98,27 @@ pnpm test          # unit tests
 pnpm build         # dist/ with declarations
 ```
 
-The FMMM engine and its wasm build are in
-[graph-fmmm-layout](https://github.com/GMOD/graph-fmmm-layout).
-
-CI also packs the core and runs the typecheck and tests of
-[BandageJS](https://github.com/cmdcolin/BandageJS) and
-[jbrowse-plugin-graphgenomeviewer](https://github.com/GMOD/jbrowse-plugin-graphgenomeviewer)
-against it. For an API change, push the consumer's matching change to a
-`core-next` branch in that consumer's repo, which CI tests in place of `main`
-until the release.
-
-Release with `pnpm version patch`: it lints, tests, stamps `src/version.ts`,
-writes the changelog with git-cliff and pushes the `v*` tag. `publish.yml` then
-runs CI, consumers included, and publishes to npm with trusted publishing only
-if it passes. When a consumer fails, push its side to `core-next` and rerun the
-failed jobs.
+- The FMMM engine and its wasm build are in
+  [graph-fmmm-layout](https://github.com/GMOD/graph-fmmm-layout)
+- CI also packs the core and runs the typecheck and tests of
+  [BandageJS](https://github.com/cmdcolin/BandageJS) and
+  [jbrowse-plugin-graphgenomeviewer](https://github.com/GMOD/jbrowse-plugin-graphgenomeviewer)
+  against it. For an API change, push the consumer's matching change to a
+  `core-next` branch in that consumer's repo, which CI tests in place of `main`
+  until the release
+- `src/foldParity.test.ts` folds a few hundred random rGFA graphs with
+  `foldVariants` and with the gfa-to-tabix release that
+  `.github/actions/gfa-to-tabix` pins, and fails when they fold differently.
+  Locally the test runs the `gfa-to-tabix` on PATH or named by `GFA_TO_TABIX`,
+  and skips without one. In the other direction, gfa-to-tabix's
+  `scripts/parity-fold.sh` checks that `gfa-to-tabix fold` writes the same bytes
+  as `bandage-fold | gfa-to-tabix -`, and its CI tests the port against a pinned
+  bandage-core
+- Release with `pnpm version patch`: it lints, tests, stamps `src/version.ts`,
+  writes the changelog with git-cliff and pushes the `v*` tag. `publish.yml`
+  then runs CI, consumers included, and publishes to npm with trusted publishing
+  only if it passes. When a consumer fails, push its side to `core-next` and
+  rerun the failed jobs
 
 ## See also
 

package/dist/bubbles/bubbleHalos.js

@@ -1,17 +1,17 @@
 import {
   bubbleHalos,
   coversGraph
-} from "../chunks/chunk-BLDUBB7X.js";
-import "../chunks/chunk-AWJJSA7D.js";
+} from "../chunks/chunk-4YPCUVMC.js";
+import "../chunks/chunk-OIOAK7BS.js";
 import "../chunks/chunk-FX4RDMDN.js";
-import "../chunks/chunk-N73RA4DR.js";
+import "../chunks/chunk-6CXLLJ2C.js";
 import "../chunks/chunk-HMXCN6PG.js";
 import "../chunks/chunk-AB35TJST.js";
-import "../chunks/chunk-2VMKQKVO.js";
-import "../chunks/chunk-P276TWPM.js";
+import "../chunks/chunk-YIWN32ZX.js";
+import "../chunks/chunk-3CXZUC2Y.js";
 import "../chunks/chunk-TLWXLNLY.js";
 import "../chunks/chunk-3YBP46PB.js";
-import "../chunks/chunk-VACK24HF.js";
+import "../chunks/chunk-735MPLUL.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-ZPZ7GNBT.js";
 import "../chunks/chunk-BSOZW3FC.js";

package/dist/bubbles/classifyBubble.js

@@ -3,16 +3,16 @@ import {
   BUBBLE_KIND_NAMES,
   bubbleSegmentIds,
   classifyBubble
-} from "../chunks/chunk-AWJJSA7D.js";
+} from "../chunks/chunk-OIOAK7BS.js";
 import "../chunks/chunk-FX4RDMDN.js";
-import "../chunks/chunk-N73RA4DR.js";
+import "../chunks/chunk-6CXLLJ2C.js";
 import "../chunks/chunk-HMXCN6PG.js";
 import "../chunks/chunk-AB35TJST.js";
-import "../chunks/chunk-2VMKQKVO.js";
-import "../chunks/chunk-P276TWPM.js";
+import "../chunks/chunk-YIWN32ZX.js";
+import "../chunks/chunk-3CXZUC2Y.js";
 import "../chunks/chunk-TLWXLNLY.js";
 import "../chunks/chunk-3YBP46PB.js";
-import "../chunks/chunk-VACK24HF.js";
+import "../chunks/chunk-735MPLUL.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-ZPZ7GNBT.js";
 import "../chunks/chunk-BSOZW3FC.js";

package/dist/bubbles/superbubbles.js

@@ -1,22 +1,22 @@
 import {
   graphBubbles,
   superbubblesFromGraph
-} from "../chunks/chunk-KMLATBNT.js";
-import "../chunks/chunk-BLDUBB7X.js";
+} from "../chunks/chunk-SIXFXXRI.js";
+import "../chunks/chunk-4YPCUVMC.js";
 import "../chunks/chunk-RFG42VIO.js";
-import "../chunks/chunk-AWJJSA7D.js";
+import "../chunks/chunk-OIOAK7BS.js";
 import "../chunks/chunk-FX4RDMDN.js";
 import "../chunks/chunk-MHZTTLBU.js";
 import "../chunks/chunk-UAFATXYA.js";
 import "../chunks/chunk-VX656OAZ.js";
-import "../chunks/chunk-N73RA4DR.js";
+import "../chunks/chunk-6CXLLJ2C.js";
 import "../chunks/chunk-HMXCN6PG.js";
 import "../chunks/chunk-AB35TJST.js";
-import "../chunks/chunk-2VMKQKVO.js";
-import "../chunks/chunk-P276TWPM.js";
+import "../chunks/chunk-YIWN32ZX.js";
+import "../chunks/chunk-3CXZUC2Y.js";
 import "../chunks/chunk-TLWXLNLY.js";
 import "../chunks/chunk-3YBP46PB.js";
-import "../chunks/chunk-VACK24HF.js";
+import "../chunks/chunk-735MPLUL.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-ZPZ7GNBT.js";
 import "../chunks/chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-ZZZ6NVLW.js → chunk-22ZMVREZ.js}

@@ -1,6 +1,6 @@
 import {
   ownStrand
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 import {
   isBackbone
 } from "./chunk-RJWPJCIB.js";

package/dist/chunks/{chunk-VXKL2ZLR.js → chunk-2H3ALI6L.js}

@@ -1,3 +1,19 @@
+import {
+  LANE_SMOOTHING_PX,
+  THREAD_PITCH_PX,
+  THREAD_PX,
+  THREAD_REACH_PX,
+  THREAD_TAPER_PX,
+  bandScale,
+  bandSpans,
+  bandWidthPx,
+  laneLines,
+  laneRuns,
+  laneSlideAt,
+  slotCentres,
+  threadsPasses,
+  walkThreads
+} from "./chunk-7GDNDQD7.js";
 import {
   abgrToCssRgba,
   fadeAbgr,
@@ -10,13 +26,13 @@ import {
 } from "./chunk-GQZVR5DW.js";
 import {
   baseEdgeCurves
-} from "./chunk-33KUO34R.js";
+} from "./chunk-VSRRIFRF.js";
 import {
   PATH_LIGHTNESS,
   PATH_SATURATION,
   nameHue,
   pathHueAt
-} from "./chunk-GD6RUZU5.js";
+} from "./chunk-JKIAHYAW.js";
 import {
   meanDepth,
   nodeWidthPx,
@@ -26,13 +42,14 @@ import {
   referenceMidpoints
 } from "./chunk-VX656OAZ.js";
 import {
-  dashCurves,
+  dashSpans,
   pathRibbonOffsets,
   polylinePx,
+  slideCurves,
   strandSides,
   translateCurves,
   yToXOf
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";
@@ -149,13 +166,16 @@ function arrowheadFor({
     color
   };
 }
-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);
+var FIRST_THREADS = [[0, 0]];
+var ONE_PASS = [0];
+var NO_SHIFT = { dx: 0, dy: 0 };
+function nearerStart(at, segments, yToX) {
+  const gap = (p) => Math.hypot(p.x - at.x, (p.y - at.y) * yToX);
   return gap(segments[0]) < gap(segments.at(-1));
 }
+function leavesStart(edge, segments, first, stranded, yToX) {
+  return stranded ? strandSides(edge).from === "start" : nearerStart({ x: first.x0, y: first.y0 }, segments, yToX);
+}
 function intoDirection(last, toSegments) {
   if (toSegments.length < 2) {
     return void 0;
@@ -496,6 +516,74 @@ function buildGeometry(options) {
   const { pathColorByIndex, pathIndexByName } = pathPaletteOf(graph);
   const pathColorByName = (name) => pathColorByIndex[pathIndexByName.get(name) ?? -1] ?? EDGE_PATH_FALLBACK_COLOR;
   const nodePathSlots = drawPaths && pathCount > 1 ? pathSlotsOf(graph) : NO_SLOTS;
+  const liftedWalks = highlight?.walks ?? [];
+  const threaded = threadsPasses(liftedWalks);
+  const lanePasses = liftedWalks.map((w) => w.mostPasses);
+  const thinned = threaded ? bandScale(lanePasses) : 1;
+  const runs = liftedWalks.length > 1 ? laneRuns(
+    liftedWalks.flatMap((w) => w.route),
+    nodePositions,
+    yToX,
+    LANE_SMOOTHING_PX * worldPerScreenPx
+  ) : void 0;
+  const lines = runs ? laneLines(
+    runs,
+    nodePositions,
+    yToX,
+    LANE_SMOOTHING_PX * worldPerScreenPx,
+    bandWidthPx(lanePasses) * thinned * worldPerScreenPx,
+    threaded
+  ) : void 0;
+  const threads = threaded ? liftedWalks.map(
+    (w) => walkThreads(
+      w.route,
+      w.passes,
+      nodePositions,
+      yToX,
+      THREAD_REACH_PX * worldPerScreenPx
+    )
+  ) : void 0;
+  const spanField = runs && threads ? bandSpans(
+    runs,
+    threads.map((t) => t.span),
+    {
+      reach: THREAD_REACH_PX * worldPerScreenPx,
+      taper: THREAD_TAPER_PX * worldPerScreenPx
+    }
+  ) : void 0;
+  const edgeKeys = new Set(
+    threads ? graph.edges.map((e) => `${e.from}>${e.to}`) : []
+  );
+  const centresByNode = /* @__PURE__ */ new Map();
+  const laneOffset = (nodeId, laneWidth, lane, pass) => {
+    if (!threaded) {
+      return (lane - (liftedWalks.length - 1) / 2) * laneWidth;
+    }
+    let centres = centresByNode.get(nodeId);
+    if (!centres) {
+      const spans = spanField?.get(nodeId);
+      centres = slotCentres(spans?.slot ?? lanePasses, lanePasses, spans?.held);
+      centresByNode.set(nodeId, centres);
+    }
+    return (centres[lane] + pass * THREAD_PITCH_PX) * thinned;
+  };
+  const laneHalfWidth = (laneWidth) => threaded ? THREAD_PX / 2 * thinned : laneWidth / 2;
+  const laneNormals = /* @__PURE__ */ new Map();
+  const laneNormalsOf = (nodeId, segments) => {
+    let normals = laneNormals.get(nodeId);
+    if (!normals) {
+      const smoothed = lines?.normals.get(nodeId);
+      normals = smoothed ? pointNormalsOf(segments, yToX).map((n, i) => smoothed[i] ?? n) : pointNormalsOf(segments, yToX);
+      laneNormals.set(nodeId, normals);
+    }
+    return normals;
+  };
+  const laneWidths = /* @__PURE__ */ new Map();
+  const laneShiftOf = (nodeId, index) => lines?.shifts.get(nodeId)?.[index] ?? NO_SHIFT;
+  const lanePointsOf = (nodeId, segments) => lines?.shifts.has(nodeId) ? segments.map((p, i) => {
+    const { dx, dy } = laneShiftOf(nodeId, i);
+    return { ...p, x: p.x + dx, y: p.y + dy };
+  }) : segments;
   const showArrows = scale > (linearLayout ? 1 : MIN_ARROW_SCALE);
   for (let ei = 0; ei < graph.edges.length; ei++) {
     const edge = graph.edges[ei];
@@ -516,18 +604,37 @@ function buildGeometry(options) {
     const toNode = nodeById.get(edge.to);
     const intoHalfWidth = (toNode ? nodeWidthPx(toNode, contigThickness, nodeWidth, depthNorm) : contigThickness) / 2;
     const inView = (curves) => !viewportBounds || isBezierInBounds(curves, viewportBounds);
-    const stroke = (curves, thickness, color) => {
-      if (isDeletion) {
-        for (const dash of dashCurves(
-          curves,
-          DELETION_DASH_PX / scale,
-          yToX,
-          viewportBounds
-        )) {
-          edgeCurves.push({ curves: dash, thickness, color });
+    const stroke = (curves, thickness, color, lane) => {
+      const push = (pieces, from = 0, to = 1) => {
+        if (!lane) {
+          edgeCurves.push({ curves: pieces, thickness, color });
+          return;
         }
-      } else {
-        edgeCurves.push({ curves, thickness, color });
+        const start = from === 0 ? lane.start : laneSlideAt(lane.start, lane.end, from);
+        const end = to === 1 ? lane.end : laneSlideAt(lane.start, lane.end, to);
+        edgeCurves.push({
+          curves: pieces,
+          thickness,
+          color,
+          walk: lane.walk,
+          pass: lane.pass,
+          normal: start.normal,
+          offsetX: start.offsetX,
+          endNormal: end.normal,
+          endOffsetX: end.offsetX
+        });
+      };
+      if (!isDeletion) {
+        push(curves);
+        return;
+      }
+      for (const dash of dashSpans(
+        curves,
+        DELETION_DASH_PX / scale,
+        yToX,
+        viewportBounds
+      )) {
+        push(dash.curves, dash.startAlong, dash.endAlong);
       }
     };
     const arrowOn = (curves) => {
@@ -549,32 +656,86 @@ function buildGeometry(options) {
     const arrowStart = arrows.length;
     const laneWalks = highlight?.walks.length && onWalk && !ribbons ? highlight.walks : void 0;
     if (laneWalks) {
-      const fromNode = nodeById.get(edge.from);
-      const width = fromNode ? nodeWidthPx(fromNode, contigThickness, nodeWidth, depthNorm) : contigThickness;
-      const laneWidth = walkLaneWidthPx(width, laneWalks.length);
-      const normals = pointNormalsOf(fromSegments, yToX);
-      const { nx, ny } = (leavesStart(
-        edge,
+      const laneWidthOf = (id) => {
+        let width = laneWidths.get(id);
+        if (width === void 0) {
+          const node = nodeById.get(id);
+          width = walkLaneWidthPx(
+            node ? nodeWidthPx(node, contigThickness, nodeWidth, depthNorm) : contigThickness,
+            laneWalks.length
+          );
+          laneWidths.set(id, width);
+        }
+        return width;
+      };
+      const endOf = (id, segments, atStart) => {
+        const at = atStart ? 0 : segments.length - 1;
+        return {
+          id,
+          laneWidth: laneWidthOf(id),
+          normal: laneNormalsOf(id, segments)[at] ?? { nx: 0, ny: 0 },
+          shift: laneShiftOf(id, at)
+        };
+      };
+      const from = endOf(
+        edge.from,
         fromSegments,
-        baseCurves[0],
-        stranded,
-        yToX
-      ) ? normals[0] : normals.at(-1)) ?? {
-        nx: 0,
-        ny: 0
+        leavesStart(edge, fromSegments, baseCurves[0], stranded, yToX)
+      );
+      const last = baseCurves.at(-1);
+      const to = threaded ? endOf(
+        edge.to,
+        toSegments,
+        nearerStart({ x: last.x1, y: last.y1 }, toSegments, yToX)
+      ) : from;
+      const slideOf = (end, offsetX) => ({
+        dx: end.shift.dx + end.normal.nx * offsetX,
+        dy: end.shift.dy + end.normal.ny * offsetX / yToX
+      });
+      const aheadKey = threads ? `${edge.from}>${edge.to}` : "";
+      const backKey = threads ? `${edge.to}>${edge.from}` : "";
+      const pairsOf = (lane) => {
+        const own = threads?.[lane]?.linkThreads;
+        if (!own?.size) {
+          return FIRST_THREADS;
+        }
+        const ahead = own.get(aheadKey);
+        const back = edgeKeys.has(backKey) ? void 0 : own.get(backKey);
+        if (!back) {
+          return ahead ?? FIRST_THREADS;
+        }
+        const turned = back.map(([a, b]) => [b, a]);
+        return ahead ? [...ahead, ...turned] : turned;
       };
+      const single = laneWalks.length === 1;
       laneWalks.forEach((walk, lane) => {
         if (!walk.edgeIndexes.has(ei)) {
           return;
         }
-        const offset = (lane - (laneWalks.length - 1) / 2) * laneWidth * worldPerScreenPx;
-        const curves = offset === 0 ? baseCurves : translateCurves(baseCurves, nx * offset, ny * offset / yToX);
-        if (inView(curves)) {
-          stroke(
-            curves,
-            laneWidth / 2,
-            walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor
+        for (const [pass, toPass] of pairsOf(lane)) {
+          const offsetX = single ? 0 : laneOffset(from.id, from.laneWidth, lane, pass) * worldPerScreenPx;
+          const start = { normal: from.normal, offsetX };
+          const end = threaded ? {
+            normal: to.normal,
+            offsetX: laneOffset(to.id, to.laneWidth, lane, toPass) * worldPerScreenPx
+          } : start;
+          const curves = threaded ? slideCurves(
+            baseCurves,
+            slideOf(from, start.offsetX),
+            slideOf(to, end.offsetX)
+          ) : offsetX === 0 ? baseCurves : translateCurves(
+            baseCurves,
+            from.normal.nx * offsetX,
+            from.normal.ny * offsetX / yToX
           );
+          if (inView(curves)) {
+            stroke(
+              curves,
+              laneHalfWidth(from.laneWidth),
+              walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor,
+              { walk: lane, pass, start, end }
+            );
+          }
         }
       });
       if (edgeCurves.length > edgeCurveStart) {
@@ -644,17 +805,34 @@ function buildGeometry(options) {
     const lanes = highlight?.walks.length && !faded && !slots?.length ? highlight.walks : void 0;
     if (drawable && lanes) {
       const laneWidth = walkLaneWidthPx(width, lanes.length);
-      const normals = pointNormalsOf(segments, yToX);
+      const normals = lanes.length > 1 ? laneNormalsOf(nodeId, segments) : [];
+      const points = lanes.length > 1 ? lanePointsOf(nodeId, segments) : segments;
       lanes.forEach((walk, lane) => {
         const laneColor = walk.colors.get(nodeId);
         if (laneColor === void 0) {
           return;
         }
-        const offset = (lane - (lanes.length - 1) / 2) * laneWidth * worldPerScreenPx;
-        nodeStrokes.push({
-          points: lanes.length === 1 ? segments : offsetPolyline(segments, normals, offset, yToX),
-          thickness: laneWidth / 2,
-          color: laneColor
+        const onThreads = threads?.[lane]?.nodeThreads.get(nodeId) ?? ONE_PASS;
+        const thickness = laneHalfWidth(laneWidth);
+        onThreads.forEach((pass) => {
+          const offsetX = lanes.length === 1 ? 0 : laneOffset(nodeId, laneWidth, lane, pass) * worldPerScreenPx;
+          nodeStrokes.push(
+            lanes.length === 1 ? {
+              points: segments,
+              thickness,
+              color: laneColor,
+              walk: lane,
+              pass
+            } : {
+              points: offsetPolyline(points, normals, offsetX, yToX),
+              thickness,
+              color: laneColor,
+              walk: lane,
+              pass,
+              normals,
+              offsetX
+            }
+          );
         });
       });
     } else if (drawable && slots?.length && slotWidth >= MIN_PATH_STRIPE_PX) {

package/dist/chunks/{chunk-F4CDC72I.js → chunk-2RCKHCF7.js}

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

package/dist/chunks/{chunk-P276TWPM.js → chunk-3CXZUC2Y.js}

@@ -9,7 +9,7 @@ import {
   edgeJoinOf,
   routedEdgeCurves,
   strandSides
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 import {
   groupBy
 } from "./chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-VNF236GG.js → chunk-3XYLEK4H.js}

@@ -3,7 +3,7 @@ import {
   hasTubeMapPaths,
   tubeMapLayout,
   tubeMapReferenceLayout
-} from "./chunk-63XWYNID.js";
+} from "./chunk-G4WQBRDS.js";
 import {
   sampleRowLayout
 } from "./chunk-XR2HMGAS.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-UAFATXYA.js";
 import {
   walkRowLayout
-} from "./chunk-SENPGW4O.js";
+} from "./chunk-VCUOYVLC.js";
 import {
   isBackbone,
   isOffReference

package/dist/chunks/{chunk-PKGPSTRW.js → chunk-4OVIUCSB.js}

@@ -3,14 +3,14 @@ import {
   boxesGenes,
   rowPitch,
   rowSpan
-} from "./chunk-EPOPGV5G.js";
+} from "./chunk-LA6JHEVV.js";
 import {
   el
 } from "./chunk-H2H4Y3TV.js";
 import {
   READOUT_ROOM,
   longestBar
-} from "./chunk-SENPGW4O.js";
+} from "./chunk-VCUOYVLC.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";

package/dist/chunks/{chunk-BLDUBB7X.js → chunk-4YPCUVMC.js}

@@ -1,10 +1,10 @@
 import {
   bubbleSegmentIds,
   classifyBubble
-} from "./chunk-AWJJSA7D.js";
+} from "./chunk-OIOAK7BS.js";
 import {
   svgPath
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 import {
   isBackbone
 } from "./chunk-RJWPJCIB.js";

package/dist/chunks/{chunk-N73RA4DR.js → chunk-6CXLLJ2C.js}

@@ -7,15 +7,15 @@ import {
 } from "./chunk-AB35TJST.js";
 import {
   polylineMidpoint
-} from "./chunk-2VMKQKVO.js";
+} from "./chunk-YIWN32ZX.js";
 import {
   edgeCurvesOf
-} from "./chunk-P276TWPM.js";
+} from "./chunk-3CXZUC2Y.js";
 import {
   curveBounds,
   curveMidpoint,
   polylinePx
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 
 // src/graphLabels.ts
 var MIN_DELETION_LABEL_PX = 26;

package/dist/chunks/{chunk-4SN7R4UF.js → chunk-6MD4VS2F.js}

@@ -1,6 +1,6 @@
 import {
   ENGINE_DEFAULTS
-} from "./chunk-XKPXOIWD.js";
+} from "./chunk-S3ICPPXC.js";
 
 // src/figureSettings.ts
 var FIGURE_DEFAULTS = {