@jbrowse/bandage-core 6.1.0 → 6.2.0

package/dist/chunks/{chunk-SMQ545MU.js → chunk-3GMVZMKD.js}

@@ -2,7 +2,7 @@ import {
   LIFT_BACKDROP_CSS,
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-RX5CSWJW.js";
+} from "./chunk-VUBLSA6P.js";
 import {
   abgrToCssRgba
 } from "./chunk-UMNCCYBN.js";

package/dist/chunks/{chunk-KKU6JRJC.js → chunk-5HF753RL.js}

@@ -5,36 +5,36 @@ import {
   stripGeneGaps,
   walkStripFrame,
   walkStripLabelsTree
-} from "./chunk-V5BPIOLS.js";
+} from "./chunk-7R2UGY4I.js";
 import {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree
-} from "./chunk-PJESIRDU.js";
+} from "./chunk-YQZWW2V6.js";
 import {
   Canvas2DRenderer
 } from "./chunk-CH3DLBUT.js";
-import {
-  genePins
-} from "./chunk-BUBZ32IC.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
   exonStretches
 } from "./chunk-3S3YVOJ7.js";
+import {
+  genePins
+} from "./chunk-BUBZ32IC.js";
 import {
   version
-} from "./chunk-LPFN4POU.js";
+} from "./chunk-HE3NRWH7.js";
 import {
   axisScaleOf
-} from "./chunk-AMHZMY6E.js";
+} from "./chunk-M6SAUIYR.js";
 import {
   facetLifts,
   walkLift
-} from "./chunk-ZKGM7VLA.js";
+} from "./chunk-A7VOULBP.js";
 import {
   encodingStops
-} from "./chunk-X4VVPLI5.js";
+} from "./chunk-6CO564AN.js";
 import {
   rangeText,
   walkKey
@@ -43,11 +43,14 @@ import {
   FIT_PADDING,
   drawingBounds,
   fitTransform
-} from "./chunk-6UACM7VU.js";
+} from "./chunk-YFRTTBCZ.js";
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-RX5CSWJW.js";
+} from "./chunk-VUBLSA6P.js";
+import {
+  nodeInk
+} from "./chunk-PBENCR5L.js";
 import {
   geneLabelCandidates
 } from "./chunk-DKOB2OPC.js";
@@ -67,9 +70,6 @@ import {
   occupancy,
   placeLabels
 } from "./chunk-AB35TJST.js";
-import {
-  nodeInk
-} from "./chunk-PBENCR5L.js";
 import {
   resolveColorScheme
 } from "./chunk-JKJWSY4V.js";

package/dist/chunks/{chunk-X4VVPLI5.js → chunk-6CO564AN.js}

@@ -2,7 +2,7 @@ import {
   REFERENCE_RAMP_ALT_COLOR,
   REFERENCE_RAMP_MAX_HUE,
   hslToRgb
-} from "./chunk-RX5CSWJW.js";
+} from "./chunk-VUBLSA6P.js";
 import {
   packAbgr
 } from "./chunk-UMNCCYBN.js";

package/dist/chunks/{chunk-V5BPIOLS.js → chunk-7R2UGY4I.js}

@@ -1,7 +1,7 @@
 import {
   alongRow,
   boxesGenes
-} from "./chunk-PJESIRDU.js";
+} from "./chunk-YQZWW2V6.js";
 import {
   pathOrigin
 } from "./chunk-ST2IBUAN.js";

package/dist/chunks/{chunk-ZKGM7VLA.js → chunk-A7VOULBP.js}

@@ -1,7 +1,7 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-X4VVPLI5.js";
+} from "./chunk-6CO564AN.js";
 import {
   pathOrigin
 } from "./chunk-ST2IBUAN.js";

package/dist/chunks/{chunk-ZHCDYSA5.js → chunk-GD7FYNGS.js}

@@ -1,6 +1,6 @@
 import {
   REFERENCE_RAMP_MAX_HUE
-} from "./chunk-RX5CSWJW.js";
+} from "./chunk-VUBLSA6P.js";
 
 // src/referenceRampCss.ts
 function rampHueCss(hue) {

package/dist/chunks/{chunk-LPFN4POU.js → chunk-HE3NRWH7.js}

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

package/dist/chunks/chunk-L53SXJZI.js

@@ -0,0 +1,22 @@
+import {
+  stressLayout
+} from "./chunk-O4TGF4WS.js";
+import {
+  loadBandage
+} from "./chunk-7XHHVYG7.js";
+
+// src/layoutEngines.ts
+var layoutEngine = async (request) => {
+  const start = performance.now();
+  if (request.options.engine === "stress") {
+    const result2 = stressLayout(request);
+    return { result: result2, duration: performance.now() - start };
+  }
+  const bandage = await loadBandage();
+  const result = bandage.computeLayout(request.graph, request.options);
+  return { result, duration: performance.now() - start };
+};
+
+export {
+  layoutEngine
+};

package/dist/chunks/{chunk-AMHZMY6E.js → chunk-M6SAUIYR.js}

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

package/dist/chunks/chunk-O4TGF4WS.js

@@ -0,0 +1,503 @@
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/stressEngine.ts
+var LAYOUT_ENGINES = [
+  {
+    value: "fmmm",
+    label: "Bandage (FMMM)",
+    description: "Bandage's force-directed layout: OGDF's fast multipole multilevel method, compiled to wasm."
+  },
+  {
+    value: "stress",
+    label: "Stress (experimental)",
+    description: "Stress layout by stochastic gradient descent in plain JS: distances along the graph become distances on the page, so the reference reads straight and a repeat loop reads as a ring."
+  }
+];
+var LAYOUT_ENGINE_VALUES = LAYOUT_ENGINES.map((e) => e.value);
+var QUALITY = [
+  { walks: 2, iterations: 15 },
+  { walks: 4, iterations: 30 },
+  { walks: 8, iterations: 60 },
+  { walks: 12, iterations: 90 },
+  { walks: 16, iterations: 120 }
+];
+var UNTANGLE_PASSES = 20;
+var UNTANGLE_RADIUS = 15;
+var UNTANGLE_PUSH = 0.3;
+var SMOOTH_PASSES = 2;
+var MAX_HOPS = 200;
+var EPS = 0.1;
+function flipped(strand, name) {
+  const own = name.at(-1);
+  return (strand === "+" || strand === "-") && (own === "+" || own === "-") && strand !== own;
+}
+function xorshift(seed) {
+  let s = Math.imul(seed, 2654435761) >>> 0 || 1;
+  return () => {
+    s ^= s << 13;
+    s >>>= 0;
+    s ^= s >>> 17;
+    s ^= s << 5;
+    s >>>= 0;
+    return s / 4294967296;
+  };
+}
+function num(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function chains(request) {
+  const { nodes, edges } = request.graph;
+  const o = request.options;
+  const perMegabase = num(o.nodeLengthPerMegabase, 1e3);
+  const minimum = num(o.minimumNodeLength, 1);
+  const segment = num(o.nodeSegmentLength, 1);
+  const link = num(o.edgeLength, 1);
+  const ids = nodes.map((n2) => n2.id);
+  const first = new Int32Array(nodes.length);
+  const count = new Int32Array(nodes.length);
+  const per = new Float64Array(nodes.length);
+  let n = 0;
+  nodes.forEach((node, k) => {
+    const drawn = Math.max(perMegabase * node.length / 1e6, minimum);
+    const steps = Math.max(1, Math.ceil(drawn / segment));
+    first[k] = n;
+    count[k] = steps + 1;
+    per[k] = drawn / steps;
+    n += steps + 1;
+  });
+  const chainOf = new Int32Array(n);
+  const indexOf = new Int32Array(n);
+  const seedX = new Float64Array(n).fill(NaN);
+  const seedY = new Float64Array(n).fill(NaN);
+  const backbone = new Uint8Array(n);
+  const adjacent = Array.from({ length: n }, () => []);
+  nodes.forEach((node, k) => {
+    const seeded = typeof node.x === "number" && typeof node.y === "number";
+    const reference = isBackbone(node) ? 1 : 0;
+    for (let i = 0; i < count[k]; i++) {
+      const v = first[k] + i;
+      chainOf[v] = k;
+      indexOf[v] = i;
+      backbone[v] = reference;
+      if (seeded) {
+        seedX[v] = node.x + i * per[k];
+        seedY[v] = node.y;
+      }
+      if (i > 0) {
+        adjacent[v - 1].push([v, per[k]]);
+        adjacent[v].push([v - 1, per[k]]);
+      }
+    }
+  });
+  const index = new Map(ids.map((id, k) => [id, k]));
+  const links = nodes.map(() => [[], []]);
+  for (const edge of edges) {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a === void 0 || b === void 0) {
+      continue;
+    }
+    if (a === b && count[a] <= 2) {
+      continue;
+    }
+    const fromSide = flipped(edge.fromStrand, edge.from) ? 0 : 1;
+    const toSide = flipped(edge.toStrand, edge.to) ? 1 : 0;
+    const u = first[a] + (fromSide ? count[a] - 1 : 0);
+    const v = first[b] + (toSide ? count[b] - 1 : 0);
+    adjacent[u].push([v, link]);
+    adjacent[v].push([u, link]);
+    links[a][fromSide].push([b, toSide]);
+    links[b][toSide].push([a, fromSide]);
+  }
+  const off = new Int32Array(n + 1);
+  for (let i = 0; i < n; i++) {
+    off[i + 1] = off[i] + adjacent[i].length;
+  }
+  const nb = new Int32Array(off[n]);
+  const wt = new Float64Array(off[n]);
+  for (let i = 0; i < n; i++) {
+    adjacent[i].forEach(([v, w], k) => {
+      nb[off[i] + k] = v;
+      wt[off[i] + k] = w;
+    });
+  }
+  return {
+    ids,
+    first,
+    count,
+    per,
+    links,
+    chainOf,
+    indexOf,
+    seedX,
+    seedY,
+    backbone,
+    off,
+    nb,
+    wt,
+    n
+  };
+}
+function stressLayout(request, opts = {}) {
+  const c = chains(request);
+  const { n, off, nb, wt, seedX, seedY, backbone, first, count, per } = c;
+  const o = request.options;
+  const quality = QUALITY[Math.max(0, Math.min(4, num(opts.quality ?? o.quality, 2)))];
+  const gap = num(opts.componentSeparation ?? o.componentSeparation, 15);
+  const rand = xorshift(num(opts.seed ?? o.seed, 1));
+  const X = new Float64Array(n);
+  const Y = new Float64Array(n);
+  const nodePositions = {};
+  if (n === 0) {
+    return { nodePositions };
+  }
+  let dmin = Infinity;
+  let total = 0;
+  for (let e = 0; e < nb.length; e++) {
+    dmin = Math.min(dmin, wt[e]);
+    total += wt[e];
+  }
+  total /= 2;
+  let anySeed = false;
+  for (let i = 0; i < n; i++) {
+    if (!Number.isNaN(seedX[i])) {
+      anySeed = true;
+      break;
+    }
+  }
+  const side = Math.sqrt(n) * 20;
+  for (let i = 0; i < n; i++) {
+    if (anySeed && !Number.isNaN(seedX[i])) {
+      X[i] = seedX[i] + rand() - 0.5;
+      Y[i] = seedY[i] + rand() - 0.5;
+    } else {
+      X[i] = rand() * side;
+      Y[i] = rand() * side;
+    }
+  }
+  const refIdx = [];
+  for (let i = 0; i < n; i++) {
+    if (backbone[i] && !Number.isNaN(seedX[i])) {
+      refIdx.push(i);
+    }
+  }
+  refIdx.sort((a, b) => seedX[a] - seedX[b]);
+  const refX = Float64Array.from(refIdx, (i) => seedX[i]);
+  const span = refIdx.length ? refX[refX.length - 1] - refX[0] : 0;
+  const dmax = Math.max(span, total / 4, dmin * 10);
+  const etaMax = dmax * dmax;
+  const etaMin = EPS * dmin * dmin;
+  const { walks, iterations } = quality;
+  const lambda = Math.log(etaMax / etaMin) / Math.max(1, iterations - 1);
+  const logMin = Math.log(dmin);
+  const logMax = Math.log(dmax);
+  const move = (i, j, d, eta) => {
+    let mu = eta / (d * d);
+    if (mu > 1) {
+      mu = 1;
+    }
+    const dx = X[i] - X[j];
+    const dy = Y[i] - Y[j];
+    const mag = Math.sqrt(dx * dx + dy * dy) || 1e-9;
+    const r = mu * (mag - d) / (2 * mag);
+    const rx = r * dx;
+    const ry = r * dy;
+    X[i] = X[i] - rx;
+    Y[i] = Y[i] - ry;
+    X[j] = X[j] + rx;
+    Y[j] = Y[j] + ry;
+  };
+  const walk = (i, length) => {
+    let chain = c.chainOf[i];
+    let idx = c.indexOf[i];
+    let dir = rand() < 0.5 ? -1 : 1;
+    let remaining = length;
+    for (let hops = 0; hops < MAX_HOPS; hops++) {
+      const points = count[chain];
+      const step = per[chain];
+      const toEnd = (dir > 0 ? points - 1 - idx : idx) * step;
+      if (remaining <= toEnd) {
+        return first[chain] + idx + dir * Math.round(remaining / step);
+      }
+      remaining -= toEnd;
+      const out = c.links[chain][dir > 0 ? 1 : 0];
+      if (out.length === 0) {
+        return first[chain] + (dir > 0 ? points - 1 : 0);
+      }
+      const [next, enterSide] = out[Math.floor(rand() * out.length)];
+      remaining -= num(o.edgeLength, 1);
+      chain = next;
+      dir = enterSide === 0 ? 1 : -1;
+      idx = enterSide === 0 ? 0 : count[next] - 1;
+      if (remaining <= 0) {
+        return first[chain] + idx;
+      }
+    }
+    return -1;
+  };
+  const refPartner = (i) => {
+    const length = Math.exp(logMin + rand() * (logMax - logMin)) * (rand() < 0.5 ? -1 : 1);
+    const target = seedX[i] + length;
+    let lo = 0;
+    let hi = refX.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (refX[mid] < target) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    return refIdx[Math.min(lo, refIdx.length - 1)];
+  };
+  const referenceTerm = (i, eta) => {
+    if (!backbone[i] || refIdx.length < 2 || Number.isNaN(seedX[i])) {
+      return;
+    }
+    const j = refPartner(i);
+    const d = Math.abs(seedX[i] - seedX[j]);
+    if (j !== i && d > 0) {
+      move(i, j, d, eta);
+    }
+  };
+  const adjacentTerms = (i, eta) => {
+    for (let e = off[i]; e < off[i + 1]; e++) {
+      const j = nb[e];
+      if (j > i) {
+        move(i, j, wt[e], eta);
+      }
+    }
+  };
+  const order = new Int32Array(n);
+  for (let i = 0; i < n; i++) {
+    order[i] = i;
+  }
+  for (let t = 0; t < iterations; t++) {
+    const eta = etaMax * Math.exp(-lambda * t);
+    for (let k = n - 1; k > 0; k--) {
+      const r = Math.floor(rand() * (k + 1));
+      const tmp = order[k];
+      order[k] = order[r];
+      order[r] = tmp;
+    }
+    for (let q = 0; q < n; q++) {
+      const i = order[q];
+      adjacentTerms(i, eta);
+      for (let w = 0; w < walks; w++) {
+        const length = Math.exp(logMin + rand() * (logMax - logMin));
+        const j = walk(i, length);
+        if (j >= 0 && j !== i) {
+          move(i, j, length, eta);
+        }
+      }
+      referenceTerm(i, eta);
+    }
+  }
+  const cell = UNTANGLE_RADIUS;
+  const key = (x, y) => Math.floor(x / cell) * 73856093 ^ Math.floor(y / cell) * 19349663;
+  for (let u = 0; u < UNTANGLE_PASSES; u++) {
+    const grid = /* @__PURE__ */ new Map();
+    for (let i = 0; i < n; i++) {
+      const k = key(X[i], Y[i]);
+      const list = grid.get(k);
+      if (list) {
+        list.push(i);
+      } else {
+        grid.set(k, [i]);
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      const cx = Math.floor(X[i] / cell);
+      const cy = Math.floor(Y[i] / cell);
+      for (let gx = cx - 1; gx <= cx + 1; gx++) {
+        for (let gy = cy - 1; gy <= cy + 1; gy++) {
+          const list = grid.get(gx * 73856093 ^ gy * 19349663);
+          if (!list) {
+            continue;
+          }
+          for (const j of list) {
+            if (j <= i) {
+              continue;
+            }
+            let joined = false;
+            for (let e = off[i]; e < off[i + 1]; e++) {
+              if (nb[e] === j) {
+                joined = true;
+                break;
+              }
+            }
+            if (joined) {
+              continue;
+            }
+            const dx = X[i] - X[j];
+            const dy = Y[i] - Y[j];
+            const mag = Math.sqrt(dx * dx + dy * dy);
+            if (mag >= UNTANGLE_RADIUS) {
+              continue;
+            }
+            let rx;
+            let ry;
+            if (mag > 1e-6) {
+              const r = UNTANGLE_PUSH * (UNTANGLE_RADIUS - mag) / (2 * mag);
+              rx = r * dx;
+              ry = r * dy;
+            } else {
+              rx = UNTANGLE_PUSH * UNTANGLE_RADIUS * (rand() - 0.5);
+              ry = UNTANGLE_PUSH * UNTANGLE_RADIUS * (rand() - 0.5);
+            }
+            X[i] = X[i] + rx;
+            Y[i] = Y[i] + ry;
+            X[j] = X[j] - rx;
+            Y[j] = Y[j] - ry;
+          }
+        }
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      adjacentTerms(i, Infinity);
+      referenceTerm(i, etaMin * 4);
+    }
+  }
+  for (let k = 0; k < count.length; k++) {
+    const a = first[k];
+    const m = count[k];
+    if (m < 3) {
+      continue;
+    }
+    for (let s = 0; s < SMOOTH_PASSES; s++) {
+      const xs = X.slice(a, a + m);
+      const ys = Y.slice(a, a + m);
+      for (let i = 1; i + 1 < m; i++) {
+        X[a + i] = 0.5 * xs[i] + 0.25 * (xs[i - 1] + xs[i + 1]);
+        Y[a + i] = 0.5 * ys[i] + 0.25 * (ys[i - 1] + ys[i + 1]);
+      }
+    }
+    let length = 0;
+    let cx = 0;
+    let cy = 0;
+    for (let i = 0; i < m; i++) {
+      cx += X[a + i];
+      cy += Y[a + i];
+      if (i > 0) {
+        length += Math.hypot(
+          X[a + i] - X[a + i - 1],
+          Y[a + i] - Y[a + i - 1]
+        );
+      }
+    }
+    cx /= m;
+    cy /= m;
+    const scale = length > 0 ? per[k] * (m - 1) / length : 1;
+    for (let i = 0; i < m; i++) {
+      X[a + i] = cx + (X[a + i] - cx) * scale;
+      Y[a + i] = cy + (Y[a + i] - cy) * scale;
+    }
+  }
+  packComponents(c, X, Y, anySeed, gap);
+  for (let k = 0; k < c.ids.length; k++) {
+    const points = [];
+    for (let i = 0; i < count[k]; i++) {
+      points.push({ x: X[first[k] + i], y: Y[first[k] + i] });
+    }
+    nodePositions[c.ids[k]] = points;
+  }
+  return { nodePositions };
+}
+function packComponents(c, X, Y, anySeed, gap) {
+  const { n, off, nb } = c;
+  const comp = new Int32Array(n).fill(-1);
+  let components = 0;
+  for (let s = 0; s < n; s++) {
+    if (comp[s] >= 0) {
+      continue;
+    }
+    const queue = [s];
+    comp[s] = components;
+    for (const u of queue) {
+      for (let e = off[u]; e < off[u + 1]; e++) {
+        const v = nb[e];
+        if (comp[v] < 0) {
+          comp[v] = components;
+          queue.push(v);
+        }
+      }
+    }
+    components++;
+  }
+  if (!anySeed) {
+    for (let k = 0; k < components; k++) {
+      rotateToPrincipalAxis(X, Y, comp, k);
+    }
+  }
+  if (components < 2) {
+    return;
+  }
+  const minX = new Float64Array(components).fill(Infinity);
+  const minY = new Float64Array(components).fill(Infinity);
+  const maxY = new Float64Array(components).fill(-Infinity);
+  for (let i = 0; i < n; i++) {
+    const k = comp[i];
+    minX[k] = Math.min(minX[k], X[i]);
+    minY[k] = Math.min(minY[k], Y[i]);
+    maxY[k] = Math.max(maxY[k], Y[i]);
+  }
+  const shift = new Float64Array(components);
+  let y = 0;
+  for (let k = 0; k < components; k++) {
+    shift[k] = y - minY[k];
+    y += maxY[k] - minY[k] + gap;
+  }
+  for (let i = 0; i < n; i++) {
+    const k = comp[i];
+    X[i] = X[i] - minX[k];
+    Y[i] = Y[i] + shift[k];
+  }
+}
+function rotateToPrincipalAxis(X, Y, comp, k) {
+  let m = 0;
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < X.length; i++) {
+    if (comp[i] === k) {
+      cx += X[i];
+      cy += Y[i];
+      m++;
+    }
+  }
+  if (m < 3) {
+    return;
+  }
+  cx /= m;
+  cy /= m;
+  let sxx = 0;
+  let syy = 0;
+  let sxy = 0;
+  for (let i = 0; i < X.length; i++) {
+    if (comp[i] === k) {
+      const dx = X[i] - cx;
+      const dy = Y[i] - cy;
+      sxx += dx * dx;
+      syy += dy * dy;
+      sxy += dx * dy;
+    }
+  }
+  const angle = -0.5 * Math.atan2(2 * sxy, sxx - syy);
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  for (let i = 0; i < X.length; i++) {
+    if (comp[i] === k) {
+      const dx = X[i] - cx;
+      const dy = Y[i] - cy;
+      X[i] = cx + cos * dx - sin * dy;
+      Y[i] = cy + sin * dx + cos * dy;
+    }
+  }
+}
+
+export {
+  LAYOUT_ENGINES,
+  LAYOUT_ENGINE_VALUES,
+  stressLayout
+};

package/dist/chunks/{chunk-ZZA2AFB4.js → chunk-P2KU2TXS.js}

@@ -1,7 +1,7 @@
 import {
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-RX5CSWJW.js";
+} from "./chunk-VUBLSA6P.js";
 import {
   abgrToCssRgba
 } from "./chunk-UMNCCYBN.js";

package/dist/chunks/{chunk-C6USNTTP.js → chunk-STNG3Y5X.js}

@@ -40,11 +40,32 @@ function withDeletionRoutes(graph, deletions, dropped = /* @__PURE__ */ new Set(
   };
 }
 function closableDeletions(graph, deletions) {
-  const lengths = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  const parent = /* @__PURE__ */ new Map();
+  const root = (id) => {
+    let r = id;
+    while (parent.has(r)) {
+      r = parent.get(r);
+    }
+    if (r !== id) {
+      parent.set(id, r);
+    }
+    return r;
+  };
+  const join = (a, b) => {
+    const [ra, rb] = [root(a), root(b)];
+    if (ra !== rb) {
+      parent.set(ra, rb);
+    }
+    return ra !== rb;
+  };
+  const candidates = new Set(deletions.map((d) => d.edgeIndex));
+  graph.edges.forEach((e, ei) => {
+    if (!candidates.has(ei)) {
+      join(e.from, e.to);
+    }
+  });
   return new Set(
-    deletions.filter(
-      (d) => d.bypassed.reduce((sum, id) => sum + (lengths.get(id) ?? 0), 0) >= d.bp
-    ).map((d) => d.edgeIndex)
+    deletions.filter((d) => !join(d.from, d.to)).map((d) => d.edgeIndex)
   );
 }
 function routeNodes(graph, deletions, routes, drawnOf, opts) {