@jbrowse/bandage-core 10.2.7 → 10.3.0

package/dist/chunks/{chunk-LKW2TP4N.js → chunk-5YILQTHE.js}

@@ -1,10 +1,13 @@
 import {
   pathOrigin
-} from "./chunk-M6LK4GII.js";
+} from "./chunk-LGJBB5BP.js";
+import {
+  groupBy
+} from "./chunk-BSOZW3FC.js";
 import {
   panSNContig,
   panSNSample
-} from "./chunk-BPLIXMH7.js";
+} from "./chunk-4XWZNPQ2.js";
 
 // src/layout/walkRows.ts
 function sampleOf(path) {
@@ -150,29 +153,27 @@ function filterSamples(rows, samples) {
     (a, b) => samples.indexOf(a.sample) - samples.indexOf(b.sample) || a.label.localeCompare(b.label)
   ) : rows;
 }
-function walkRows(graph, region, unit) {
-  const paths = graph.paths ?? [];
-  const nameOf = (p) => pathOrigin(p.name).name;
+function referenceWalkName(graph) {
+  const names = (graph.paths ?? []).map((p) => pathOrigin(p.name).name);
+  if (graph.referencePath !== void 0 && names.includes(graph.referencePath)) {
+    return graph.referencePath;
+  }
   const rankZero = new Set(
     graph.nodes.flatMap((n) => n.stable?.rank === 0 ? [n.stable.refName] : [])
   );
-  const names = paths.map(nameOf);
-  const referenceName = graph.referencePath !== void 0 && names.includes(graph.referencePath) ? graph.referencePath : names.find((n) => rankZero.has(n)) ?? names[0];
+  return names.find((n) => rankZero.has(n)) ?? names[0];
+}
+function walkRows(graph, region, unit) {
+  const paths = graph.paths ?? [];
+  const nameOf = (p) => pathOrigin(p.name).name;
+  const referenceName = referenceWalkName(graph);
   const referencePieces = paths.filter((p) => nameOf(p) === referenceName).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
   const first = referencePieces[0];
   const others = paths.filter((p) => !referencePieces.includes(p));
   if (!first || others.length === 0) {
     return void 0;
   }
-  const walks = /* @__PURE__ */ new Map();
-  for (const path of others) {
-    const pieces = walks.get(path.name);
-    if (pieces) {
-      pieces.push(path);
-    } else {
-      walks.set(path.name, [path]);
-    }
-  }
+  const walks = groupBy(others, nameOf);
   const table = new NodeTable(graph);
   const referenceStart = first.start ?? 0;
   const cut = region && region.end > region.start ? region : void 0;
@@ -285,5 +286,6 @@ function walkRows(graph, region, unit) {
 
 export {
   filterSamples,
+  referenceWalkName,
   walkRows
 };

package/dist/chunks/{chunk-B6IW3IRE.js → chunk-65ILXEIN.js}

@@ -1,15 +1,21 @@
 import {
   tubeMapMismatches
-} from "./chunk-XXT2JCAC.js";
+} from "./chunk-BX4AUMZE.js";
 import {
   MAX_GAP_PX
-} from "./chunk-HK5Y2YWV.js";
+} from "./chunk-MYDHU2UV.js";
 import {
   readColor
-} from "./chunk-CWFNEKST.js";
+} from "./chunk-A7H753BA.js";
+import {
+  referenceWalkName
+} from "./chunk-5YILQTHE.js";
 import {
   pathOrigin
-} from "./chunk-M6LK4GII.js";
+} from "./chunk-LGJBB5BP.js";
+import {
+  pushTo
+} from "./chunk-BSOZW3FC.js";
 
 // src/tubeMap/draw.ts
 import { curvePaths, flattenPath, nodeOutlinePath } from "@jbrowse/tubemap-core";
@@ -102,8 +108,9 @@ function layerOf(layout, type, colors, referenceIds, gapWidth) {
 }
 function referenceTrackIds(graph) {
   const ids = /* @__PURE__ */ new Set();
+  const name = graph && referenceWalkName(graph);
   graph?.paths?.forEach((path, i) => {
-    if (pathOrigin(path.name).name === graph.referencePath) {
+    if (pathOrigin(path.name).name === name) {
       ids.add(i);
     }
   });
@@ -132,9 +139,7 @@ function tubeMapPicture({
       layerOf(layout, "read", colors, referenceIds, gapWidth)
     ],
     nodes,
-    mismatches: tubeMapMismatches(layout).filter(
-      (m) => m.kind !== "insertion" || !m.softClip
-    )
+    mismatches: tubeMapMismatches(layout)
   };
 }
 function trace(ctx, commands, x, y) {
@@ -180,13 +185,7 @@ function fillByColor(ctx, items, visible, colorOf, addTo) {
   const byColor = /* @__PURE__ */ new Map();
   for (const item of items) {
     if (visible(item)) {
-      const color = colorOf(item);
-      const list = byColor.get(color);
-      if (list) {
-        list.push(item);
-      } else {
-        byColor.set(color, [item]);
-      }
+      pushTo(byColor, colorOf(item), item);
     }
   }
   for (const list of byColor.values()) {

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

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

package/dist/chunks/{chunk-QBHPHLAQ.js → chunk-7JGLJK44.js}

@@ -1,19 +1,19 @@
 import {
   svgCanvas
-} from "./chunk-RUCH6ZFL.js";
+} from "./chunk-V4YML3GR.js";
 import {
   stripGeneGaps,
   walkStripFrame,
   walkStripLabelsTree
-} from "./chunk-WBSWROE6.js";
+} from "./chunk-SHKGYGM4.js";
 import {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree
-} from "./chunk-EFQLEGWM.js";
+} from "./chunk-SZHQK6GL.js";
 import {
   Canvas2DRenderer
-} from "./chunk-QLWI2PZ3.js";
+} from "./chunk-EJRJAAN7.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
@@ -21,43 +21,45 @@ import {
 } from "./chunk-JSUCGZ6K.js";
 import {
   genePins
-} from "./chunk-RPRHR56C.js";
+} from "./chunk-BS6HPYCZ.js";
 import {
   geneLabelCandidates
-} from "./chunk-KC7T5RWG.js";
+} from "./chunk-PSCSZSVK.js";
 import {
   nodesUnderBox
-} from "./chunk-4HWM3FNK.js";
+} from "./chunk-OMUPUB4J.js";
 import {
   escapeAttr,
   serializeEl
 } from "./chunk-H2H4Y3TV.js";
 import {
   version
-} from "./chunk-CG35S2S2.js";
+} from "./chunk-PTQPTDZH.js";
 import {
   axisScaleOf
-} from "./chunk-A7CFWFQS.js";
-import {
-  rangeText,
-  walkKey
-} from "./chunk-4ETPXDO6.js";
+} from "./chunk-WONB6LMC.js";
 import {
   figureScene
-} from "./chunk-23YFB5BB.js";
+} from "./chunk-XUT4HXVE.js";
 import {
   encodingStops
-} from "./chunk-VQC7KELB.js";
+} from "./chunk-V7J6U4XC.js";
+import {
+  rangeText
+} from "./chunk-CGFPFBT2.js";
 import {
   walkRowLabels
-} from "./chunk-L2HDM2R3.js";
+} from "./chunk-QQCOVMMT.js";
 import {
   nodeInk
-} from "./chunk-JBCZIBFC.js";
+} from "./chunk-CRCD3ODN.js";
+import {
+  FIGURE_DEFAULTS
+} from "./chunk-ZPBEUOBM.js";
 import {
   FIT_PADDING,
   fitTransform
-} from "./chunk-QXUEF3AJ.js";
+} from "./chunk-KWHWNOTY.js";
 import {
   LABEL_CHAR_PX,
   LABEL_PAD,
@@ -69,9 +71,8 @@ import {
   FACET_GAP_PX,
   FACET_PAD_PX,
   FACET_TITLE_PX,
-  facetCells,
   facetGrid
-} from "./chunk-XV4P5KEQ.js";
+} from "./chunk-TGUFT6KK.js";
 
 // src/figure.ts
 var FONT = 'font-family="Helvetica, Arial, sans-serif" font-size="11"';
@@ -100,15 +101,14 @@ function exonKeySvg(x, y) {
     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);
+function walkKeySvg(id, x, y, walk, label, key) {
   return keySvg(
     id,
     x,
     y,
     encodingStops(walk.encoding),
     label,
-    key.delta + key.outside + key.reversed,
+    key.note,
     key.scale
   );
 }
@@ -122,8 +122,8 @@ function chip(x, y, w, name, note) {
   return `<rect x="${x - w / 2}" y="${y - LABEL_PX - LABEL_PAD + 2}" width="${w}" height="${LABEL_PX + LABEL_PAD * 2 - 2}" rx="3" fill="#fff" fill-opacity="0.85" stroke="${EXON_COLOR}"/><text x="${x}" y="${y}" font-family="Helvetica, Arial, sans-serif" font-size="${LABEL_PX}" fill="${GENE_INK}" text-anchor="middle"><tspan font-style="italic" font-weight="600">${escapeAttr(name)}</tspan>${note ? escapeAttr(note) : ""}</text>`;
 }
 function figureSvg(graph, layout, o = {}) {
-  const width = o.width ?? 1200;
-  const room = o.height ?? 800;
+  const width = o.width ?? FIGURE_DEFAULTS.width;
+  const room = o.height ?? FIGURE_DEFAULTS.height;
   const rows = o.walkRows;
   const {
     bounds,
@@ -132,10 +132,10 @@ function figureSvg(graph, layout, o = {}) {
     layers,
     lift,
     facet,
-    panels,
+    facets,
     labelOf,
     referenceName,
-    reference,
+    keyText,
     contigThickness,
     nodeWidth,
     geometry
@@ -209,7 +209,7 @@ function figureSvg(graph, layout, o = {}) {
       w,
       h,
       pixelRows,
-      panels ? {
+      facets ? {
         padLeft: FACET_PAD_PX,
         padTop: FACET_PAD_PX,
         padRight: FACET_PAD_PX,
@@ -235,12 +235,8 @@ function figureSvg(graph, layout, o = {}) {
   }
   const parts = [];
   let height;
-  if (panels) {
-    const place = facetCells(
-      panels.map((p) => p.walks[0].name),
-      facet.field || "walk",
-      facet.domain
-    );
+  if (facets) {
+    const { panels, place } = facets;
     const grid = facetGrid({
       count: place.count,
       bounds,
@@ -255,7 +251,14 @@ function figureSvg(graph, layout, o = {}) {
       const y = Math.floor(cell / grid.columns) * (grid.height + FACET_TITLE_PX + FACET_GAP_PX);
       const walk = panel.walks[0];
       parts.push(
-        walkKeySvg(`key${i}`, x + 6, y + 2, walk, labelOf(walk.name), reference).markup,
+        walkKeySvg(
+          `key${i}`,
+          x + 6,
+          y + 2,
+          walk,
+          labelOf(walk.name),
+          keyText(walk)
+        ).markup,
         `<svg x="${x}" y="${y + FACET_TITLE_PX}" width="${grid.width}" height="${grid.height}">${drawing(panel, grid.width, grid.height)}</svg>`
       );
     });
@@ -268,7 +271,9 @@ function figureSvg(graph, layout, o = {}) {
     };
     if (lift) {
       lift.walks.forEach((walk, i) => {
-        push(walkKeySvg(`key${i}`, x, 2, walk, labelOf(walk.name), reference));
+        push(
+          walkKeySvg(`key${i}`, x, 2, walk, labelOf(walk.name), keyText(walk))
+        );
       });
       push(
         keySvg(

package/dist/chunks/{chunk-T2PCSAFY.js → chunk-7XR26JST.js}

@@ -1,7 +1,7 @@
 import {
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-A4PFFC4Q.js";
+} from "./chunk-2XEQR54X.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";
@@ -11,7 +11,7 @@ function tubeMapNodeColors(graph, colorScheme, referenceRamp) {
   if (colorScheme === "uniform" || colorScheme === "grey") {
     return void 0;
   }
-  const range = { ...computeColorSchemeRange(graph), referenceRamp };
+  const range = computeColorSchemeRange(graph, referenceRamp);
   return new Map(
     graph.nodes.map((node, index) => [
       node.id,

package/dist/chunks/{chunk-URZ3CH2R.js → chunk-A4JDEUAI.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-FX4RDMDN.js";
 import {
   formatBp
-} from "./chunk-PTABFYQ7.js";
+} from "./chunk-PFRQBCGC.js";
 
 // src/bubbles/classifyBubble.ts
 var REPEAT_GROWTH = 10;

package/dist/chunks/{chunk-JLSJMCDJ.js → chunk-A54O52XZ.js}

@@ -2,13 +2,13 @@ import {
   LIFT_BACKDROP_CSS,
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-A4PFFC4Q.js";
+} from "./chunk-2XEQR54X.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";
 import {
   isBackbone
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/referenceStrip.ts
 var REFERENCE_STRIP_PX = 12;
@@ -21,7 +21,7 @@ function referenceStripBlocks(graph, {
   referenceRamp,
   walks
 }) {
-  const range = { ...computeColorSchemeRange(graph), referenceRamp };
+  const range = computeColorSchemeRange(graph, referenceRamp);
   const out = [];
   graph.nodes.forEach((node, index) => {
     if (isBackbone(node)) {

package/dist/chunks/chunk-A55OZVYX.js

@@ -0,0 +1,327 @@
+import {
+  pathSteps
+} from "./chunk-ZNJ4JAPT.js";
+import {
+  pathOrigin
+} from "./chunk-LGJBB5BP.js";
+import {
+  PathVisitsBuilder
+} from "./chunk-ZPZ7GNBT.js";
+import {
+  isBackbone
+} from "./chunk-RJWPJCIB.js";
+import {
+  partitionPoint
+} from "./chunk-HOAIOEI7.js";
+
+// src/tubeMap/coarsen.ts
+function readWalk(path, steps) {
+  const runs = [];
+  const open = () => ({ a: -Infinity, b: Infinity, detour: [], bp: 0 });
+  const gaps = [open()];
+  for (const { node, strand } of steps) {
+    const gap = gaps.at(-1);
+    const last = runs.at(-1);
+    if (isBackbone(node)) {
+      const start = node.stable.start;
+      const end = start + node.length;
+      const inverted = strand !== (node.stable.strand ?? "+");
+      const joins = last !== void 0 && gap.detour.length === 0;
+      if (joins && !last.inverted && !inverted && last.end === start) {
+        last.end = end;
+      } else if (joins && last.inverted && inverted && last.start === end) {
+        last.start = start;
+      } else {
+        runs.push({ start, end, inverted });
+        gaps.push(open());
+      }
+    } else {
+      gap.detour.push({ node, strand });
+      gap.bp += node.length;
+    }
+  }
+  runs.forEach((run, i) => {
+    gaps[i].b = run.start;
+    gaps[i + 1].a = run.end;
+  });
+  return { path, runs, gaps };
+}
+function isSmall(gap, sigma) {
+  return Number.isFinite(gap.a) && Number.isFinite(gap.b) && gap.b >= gap.a && Math.max(gap.b - gap.a, gap.bp) < sigma;
+}
+function strictlyInside(cuts, a, b) {
+  const i = partitionPoint(cuts.length, (j) => cuts[j] <= a);
+  return i < cuts.length && cuts[i] < b;
+}
+function referenceGaps(backbone) {
+  const cuts = /* @__PURE__ */ new Map();
+  for (let i = 1; i < backbone.length; i++) {
+    const prev = backbone[i - 1];
+    const node = backbone[i];
+    const end = prev.stable.start + prev.length;
+    if (end !== node.stable.start) {
+      cuts.set(end, "reference-gap");
+      cuts.set(node.stable.start, "reference-gap");
+    }
+  }
+  return cuts;
+}
+function findCuts(walks, sigma, cuts) {
+  const cut = (bp, cause) => {
+    if (Number.isFinite(bp) && !cuts.has(bp)) {
+      cuts.set(bp, cause);
+    }
+  };
+  for (const { runs, gaps } of walks) {
+    const first = runs[0];
+    const last = runs.at(-1);
+    if (first && last) {
+      cut(first.start, "walk-end");
+      cut(last.end, "walk-end");
+    }
+    for (const run of runs) {
+      if (run.inverted && run.end - run.start >= sigma) {
+        cut(run.start, "inversion");
+        cut(run.end, "inversion");
+      }
+    }
+    for (const gap of gaps) {
+      if (gap.b < gap.a) {
+        cut(gap.a, "backward");
+        cut(gap.b, "backward");
+      } else if (!isSmall(gap, sigma)) {
+        cut(gap.a, "variant");
+        cut(gap.b, "variant");
+      }
+    }
+  }
+  const spans = walks.flatMap(({ runs, gaps }) => [
+    ...gaps.filter((g) => isSmall(g, sigma)).map((g) => [g.a, g.b]),
+    ...runs.filter((r) => r.inverted && r.end - r.start < sigma).map((r) => [r.start, r.end])
+  ]);
+  for (let changed = true; changed; ) {
+    changed = false;
+    const sorted = [...cuts.keys()].sort((x, y) => x - y);
+    for (const [a, b] of spans) {
+      if (strictlyInside(sorted, a, b)) {
+        changed ||= !cuts.has(a) || !cuts.has(b);
+        cut(a, "overlap");
+        cut(b, "overlap");
+      }
+    }
+  }
+  return cuts;
+}
+function mergeReference(backbone, cuts) {
+  const merged = [];
+  let group = [];
+  const close = () => {
+    const first = group[0];
+    const last = group.at(-1);
+    if (first && last) {
+      const bp0 = first.stable.start;
+      const bp1 = last.stable.start + last.length;
+      const name = `${bp0}-${bp1}`;
+      merged.push({
+        node: {
+          id: `${name}+`,
+          name,
+          length: bp1 - bp0,
+          depth: 0,
+          stable: {
+            refName: first.stable.refName,
+            start: bp0,
+            rank: 0,
+            strand: "+"
+          }
+        },
+        members: group
+      });
+    }
+    group = [];
+  };
+  for (const node of backbone) {
+    if (cuts.has(node.stable.start)) {
+      close();
+    }
+    group.push(node);
+  }
+  close();
+  return merged;
+}
+function lastAtMost(items, key, x) {
+  return Math.max(0, partitionPoint(items.length, (i) => key(items[i]) <= x) - 1);
+}
+function coarsenTubeMap(graph, sigma) {
+  const backbone = graph.nodes.filter(isBackbone).sort((a, b) => a.stable.start - b.stable.start);
+  const paths = graph.paths ?? [];
+  if (backbone.length === 0 || paths.length === 0) {
+    return void 0;
+  }
+  const stepsOf = pathSteps(graph);
+  const walks = paths.map((p, i) => readWalk(p, stepsOf[i]));
+  const cuts = findCuts(walks, sigma, referenceGaps(backbone));
+  const sortedCuts = [...cuts.keys()].sort((x, y) => x - y);
+  const merged = mergeReference(backbone, cuts);
+  const mergedAt = (bp) => lastAtMost(merged, (m) => m.node.stable.start, bp);
+  const members = /* @__PURE__ */ new Map();
+  const coarseOf = /* @__PURE__ */ new Map();
+  for (const m of merged) {
+    members.set(
+      m.node.id,
+      m.members.map((n) => n.id)
+    );
+    for (const n of m.members) {
+      coarseOf.set(n.id, m.node.id);
+    }
+  }
+  const routes = /* @__PURE__ */ new Map();
+  const routeFor = (gap) => {
+    const key = `${gap.a}	${gap.b}	${gap.detour.map((s) => s.node.id + s.strand).join(",")}`;
+    let node = routes.get(key);
+    if (!node) {
+      const name = `r${routes.size}`;
+      node = {
+        id: `${name}+`,
+        name,
+        length: gap.bp,
+        depth: 0,
+        stable: {
+          refName: backbone[0].stable.refName,
+          start: Number.isFinite(gap.a) ? gap.a : gap.b,
+          rank: 1,
+          strand: "+"
+        }
+      };
+      routes.set(key, node);
+      members.set(
+        node.id,
+        gap.detour.map((s) => s.node.id)
+      );
+      for (const s of gap.detour) {
+        if (!coarseOf.has(s.node.id)) {
+          coarseOf.set(s.node.id, node.id);
+        }
+      }
+    }
+    return node;
+  };
+  const deviations = /* @__PURE__ */ new Map();
+  const coarsePaths = [];
+  const pathVisits = new PathVisitsBuilder();
+  const edges = /* @__PURE__ */ new Map();
+  const depth = /* @__PURE__ */ new Map();
+  for (const { path, runs, gaps } of walks) {
+    const steps = [];
+    const devs = [];
+    let continuing = false;
+    const append = (node, strand) => {
+      const last = steps.at(-1);
+      if (!(continuing && last?.node === node && last.strand === strand)) {
+        steps.push({ node, strand });
+      }
+      continuing = true;
+    };
+    const structural = (gap) => {
+      continuing = false;
+      if (gap.detour.length > 0) {
+        append(routeFor(gap), "+");
+        continuing = false;
+      }
+    };
+    const fold = (gap) => {
+      if (gap.bp > 0 || gap.b > gap.a) {
+        devs.push({ start: gap.a, end: gap.b, bp: gap.bp });
+      }
+      const home = merged[mergedAt(gap.b > gap.a ? gap.a : gap.a - 1)];
+      for (const s of gap.detour) {
+        if (!coarseOf.has(s.node.id)) {
+          coarseOf.set(s.node.id, home.node.id);
+          members.get(home.node.id).push(s.node.id);
+        }
+      }
+    };
+    runs.forEach((run, i) => {
+      const gap = gaps[i];
+      if (isSmall(gap, sigma) && !strictlyInside(sortedCuts, gap.a, gap.b)) {
+        fold(gap);
+      } else {
+        structural(gap);
+      }
+      const i0 = mergedAt(run.start);
+      const i1 = mergedAt(run.end - 1);
+      const small = run.end - run.start < sigma;
+      if (run.inverted && !small) {
+        continuing = false;
+        for (let j = i1; j >= i0; j--) {
+          append(merged[j].node, "-");
+        }
+        continuing = false;
+      } else {
+        if (run.inverted) {
+          devs.push({
+            start: run.start,
+            end: run.end,
+            bp: run.end - run.start,
+            inverted: true
+          });
+        }
+        for (let j = i0; j <= i1; j++) {
+          append(merged[j].node, "+");
+        }
+      }
+    });
+    structural(gaps.at(-1));
+    const visitName = pathOrigin(path.name).name;
+    let pos = 0;
+    steps.forEach(({ node, strand }, i) => {
+      depth.set(node.id, (depth.get(node.id) ?? 0) + 1);
+      pathVisits.add(
+        node.name,
+        visitName,
+        path.sample ?? visitName,
+        pos,
+        strand === "-"
+      );
+      pos += node.length;
+      const next = steps[i + 1];
+      if (next) {
+        const key = `${node.id}${strand}	${next.node.id}${next.strand}`;
+        const edge = edges.get(key);
+        if (edge) {
+          edge.pathIds.push(path.name);
+        } else {
+          edges.set(key, {
+            from: node.id,
+            to: next.node.id,
+            fromStrand: strand,
+            toStrand: next.strand,
+            pathIds: [path.name]
+          });
+        }
+      }
+    });
+    coarsePaths.push({ ...path, nodeIds: steps.map((s) => s.node.id) });
+    deviations.set(path.name, devs);
+  }
+  const nodes = [...merged.map((m) => m.node), ...routes.values()].filter((n) => depth.has(n.id)).map((n) => ({ ...n, depth: depth.get(n.id) }));
+  return {
+    graph: {
+      ...graph,
+      nodes,
+      edges: [...edges.values()],
+      paths: coarsePaths,
+      pathVisits: pathVisits.build(),
+      reads: void 0
+    },
+    members,
+    coarseOf,
+    deviations,
+    cuts
+  };
+}
+
+export {
+  lastAtMost,
+  coarsenTubeMap
+};