jbrowse-plugin-graphgenomeviewer 7.2.0 → 7.2.1

package/dist/chunks/chunk-ZNT7TQLN.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/RgfaTabixAdapter/walkReader.ts"],
-  "sourcesContent": ["import { resolvePanSNPrefix } from '@jbrowse/bandage-core/pansn'\nimport { WalkReader, referenceNodes, walksKept } from '@jbrowse/graph-walks'\n\nimport { getLines } from '../tabixRange.ts'\nimport { walkCutFor } from './walkRowRuns.ts'\n\nimport type { SubgraphAdapterOptions } from '../GetSubgraph.ts'\nimport type { TabixIndexedFile } from '@gmod/tabix'\nimport type {\n  BaseFeatureDataAdapter,\n  BaseOptions,\n} from '@jbrowse/core/data_adapters/BaseAdapter'\n\n// The zoom-in notices name the config slots that set the budgets\nexport const BUDGET_SLOTS = {\n  steps: 'walkStepBudget',\n  bytes: 'walkByteBudget',\n}\n\n/**\n * A walk file and the answers both walk-indexed adapters give from it,\n * RgfaTabixAdapter and WalkTabixSyntenyAdapter, whose schemas declare the\n * budget slots. @jbrowse/graph-walks reads and cuts the file.\n */\nexport class WalkIndex {\n  readonly reader: WalkReader\n\n  constructor(\n    readonly file: TabixIndexedFile,\n    private adapter: BaseFeatureDataAdapter,\n  ) {\n    this.reader = new WalkReader(file)\n  }\n\n  /**\n   * The haplotypes the header names, `sample#haplotype` in byte order, or\n   * undefined when it names none\n   */\n  async haplotypeNames(opts: BaseOptions = {}) {\n    const { haplotypes } = await this.reader.header(opts)\n    return haplotypes.length > 0 ? haplotypes : undefined\n  }\n\n  budgets() {\n    return {\n      stepBudget: this.adapter.getConf('walkStepBudget') as number,\n      byteBudget: this.adapter.getConf('walkByteBudget') as number,\n      budgetNames: BUDGET_SLOTS,\n    }\n  }\n\n  /**\n   * The graph display's cut of a window: the reference walk, the walks of\n   * `haplotypes` (every walk when unset), and the nodes and links they visit.\n   * Walk rows draw runs, so the step budget spares them.\n   */\n  async subgraph(\n    refName: string,\n    region: { start: number; end: number },\n    { signal, haplotypes, walkRows }: SubgraphAdapterOptions,\n  ) {\n    const budgets = this.budgets()\n    const { graph, kept, fragments } = await this.reader.cut(refName, region, {\n      ...budgets,\n      stepBudget: walkRows ? Infinity : budgets.stepBudget,\n      signal,\n      keep: walksKept(\n        haplotypes?.map(lane => resolvePanSNPrefix(this.adapter, lane)),\n        refName,\n      ),\n    })\n    return walkCutFor(graph.tables(kept, fragments), region, walkRows)\n  }\n\n  /**\n   * The reference nodes overlapping a window, from the ref rows of its\n   * chunks. A row's tabix interval is its chunk's first base, and gfa-to-tabix\n   * files a node crossing in from a chunk before under that chunk, so the read\n   * starts at queryStart.\n   */\n  async referenceNodes(\n    refName: string,\n    region: { start: number; end: number },\n    opts: BaseOptions,\n  ) {\n    const refRows: string[][] = []\n    await getLines(\n      this.file,\n      refName,\n      await this.reader.queryStart(region.start, opts),\n      region.end,\n      {\n        signal: opts.signal,\n        lineCallback: line => {\n          const cols = line.split('\\t')\n          if (cols[3] === 'ref') {\n            refRows.push(cols)\n          }\n        },\n      },\n    )\n    const seen = new Set<number>()\n    return referenceNodes(refRows).filter(node => {\n      if (\n        node.refName !== refName ||\n        node.end <= region.start ||\n        node.start >= region.end ||\n        seen.has(node.id)\n      ) {\n        return false\n      }\n      seen.add(node.id)\n      return true\n    })\n  }\n}\n"],
-  "mappings": "6IAcO,IAAMA,EAAe,CAC1B,MAAO,iBACP,MAAO,gBACT,EAOaC,EAAN,KAAgB,CAGrB,YACWC,EACDC,EACR,CAFS,UAAAD,EACD,aAAAC,EAER,KAAK,OAAS,IAAIC,EAAWF,CAAI,CACnC,CAMA,MAAM,eAAeG,EAAoB,CAAC,EAAG,CAC3C,GAAM,CAAE,WAAAC,CAAW,EAAI,MAAM,KAAK,OAAO,OAAOD,CAAI,EACpD,OAAOC,EAAW,OAAS,EAAIA,EAAa,MAC9C,CAEA,SAAU,CACR,MAAO,CACL,WAAY,KAAK,QAAQ,QAAQ,gBAAgB,EACjD,WAAY,KAAK,QAAQ,QAAQ,gBAAgB,EACjD,YAAaN,CACf,CACF,CAOA,MAAM,SACJO,EACAC,EACA,CAAE,OAAAC,EAAQ,WAAAH,EAAY,SAAAI,CAAS,EAC/B,CACA,IAAMC,EAAU,KAAK,QAAQ,EACvB,CAAE,MAAAC,EAAO,KAAAC,EAAM,UAAAC,CAAU,EAAI,MAAM,KAAK,OAAO,IAAIP,EAASC,EAAQ,CACxE,GAAGG,EACH,WAAYD,EAAW,IAAWC,EAAQ,WAC1C,OAAAF,EACA,KAAMM,EACJT,GAAY,IAAIU,GAAQC,EAAmB,KAAK,QAASD,CAAI,CAAC,EAC9DT,CACF,CACF,CAAC,EACD,OAAOW,EAAWN,EAAM,OAAOC,EAAMC,CAAS,EAAGN,EAAQE,CAAQ,CACnE,CAQA,MAAM,eACJH,EACAC,EACAH,EACA,CACA,IAAMc,EAAsB,CAAC,EAC7B,MAAMC,EACJ,KAAK,KACLb,EACA,MAAM,KAAK,OAAO,WAAWC,EAAO,MAAOH,CAAI,EAC/CG,EAAO,IACP,CACE,OAAQH,EAAK,OACb,aAAcgB,GAAQ,CACpB,IAAMC,EAAOD,EAAK,MAAM,GAAI,EACxBC,EAAK,CAAC,IAAM,OACdH,EAAQ,KAAKG,CAAI,CAErB,CACF,CACF,EACA,IAAMC,EAAO,IAAI,IACjB,OAAOC,EAAeL,CAAO,EAAE,OAAOM,GAElCA,EAAK,UAAYlB,GACjBkB,EAAK,KAAOjB,EAAO,OACnBiB,EAAK,OAASjB,EAAO,KACrBe,EAAK,IAAIE,EAAK,EAAE,EAET,IAETF,EAAK,IAAIE,EAAK,EAAE,EACT,GACR,CACH,CACF",
-  "names": ["BUDGET_SLOTS", "WalkIndex", "file", "adapter", "WalkReader", "opts", "haplotypes", "refName", "region", "signal", "walkRows", "budgets", "graph", "kept", "fragments", "walksKept", "lane", "resolvePanSNPrefix", "walkCutFor", "refRows", "getLines", "line", "cols", "seen", "referenceNodes", "node"]
-}

package/src/RgfaTabixAdapter/rgfaBed.test.ts

@@ -1,254 +0,0 @@
-import {
-  closingLinks,
-  closingSpans,
-  formatSubgraph,
-  parseLinkLine,
-  parseSegmentLine,
-  segmentSamples,
-} from './rgfaBed.ts'
-
-import type { RgfaLink, RgfaSegment } from './rgfaBed.ts'
-
-// A five-column row is what `gfatools gfa2bed -m` writes for an rGFA. There is
-// no tag column at all, which is the backward-compatible case.
-const RGFA_SEG = 'K12#1#chr\t100\t150\ts1\t0'
-
-// A six-column row is what a path walk or a level-of-detail tier writes. The
-// sixth column is a space-separated GFA tag list.
-const TAGGED_SEG =
-  'GRCh38#0#chr1\t103611080\t103732636\ts10472\t1\t' +
-  'ct:Z:bubble cn:i:95 cw:i:269401 cs:i:26889 cl:i:316616 cv:i:1'
-
-function subgraphOf(segments: RgfaSegment[], links: RgfaLink[] = []) {
-  return formatSubgraph(
-    new Map(segments.map(s => [s.id, s])),
-    new Map(links.map((l, i) => [String(i), l])),
-  )
-}
-
-test('an rGFA row has no tags and synthesizes the S-line it always did', () => {
-  const segment = parseSegmentLine(RGFA_SEG)
-  expect(segment.tags).toBe('')
-  expect(subgraphOf([segment])).toBe(
-    ['H\tVN:Z:1.0', 'S\ts1\t*\tLN:i:50\tSN:Z:K12#1#chr\tSO:i:100\tSR:i:0'].join(
-      '\n',
-    ),
-  )
-})
-
-// The hops' tabix queries run together and fill the map in arrival order
-test('segments at one position come out in the same order whichever arrived first', () => {
-  const at = (id: string) => parseSegmentLine(`K12#1#chr\t100\t100\t${id}\t1`)
-  expect(subgraphOf([at('s2'), at('s1')])).toBe(
-    subgraphOf([at('s1'), at('s2')]),
-  )
-})
-
-test('a tag column reaches the S-line as tab-separated GFA tags', () => {
-  const segment = parseSegmentLine(TAGGED_SEG)
-  expect(segment.tags).toBe(
-    'ct:Z:bubble cn:i:95 cw:i:269401 cs:i:26889 cl:i:316616 cv:i:1',
-  )
-  expect(subgraphOf([segment])).toBe(
-    [
-      'H\tVN:Z:1.0',
-      'S\ts10472\t*\tLN:i:121556\tSN:Z:GRCh38#0#chr1\tSO:i:103611080\tSR:i:1' +
-        '\tct:Z:bubble\tcn:i:95\tcw:i:269401\tcs:i:26889\tcl:i:316616\tcv:i:1',
-    ].join('\n'),
-  )
-})
-
-// A segment can enter a subgraph only through a link row, when the region
-// covers one endpoint and its neighbour sits elsewhere, so the endpoint records
-// carry tags too or a tier node reached that way would lose its summary.
-test('link rows carry each endpoint tags', () => {
-  const link = parseLinkLine(
-    [
-      'GRCh38#0#chr1',
-      '0',
-      '10',
-      's1+',
-      's2+',
-      'GRCh38#0#chr1',
-      '0',
-      '10',
-      '0',
-      'GRCh38#0#chr1',
-      '10',
-      '20',
-      '1',
-      'ct:Z:backbone',
-      'ct:Z:bubble cl:i:104730',
-    ].join('\t'),
-  )
-  expect(link.sourceSegment.tags).toBe('ct:Z:backbone')
-  expect(link.targetSegment.tags).toBe('ct:Z:bubble cl:i:104730')
-  expect(subgraphOf([link.sourceSegment, link.targetSegment], [link])).toBe(
-    [
-      'H\tVN:Z:1.0',
-      'S\ts1\t*\tLN:i:10\tSN:Z:GRCh38#0#chr1\tSO:i:0\tSR:i:0\tct:Z:backbone',
-      'S\ts2\t*\tLN:i:10\tSN:Z:GRCh38#0#chr1\tSO:i:10\tSR:i:1\tct:Z:bubble\tcl:i:104730',
-      'L\ts1\t+\ts2\t+\t0M',
-    ].join('\n'),
-  )
-})
-
-// An older six-column file from build_pggb_tabix.sh wrote a bare comma list
-// rather than a tag. It must not be emitted as a malformed GFA tag.
-test('a link row with no tag columns parses as untagged', () => {
-  const link = parseLinkLine('c\t0\t10\ts1+\ts2+\tc\t0\t10\t0\tc\t10\t20\t1')
-  expect(link.sourceSegment.tags).toBe('')
-  expect(link.targetSegment.tags).toBe('')
-})
-
-// build_pggb_tabix.sh wrote a bare comma list in column 6 before the tag column
-// existed. Those files are still hosted, and a bare list is not a GFA tag.
-test('a legacy bare sample list is dropped rather than emitted as a tag', () => {
-  const segment = parseSegmentLine('c\t0\t10\ts1\t1\tK12,Sakai,CFT073')
-  expect(segment.tags).toBe('K12,Sakai,CFT073')
-  expect(subgraphOf([segment])).toBe(
-    ['H\tVN:Z:1.0', 'S\ts1\t*\tLN:i:10\tSN:Z:c\tSO:i:0\tSR:i:1'].join('\n'),
-  )
-})
-
-test('a valid tag beside a malformed one keeps only the valid one', () => {
-  const segment = parseSegmentLine('c\t0\t10\ts1\t1\tgarbage SM:Z:HG002.1')
-  expect(subgraphOf([segment])).toBe(
-    [
-      'H\tVN:Z:1.0',
-      'S\ts1\t*\tLN:i:10\tSN:Z:c\tSO:i:0\tSR:i:1\tSM:Z:HG002.1',
-    ].join('\n'),
-  )
-})
-
-test('segmentSamples reads the samples off the tag column', () => {
-  const segment = parseSegmentLine(
-    'K12#1#chr\t1004477\t1004500\ts119690\t0\tSM:Z:K12.1,Sakai.1,NCTC86.1',
-  )
-  expect(segmentSamples(segment)).toEqual(['K12.1', 'Sakai.1', 'NCTC86.1'])
-})
-
-// Undefined, not [], so a lane can tell a graph that records no samples from a
-// segment no path visits.
-test('segmentSamples is undefined when the column says nothing', () => {
-  expect(segmentSamples(parseSegmentLine(RGFA_SEG))).toBeUndefined()
-  expect(segmentSamples(parseSegmentLine(TAGGED_SEG))).toBeUndefined()
-})
-
-// Same reason formatSegment checks the grammar: build_pggb_tabix.sh wrote a
-// bare comma list here before the tag column existed, and reading it would
-// invent a single sample named after the whole list.
-test('segmentSamples drops a legacy bare sample list', () => {
-  const segment = parseSegmentLine('c\t0\t10\ts1\t1\tK12,Sakai,CFT073')
-  expect(segmentSamples(segment)).toBeUndefined()
-})
-
-test('segmentSamples finds the tag beside other tags', () => {
-  const segment = parseSegmentLine(
-    'c\t0\t10\ts1\t1\tct:Z:bubble SM:Z:HG002.1,HG002.2 cn:i:95',
-  )
-  expect(segmentSamples(segment)).toEqual(['HG002.1', 'HG002.2'])
-})
-
-// The whole samples chain in one test, because it spans three files and each
-// half is covered on its own: a segs.bed SM:Z: column -> the synthesized S-line
-// -> the GFA parser -> GraphNode.samples, which model.ts renders as `samples`
-// in the node popup. An indexed cut has no P/W lines, so this tag is its only
-// record of which haplotypes visit a segment, and nothing else asserts that it
-// survives the round trip.
-test('SM:Z: on a segs row reaches GraphNode.samples', async () => {
-  const { parseGFA } = await import('@jbrowse/bandage-core/gfa-core/index')
-  const { convertGFAToGraph } =
-    await import('@jbrowse/bandage-core/gfa/gfaConverter')
-  const segment = parseSegmentLine(
-    'K12#1#chr\t1004477\t1004500\ts119690\t0\tSM:Z:K12.1,Sakai.1,NCTC86.1',
-  )
-  const graph = convertGFAToGraph(parseGFA(subgraphOf([segment])))
-  expect(graph.nodes[0]!.samples).toEqual(['K12.1', 'Sakai.1', 'NCTC86.1'])
-})
-
-// The C4 allele's shape on NA18948#2: one hop reached 352179 and 352180 from
-// the left end and 352183 and 352184 from the right, with 352181 and 352182
-// between them unreached.
-const NA18948 = 'NA18948#2#CM101588.1'
-const piece = (id: string, start: number, end: number): RgfaSegment => ({
-  refName: NA18948,
-  start,
-  end,
-  id,
-  rank: 77,
-  tags: '',
-})
-const reached = [
-  piece('s352179', 32015241, 32036237),
-  piece('s352180', 32036237, 32036352),
-  piece('s352183', 32041508, 32047945),
-  piece('s352184', 32047945, 32047979),
-]
-
-const C4_WINDOW = { refName: 'GRCh38#0#chr6', start: 31979972, end: 32049972 }
-
-test('pieces of one stable sequence close as one span over the gap between them', () => {
-  expect(closingSpans(reached, new Set(), C4_WINDOW)).toEqual([
-    { refName: NA18948, start: 32015241, end: 32047979 },
-  ])
-})
-
-test('a gap wider than the window splits the span, and read pieces that abut need nothing', () => {
-  const narrow = { ...C4_WINDOW, end: C4_WINDOW.start + 1000 }
-  expect(closingSpans(reached, new Set(), narrow)).toEqual([])
-  expect(closingSpans(reached, new Set(['s352183']), narrow)).toEqual([
-    { refName: NA18948, start: 32041508, end: 32047979 },
-  ])
-})
-
-test('backbone past the window closes between abutting pieces only', () => {
-  const backbone = (id: string, start: number, end: number): RgfaSegment => ({
-    refName: C4_WINDOW.refName,
-    start,
-    end,
-    id,
-    rank: 0,
-    tags: '',
-  })
-  const held = [
-    backbone('s329760', 31932655, 31984683),
-    backbone('s400000', 32049000, 32050100),
-    backbone('s400001', 32050100, 32050200),
-    backbone('s400005', 32060000, 32060100),
-  ]
-  expect(closingSpans(held, new Set(), C4_WINDOW)).toEqual([
-    { refName: C4_WINDOW.refName, start: 32050100, end: 32050200 },
-    { refName: C4_WINDOW.refName, start: 32060000, end: 32060100 },
-  ])
-})
-
-test('a closing read keeps links between held segments and the pieces inside its span', () => {
-  const held = new Map(reached.map(s => [s.id, s]))
-  const link = (source: RgfaSegment, target: RgfaSegment): RgfaLink => ({
-    source: source.id,
-    sourceStrand: '+',
-    target: target.id,
-    targetStrand: '+',
-    sourceSegment: source,
-    targetSegment: target,
-  })
-  const s352181 = piece('s352181', 32036352, 32041501)
-  const s352182 = piece('s352182', 32041501, 32041508)
-  const elsewhere: RgfaSegment = {
-    ...piece('s355491', 31985674, 31985801),
-    refName: 'HG03688#1#JBHDTJ010000054.1',
-  }
-  const spans = closingSpans(reached, new Set(), C4_WINDOW)
-  const found = [
-    link(reached[1]!, s352181),
-    link(s352181, s352182),
-    link(s352182, reached[2]!),
-    link(s352181, elsewhere),
-  ]
-  expect(closingLinks(found, held, spans).map(l => l.target)).toEqual([
-    's352181',
-    's352182',
-    's352183',
-  ])
-})

package/src/RgfaTabixAdapter/rgfaBed.ts

@@ -1,314 +0,0 @@
-// A segment as it appears in segs.bed.gz, and as it is repeated inside every
-// links.bed.gz row: `stableName start end segmentId rank [tags]`. The first
-// five are the SN/SO/SR tags rGFA already carries, projected to BED by
-// `gfatools gfa2bed -m`.
-//
-// `tags` is a space-separated list of GFA tags, written verbatim onto the
-// S-line formatSegment synthesizes, where the GFA parser reads them into
-// `GraphNode.tags` with no work here. It is the extension point for everything
-// the five columns cannot say: carriage on a path-derived graph (`SM:Z:`), the
-// collapse summary on a level-of-detail tier (`ct:Z:`, `cn:i:`, ...), a
-// precomputed layout position later. rGFA files have no sixth column at all,
-// so this is empty for them and nothing changes.
-export interface RgfaSegment {
-  refName: string
-  start: number
-  end: number
-  id: string
-  rank: number
-  tags: string
-}
-
-export interface RgfaLink {
-  source: string
-  sourceStrand: string
-  target: string
-  targetStrand: string
-  sourceSegment: RgfaSegment
-  targetSegment: RgfaSegment
-}
-
-export function parseSegmentLine(line: string): RgfaSegment {
-  return parseSegmentRow(line).segment
-}
-
-// gfa-to-tabix's anchored layout files a segment under the reference interval
-// its bubble hangs from and states the segment's own coordinate after the rank:
-// `anchorName anchorStart anchorEnd segmentId rank stableName start end [tags]`.
-// One query over a region then returns every segment of every bubble under it,
-// and `anchored` tells a cut it has nothing left to follow.
-export function parseSegmentRow(line: string) {
-  const cols = line.split('\t')
-  const anchored = cols.length >= 8
-  const own = anchored ? 5 : 0
-  return {
-    anchored,
-    segment: {
-      refName: cols[own]!,
-      start: +cols[own + 1]!,
-      end: +cols[own + 2]!,
-      id: cols[3]!,
-      rank: +cols[4]!,
-      tags: cols[anchored ? 8 : 5] ?? '',
-    } satisfies RgfaSegment,
-  }
-}
-
-// Carriage as an ordinary feature attribute, for the linear track rather than
-// the graph. The tag column reaches the graph view through the synthesized
-// S-line (formatSegment below, then gfaConverter reads SM into
-// `GraphNode.samples`), and that route ends at the graph: `getFeatures` builds
-// its own features and had no way to say who carries a segment, so a lane
-// colored by carriage was not expressible.
-//
-// `SM:Z:` is its own grammar check here. build_pggb_tabix.sh wrote a bare
-// comma-separated list in this column before the tag column existed, and those
-// files are still hosted; a bare list has no prefix to match, so it is dropped
-// rather than read as one sample named `K12,Sakai,CFT073`.
-//
-// Undefined rather than [] when the tag is absent, matching gfaConverter: an
-// rGFA has no sixth column at all, so a segment that says nothing about
-// carriage stays distinguishable from one carried by nobody.
-export function segmentSamples(segment: RgfaSegment) {
-  const tag = segment.tags.split(' ').find(t => t.startsWith('SM:Z:'))
-  if (tag === undefined) {
-    return undefined
-  }
-  const samples = tag
-    .slice('SM:Z:'.length)
-    .split(',')
-    .map(s => s.trim())
-    .filter(Boolean)
-  return samples.length > 0 ? samples : undefined
-}
-
-// `s322+` — the L-line's segment id with its orientation appended, mirroring
-// the GFA record it came from.
-function parseEndpoint(field: string) {
-  return { id: field.slice(0, -1), strand: field.slice(-1) }
-}
-
-export function parseLinkLine(line: string): RgfaLink {
-  const cols = line.split('\t')
-  const source = parseEndpoint(cols[3]!)
-  const target = parseEndpoint(cols[4]!)
-  return {
-    source: source.id,
-    sourceStrand: source.strand,
-    target: target.id,
-    targetStrand: target.strand,
-    sourceSegment: {
-      id: source.id,
-      refName: cols[5]!,
-      start: +cols[6]!,
-      end: +cols[7]!,
-      rank: +cols[8]!,
-      tags: cols[13] ?? '',
-    },
-    targetSegment: {
-      id: target.id,
-      refName: cols[9]!,
-      start: +cols[10]!,
-      end: +cols[11]!,
-      rank: +cols[12]!,
-      tags: cols[14] ?? '',
-    },
-  }
-}
-
-export function linkKey(link: RgfaLink) {
-  return `${link.source}${link.sourceStrand}${link.target}${link.targetStrand}`
-}
-
-// gfa-to-tabix writes both endpoints of a link into every row and files the
-// link under each endpoint's stable sequence, so a read covering both returns
-// it twice; linkKey dedupes it. Returns the endpoints the cut lacked.
-export function addLink(
-  segments: Map<string, RgfaSegment>,
-  links: Map<string, RgfaLink>,
-  link: RgfaLink,
-) {
-  links.set(linkKey(link), link)
-  const added: RgfaSegment[] = []
-  for (const segment of [link.sourceSegment, link.targetSegment]) {
-    if (!segments.has(segment.id)) {
-      segments.set(segment.id, segment)
-      added.push(segment)
-    }
-  }
-  return added
-}
-
-// The cut an anchored index gives: `under` is what the segment file returned
-// for the window, every segment of every bubble under it, and `found` is what
-// the link file returned. gfa-to-tabix files a link widely enough that `found`
-// holds every link touching a segment in `under` and every link between the
-// segments those lead to, plus links of neither kind, which are dropped here.
-// A backbone link that jumps the whole window, as a deletion or inversion
-// spanning it does, touches nothing in `under` and is kept by its own rule.
-export function anchoredCut(
-  under: Map<string, RgfaSegment>,
-  found: RgfaLink[],
-  window: StableSpan,
-) {
-  const side = (segment: RgfaSegment) =>
-    segment.rank !== 0 || segment.refName !== window.refName
-      ? 0
-      : segment.end <= window.start
-        ? -1
-        : segment.start >= window.end
-          ? 1
-          : 0
-  const segments = new Map(under)
-  const links = new Map<string, RgfaLink>()
-  for (const link of found) {
-    if (
-      under.has(link.source) ||
-      under.has(link.target) ||
-      side(link.sourceSegment) * side(link.targetSegment) === -1
-    ) {
-      addLink(segments, links, link)
-    }
-  }
-  for (const link of found) {
-    if (segments.has(link.source) && segments.has(link.target)) {
-      links.set(linkKey(link), link)
-    }
-  }
-  return { segments, links }
-}
-
-export interface StableSpan {
-  refName: string
-  start: number
-  end: number
-}
-
-// Where a cut reads links once more to close itself. A hop reads the links of
-// the segments the round before it reached, so a link between two segments of
-// the last round is never read and an allele reached from both ends draws as
-// two stubs. rGFA lays an allele out as one stretch of the stable sequence that
-// introduced it, so pieces of one sequence within the window's length of each
-// other merge into a span, and reading it brings the pieces between too.
-// Backbone reached past the window is unread for the same reason; its spans
-// join only abutting pieces, since the reference past the window is not the
-// cut's to fill. A span whose segments were all read and abut is skipped.
-export function closingSpans(
-  held: RgfaSegment[],
-  unread: Set<string>,
-  window: StableSpan,
-) {
-  const outside = (segment: RgfaSegment) =>
-    segment.refName !== window.refName ||
-    segment.end <= window.start ||
-    segment.start >= window.end
-  return [
-    ...mergedSpans(
-      held.filter(segment => segment.rank > 0),
-      segment => unread.has(segment.id),
-      window.end - window.start,
-    ),
-    ...mergedSpans(
-      held.filter(segment => segment.rank === 0 && outside(segment)),
-      () => true,
-      0,
-    ),
-  ]
-}
-
-function mergedSpans(
-  segments: RgfaSegment[],
-  isUnread: (segment: RgfaSegment) => boolean,
-  maxGap: number,
-) {
-  const sorted = [...segments].sort(
-    (a, b) => compare(a.refName, b.refName) || a.start - b.start,
-  )
-  const spans: (StableSpan & { needed: boolean })[] = []
-  for (const segment of sorted) {
-    const span = spans.at(-1)
-    if (
-      span?.refName === segment.refName &&
-      segment.start - span.end <= maxGap
-    ) {
-      span.needed ||= segment.start > span.end || isUnread(segment)
-      span.end = Math.max(span.end, segment.end)
-    } else {
-      spans.push({
-        refName: segment.refName,
-        start: segment.start,
-        end: segment.end,
-        needed: isUnread(segment),
-      })
-    }
-  }
-  return spans
-    .filter(span => span.needed)
-    .map(({ refName, start, end }): StableSpan => ({ refName, start, end }))
-}
-
-// The links a closing read keeps: each end is a segment the cut holds or one
-// lying inside a span. Following anything else is what another hop is for.
-export function closingLinks(
-  found: RgfaLink[],
-  held: Map<string, RgfaSegment>,
-  spans: StableSpan[],
-) {
-  const inside = (segment: RgfaSegment) =>
-    held.has(segment.id) ||
-    spans.some(
-      span =>
-        span.refName === segment.refName &&
-        segment.start >= span.start &&
-        segment.end <= span.end,
-    )
-  return found.filter(
-    link => inside(link.sourceSegment) && inside(link.targetSegment),
-  )
-}
-
-// Segments carry no sequence here — the BED records only their span — so every
-// S-line is written with `*` and an LN tag, which is what the GFA spec asks for
-// and what packages/graph-core's parser reads back as the node length.
-// `NM:i:0`, `SM:Z:HG002.1,HG002.2` — the GFA tag grammar, checked rather than
-// trusted. Files built before the tag column existed put a bare comma-separated
-// sample list here, and passing that through would put a field that is not a
-// tag on an S-line, which is a malformed GFA rather than a missing annotation.
-// Dropping it degrades to the pre-tag behaviour instead.
-const GFA_TAG = /^[A-Za-z][A-Za-z0-9]:[AifZJHB]:/
-
-function formatSegment(segment: RgfaSegment) {
-  const { id, refName, start, end, rank, tags } = segment
-  const valid = tags.split(' ').filter(t => GFA_TAG.test(t))
-  const extra = valid.length === 0 ? '' : `\t${valid.join('\t')}`
-  return `S\t${id}\t*\tLN:i:${end - start}\tSN:Z:${refName}\tSO:i:${start}\tSR:i:${rank}${extra}`
-}
-
-function formatLink(link: RgfaLink) {
-  const { source, sourceStrand, target, targetStrand } = link
-  return `L\t${source}\t${sourceStrand}\t${target}\t${targetStrand}\t0M`
-}
-
-// Codepoint order, not localeCompare: the byte-identical-output guarantee below
-// has to hold across locales.
-function compare(a: string, b: string) {
-  return a < b ? -1 : a > b ? 1 : 0
-}
-
-// Deterministic ordering: the same region always produces byte-identical GFA,
-// so a layout computed from it is reproducible.
-export function formatSubgraph(
-  segments: Map<string, RgfaSegment>,
-  links: Map<string, RgfaLink>,
-) {
-  const sortedSegments = [...segments.values()].sort(
-    (a, b) =>
-      compare(a.refName, b.refName) || a.start - b.start || compare(a.id, b.id),
-  )
-  const sortedLinks = [...links.keys()].sort((a, b) => compare(a, b))
-  return [
-    'H\tVN:Z:1.0',
-    ...sortedSegments.map(s => formatSegment(s)),
-    ...sortedLinks.map(k => formatLink(links.get(k)!)),
-  ].join('\n')
-}