jbrowse-plugin-graphgenomeviewer 8.0.2 → 8.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbrowse-plugin-graphgenomeviewer",
-  "version": "8.0.2",
+  "version": "8.2.0",
   "description": "JBrowse 2 graph genome (pangenome) view: rGFA reference-anchored layouts, the Bandage force-directed engine, and haplotype lanes read from a gbz-base database",
   "license": "GPL-3.0-or-later",
   "repository": {
@@ -27,12 +27,12 @@
   "dependencies": {
     "@gmod/bgzf-filehandle": "^6.8.0",
     "@gmod/gbz-base": "^7.4.1",
-    "@gmod/tabix": "^3.11.0",
+    "@gmod/tabix": "^3.13.0",
     "@jbrowse/cigar-utils": "5.0.0-beta.18",
     "@jbrowse/core": "5.0.0-beta.18",
     "@jbrowse/display-kit": "5.0.0-beta.18",
     "@jbrowse/display-ui": "5.0.0-beta.18",
-    "@jbrowse/graph-walks": "^4.2.0",
+    "@jbrowse/graph-walks": "^4.4.0",
     "@jbrowse/render-core": "5.0.0-beta.18",
     "@jbrowse/synteny-core": "5.0.0-beta.18"
   },
@@ -40,7 +40,7 @@
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.1",
     "@eslint/js": "^10.0.1",
-    "@jbrowse/bandage-core": "^12.0.2",
+    "@jbrowse/bandage-core": "^12.1.1",
     "@jbrowse/cli": "^4.3.0",
     "@jbrowse/mobx-state-tree": "^6.10.0",
     "@jbrowse/plugin-linear-genome-view": "5.0.0-beta.18",

package/src/GraphAddTrackWorkflow/buildTrackConfig.ts

@@ -2,6 +2,7 @@ import { makeIndexType } from '@jbrowse/core/util/tracks'
 
 import { besideSegments, segmentsSibling } from './graphManifest'
 import {
+  GRAPH_SUFFIX,
   SEGMENTS_SUFFIX,
   WALKS_SUFFIX,
   locationName,
@@ -21,7 +22,7 @@ export type GraphFileChoice =
   | 'MinigraphBubbleAdapter'
 
 export const GRAPH_FILE_LABELS: Record<GraphFileChoice, string> = {
-  RgfaTabixAdapter: 'rGFA segments (tabix BED pair)',
+  RgfaTabixAdapter: 'Indexed GFA (gfa-to-tabix .segs.bed.gz or .graph.bed.gz)',
   RgfaTabixWalks: 'Haplotype walks (.walks.bed.gz)',
   GbzBaseSyntenyAdapter: 'GBZ database (.gbz.db)',
   MinigraphBubbleAdapter: 'Minigraph bubbles (tabix BED)',
@@ -29,7 +30,7 @@ export const GRAPH_FILE_LABELS: Record<GraphFileChoice, string> = {
 
 export const GRAPH_FILE_FIELDS: Record<GraphFileChoice, string> = {
   RgfaTabixAdapter:
-    'Path to segments BED (.segs.bed.gz from gfa-to-tabix; the .links.bed.gz, its index and any .graph.json are read beside it)',
+    "Path to segments BED (.segs.bed.gz from gfa-to-tabix; the .links.bed.gz, its index and any .graph.json are read beside it), or format 2's .graph.bed.gz",
   RgfaTabixWalks:
     'Path to a walk file (<prefix>.<sample>.walks.bed.gz from gfa-to-tabix --walks, for the sample this assembly is)',
   GbzBaseSyntenyAdapter: 'Path to the .gbz.db written by gbz-base construct',
@@ -187,6 +188,15 @@ export function buildAdapterConfig({
       ...panSN(assembly, sample),
     }
   }
+  if (locationName(loc).endsWith(GRAPH_SUFFIX)) {
+    return {
+      type: 'RgfaTabixAdapter',
+      graphLocation: loc,
+      graphIndex: tabixIndex(loc, indexLoc),
+      ...referencePanSN(assembly, sample, manifest?.reference),
+      ...coarseTier(loc, indexLoc, manifest?.tier),
+    }
+  }
   const links = linksLocation(loc)
   return {
     type: 'RgfaTabixAdapter',

package/src/GraphAddTrackWorkflow/graphManifest.ts

@@ -1,6 +1,7 @@
 import { openLocation } from '@jbrowse/core/util/io'
 
 import {
+  GRAPH_SUFFIX,
   SEGMENTS_SUFFIX,
   locationName,
   readsSiblings,
@@ -76,21 +77,27 @@ export function besideSegments(segs: FileLocation, fileName: string) {
   return renamed(segs, name => name.replace(/[^/\\]*$/, fileName))
 }
 
-// A segments BED the links BED and the manifest can be found beside
-export function isSegmentsLocation(loc: FileLocation) {
-  return readsSiblings(loc) && locationName(loc).endsWith(SEGMENTS_SUFFIX)
+// The suffix of a gfa-to-tabix index file: format 1's segments BED or format
+// 2's graph BED
+function indexSuffix(loc: FileLocation) {
+  const name = locationName(loc)
+  return [SEGMENTS_SUFFIX, GRAPH_SUFFIX].find(suffix => name.endsWith(suffix))
 }
 
-// `<prefix><suffix>` beside `<prefix>.segs.bed.gz`
+// A segments BED, or format 2's graph BED, the rest of the index and the
+// manifest can be found beside
+export function isGraphIndexLocation(loc: FileLocation) {
+  return readsSiblings(loc) && indexSuffix(loc) !== undefined
+}
+
+// `<prefix><suffix>` beside `<prefix>.segs.bed.gz` or `<prefix>.graph.bed.gz`
 export function segmentsSibling(segs: FileLocation, suffix: string) {
-  return renamed(
-    segs,
-    name => `${name.slice(0, -SEGMENTS_SUFFIX.length)}${suffix}`,
-  )
+  const own = indexSuffix(segs) ?? SEGMENTS_SUFFIX
+  return renamed(segs, name => `${name.slice(0, -own.length)}${suffix}`)
 }
 
 export function manifestLocation(segs: FileLocation) {
-  return isSegmentsLocation(segs)
+  return isGraphIndexLocation(segs)
     ? segmentsSibling(segs, '.graph.json')
     : undefined
 }

package/src/GraphGenomeView/components/HoverTooltip.tsx

@@ -63,6 +63,14 @@ function hoverTip(
               {own.sample} {regionLabel(own)} (rank {node.stable?.rank})
             </>
           ) : null}
+          {/* gfa-to-tabix --max-component left its component off the
+              reference, so the cut holds only its ends */}
+          {node.moved ? (
+            <>
+              <br />
+              End of a component too large to draw here
+            </>
+          ) : null}
         </>
       ),
     }

package/src/GraphGenomeView/pane/paneBase.ts

@@ -7,7 +7,7 @@ import { viewportOf } from '@jbrowse/bandage-core/viewport'
 import { types } from '@jbrowse/mobx-state-tree'
 import { RenderLifecycleMixin } from '@jbrowse/render-core/RenderLifecycleMixin'
 
-import { SEGMENTS_SUFFIX } from '../../locationName.ts'
+import { GRAPH_SUFFIX, SEGMENTS_SUFFIX } from '../../locationName.ts'
 import { lenientOptionalEnum } from '../lenientEnum'
 
 import type { MorphEntering } from './morph'
@@ -76,18 +76,23 @@ export const TUBE_MAP_FOLDS = [
   { bp: 1000, label: 'Under 1 kb' },
 ]
 
-// The rGFA index prefix an adapter config names, from either spelling the
-// config schema accepts: the `uri` shorthand or an explicit segments location.
+// The rGFA index prefix an adapter config names, from any spelling the config
+// schema accepts: the `uri` shorthand, or an explicit segments location or
+// format 2 graph location.
 export function bubblePrefix(adapterConfig: Record<string, unknown>) {
   if (typeof adapterConfig.uri === 'string') {
     return adapterConfig.uri
   }
-  const segments = adapterConfig.segmentsLocation as
-    { uri?: string } | undefined
-  const uri = segments?.uri
-  return typeof uri === 'string' && uri.endsWith(SEGMENTS_SUFFIX)
-    ? uri.slice(0, -SEGMENTS_SUFFIX.length)
-    : undefined
+  for (const [slot, suffix] of [
+    ['segmentsLocation', SEGMENTS_SUFFIX],
+    ['graphLocation', GRAPH_SUFFIX],
+  ] as const) {
+    const uri = (adapterConfig[slot] as { uri?: string } | undefined)?.uri
+    if (typeof uri === 'string' && uri.endsWith(suffix)) {
+      return uri.slice(0, -suffix.length)
+    }
+  }
+  return undefined
 }
 export const HOVER_BRIGHTEN = 1.15
 export const SELECT_BRIGHTEN = 1.6

package/src/RgfaTabixAdapter/RgfaTabixAdapter.ts

@@ -1,7 +1,13 @@
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter'
 import { SimpleFeature, updateStatus } from '@jbrowse/core/util'
 import { ObservableCreate } from '@jbrowse/core/util/rxjs'
-import { parseSegmentRow, rgfaCut, segmentSamples } from '@jbrowse/graph-walks'
+import {
+  parseGraphHeader,
+  parseGraphRow,
+  parseSegmentRow,
+  rgfaCut,
+  segmentSamples,
+} from '@jbrowse/graph-walks'
 
 import { locationIsSet } from '../locationName.ts'
 import { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'
@@ -15,10 +21,13 @@ import type { TabixIndexedFile } from '@gmod/tabix'
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'
 import type { Feature } from '@jbrowse/core/util'
 import type { FileLocation, Region } from '@jbrowse/core/util/types'
+import type { RgfaSegment } from '@jbrowse/graph-walks'
 
-interface GraphIndex {
-  segments: TabixIndexedFile
-  links: TabixIndexedFile
+// gfa-to-tabix's format 1 pair, or format 2's one file
+type GraphIndex = (
+  | { segments: TabixIndexedFile; links: TabixIndexedFile }
+  | { graph: TabixIndexedFile }
+) & {
   walks?: WalkIndex
   refNames: PanSNRefNames
 }
@@ -31,9 +40,33 @@ export default class RgfaTabixAdapter extends BaseFeatureDataAdapter<RgfaTabixAd
 
   // refNames off the SEGMENT index: it is the one that names every stable
   // sequence the graph is anchored to, where the link index only names those a
-  // link touches. A walk-indexed graph's walk file names the same sequences,
-  // and it has no segment file.
+  // link touches. Format 2's one file names them all. A walk-indexed graph's
+  // walk file names the same sequences, and it has no segment file.
   private openIndex(under: string[]): GraphIndex {
+    const walksLocation: FileLocation = this.getConf('walksLocation')
+    const walks =
+      under.length === 0 && locationIsSet(walksLocation)
+        ? new WalkIndex(
+            openTabixSlot(this, ['walksLocation'], ['walksIndex']),
+            this,
+          )
+        : undefined
+    const graphLocation: FileLocation =
+      under.length === 0
+        ? this.getConf('graphLocation')
+        : this.getConf(['coarse', 'graphLocation'])
+    if (locationIsSet(graphLocation)) {
+      const graph = openTabixSlot(
+        this,
+        [...under, 'graphLocation'],
+        [...under, 'graphIndex'],
+      )
+      return {
+        graph,
+        walks,
+        refNames: new PanSNRefNames(walks?.file ?? graph, this),
+      }
+    }
     const segments = openTabixSlot(
       this,
       [...under, 'segmentsLocation'],
@@ -44,14 +77,6 @@ export default class RgfaTabixAdapter extends BaseFeatureDataAdapter<RgfaTabixAd
       [...under, 'linksLocation'],
       [...under, 'linksIndex'],
     )
-    const walksLocation: FileLocation = this.getConf('walksLocation')
-    const walks =
-      under.length === 0 && locationIsSet(walksLocation)
-        ? new WalkIndex(
-            openTabixSlot(this, ['walksLocation'], ['walksIndex']),
-            this,
-          )
-        : undefined
     return {
       segments,
       links,
@@ -142,41 +167,69 @@ export default class RgfaTabixAdapter extends BaseFeatureDataAdapter<RgfaTabixAd
     }
   }
 
-  private async segmentFeatures(
+  // Each segment row under the window, from the segment file or from format
+  // 2's node rows, with whether the index is anchored
+  private async segmentRows(
     tabixRefName: string,
     query: Region,
     opts: BaseOptions,
-    emit: (feature: Feature) => void,
+    each: (segment: RgfaSegment, anchored: boolean) => void,
   ) {
-    await updateStatus('Downloading segments', opts.statusCallback, () =>
-      getLines(this.fine.segments, tabixRefName, query.start, query.end, {
+    const index = this.fine
+    if ('graph' in index) {
+      const header = parseGraphHeader(
+        await index.graph.getHeaderLines({ signal: opts.signal }),
+      )
+      return getLines(index.graph, tabixRefName, query.start, query.end, {
         signal: opts.signal,
         lineCallback: line => {
-          const { segment, anchored } = parseSegmentRow(line)
-          // An anchored index also returns the alleles under the region,
-          // which lie on other stable sequences and have no place on this one
-          if (anchored && segment.refName !== tabixRefName) {
-            return
+          const row = parseGraphRow(line, header)
+          if (row?.kind === 'N') {
+            each(row.segment, header.anchored)
           }
-          // `samples` lists the haplotypes whose paths visit the segment and
-          // `sampleCount` counts them. A lane's color reads the count, and
-          // a count in jexl would otherwise rely on `.length` resolving
-          // through a member access on an array.
-          const samples = segmentSamples(segment)
-          emit(
-            new SimpleFeature({
-              uniqueId: segment.id,
-              refName: query.refName,
-              start: segment.start,
-              end: segment.end,
-              name: segment.id,
-              type: 'segment',
-              rank: segment.rank,
-              stableName: segment.refName,
-              ...(samples && { samples, sampleCount: samples.length }),
-            }),
-          )
         },
+      })
+    }
+    return getLines(index.segments, tabixRefName, query.start, query.end, {
+      signal: opts.signal,
+      lineCallback: line => {
+        const { segment, anchored } = parseSegmentRow(line)
+        each(segment, anchored)
+      },
+    })
+  }
+
+  private async segmentFeatures(
+    tabixRefName: string,
+    query: Region,
+    opts: BaseOptions,
+    emit: (feature: Feature) => void,
+  ) {
+    await updateStatus('Downloading segments', opts.statusCallback, () =>
+      this.segmentRows(tabixRefName, query, opts, (segment, anchored) => {
+        // An anchored index also returns the alleles under the region,
+        // which lie on other stable sequences and have no place on this one
+        if (anchored && segment.refName !== tabixRefName) {
+          return
+        }
+        // `samples` lists the haplotypes whose paths visit the segment and
+        // `sampleCount` counts them. A lane's color reads the count, and
+        // a count in jexl would otherwise rely on `.length` resolving
+        // through a member access on an array.
+        const samples = segmentSamples(segment)
+        emit(
+          new SimpleFeature({
+            uniqueId: segment.id,
+            refName: query.refName,
+            start: segment.start,
+            end: segment.end,
+            name: segment.id,
+            type: 'segment',
+            rank: segment.rank,
+            stableName: segment.refName,
+            ...(samples && { samples, sampleCount: samples.length }),
+          }),
+        )
       }),
     )
   }

package/src/RgfaTabixAdapter/configSchema.ts

@@ -1,6 +1,7 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration'
 import { WALK_BUDGETS } from '@jbrowse/graph-walks'
 
+import { GRAPH_SUFFIX } from '../locationName.ts'
 import {
   fileLocationSlot,
   tabixIndexSchema,
@@ -21,7 +22,10 @@ import type { Instance } from '@jbrowse/mobx-state-tree'
  * where the adapter follows links onto other contigs.
  *
  * The `uri` shorthand takes the prefix the build script was given and resolves
- * `<uri>.segs.bed.gz`, `<uri>.links.bed.gz` and their `.tbi` indexes. `coarse`
+ * `<uri>.segs.bed.gz`, `<uri>.links.bed.gz` and their `.tbi` indexes. With
+ * `format: 2` it resolves gfa-to-tabix's format 2 instead, `<uri>.graph.bed.gz`
+ * and its index: nodes and links in one file, a plain GFA's carriers as bits,
+ * from `gfa-to-tabix --format 2`. `coarse`
  * takes the same shorthand for a second pair at one node per bubble, built by
  * `gfa-to-tabix fold`, plus either the zoom past which a graph view following
  * a linear view cuts it (`aboveBpPerPx`) or the size it was folded at
@@ -56,16 +60,23 @@ import type { Instance } from '@jbrowse/mobx-state-tree'
  */
 
 function prefixLocations(snap: Record<string, unknown>) {
-  const { uri, baseUri, csi } = snap
-  return typeof uri === 'string'
+  const { uri, baseUri, csi, format } = snap
+  if (typeof uri !== 'string') {
+    return snap
+  }
+  return format === 2
     ? {
+        ...snap,
+        graphLocation: { uri: `${uri}${GRAPH_SUFFIX}`, baseUri },
+        graphIndex: tbiBeside(`${uri}${GRAPH_SUFFIX}`, baseUri, csi),
+      }
+    : {
         ...snap,
         segmentsLocation: { uri: `${uri}.segs.bed.gz`, baseUri },
         segmentsIndex: tbiBeside(`${uri}.segs.bed.gz`, baseUri, csi),
         linksLocation: { uri: `${uri}.links.bed.gz`, baseUri },
         linksIndex: tbiBeside(`${uri}.links.bed.gz`, baseUri, csi),
       }
-    : snap
 }
 
 function normalizeSnapshot(snap: Record<string, unknown>) {
@@ -119,6 +130,15 @@ const RgfaTabixCoarseTier = ConfigurationSchema('RgfaTabixCoarseTier', {
     'RgfaCoarseLinksIndex',
     '/path/to/graph.tier.links.bed.gz.tbi',
   ),
+  /**
+   * #slot
+   * format 2's one file in place of the pair; see the adapter's `graphLocation`
+   */
+  graphLocation: fileLocationSlot(''),
+  /**
+   * #slot
+   */
+  graphIndex: tabixIndexSchema('RgfaCoarseGraphIndex'),
 })
 
 const RgfaTabixAdapter = ConfigurationSchema(
@@ -150,6 +170,17 @@ const RgfaTabixAdapter = ConfigurationSchema(
       'RgfaLinksIndex',
       '/path/to/graph.links.bed.gz.tbi',
     ),
+    /**
+     * #slot
+     * gfa-to-tabix's format 2, `<prefix>.graph.bed.gz`: segments and links in
+     * one file, read in place of `segmentsLocation` and `linksLocation`.
+     * Unset means the graph is the pair.
+     */
+    graphLocation: fileLocationSlot(''),
+    /**
+     * #slot
+     */
+    graphIndex: tabixIndexSchema('RgfaGraphIndex'),
     /**
      * #slot
      * a `gfa-to-tabix --walks` file in walk format 5: per reference chunk,

package/src/RgfaTabixAdapter/format2.test.ts

@@ -0,0 +1,128 @@
+import { readConfObject } from '@jbrowse/core/configuration'
+import { firstValueFrom } from 'rxjs'
+import { toArray } from 'rxjs/operators'
+
+import Adapter from './RgfaTabixAdapter.ts'
+import configSchema from './configSchema.ts'
+import { buildAdapterConfig } from '../GraphAddTrackWorkflow/buildTrackConfig.ts'
+import { bubblePrefix } from '../GraphGenomeView/pane/paneBase.ts'
+
+// gfa-to-tabix 1.5's anchored index of test_data/ecoli_pggb_subgraph.gfa on
+// K12, in format 1 (`pggb_ecoli_f1`, a segs/links pair) and format 2
+// (`pggb_ecoli_f2.graph.bed.gz`, one file, carriers as SB:H: bits)
+const DATA = require
+  .resolve('./test_data/pggb_ecoli_f2.graph.bed.gz')
+  .replace(/pggb_ecoli_f2\.graph\.bed\.gz$/, '')
+const local = (path: string) => ({
+  localPath: path,
+  locationType: 'LocalPathLocation',
+})
+
+function formatOne() {
+  const f = `${DATA}pggb_ecoli_f1`
+  return new Adapter(
+    configSchema.create({
+      segmentsLocation: local(`${f}.segs.bed.gz`),
+      segmentsIndex: { location: local(`${f}.segs.bed.gz.tbi`) },
+      linksLocation: local(`${f}.links.bed.gz`),
+      linksIndex: { location: local(`${f}.links.bed.gz.tbi`) },
+    }),
+  )
+}
+
+function formatTwo() {
+  const f = `${DATA}pggb_ecoli_f2.graph.bed.gz`
+  return new Adapter(
+    configSchema.create({
+      graphLocation: local(f),
+      graphIndex: { location: local(`${f}.tbi`) },
+    }),
+  )
+}
+
+const window = (start: number) => ({
+  refName: 'chr',
+  assemblyName: 'K12',
+  start,
+  end: start + 60,
+})
+
+// A segment's carriers as a set, since format 2 names them in #samples order
+const sorted = (samples: unknown) =>
+  Array.isArray(samples) ? [...samples].sort() : samples
+
+test('format 2 names the same reference sequences', async () => {
+  expect(await formatTwo().getRefNames()).toEqual(
+    await formatOne().getRefNames(),
+  )
+})
+
+test('format 2 gives the carriage lane the same segments and carriers', async () => {
+  const features = (adapter: Adapter, start: number) =>
+    firstValueFrom(adapter.getFeatures(window(start)).pipe(toArray()))
+  for (let start = 1004500; start < 1004961; start += 41) {
+    const one = await features(formatOne(), start)
+    const two = await features(formatTwo(), start)
+    const shape = (f: (typeof one)[number]) => ({
+      name: f.get('name'),
+      start: f.get('start'),
+      end: f.get('end'),
+      rank: f.get('rank'),
+      samples: sorted(f.get('samples')),
+      sampleCount: f.get('sampleCount'),
+    })
+    expect(two.map(shape)).toEqual(one.map(shape))
+    expect(two.every(f => (f.get('sampleCount') as number) > 0)).toBe(true)
+  }
+})
+
+test('format 2 cuts the same graph', async () => {
+  const lines = (gfa: unknown) =>
+    String(gfa)
+      .split('\n')
+      .map(l => l.replace(/\tSM:Z:\S*/, ''))
+  for (let start = 1004500; start < 1004961; start += 41) {
+    const one = await formatOne().getSubgraph(window(start))
+    const two = await formatTwo().getSubgraph(window(start))
+    expect(lines(two)).toEqual(lines(one))
+  }
+})
+
+test('the uri shorthand with format: 2 resolves the one file', () => {
+  const config = configSchema.create({
+    uri: 'hprc',
+    format: 2,
+    baseUri: 'https://example.com/',
+  })
+  expect(readConfObject(config, 'graphLocation')).toMatchObject({
+    uri: 'hprc.graph.bed.gz',
+    baseUri: 'https://example.com/',
+  })
+  expect(readConfObject(config, ['graphIndex', 'location'])).toMatchObject({
+    uri: 'hprc.graph.bed.gz.tbi',
+  })
+})
+
+test('Open track takes a format 2 graph file', () => {
+  const loc = {
+    uri: 'https://example.com/hprc.graph.bed.gz',
+    locationType: 'UriLocation' as const,
+  }
+  const adapter = buildAdapterConfig({
+    choice: 'RgfaTabixAdapter',
+    loc,
+    indexLoc: undefined,
+    assembly: 'hg38',
+    sample: 'GRCh38',
+  })
+  expect(adapter).toMatchObject({
+    type: 'RgfaTabixAdapter',
+    graphLocation: loc,
+    graphIndex: {
+      location: { uri: 'https://example.com/hprc.graph.bed.gz.tbi' },
+    },
+    assemblyNameToPanSN: { hg38: 'GRCh38' },
+  })
+  expect(adapter).not.toHaveProperty('segmentsLocation')
+  expect(bubblePrefix(adapter)).toBe('https://example.com/hprc')
+})

package/src/RgfaTabixAdapter/walkFiles.test.ts

@@ -365,6 +365,27 @@ test('a walk leaving the window is measured to where it rejoins the reference',
   ])
 })
 
+// gfa-to-tabix 1.5 --walks --chunk 10 of ten 10 bp reference nodes:
+//   W GRCh38 0 chr1 >1>2>3>4>5>6>7>8>9>10
+//   W HG002  1 ctg  >1>2>9>10   a deletion of 20-80, whose chunks hold skip rows
+const skipPrefix = fixture('walks5_skip')
+
+test('a haplotype that jumps over the window draws as a deletion row', async () => {
+  const cut = (await makeAdapter(skipPrefix).getSubgraph(chr1(31, 60), {
+    walkRows: true,
+  })) as WalkCut
+  const rows = walkRowsOf(cut.walkRowRuns!).rows
+  expect(
+    rows.map(({ label, bp, gapBp, complete }) => ({
+      label,
+      bp,
+      gapBp,
+      complete,
+    })),
+  ).toEqual([{ label: 'HG002#1', bp: 0, gapBp: 29, complete: true }])
+  expect(rows[0]!.runs.map(run => run.cause)).toEqual(['deleted'])
+})
+
 test('a walk the read cuts off is read on to the chunk its row names', async () => {
   const getLines = vi.spyOn(TabixIndexedFile.prototype, 'getLines')
   const cut = (await makeAdapter(followPrefix).getSubgraph(chr1(1000, 1500), {

package/src/RgfaTabixAdapter/walkReader.ts

@@ -55,9 +55,10 @@ export class WalkIndex {
 
   /**
    * The graph display's cut of a window: the reference walk, the walks of
-   * `haplotypes` (every walk when unset), and the nodes and links they visit.
-   * Walk rows draw runs, so the step budget spares them, and read a short
-   * list of named walks in full where format 5 abridged them.
+   * `haplotypes` (every walk when unset), and the nodes and links they visit,
+   * with the haplotypes whose deletion spans the window as `skips`, which walk
+   * rows draw. Walk rows draw runs, so the step budget spares them, and read a
+   * short list of named walks in full where format 5 abridged them.
    */
   async subgraph(
     refName: string,
@@ -76,18 +77,22 @@ export class WalkIndex {
     const asked = expand?.length
       ? (name: string) => expand.includes(name)
       : undefined
-    const { graph, kept, fragments } = await this.reader.cut(refName, region, {
-      ...budgets,
-      stepBudget: walkRows ? Infinity : budgets.stepBudget,
-      signal,
-      keep,
-      ...(named || asked
-        ? {
-            expand: (name: string) => !!named?.(name) || !!asked?.(name),
-          }
-        : {}),
-    })
-    return walkCutFor(graph.tables(kept, fragments), region, walkRows)
+    const { graph, kept, fragments, skips } = await this.reader.cut(
+      refName,
+      region,
+      {
+        ...budgets,
+        stepBudget: walkRows ? Infinity : budgets.stepBudget,
+        signal,
+        keep,
+        ...(named || asked
+          ? {
+              expand: (name: string) => !!named?.(name) || !!asked?.(name),
+            }
+          : {}),
+      },
+    )
+    return walkCutFor(graph.tables(kept, fragments, skips), region, walkRows)
   }
 
   /**