@jbrowse/bandage-core 4.0.28 → 4.0.29

package/dist/chunks/{chunk-G3HO75W7.js → chunk-QN464POI.js}

@@ -145,6 +145,9 @@ function isOffReference(node) {
 function backboneNodes(graph) {
   return graph.nodes.filter(isBackbone);
 }
+function overlapsWindow(node, window) {
+  return node.stable.start < window.end && node.stable.start + node.length > window.start;
+}
 function backbonePositions(backbone) {
   const positions = {};
   for (const node of backbone) {
@@ -445,6 +448,7 @@ function surveySegments(gfaGraph) {
   }
   return { canonical, traversals };
 }
+var walkStart = (w) => w.start === -1 ? 0 : w.start;
 function anchorablePaths(gfaGraph) {
   return [
     ...gfaGraph.paths.map((p) => ({
@@ -456,10 +460,7 @@ function anchorablePaths(gfaGraph) {
     })),
     ...gfaGraph.walks.map((w) => ({
       name: `${w.sample}#${w.haplotype}#${w.contig}`,
-      // `*` parses to -1, meaning the record declines to say; 0 is then the
-      // only offset that can be assumed, and it makes the walk self-relative
-      // rather than wrong
-      start: w.start === -1 ? 0 : w.start,
+      start: walkStart(w),
       steps: w.segments.map((s) => ({
         id: s.id,
         strand: s.strand === "-" ? "-" : "+"
@@ -521,7 +522,11 @@ function convertGFAToGraph(gfaGraph, name = "Imported GFA") {
   }
   for (const gfaPath of gfaGraph.paths) {
     const nodeIds = gfaPath.path.split(",").map((segment) => nodeId(segment.slice(0, -1)));
-    paths.push({ name: gfaPath.name, nodeIds });
+    paths.push({
+      name: gfaPath.name,
+      nodeIds,
+      start: pathOrigin(gfaPath.name).start
+    });
     recordPathEdges(nodeIds, gfaPath.name);
   }
   for (const walk of gfaGraph.walks) {
@@ -530,6 +535,7 @@ function convertGFAToGraph(gfaGraph, name = "Imported GFA") {
     paths.push({
       name: name2,
       nodeIds,
+      start: walkStart(walk),
       sample: walk.sample,
       haplotype: walk.haplotype,
       contig: walk.contig
@@ -1910,18 +1916,25 @@ function offsetTiers(name, tiers) {
   return tiers.map((t) => `${t} @${groupDigits(start)}`);
 }
 function pathLegend(paths, colors) {
-  const named = paths.map((p) => labelTiers(p.name));
+  const firstOf = /* @__PURE__ */ new Map();
+  paths.forEach((path, i) => {
+    if (!firstOf.has(path.name)) {
+      firstOf.set(path.name, i);
+    }
+  });
+  const entries = [...firstOf].map(([name, i]) => ({ name, i }));
+  const named = entries.map((e) => labelTiers(e.name));
   const candidates = [0, 1, 2].flatMap((t) => [
-    paths.map((_, i) => named[i][t]),
-    paths.map((p, i) => offsetTiers(p.name, named[i])[t])
+    entries.map((_, k) => named[k][t]),
+    entries.map((e, k) => offsetTiers(e.name, named[k])[t])
   ]);
   const distinct = candidates.find(
-    (labels2) => new Set(labels2).size === paths.length
+    (labels2) => new Set(labels2).size === entries.length
   );
   const labels = distinct ?? candidates.at(-1);
-  return paths.map((path, i) => ({
-    name: path.name,
-    label: labels[i],
+  return entries.map(({ name, i }, k) => ({
+    name,
+    label: labels[k],
     color: colors?.[i] ?? pathCssColor(i, paths.length)
   }));
 }
@@ -1962,21 +1975,26 @@ function sliceBetween(nodeIds, span, region, flanked = true) {
 }
 function walkRows(graph, region, unit) {
   const paths = graph.paths ?? [];
-  const reference = paths.find((p) => pathOrigin(p.name).name === graph.referencePath) ?? paths[0];
-  if (!reference || paths.length < 2) {
+  const isReference2 = (p) => pathOrigin(p.name).name === graph.referencePath;
+  const referencePieces2 = paths.some(isReference2) ? paths.filter(isReference2).sort((a, b) => (a.start ?? 0) - (b.start ?? 0)) : paths.slice(0, 1);
+  const first = referencePieces2[0];
+  const others = paths.filter((p) => !referencePieces2.includes(p));
+  if (!first || others.length === 0) {
     return void 0;
   }
   const lengthOf = new Map(graph.nodes.map((n2) => [n2.id, n2.length]));
-  const referenceStart = graph.anchorPaths?.find((p) => p.name === pathOrigin(reference.name).name)?.start ?? 0;
+  const referenceStart = first.start ?? 0;
   const cut = region && region.end > region.start ? region : void 0;
   const span = /* @__PURE__ */ new Map();
-  let pos = referenceStart;
-  for (const id of reference.nodeIds) {
-    const len = lengthOf.get(id) ?? 0;
-    if (!span.has(id)) {
-      span.set(id, { start: pos, end: pos + len });
+  for (const piece of referencePieces2) {
+    let pos = piece.start ?? 0;
+    for (const id of piece.nodeIds) {
+      const len = lengthOf.get(id) ?? 0;
+      if (!span.has(id)) {
+        span.set(id, { start: pos, end: pos + len });
+      }
+      pos += len;
     }
-    pos += len;
   }
   const flanked = cut === void 0 || [...span.values()].some((s) => s.end <= cut.start) && [...span.values()].some((s) => s.start >= cut.end);
   const rowOf = (path) => {
@@ -2026,18 +2044,15 @@ function walkRows(graph, region, unit) {
       runs
     };
   };
-  const meetsReference = (p) => p.nodeIds.some((id) => span.has(id));
-  const placedWalks = new Set(
-    paths.filter((p) => p !== reference && meetsReference(p)).map((p) => p.name)
-  );
   const origin = cut ? cut.start : referenceStart;
   return {
     origin,
     unit,
-    reference: rowOf(reference),
-    rows: paths.filter(
-      (p) => p !== reference && (meetsReference(p) || !placedWalks.has(p.name))
-    ).map(rowOf).sort(
+    reference: rowOf({
+      ...first,
+      nodeIds: referencePieces2.flatMap((piece) => piece.nodeIds)
+    }),
+    rows: others.map(rowOf).sort(
       (a, b) => Number(b.complete) - Number(a.complete) || b.bp - a.bp || a.label.localeCompare(b.label)
     )
   };
@@ -2061,7 +2076,10 @@ function walkRowLayout(graph, region) {
   if (backbone.length === 0 || !walks) {
     return void 0;
   }
-  const nodePositions = backbonePositions(backbone);
+  const overWindow = region ? backbone.filter((n2) => overlapsWindow(n2, region)) : backbone;
+  const nodePositions = backbonePositions(
+    overWindow.length > 0 ? overWindow : backbone
+  );
   const rowLabels = [
     { label: walks.reference.label, y: 0 },
     ...walks.rows.map((row, i) => ({
@@ -4168,12 +4186,14 @@ function encodingSwatchCss(encoding) {
 }
 
 // src/walkHighlight.ts
-function referenceOf(graph) {
-  return graph.referencePath ? graph.paths?.find((p) => pathOrigin(p.name).name === graph.referencePath) : void 0;
+var isReference = (graph, name) => !!graph.referencePath && pathOrigin(name).name === graph.referencePath;
+function piecesOf(graph, name) {
+  return (graph.paths ?? []).filter((p) => p.name === name).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
 }
 function walkHighlight(graph, name) {
-  const path = graph.paths?.find((p) => p.name === name);
-  if (!path) {
+  const pieces = piecesOf(graph, name);
+  const first = pieces[0];
+  if (!first) {
     return void 0;
   }
   const byId = new Map(graph.nodes.map((n2) => [n2.id, n2]));
@@ -4181,43 +4201,51 @@ function walkHighlight(graph, name) {
   graph.edges.forEach((e, i) => {
     edgeAt.set(`${e.from}>${e.to}`, i);
   });
-  const edgeIndexes = /* @__PURE__ */ new Set();
-  for (let i = 1; i < path.nodeIds.length; i++) {
-    const a = path.nodeIds[i - 1];
-    const b = path.nodeIds[i];
-    const index = edgeAt.get(`${a}>${b}`) ?? edgeAt.get(`${b}>${a}`);
-    if (index !== void 0) {
-      edgeIndexes.add(index);
-    }
-  }
   const lengthOf = (id) => byId.get(id)?.length ?? 0;
-  const bp = path.nodeIds.reduce((sum, id) => sum + lengthOf(id), 0);
+  const bpOf = (path) => path.nodeIds.reduce((sum, id) => sum + lengthOf(id), 0);
+  const bp = pieces.reduce((sum, piece) => sum + bpOf(piece), 0);
+  const range = first.start === void 0 ? void 0 : {
+    contig: first.contig ?? panSNContig(pathOrigin(name).name),
+    start: first.start,
+    end: Math.max(...pieces.map((p) => (p.start ?? 0) + bpOf(p)))
+  };
+  const span = range ? range.end - range.start : bp;
+  const nodeIds = /* @__PURE__ */ new Set();
+  const edgeIndexes = /* @__PURE__ */ new Set();
   const progress = /* @__PURE__ */ new Map();
   let before = 0;
-  for (const id of path.nodeIds) {
-    const length = lengthOf(id);
-    if (!progress.has(id)) {
-      progress.set(id, bp > 0 ? (before + length / 2) / bp : 0);
-    }
-    before += length;
+  for (const piece of pieces) {
+    if (range) {
+      before = Math.max(before, (piece.start ?? 0) - range.start);
+    }
+    piece.nodeIds.forEach((id, i) => {
+      nodeIds.add(id);
+      if (i > 0) {
+        const a = piece.nodeIds[i - 1];
+        const index = edgeAt.get(`${a}>${id}`) ?? edgeAt.get(`${id}>${a}`);
+        if (index !== void 0) {
+          edgeIndexes.add(index);
+        }
+      }
+      const length = lengthOf(id);
+      if (!progress.has(id)) {
+        progress.set(id, span > 0 ? (before + length / 2) / span : 0);
+      }
+      before += length;
+    });
   }
-  const reference = referenceOf(graph);
-  const originName = pathOrigin(name).name;
-  const origin = graph.anchorPaths?.find((a) => a.name === originName && a.length === bp) ?? graph.anchorPaths?.find((a) => a.name === originName);
+  const reference = isReference(graph, name);
+  const referencePieces2 = reference ? [] : (graph.paths ?? []).filter((p) => isReference(graph, p.name));
   return {
     name,
-    reference: reference === path,
-    range: origin ? {
-      contig: path.contig ?? panSNContig(origin.name),
-      start: origin.start,
-      end: origin.start + origin.length
-    } : void 0,
-    nodeIds: new Set(path.nodeIds),
+    reference,
+    range,
+    nodeIds,
     edgeIndexes,
     progress,
-    steps: path.nodeIds.length,
+    steps: pieces.reduce((sum, piece) => sum + piece.nodeIds.length, 0),
     bp,
-    referenceBp: reference && reference !== path ? reference.nodeIds.reduce((sum, id) => sum + lengthOf(id), 0) : void 0
+    referenceBp: referencePieces2.length > 0 ? referencePieces2.reduce((sum, piece) => sum + bpOf(piece), 0) : void 0
   };
 }
 function laneColors(graph, walk, encoding, ramp) {
@@ -4232,14 +4260,13 @@ function laneColors(graph, walk, encoding, ramp) {
   return colors;
 }
 function reversedNodes(graph, walk) {
-  const reference = referenceOf(graph);
   const reversed = /* @__PURE__ */ new Set();
   let bp = 0;
-  if (!reference || walk.reference) {
+  const referencePath = graph.referencePath;
+  if (!referencePath || walk.reference) {
     return { reversed, bp };
   }
   const walkPath = pathOrigin(walk.name).name;
-  const referencePath = pathOrigin(reference.name).name;
   const byId = new Map(graph.nodes.map((n2) => [n2.id, n2]));
   for (const id of walk.progress.keys()) {
     const node = byId.get(id);
@@ -4336,7 +4363,9 @@ function walkPosition(walk, nodeId, length) {
   if (progress === void 0 || !range) {
     return void 0;
   }
-  const start = Math.round(range.start + progress * walk.bp - length / 2);
+  const start = Math.round(
+    range.start + progress * (range.end - range.start) - length / 2
+  );
   return `${range.contig}:${groupDigits(start)}-${groupDigits(start + length)}`;
 }
 
@@ -4389,11 +4418,26 @@ function facetGrid({
   }
   return best;
 }
-function facetCells(names, by) {
+function facetSettingOf(facet) {
+  const raw = typeof facet === "string" ? { field: facet } : facet ?? {};
+  const field = raw.field === "walk" || raw.field === "sample" ? raw.field : "";
+  return {
+    field,
+    domain: [...raw.domain ?? []],
+    ...raw.columns === void 0 ? {} : { columns: raw.columns }
+  };
+}
+function domainFirst(names, domain) {
+  const rank = new Map(domain.map((name, i) => [name, i]));
+  const listed = (name) => rank.get(name) ?? domain.length;
+  return names.map((name, i) => ({ name, i })).sort((a, b) => listed(a.name) - listed(b.name) || a.i - b.i).map(({ name }) => name);
+}
+function facetCells(names, by, domain = []) {
+  const wrapOrder = domainFirst(names, domain);
   const wrap = {
     columns: void 0,
     count: names.length,
-    cells: names.map((_, i) => i)
+    cells: names.map((name) => wrapOrder.indexOf(name))
   };
   if (by === "walk") {
     return wrap;
@@ -4403,7 +4447,10 @@ function facetCells(names, by) {
     const n2 = Number(haplotype);
     return contig !== void 0 && Number.isInteger(n2) && n2 >= 0 ? { sample, column: Math.max(0, n2 - 1) } : void 0;
   });
-  const rows = [...new Set(places.map((p) => p?.sample))];
+  const rows = domainFirst(
+    [...new Set(places.flatMap((p) => p ? [p.sample] : []))],
+    domain
+  );
   const columns = Math.max(1, ...places.map((p) => p ? p.column + 1 : 1));
   const cells = places.map(
     (p) => p ? rows.indexOf(p.sample) * columns + p.column : -1
@@ -4741,7 +4788,7 @@ function svgCanvas(width, height) {
 }
 
 // src/version.ts
-var version = "4.0.28";
+var version = "4.0.29";
 
 // src/viewport.ts
 function axisScaleOf(scale, pixelRows) {
@@ -4848,8 +4895,8 @@ function figureSvg(graph, layout, o = {}) {
   const layers = o.walks ?? [];
   const walkRamp = layers.some((l) => l.color?.field === "reference") ? referenceRamp ?? computeReferenceRamp(graph, rampDomain) : void 0;
   const lift = layers.length > 0 && !layout.tubeMap ? walkLift(graph, layers, walkRamp) : void 0;
-  const by = o.facet ?? "none";
-  const panels = by !== "none" && lift && lift.walks.length > 1 ? facetLifts(graph, lift, layers, walkRamp) : void 0;
+  const facet = facetSettingOf(o.facet);
+  const panels = facet.field && lift && lift.walks.length > 1 ? facetLifts(graph, lift, layers, walkRamp) : void 0;
   const labels = new Map(
     (graph.paths?.length ? pathLegend(graph.paths) : []).map((p) => [
       p.name,
@@ -4966,7 +5013,8 @@ function figureSvg(graph, layout, o = {}) {
   if (panels) {
     const place = facetCells(
       panels.map((p) => p.walks[0].name),
-      by
+      facet.field || "walk",
+      facet.domain
     );
     const grid = facetGrid({
       count: place.count,
@@ -4974,7 +5022,7 @@ function figureSvg(graph, layout, o = {}) {
       pixelRows,
       width,
       room,
-      columns: place.columns ?? o.columns
+      columns: place.columns ?? facet.columns
     });
     panels.forEach((panel, i) => {
       const cell = place.cells[i];
@@ -5343,6 +5391,135 @@ function featuresOnBackbone(features, backbone, aliases) {
   });
 }
 
+// src/gbzJoin.ts
+var UNKNOWN_SAMPLE = "unknown";
+function parseWalk(line) {
+  const fields = line.split("	");
+  return {
+    fields,
+    name: fields.slice(1, 4).join("	"),
+    start: +fields[4],
+    end: +fields[5]
+  };
+}
+var stepsOf = (walk) => walk.fields[6].match(/[<>][^<>]+/g) ?? [];
+function segmentLengths(lines) {
+  const lengths = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (line.startsWith("S	")) {
+      const [, id, sequence, ...tags] = line.split("	");
+      const ln = tags.find((tag) => tag.startsWith("LN:i:"));
+      lengths.set(
+        id,
+        sequence === "*" && ln ? +ln.slice("LN:i:".length) : sequence.length
+      );
+    }
+  }
+  return lengths;
+}
+function extend(a, b, lengths) {
+  if (b.end <= a.end) {
+    return a;
+  }
+  const steps = stepsOf(b);
+  let pos = b.start;
+  for (const [i, step] of steps.entries()) {
+    if (pos === a.end) {
+      const fields = [...a.fields];
+      fields[5] = String(b.end);
+      fields[6] = a.fields[6] + steps.slice(i).join("");
+      return { ...a, fields, end: b.end };
+    }
+    const length = lengths.get(step.slice(1));
+    if (pos > a.end || length === void 0) {
+      return void 0;
+    }
+    pos += length;
+  }
+  return void 0;
+}
+function joinPieces(pieces, lengths, startsPath) {
+  const joined = [];
+  for (const piece of pieces.sort((a, b) => a.start - b.start)) {
+    const last = joined.at(-1);
+    const [, sample, haplotype, contig] = piece.fields;
+    const joins = last !== void 0 && (piece.start < last.end || piece.start === last.end && !startsPath(sample, +haplotype, contig, piece.start));
+    const extended = joins ? extend(last, piece, lengths) : void 0;
+    if (extended) {
+      joined[joined.length - 1] = extended;
+    } else {
+      joined.push(piece);
+    }
+  }
+  return joined;
+}
+var flip2 = (sign) => sign === "+" ? "-" : "+";
+function* stepLinks(walk) {
+  const steps = stepsOf(walk).map((step) => ({
+    id: step.slice(1),
+    sign: step.startsWith(">") ? "+" : "-"
+  }));
+  for (let i = 1; i < steps.length; i++) {
+    const a = steps[i - 1];
+    const b = steps[i];
+    yield {
+      forward: `L	${a.id}	${a.sign}	${b.id}	${b.sign}	0M`,
+      reverse: `L	${b.id}	${flip2(b.sign)}	${a.id}	${flip2(a.sign)}	0M`
+    };
+  }
+}
+function joinCuts(gfas, startsPath) {
+  if (gfas.length <= 1) {
+    return gfas[0] ?? "";
+  }
+  const cuts = gfas.map((gfa) => gfa.split("\n").filter((line) => line !== ""));
+  const ofType = (cut, type) => cut.filter((line) => line.startsWith(`${type}	`));
+  const lengths = segmentLengths(cuts.flat());
+  let unknownOffset = 0;
+  const walksByCut = cuts.map((cut) => {
+    const walks2 = ofType(cut, "W").map(parseWalk);
+    const offset = unknownOffset;
+    for (const walk of walks2.filter((w) => w.fields[1] === UNKNOWN_SAMPLE)) {
+      const haplotype = +walk.fields[2] + offset;
+      walk.fields[2] = String(haplotype);
+      walk.name = walk.fields.slice(1, 4).join("	");
+      unknownOffset = Math.max(unknownOffset, haplotype);
+    }
+    return walks2;
+  });
+  const byName = /* @__PURE__ */ new Map();
+  for (const walk of [
+    ...walksByCut.flatMap((walks2) => walks2.slice(0, 1)),
+    ...walksByCut.flatMap((walks2) => walks2.slice(1))
+  ]) {
+    const pieces = byName.get(walk.name);
+    if (pieces) {
+      pieces.push(walk);
+    } else {
+      byName.set(walk.name, [walk]);
+    }
+  }
+  const walks = [...byName.values()].flatMap(
+    (pieces) => joinPieces(pieces, lengths, startsPath)
+  );
+  const links = new Set(cuts.flatMap((cut) => ofType(cut, "L")));
+  for (const walk of walks) {
+    for (const link of stepLinks(walk)) {
+      if (!links.has(link.forward) && !links.has(link.reverse)) {
+        links.add(link.forward);
+      }
+    }
+  }
+  const lines = /* @__PURE__ */ new Set([
+    ...ofType(cuts[0], "H"),
+    ...cuts.flatMap((cut) => ofType(cut, "S")),
+    ...links,
+    ...walks.map((walk) => walk.fields.join("	"))
+  ]);
+  return `${[...lines].join("\n")}
+`;
+}
+
 // src/gbzWindow.ts
 var NoReferenceSampleError = class extends Error {
   constructor(anchor, referenceSamples) {
@@ -5399,13 +5576,13 @@ async function referencePathQuery(db, referenceSample2, refName) {
     haplotype: path.name.haplotype
   } : void 0;
 }
-function nodeLimitError(error, limit, windowBp) {
+function nodeLimitError(error, limit, windowBp, walkedFrom = 0) {
   const isLimit = error instanceof Error && (error.name === "SubgraphLimitError" || /^Subgraph size limit of \d+ nodes exceeded/.test(error.message));
   if (!isLimit) {
     return void 0;
   } else {
     const walked = error.walkedBp;
-    const fits = typeof walked === "number" && walked > 0 ? Math.floor(walked * 0.8) : Math.floor(windowBp / 2);
+    const fits = typeof walked === "number" && walked > 0 ? Math.floor((walkedFrom + walked) * 0.8) : Math.floor(windowBp / 2);
     return new NodeLimitError(limit, windowBp, Math.max(fits, 1));
   }
 }
@@ -5424,19 +5601,6 @@ async function referencePieces(db, query, start, end) {
     end: pieceEnd
   }));
 }
-function joinCuts(gfas) {
-  const cuts = gfas.map((gfa) => gfa.split("\n").filter((line) => line !== ""));
-  const ofType = (cut, type) => cut.filter((line) => line.startsWith(type));
-  const lines = /* @__PURE__ */ new Set([
-    ...ofType(cuts[0] ?? [], "H"),
-    ...cuts.flatMap((cut) => ofType(cut, "S")),
-    ...cuts.flatMap((cut) => ofType(cut, "L")),
-    ...cuts.flatMap((cut) => ofType(cut, "W").slice(0, 1)),
-    ...cuts.flatMap((cut) => ofType(cut, "W").slice(1))
-  ]);
-  return lines.size === 0 ? "" : `${[...lines].join("\n")}
-`;
-}
 async function cutWindowGFA(db, query, start, end, { keep, ...opts }) {
   if (!query) {
     return "";
@@ -5449,15 +5613,24 @@ async function cutWindowGFA(db, query, start, end, { keep, ...opts }) {
         haplotypes: "all",
         ...keep === void 0 ? {} : { keep }
       }).catch((error) => {
-        throw nodeLimitError(error, opts.limit, end - start) ?? error;
+        throw nodeLimitError(
+          error,
+          opts.limit,
+          end - start,
+          piece.start - start
+        ) ?? error;
       })
     )
   );
+  const paths = await db.paths();
   return joinCuts(
     await Promise.all(
       subgraphs.flatMap(
         (subgraph) => subgraph ? [subgraph.toGFA({ names: "resolved" })] : []
       )
+    ),
+    (sample, haplotype, contig, at) => paths.some(
+      ({ name }) => name.sample === sample && name.haplotype === haplotype && name.contig === contig && name.fragment === at
     )
   );
 }
@@ -5596,6 +5769,7 @@ export {
   FACET_TITLE_PX,
   FACET_PAD_PX,
   facetGrid,
+  facetSettingOf,
   facetCells,
   genePins,
   HALO_FACTOR,

package/dist/cli/figure.js

@@ -17,7 +17,7 @@ import {
   openGbz,
   parseRegion,
   refNameBinding
-} from "../chunks/chunk-G3HO75W7.js";
+} from "../chunks/chunk-QN464POI.js";
 
 // src/cli/figure.ts
 import { access, open, readFile, writeFile } from "node:fs/promises";

package/dist/index.js

@@ -42,6 +42,7 @@ import {
   facetCells,
   facetGrid,
   facetLifts,
+  facetSettingOf,
   featuresOnBackbone,
   figureSvg,
   fitTransform,
@@ -100,7 +101,7 @@ import {
   wellKnownSample,
   yToXOf,
   zoomAbout
-} from "./chunks/chunk-G3HO75W7.js";
+} from "./chunks/chunk-QN464POI.js";
 
 // src/index.ts
 import { getDpr } from "@jbrowse/render-core/canvas2dUtils";
@@ -1715,6 +1716,7 @@ function bubbleSubgraph(graph, segmentIds) {
   const keep = new Set(segmentIds);
   const nodes = graph.nodes.filter((n) => keep.has(n.name));
   const ids = new Set(nodes.map((n) => n.id));
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
   const kept = /* @__PURE__ */ new Map();
   const paths = graph.paths?.flatMap((p) => {
     const first = p.nodeIds.findIndex((id) => ids.has(id));
@@ -1723,7 +1725,14 @@ function bubbleSubgraph(graph, segmentIds) {
     }
     const nodeIds = p.nodeIds.filter((id) => ids.has(id));
     kept.set(p.name, { first, nodeIds });
-    return [{ ...p, nodeIds }];
+    const before = p.nodeIds.slice(0, first).reduce((sum, id) => sum + (lengthOf.get(id) ?? 0), 0);
+    return [
+      {
+        ...p,
+        nodeIds,
+        ...p.start === void 0 ? {} : { start: p.start + before }
+      }
+    ];
   });
   return {
     name: graph.name,
@@ -1790,6 +1799,7 @@ export {
   facetCells,
   facetGrid,
   facetLifts,
+  facetSettingOf,
   featuresOnBackbone,
   figureSvg,
   findHoveredEdge,

package/dist/types/anchoredNodes.d.ts

@@ -8,6 +8,10 @@ export declare function isAnchored(node: GraphNode): node is AnchoredNode;
 export declare function isBackbone(node: GraphNode): node is AnchoredNode;
 export declare function isOffReference(node: GraphNode): node is AnchoredNode;
 export declare function backboneNodes(graph: Graph): AnchoredNode[];
+export declare function overlapsWindow(node: AnchoredNode, window: {
+    start: number;
+    end: number;
+}): boolean;
 export declare function backbonePositions(backbone: AnchoredNode[]): Record<string, NodeSegment[]>;
 export declare function firstNodeAtOrAfter(nodes: AnchoredNode[], bp: number): number;
 export declare function backboneSpan(backbone: AnchoredNode[]): number;

package/dist/types/facetGrid.d.ts

@@ -20,7 +20,28 @@ export declare function facetGrid({ count, bounds, pixelRows, width, room, colum
     columns?: number;
 }): FacetGrid;
 export type FacetBy = 'walk' | 'sample';
-export declare function facetCells(names: string[], by: FacetBy): {
+/**
+ * The facet as a session or a figure spec writes it, in the shape every
+ * JBrowse display's `facet` takes: the field the panels split on, `walk` for
+ * a panel per lifted walk or `sample` for a row per sample and a column per
+ * haplotype, the order the panels take, and how many go across under `walk`.
+ */
+export interface FacetSetting {
+    field: '' | FacetBy;
+    /** The walks, or under `sample` the samples, whose panels come first, in order. */
+    domain: string[];
+    /** How many panels go across; unset takes whichever count draws each largest. */
+    columns?: number;
+}
+/** What a session or a spec may write for the facet: the field bare, or the setting's members. */
+export type FacetInput = string | {
+    field?: string;
+    domain?: readonly string[];
+    columns?: number;
+};
+/** A facet written bare is its field, and a field the pane cannot split on is none. */
+export declare function facetSettingOf(facet: FacetInput | undefined): FacetSetting;
+export declare function facetCells(names: string[], by: FacetBy, domain?: readonly string[]): {
     columns: undefined;
     count: number;
     cells: number[];

package/dist/types/figure.d.ts

@@ -1,5 +1,5 @@
 import type { ColorScheme } from './colorSchemes.js';
-import type { FacetBy } from './facetGrid.js';
+import type { FacetInput } from './facetGrid.js';
 import type { GeneModel } from './genes/genePins.js';
 import type { NodeWidth } from './nodeWidths.js';
 import type { Graph, LayoutResult } from './types.js';
@@ -8,8 +8,7 @@ export interface FigureOptions {
     width?: number;
     height?: number;
     walks?: WalkLayer[];
-    facet?: 'none' | FacetBy;
-    columns?: number;
+    facet?: FacetInput;
     colorScheme?: ColorScheme;
     nodeWidth?: NodeWidth;
     showDeletionEdges?: boolean;

package/dist/types/gbzJoin.d.ts

@@ -0,0 +1,2 @@
+export type StartsPath = (sample: string, haplotype: number, contig: string, at: number) => boolean;
+export declare function joinCuts(gfas: string[], startsPath: StartsPath): string;

package/dist/types/gbzWindow.d.ts

@@ -16,7 +16,7 @@ export declare function resolveReferenceSample({ configured, anchorPrefix, refer
     referenceSamples: string[];
 }): string;
 export declare function referencePathQuery(db: GBZBase, referenceSample: string, refName: string): Promise<PathQuery | undefined>;
-export declare function nodeLimitError(error: unknown, limit: number, windowBp: number): NodeLimitError | undefined;
+export declare function nodeLimitError(error: unknown, limit: number, windowBp: number, walkedFrom?: number): NodeLimitError | undefined;
 export interface GbzWindowOptions {
     context: number;
     snarls: RangeOptions['snarls'];

package/dist/types/index.d.ts

@@ -42,8 +42,8 @@ export type { GbzSource } from './gbzCut.js';
 export { version } from './version.js';
 export type { FigureOptions } from './figure.js';
 export { svgCanvas } from './renderer/svgCanvas.js';
-export { FACET_GAP_PX, FACET_PAD_PX, FACET_TITLE_PX, facetCells, facetGrid, } from './facetGrid.js';
-export type { FacetBy, FacetGrid } from './facetGrid.js';
+export { FACET_GAP_PX, FACET_PAD_PX, FACET_TITLE_PX, facetCells, facetGrid, facetSettingOf, } from './facetGrid.js';
+export type { FacetBy, FacetGrid, FacetInput, FacetSetting } from './facetGrid.js';
 export type { LiftedWalk, WalkLift } from './walkHighlight.js';
 export { WALK_FIELDS, WALK_SCHEMES, encodingStops, encodingSwatchCss, resolveEncoding, schemeCss, } from './walkEncoding.js';
 export type { WalkEncoding, WalkField, WalkLayer, WalkScheme, } from './walkEncoding.js';

package/dist/types/types.d.ts

@@ -19,6 +19,7 @@ export interface GraphEdge {
 export interface GraphPath {
     name: string;
     nodeIds: string[];
+    start?: number;
     sample?: string;
     haplotype?: number;
     contig?: string;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.0.28";
+export declare const version = "4.0.29";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/bandage-core",
-  "version": "4.0.28",
+  "version": "4.0.29",
   "description": "Pangenome graph layout and drawing with no host: GFA in, the Bandage force-directed engine and reference-anchored layouts, a Canvas2D renderer, hit testing and labels out",
   "license": "GPL-3.0-or-later",
   "repository": {