@jbrowse/bandage-core 8.2.0 → 9.1.0

package/dist/chunks/chunk-FUVI4WQP.js

@@ -0,0 +1,273 @@
+import {
+  bubbleSubgraph
+} from "./chunk-VHW7FDHU.js";
+import {
+  coversGraph
+} from "./chunk-2AWUWGAD.js";
+import {
+  bubblesFromGraph,
+  walkIndexOf,
+  walkRoutes
+} from "./chunk-GOZYKNQ2.js";
+import {
+  bubbleSegmentIds
+} from "./chunk-XKWD2RY3.js";
+import {
+  SATURATED_PATH_COUNT
+} from "./chunk-FX4RDMDN.js";
+import {
+  strandSides
+} from "./chunk-2CVHXFK7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/bubbles/superbubbles.ts
+var MAX_SUPERBUBBLES = 50;
+function slotGraph(graph, index) {
+  const slots = graph.nodes.length * 2;
+  const seen = /* @__PURE__ */ new Set();
+  const pairs = [];
+  const degree = new Int32Array(slots);
+  for (const e of graph.edges) {
+    const a = index.get(e.from);
+    const b = index.get(e.to);
+    if (a === void 0 || b === void 0) {
+      continue;
+    }
+    const sides = strandSides(e);
+    const ka = a * 2 + (sides.from === "end" ? 1 : 0);
+    const kb = b * 2 + (sides.to === "end" ? 1 : 0);
+    const id = Math.min(ka, kb) * slots + Math.max(ka, kb);
+    if (seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    pairs.push(ka, kb);
+    degree[ka]++;
+    if (ka !== kb) {
+      degree[kb]++;
+    }
+  }
+  const offset = new Int32Array(slots + 1);
+  for (let k = 0; k < slots; k++) {
+    offset[k + 1] = offset[k] + degree[k];
+  }
+  const next = new Int32Array(offset[slots]);
+  const fill = offset.slice(0, slots);
+  for (let i = 0; i < pairs.length; i += 2) {
+    const ka = pairs[i];
+    const kb = pairs[i + 1];
+    next[fill[ka]++] = kb;
+    if (ka !== kb) {
+      next[fill[kb]++] = ka;
+    }
+  }
+  return { offset, next };
+}
+function searcher(nodes, offset, next) {
+  const visited = new Int32Array(nodes);
+  const pending = new Uint8Array(nodes * 2);
+  const stack = new Int32Array(nodes * 2);
+  const inside = new Int32Array(nodes);
+  const touched = [];
+  let stamp = 0;
+  return (start) => {
+    const s = start >> 1;
+    stamp++;
+    touched.length = 0;
+    let open = 0;
+    let top = 0;
+    let count = 0;
+    let found;
+    const expect = (k) => {
+      if (!pending[k]) {
+        pending[k] = 1;
+        open++;
+        touched.push(k);
+      }
+    };
+    expect(start);
+    stack[top++] = start;
+    search: while (top > 0) {
+      const k = stack[--top];
+      const v = k >> 1;
+      visited[v] = stamp;
+      if (v !== s) {
+        inside[count++] = k;
+      }
+      if (pending[k]) {
+        pending[k] = 0;
+        open--;
+      }
+      if (offset[k] === offset[k + 1]) {
+        break;
+      }
+      for (let p = offset[k]; p < offset[k + 1]; p++) {
+        const entry = next[p];
+        const u = entry >> 1;
+        if (u === s) {
+          break search;
+        }
+        expect(entry ^ 1);
+        if (visited[u] === stamp) {
+          continue;
+        }
+        let ready = true;
+        for (let q = offset[entry]; q < offset[entry + 1]; q++) {
+          if (visited[next[q] >> 1] !== stamp) {
+            ready = false;
+            break;
+          }
+        }
+        if (ready) {
+          stack[top++] = entry ^ 1;
+        }
+      }
+      if (top === 1 && open === 1) {
+        if (count > 0) {
+          found = {
+            source: start,
+            sink: stack[0],
+            inside: inside.slice(0, count)
+          };
+        }
+        break;
+      }
+    }
+    for (const k of touched) {
+      pending[k] = 0;
+    }
+    return found;
+  };
+}
+function reversed(f) {
+  return {
+    source: f.sink ^ 1,
+    sink: f.source ^ 1,
+    inside: f.inside.map((k) => k ^ 1).reverse()
+  };
+}
+var collator = new Intl.Collator(void 0, { numeric: true });
+function onReference(a, b) {
+  return isBackbone(a) && isBackbone(b) && a.stable.refName === b.stable.refName;
+}
+function forward(f, nodes) {
+  const a = nodes[f.source >> 1];
+  const b = nodes[f.sink >> 1];
+  const byRef = onReference(a, b) ? a.stable.start - b.stable.start : 0;
+  const bySide = ((f.sink ^ 1) & 1) - (f.source & 1);
+  return (byRef || bySide || collator.compare(a.name, b.name)) < 0;
+}
+function nodesOf(f) {
+  return [f.source >> 1, ...Array.from(f.inside, (k) => k >> 1), f.sink >> 1];
+}
+function allSuperbubbles(graph) {
+  const { nodes } = graph;
+  const index = new Map(nodes.map((n, i) => [n.id, i]));
+  const { offset, next } = slotGraph(graph, index);
+  const find = searcher(nodes.length, offset, next);
+  const byEnds = /* @__PURE__ */ new Map();
+  for (let k = 0; k < nodes.length * 2; k++) {
+    const hit = find(k);
+    if (!hit) {
+      continue;
+    }
+    const a = hit.source >> 1;
+    const b = hit.sink >> 1;
+    const id = Math.min(a, b) * nodes.length + Math.max(a, b);
+    if (forward(hit, nodes) || !byEnds.has(id)) {
+      byEnds.set(id, hit);
+    }
+  }
+  const found = [...byEnds.values()].map(
+    (f) => forward(f, nodes) ? f : reversed(f)
+  );
+  return { found, offset, next };
+}
+function routesThrough(nodes, offset, next, f) {
+  const sink = f.sink >> 1;
+  const best = /* @__PURE__ */ new Map([
+    [f.source >> 1, { min: 0, max: 0, n: 1 }]
+  ]);
+  for (const k of [f.source, ...f.inside]) {
+    const cur = best.get(k >> 1);
+    if (!cur) {
+      continue;
+    }
+    for (let p = offset[k]; p < offset[k + 1]; p++) {
+      const u = next[p] >> 1;
+      const add = u === sink ? 0 : nodes[u].length;
+      const prev = best.get(u);
+      best.set(u, {
+        min: Math.min(prev?.min ?? Infinity, cur.min + add),
+        max: Math.max(prev?.max ?? -Infinity, cur.max + add),
+        n: Math.min(SATURATED_PATH_COUNT, cur.n + (prev?.n ?? 0))
+      });
+    }
+  }
+  return best.get(sink) ?? { min: 0, max: 0, n: 0 };
+}
+function superbubblesFromGraph(graph, span) {
+  const { nodes } = graph;
+  const { found, offset, next } = allSuperbubbles(graph);
+  const covers = found.map((f) => coversGraph(f.inside.length, nodes.length));
+  const members = found.map(nodesOf);
+  const holders = /* @__PURE__ */ new Map();
+  members.forEach((vs, i) => {
+    for (const v of vs) {
+      ;
+      (holders.get(v) ?? holders.set(v, []).get(v)).push(i);
+    }
+  });
+  const nested = (f, i) => holders.get(f.inside[0] >> 1).some(
+    (j) => j !== i && !covers[j] && members[j].length > members[i].length && members[i].every((v) => holders.get(v).includes(j))
+  );
+  const placed = (f) => span !== void 0 || onReference(nodes[f.source >> 1], nodes[f.sink >> 1]);
+  const outermost = found.filter((f, i) => !covers[i] && placed(f) && !nested(f, i)).sort((a, b) => b.inside.length - a.inside.length).slice(0, MAX_SUPERBUBBLES);
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const walkIndex = walkIndexOf(graph);
+  return outermost.map((f) => {
+    const source = nodes[f.source >> 1];
+    const sink = nodes[f.sink >> 1];
+    const walked = walkIndex && walkRoutes(graph, byId, walkIndex, source.id, sink.id);
+    const crossed = walked?.n ? walked : void 0;
+    const routes = crossed ?? routesThrough(nodes, offset, next, f);
+    const placedOn = onReference(source, sink);
+    return {
+      refName: placedOn ? source.stable.refName : span.refName,
+      start: placedOn ? source.stable.start + source.length : span.start,
+      end: placedOn ? sink.stable.start : span.end,
+      segmentCount: f.inside.length + 2,
+      pathCount: routes.n,
+      inversion: false,
+      shortestAlleleLength: routes.min,
+      longestAlleleLength: routes.max,
+      segments: nodesOf(f).map((v) => nodes[v].name).join(","),
+      shortestAllele: void 0,
+      longestAllele: void 0,
+      partial: walked !== void 0 && walked.left > 0,
+      routes: crossed?.routes,
+      key: `${source.name}>${sink.name}`,
+      ...placedOn ? {} : { offReference: true }
+    };
+  }).sort(
+    (a, b) => a.start - b.start || a.end - b.end || collator.compare(a.key, b.key)
+  );
+}
+function graphBubbles(graph, span) {
+  const n = graph.nodes.length;
+  const reach = bubblesFromGraph(graph);
+  return reach.length === 0 ? superbubblesFromGraph(graph, span) : reach.flatMap(
+    (b) => coversGraph(b.segmentCount - 2, n) ? superbubblesFromGraph(
+      b.segmentCount === n ? graph : bubbleSubgraph(graph, bubbleSegmentIds(b)),
+      b
+    ) : [b]
+  );
+}
+
+export {
+  MAX_SUPERBUBBLES,
+  superbubblesFromGraph,
+  graphBubbles
+};

package/dist/chunks/{chunk-MFKORG3F.js → chunk-FX4RDMDN.js}

@@ -19,7 +19,10 @@ function parseBubbleLine(line) {
   };
 }
 function sameBubble(a, b) {
-  return a.refName === b.refName && a.start === b.start && a.end === b.end;
+  return a.key !== void 0 || b.key !== void 0 ? a.key === b.key : a.refName === b.refName && a.start === b.start && a.end === b.end;
+}
+function bubbleKey(b) {
+  return b.key ?? `${b.refName}:${b.start}-${b.end}`;
 }
 function bubbleLabel(bubble) {
   const { shortestAlleleLength: min, longestAlleleLength: max } = bubble;
@@ -38,6 +41,7 @@ function bubbleDescription(bubble) {
 export {
   parseBubbleLine,
   sameBubble,
+  bubbleKey,
   bubbleLabel,
   SATURATED_PATH_COUNT,
   bubbleDescription

package/dist/chunks/{chunk-4S47XRYA.js → chunk-GOZYKNQ2.js}

@@ -1,6 +1,6 @@
 import {
   SATURATED_PATH_COUNT
-} from "./chunk-MFKORG3F.js";
+} from "./chunk-FX4RDMDN.js";
 import {
   referenceOrder
 } from "./chunk-HNQPEMYE.js";
@@ -38,15 +38,7 @@ function bubblesFromGraph(graph) {
   const backbone = graph.nodes.filter(isBackbone).sort((a, b) => a.stable.start - b.stable.start);
   const ends = /* @__PURE__ */ new Set([backbone[0].id, backbone.at(-1).id]);
   const boundaries = backbone.map((node) => [node, indexOf.get(node.id)]).filter(([node, i]) => ends.has(node.id) || reach[i] === 0).sort(([a, ia], [b, ib]) => ia - ib || a.stable.start - b.stable.start);
-  const walkIndex = graph.paths?.map((p) => {
-    const at = /* @__PURE__ */ new Map();
-    p.nodeIds.forEach((id, i) => {
-      if (!at.has(id)) {
-        at.set(id, i);
-      }
-    });
-    return at;
-  });
+  const walkIndex = walkIndexOf(graph);
   const bubbles = [];
   for (let i = 0; i + 1 < boundaries.length; i++) {
     const [start, i0] = boundaries[i];
@@ -112,6 +104,17 @@ function bubblesFromGraph(graph) {
   }
   return bubbles;
 }
+function walkIndexOf(graph) {
+  return graph.paths?.map((p) => {
+    const at = /* @__PURE__ */ new Map();
+    p.nodeIds.forEach((id, i) => {
+      if (!at.has(id)) {
+        at.set(id, i);
+      }
+    });
+    return at;
+  });
+}
 function walkRoutes(graph, byId, walkIndex, startId, endId) {
   const seen = /* @__PURE__ */ new Map();
   let min = Infinity;
@@ -145,5 +148,7 @@ function walkRoutes(graph, byId, walkIndex, startId, endId) {
 }
 
 export {
-  bubblesFromGraph
+  bubblesFromGraph,
+  walkIndexOf,
+  walkRoutes
 };

package/dist/chunks/chunk-INJ2UVOT.js

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