jbrowse-plugin-graphgenomeviewer 4.0.12 → 4.0.13

package/src/GraphGenomeView/repeats/repeatFeatures.test.ts

@@ -112,3 +112,78 @@ test("a TRGT VCF's per-sample AL and SD are each sample's called alleles", () =>
   })
   expect(repeatArraysFrom([{ ...base, period: 2 }])[0]!.calls).toBe(undefined)
 })
+
+// Two copies of unit B then three of A, and a second allele of four A: RN
+// splits the flattened lists 2 + 1, and RUB lists every copy of every run.
+const A = 'ACGTACGTAC'
+const B = 'ACGTTCGTAC'
+const tandem = {
+  ...base,
+  ALT: ['<CNV:TR>', '<CNV:TR>'],
+  INFO: {
+    SVLEN: [30751, 30751],
+    RN: [2, 1],
+    RUS: [B, A, A],
+    RUC: [2, 3, 4],
+    RB: [20, 29, 40],
+    RUB: [10, 10, 10, 10, 9, 10, 10, 10, 10],
+  },
+  samples: {
+    HG00128: { GT: ['1|2'] },
+    HG00133: { GT: ['.|1'] },
+    GRCh38: { GT: ['0'] },
+    HG00099: { GT: ['2/1'] },
+  },
+}
+
+test("VCF 4.5 <CNV:TR>: each allele's runs off RN, RUS, RUC, RB and RUB", () => {
+  const [array] = repeatArraysFrom([tandem])
+  expect(array).toMatchObject({ start: 160616003, end: 160646754 })
+  const bThenA = [
+    { unit: B, unitLength: 10, count: 2, bp: 20, copyBp: [10, 10] },
+    { unit: A, unitLength: 10, count: 3, bp: 29, copyBp: [10, 10, 9] },
+  ]
+  const fourA = [
+    { unit: A, unitLength: 10, count: 4, bp: 40, copyBp: [10, 10, 10, 10] },
+  ]
+  expect(array!.calls).toEqual({
+    HG00128: [
+      { bp: 49, sequences: bThenA, haplotype: 1 },
+      { bp: 40, sequences: fourA, haplotype: 2 },
+    ],
+    HG00133: [{ bp: 49, sequences: bThenA, haplotype: 2 }],
+    GRCh38: [{ bp: 30751 }],
+    HG00099: [
+      { bp: 40, sequences: fourA },
+      { bp: 49, sequences: bThenA },
+    ],
+  })
+  expect(array!.units).toEqual([
+    { unit: A, unitLength: 10, copies: 7 },
+    { unit: B, unitLength: 10, copies: 2 },
+  ])
+})
+
+test('a run stating only RUL is keyed by its length, and a summary record states no calls', () => {
+  const [array] = repeatArraysFrom([
+    {
+      ...base,
+      ALT: ['<CNV:TR>'],
+      INFO: { RN: [1], RUL: [5548], RUC: [5.5] },
+      samples: { HG00097: { GT: ['1'] } },
+    },
+  ])
+  expect(array!.calls!.HG00097).toEqual([
+    {
+      bp: 30514,
+      sequences: [{ unit: '5548', unitLength: 5548, count: 5.5, bp: 30514 }],
+    },
+  ])
+  const [summary] = repeatArraysFrom([
+    { ...base, ALT: ['<CNV:TR>'], INFO: { RUL: '5548', RUC: '5.5' } },
+  ])
+  expect(summary!.calls).toBeUndefined()
+  expect(summary!.units).toEqual([
+    { unit: '5548', unitLength: 5548, copies: 5.5 },
+  ])
+})

package/src/GraphGenomeView/repeats/repeatFeatures.ts

@@ -1,11 +1,35 @@
 import type { Feature } from '@jbrowse/core/util'
 
+// One run of an allele as VCF 4.5 states a repeat sequence: `count` copies of
+// one unit. `unit` is the unit's sequence where the record gives one (RUS),
+// else its length (RUL), and is what walk rows colour a run by.
+export interface RepeatSequence {
+  unit: string
+  unitLength: number
+  count: number
+  bp: number
+  // each copy's bases (RUB), where copies differ in length
+  copyBp?: number[]
+}
+
 export interface RepeatCall {
   bp: number
   // TRGT's `SD`. Zero means the allele is a copy of the one the reads did
   // support, so its length states nothing about a second haplotype; absent
   // where the genotyper writes no such field.
   spanningReads?: number
+  // the allele's runs in order, where the record states them
+  sequences?: RepeatSequence[]
+  // the PanSN haplotype a phased genotype puts this allele on
+  haplotype?: number
+}
+
+// A unit the record's alleles repeat, with the copies of it they carry
+// between them.
+export interface RepeatUnit {
+  unit: string
+  unitLength: number
+  copies: number
 }
 
 // A tandem repeat array as the walk rows need it: its span on the reference,
@@ -28,8 +52,11 @@ export interface RepeatArray {
   unit: number
   motif?: string
   // Each sample's genotyped alleles, from a genotyper's per-sample `AL`
-  // (TRGT); absent from a catalogue.
+  // (TRGT) or a genotype over VCF 4.5 <CNV:TR> alleles; absent from a
+  // catalogue.
   calls?: Record<string, RepeatCall[]>
+  // the units the <CNV:TR> alleles repeat, most copies first
+  units?: RepeatUnit[]
 }
 
 export const REPEAT_ADAPTER_TYPES = new Set([
@@ -153,29 +180,148 @@ function numbers(value: unknown) {
   })
 }
 
-function callsOf(f: FeatureLike) {
+function strings(value: unknown) {
+  const raw: unknown[] = Array.isArray(value)
+    ? value
+    : String(value ?? '').split(',')
+  return raw.map(one => {
+    const text = String(one ?? '').trim()
+    return text === '' || text === '.' ? undefined : text
+  })
+}
+
+const TANDEM_REPEAT = '<CNV:TR>'
+
+// Each ALT allele's runs, off VCF 4.5's flattened list-of-lists: RN says how
+// many RUS/RUL/RUC/RB entries each allele takes, and RUB holds one entry per
+// copy of every run. An allele that is not <CNV:TR>, or has a run stating no
+// unit, has none.
+function tandemAlleles(f: FeatureLike) {
+  const alts = strings(own(f, 'ALT'))
+  if (!alts.includes(TANDEM_REPEAT)) {
+    return undefined
+  }
+  const rn = numbers(field(f, 'RN'))
+  const rus = strings(field(f, 'RUS'))
+  const rul = numbers(field(f, 'RUL'))
+  const ruc = numbers(field(f, 'RUC'))
+  const rb = numbers(field(f, 'RB'))
+  const rub = numbers(field(f, 'RUB')).filter(bp => bp !== undefined)
+  const counted = ruc.every(Number.isInteger)
+  let k = 0
+  let copy = 0
+  return alts.map((alt, i) => {
+    const n = rn[i] ?? (alt === TANDEM_REPEAT ? 1 : 0)
+    const runs: RepeatSequence[] = []
+    for (let j = 0; j < n; j++, k++) {
+      const stated = rus[k]
+      const sequence = stated && IUPAC.test(stated) ? stated : undefined
+      const unitLength = rul[k] ?? sequence?.length
+      const bp = rb[k]
+      const count =
+        ruc[k] ?? (unitLength && bp !== undefined ? bp / unitLength : undefined)
+      if (unitLength && count !== undefined) {
+        const copyBp =
+          counted && rub.length > 0 ? rub.slice(copy, copy + count) : undefined
+        runs.push({
+          unit: sequence ?? String(unitLength),
+          unitLength,
+          count,
+          bp: bp ?? Math.round(unitLength * count),
+          ...(copyBp?.length === count ? { copyBp } : {}),
+        })
+      }
+      copy += count ?? 0
+    }
+    return alt === TANDEM_REPEAT && runs.length === n ? runs : undefined
+  })
+}
+
+function unitsOf(alleles: (RepeatSequence[] | undefined)[]) {
+  const units = new Map<string, RepeatUnit>()
+  for (const { unit, unitLength, count } of alleles.flatMap(r => r ?? [])) {
+    const copies = (units.get(unit)?.copies ?? 0) + count
+    units.set(unit, { unit, unitLength, copies })
+  }
+  return units.size > 0
+    ? [...units.values()].sort(
+        (a, b) =>
+          b.copies - a.copies ||
+          a.unitLength - b.unitLength ||
+          a.unit.localeCompare(b.unit),
+      )
+    : undefined
+}
+
+// A sample's alleles through its genotype: 0 is the reference's, an index
+// past it the ALT allele's runs. A phased genotype's k-th allele is PanSN
+// haplotype k, the order vg deconstruct writes an assembly's haplotypes in.
+function genotyped(
+  gt: string | undefined,
+  alleles: (RepeatSequence[] | undefined)[],
+  referenceBp: number,
+) {
+  const phased = gt?.includes('|')
+  return (gt ?? '').split(/[/|]/).flatMap((index, k): RepeatCall[] => {
+    const i = Number(index)
+    const sequences = i > 0 ? alleles[i - 1] : undefined
+    if (!Number.isInteger(i) || (i > 0 && !sequences)) {
+      return []
+    }
+    return [
+      {
+        bp: sequences
+          ? sequences.reduce((sum, run) => sum + run.bp, 0)
+          : referenceBp,
+        ...(sequences ? { sequences } : {}),
+        ...(phased ? { haplotype: k + 1 } : {}),
+      },
+    ]
+  })
+}
+
+function callsOf(
+  f: FeatureLike,
+  alleles: (RepeatSequence[] | undefined)[] | undefined,
+  referenceBp: number,
+) {
   const samples = own(f, 'samples') as
     Record<string, Record<string, unknown>> | undefined
   const called: Record<string, RepeatCall[]> = {}
   for (const [sample, fields] of Object.entries(samples ?? {})) {
     const reads = numbers(fields.SD)
-    const alleles = numbers(fields.AL).flatMap((bp, i) =>
+    const lengths = numbers(fields.AL).flatMap((bp, i) =>
       bp !== undefined && bp > 0
         ? [reads[i] === undefined ? { bp } : { bp, spanningReads: reads[i] }]
         : [],
     )
-    if (alleles.length > 0) {
-      called[sample] = alleles
+    const calls =
+      lengths.length > 0 || !alleles
+        ? lengths
+        : genotyped(strings(fields.GT)[0], alleles, referenceBp)
+    if (calls.length > 0) {
+      called[sample] = calls
     }
   }
   return Object.keys(called).length > 0 ? called : undefined
 }
 
+// A <CNV:TR> record's POS is the base before the array and SVLEN the
+// reference allele's length, while a VCF feature starts at that padding base.
+function spanOf(f: FeatureLike, alleles: unknown[] | undefined) {
+  const start = field(f, 'start') as number
+  const end = field(f, 'end') as number
+  const svlen = numbers(field(f, 'SVLEN'))[0]
+  return alleles && svlen !== undefined
+    ? { start: start + 1, end: start + 1 + svlen }
+    : { start, end }
+}
+
 export function repeatArraysFrom(features: FeatureLike[]): RepeatArray[] {
   const arrays: RepeatArray[] = []
   for (const f of features) {
-    const start = field(f, 'start') as number
-    const end = field(f, 'end') as number
+    const alleles = tandemAlleles(f)
+    const { start, end } = spanOf(f, alleles)
     const unit = repeatUnitOf(f)
     if (!(end > start) || unit === undefined) {
       continue
@@ -183,6 +329,7 @@ export function repeatArraysFrom(features: FeatureLike[]): RepeatArray[] {
     const refName = field(f, 'refName') as string
     const motif = first(f, MOTIF_FIELDS)
     const stated = first(f, NAME_FIELDS)
+    const units = alleles && unitsOf(alleles)
     arrays.push({
       key: `${refName}:${start}-${end}`,
       name:
@@ -195,7 +342,8 @@ export function repeatArraysFrom(features: FeatureLike[]): RepeatArray[] {
       end,
       unit,
       motif,
-      calls: callsOf(f),
+      calls: callsOf(f, alleles, end - start),
+      ...(units ? { units } : {}),
     })
   }
   return arrays.sort((a, b) => a.start - b.start)

package/src/GraphGenomeView/repeats/walkCalls.test.ts

@@ -125,3 +125,21 @@ test('the threshold falls in a gap the ABCA7 cohort leaves empty', () => {
     uncalled: 0,
   })
 })
+
+// A phased genotype's k-th allele is PanSN haplotype k, so two walks of one
+// length with different runs still take their own; a phased allele whose
+// haplotype the cut lacks goes to no other walk.
+test('a phased allele pairs with its own haplotype, not by length', () => {
+  const hap = (haplotype: number, bp: number) => ({
+    ...walk('HG1', bp),
+    haplotype,
+  })
+  const rows = withCalls([hap(1, 100), hap(2, 100)], {
+    HG1: calls({ bp: 100, haplotype: 2 }, { bp: 100, haplotype: 1 }),
+  })
+  expect(rows.map(r => r.call?.haplotype)).toEqual([1, 2])
+  const lone = withCalls([hap(1, 100)], {
+    HG1: calls({ bp: 100, haplotype: 2 }),
+  })
+  expect(lone[0]!.call).toBeUndefined()
+})

package/src/GraphGenomeView/repeats/walkCalls.ts

@@ -67,20 +67,38 @@ function byLength<T>(items: T[], bp: (item: T) => number) {
 
 const backed = (call: RepeatCall) => call.spanningReads !== 0
 
-// The walks that span the array against the alleles reads spanned, then
-// everything else against what those two left. It decides the ambiguous cases
-// on merit: which walk carries the one allele a lone spanning read supports,
-// and which allele a walk that stops inside the array is drawn against.
-function pairSample<R extends { bp: number; complete: boolean }>(
-  rows: R[],
-  calls: RepeatCall[],
-) {
+function scored(row: { bp: number; complete: boolean }, call: RepeatCall) {
+  return {
+    ...call,
+    agrees: row.complete && backed(call) ? agrees(row.bp, call.bp) : undefined,
+  }
+}
+
+// A phased genotype names its walk's haplotype outright. The rest go by
+// length: the walks that span the array against the alleles reads spanned,
+// then everything else against what those two left. That decides the
+// ambiguous cases on merit: which walk carries the one allele a lone spanning
+// read supports, and which allele a walk that stops inside the array is drawn
+// against.
+function pairSample<
+  R extends { bp: number; complete: boolean; haplotype?: number },
+>(rows: R[], calls: RepeatCall[]) {
   const out = new Map<number, WalkCall>()
   const taken = new Set<RepeatCall>()
+  rows.forEach((row, i) => {
+    const call = calls.find(
+      c => c.haplotype !== undefined && c.haplotype === row.haplotype,
+    )
+    if (call) {
+      taken.add(call)
+      out.set(i, scored(row, call))
+    }
+  })
+  const unphased = calls.filter(call => call.haplotype === undefined)
   const ranked = byLength(rows, r => r.bp)
   const stages = [
-    [ranked.filter(r => r.item.complete), calls.filter(backed)],
-    [ranked, calls],
+    [ranked.filter(r => r.item.complete), unphased.filter(backed)],
+    [ranked, unphased],
   ] as const
   for (const [pool, group] of stages) {
     const free = pool.filter(r => !out.has(r.i))
@@ -96,13 +114,7 @@ function pairSample<R extends { bp: number; complete: boolean }>(
         const row = free[k]!
         const call = open[pick]!.item
         taken.add(call)
-        out.set(row.i, {
-          ...call,
-          agrees:
-            row.item.complete && backed(call)
-              ? agrees(row.item.bp, call.bp)
-              : undefined,
-        })
+        out.set(row.i, scored(row.item, call))
       }
     })
   }
@@ -110,7 +122,12 @@ function pairSample<R extends { bp: number; complete: boolean }>(
 }
 
 export function withCalls<
-  R extends { sample: string; bp: number; complete: boolean },
+  R extends {
+    sample: string
+    bp: number
+    complete: boolean
+    haplotype?: number
+  },
 >(rows: R[], calls: Record<string, RepeatCall[]> | undefined) {
   if (!calls) {
     return rows as (R & { call?: WalkCall })[]

package/src/GraphGenomeView/subgraphLoad.test.ts

@@ -4,6 +4,7 @@ const mockRpcCall = vi.fn()
 const mockSession = {
   tracks: [] as Record<string, unknown>[],
   rpcManager: { call: mockRpcCall },
+  assemblyManager: { has: () => false },
 }
 
 vi.mock('@jbrowse/core/util', () => ({

package/src/LinearGraphDisplay/LinearGraphDisplay.test.ts

@@ -9,17 +9,20 @@ import {
   createBaseTrackConfig,
   createBaseTrackModel,
 } from '@jbrowse/core/pluggableElementTypes/models'
+import { LAUNCH_LABEL } from '@jbrowse/core/ui'
 import { getSnapshot, types } from '@jbrowse/mobx-state-tree'
 import { linearGenomeViewStateModelFactory } from '@jbrowse/plugin-linear-genome-view'
 
 import LinearGraphDisplayF from './index'
 import GbzBaseSyntenyAdapterF from '../GbzBaseSyntenyAdapter/index'
+import graphGenomeViewModel from '../GraphGenomeView/viewModel'
 import GraphTrackF from '../GraphTrack/index'
 import RgfaTabixAdapterF from '../RgfaTabixAdapter/index'
 
 import type { LinearGraphDisplayModel } from './model'
 import type { SubgraphRegion, SubgraphTier } from '../GetSubgraph'
 import type { Renderer } from '@jbrowse/bandage-core/renderer/types'
+import type { MenuItem } from '@jbrowse/core/ui'
 
 const REF = 'chr1'
 const ASM = 'hg38'
@@ -31,14 +34,23 @@ const SETTLE_MS = 700
 
 // A backbone of `step`-long segments with a small allele bubble on every
 // second one; past 1.5 Mb the fine tier's bubbles run eight ranks deep, so a
-// re-cut there has more rows than one before it.
-function syntheticGraph(tier: SubgraphTier, region: SubgraphRegion) {
+// re-cut there has more rows than one before it. `paths` walks the reference
+// and one haplotype through every bubble, for the tube map.
+function syntheticGraph(
+  tier: SubgraphTier,
+  region: SubgraphRegion,
+  paths = false,
+) {
   const step = tier === 'fine' ? 10_000 : 250_000
   const lines = ['H\tVN:Z:1.0']
+  const ref: string[] = []
+  const alt: string[] = []
   const first = Math.floor(region.start / step)
   const last = Math.ceil(region.end / step)
   for (let k = first; k < last; k++) {
     const id = `${tier[0]}${k}`
+    ref.push(`${id}+`)
+    alt.push(`${id}+`)
     lines.push(
       `S\t${id}\t*\tLN:i:${step}\tSN:Z:${REF}\tSO:i:${k * step}\tSR:i:0`,
     )
@@ -50,6 +62,7 @@ function syntheticGraph(tier: SubgraphTier, region: SubgraphRegion) {
       let from = id
       for (let rank = 1; rank <= deep; rank++) {
         const allele = `${id}r${rank}`
+        alt.push(`${allele}+`)
         lines.push(
           `S\t${allele}\t*\tLN:i:100\tSN:Z:HG${rank}#1#${REF}\tSO:i:${k * step}\tSR:i:${rank}`,
           `L\t${from}\t+\t${allele}\t+\t0M`,
@@ -59,6 +72,9 @@ function syntheticGraph(tier: SubgraphTier, region: SubgraphRegion) {
       lines.push(`L\t${from}\t+\t${tier[0]}${k + 1}\t+\t0M`)
     }
   }
+  if (paths) {
+    lines.push(`P\t${REF}\t${ref.join(',')}\t*`, `P\tHG1\t${alt.join(',')}\t*`)
+  }
   return lines.join('\n')
 }
 
@@ -94,7 +110,7 @@ function fakeRenderer() {
 
 const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 
-function createEnvironment({ tiered = true } = {}) {
+function createEnvironment({ tiered = true, paths = false } = {}) {
   console.warn = vi.fn()
   const pluginManager = new PluginManager()
   RgfaTabixAdapterF(pluginManager)
@@ -208,6 +224,7 @@ function createEnvironment({ tiered = true } = {}) {
 
   const cuts: Cut[] = []
   const errors: string[] = []
+  const addedViews: [string, unknown][] = []
   // while set, a cut waits for the test to answer it
   let held: ((answer: () => void) => void) | undefined
   const signals: AbortSignal[] = []
@@ -235,7 +252,7 @@ function createEnvironment({ tiered = true } = {}) {
       if (args.signal) {
         signals.push(args.signal)
       }
-      const gfa = syntheticGraph(cut.tier, cut.region)
+      const gfa = syntheticGraph(cut.tier, cut.region, paths)
       const hold = held
       return hold
         ? new Promise<string>(resolve => {
@@ -295,6 +312,9 @@ function createEnvironment({ tiered = true } = {}) {
         errors.push(message)
       },
       queueDialog() {},
+      addView(type: string, snapshot: unknown) {
+        addedViews.push([type, snapshot])
+      },
     }))
 
   const session = Session.create({ configuration: {} }, { pluginManager })
@@ -303,7 +323,16 @@ function createEnvironment({ tiered = true } = {}) {
   )
   view.setWidth(WIDTH_PX)
   view.setDisplayedRegions(assemblyRegions)
-  return { session, view, cuts, errors, holdCuts, signals, rpcCall }
+  return {
+    session,
+    view,
+    cuts,
+    errors,
+    addedViews,
+    holdCuts,
+    signals,
+    rpcCall,
+  }
 }
 
 function lgvX(view: { bpPerPx: number; offsetPx: number }, bp: number) {
@@ -318,8 +347,9 @@ async function shownGraph({
   windowStart = 1_000_000,
   windowBp = 60_000,
   tiered = true,
+  paths = false,
 } = {}) {
-  const env = createEnvironment({ tiered })
+  const env = createEnvironment({ tiered, paths })
   const { view } = env
   view.zoomTo(windowBp / WIDTH_PX)
   view.scrollTo(windowStart / view.bpPerPx)
@@ -477,6 +507,75 @@ test('a restored session cuts the region it saved', async () => {
   expect(cuts[0]!.region).toEqual(saved)
 })
 
+test('a tube map on its own axis ties each reference box to its bp in the linear view', async () => {
+  const { view, pane } = await shownGraph({ paths: true })
+  await pane.switchLayout('tubemap')
+  await wait(SETTLE_MS)
+  expect(pane.hostPlacesX).toBe(false)
+  const nodes = new Map(pane.tubeMapReferenceNodes!.map(n => [n.node, n]))
+  const frame = pane.tubeMapFrame!
+  const connectors = pane.tubeMapConnectors
+  expect(connectors.length).toBeGreaterThan(3)
+  for (const c of connectors) {
+    const n = nodes.get(c.node)!
+    expect(c.top0).toBeCloseTo(lgvX(view, n.bp0), 6)
+    expect(c.top1).toBeCloseTo(lgvX(view, n.bp1), 6)
+    expect(c.bottom0).toBeCloseTo(frame.x(n.x0), 6)
+    expect(c.bottom1).toBeCloseTo(frame.x(n.x1), 6)
+  }
+
+  const c = connectors[1]!
+  const zoneBottom = pane.connectorZoneBottom
+  expect(zoneBottom).toBeGreaterThan(0)
+  const mid = (c.top0 + c.top1 + c.bottom0 + c.bottom1) / 4
+  expect(pane.tubeMapNodeAt(mid, zoneBottom / 2)).toBe(c.node)
+
+  // a frame of a pan moves the tops with the linear view, the boxes stay
+  view.horizontalScroll(50)
+  expect(pane.tubeMapConnectors[1]).toEqual({
+    ...c,
+    top0: c.top0 - 50,
+    top1: c.top1 - 50,
+  })
+
+  // on the reference axis the boxes already sit on their bp
+  await pane.switchLayout('tubemapref')
+  expect(pane.tubeMapConnectors).toEqual([])
+})
+
+test("a folded tube map draws the cut's reference as merged nodes, and the rest as ticks or routes", async () => {
+  const { pane } = await shownGraph({ paths: true })
+  const labels = () =>
+    pane.trackMenuItems().map(item => ('label' in item ? item.label : ''))
+  expect(labels()).not.toContain('Fold variants')
+  await pane.switchLayout('tubemap')
+  await wait(SETTLE_MS)
+  expect(labels()).toContain('Fold variants')
+  expect(pane.drawnGraph).toBe(pane.graph)
+  expect(pane.tubeMapKeys.foldBp).toBeUndefined()
+
+  // the haplotype's three 100 bp insertions fold under 1 kb
+  pane.setTubeMapFold(1000)
+  await pane.recomputeLayout()
+  const [merged] = pane.drawnGraph!.nodes
+  expect(pane.drawnGraph!.nodes).toHaveLength(1)
+  expect(merged!.stable).toMatchObject({ start: 1_000_000, rank: 0 })
+  expect(merged!.length).toBe(60_000)
+  expect(pane.nodeById!.get(merged!.id)).toBe(merged)
+  expect(pane.tubeMapDeviations).toHaveLength(3)
+  expect(pane.tubeMapKeys.foldBp).toBe(1000)
+  expect(pane.tubeMapConnectors.map(c => c.node)).toEqual([merged!.id])
+
+  // and stand as their own nodes under 50 bp
+  pane.setTubeMapFold(50)
+  await pane.recomputeLayout()
+  const nodes = pane.drawnGraph!.nodes
+  expect(nodes.filter(n => n.stable?.rank === 0)).toHaveLength(4)
+  expect(nodes.filter(n => n.stable?.rank === 1)).toHaveLength(3)
+  expect(pane.tubeMapDeviations).toEqual([])
+  expect(pane.tubeMapKeys.foldBp).toBeUndefined()
+})
+
 test('a layout whose x is not reference bp draws its own viewport of the window alone, and still re-cuts', async () => {
   const { view, pane, cuts } = await shownGraph()
   await pane.switchLayout('force')
@@ -496,6 +595,15 @@ test('a layout whose x is not reference bp draws its own viewport of the window
   expect(graphX(pane, 2_030_000)).toBeCloseTo(lgvX(view, 2_030_000), 6)
 })
 
+test('walk rows fit their own bars in the track, since a walk can be longer than the window', async () => {
+  const { pane } = await shownGraph({ paths: true })
+  await pane.switchLayout('walkrows')
+  await wait(SETTLE_MS)
+  expect(pane.layoutResult?.referenceAxis).toBe(true)
+  expect(pane.hostPlacesX).toBe(false)
+  expect(pane.viewportOwner).toBe('fit')
+})
+
 test('a launch in the force layout cuts the window alone', async () => {
   const { view, cuts } = createEnvironment()
   view.zoomTo(60_000 / WIDTH_PX)
@@ -623,3 +731,54 @@ test('the track menu offers the layouts, colours and the settings dialog', async
   )
   expect(labels).not.toContain('Zoom in')
 })
+
+function graphViewItem(display: LinearGraphDisplayModel) {
+  const launch = display
+    .trackMenuItems()
+    .find(item => 'label' in item && item.label === LAUNCH_LABEL) as
+    { subMenu: MenuItem[] } | undefined
+  return launch?.subMenu.find(
+    item => 'label' in item && item.label === 'Graph genome view',
+  ) as { disabled?: boolean; onClick: () => void } | undefined
+}
+
+test('the track menu opens the window on screen in a graph genome view, drawn as the track draws it', async () => {
+  const { display, addedViews } = await shownGraph()
+  display.setLayoutMode('tubemapref')
+  const item = graphViewItem(display)!
+  expect(item.disabled).toBe(false)
+
+  item.onClick()
+  expect(addedViews).toHaveLength(1)
+  const [type, spec] = addedViews[0]!
+  expect(type).toBe('GraphGenomeView')
+  expect(spec).toMatchObject({
+    loadedTrackId: 'graph',
+    loadedRegion: { refName: REF, assemblyName: ASM },
+    layoutMode: 'tubemapref',
+    subgraphContext: display.subgraphContext,
+  })
+  const { loadedRegion } = spec as { loadedRegion: SubgraphRegion }
+  expect(loadedRegion.start).toBeCloseTo(1_000_000, -1)
+  expect(loadedRegion.end).toBeCloseTo(1_060_000, -1)
+  expect(display.cutRegion!.start).toBeLessThan(loadedRegion.start)
+  expect(display.cutRegion!.end).toBeGreaterThan(loadedRegion.end)
+  expect(() =>
+    graphGenomeViewModel().create({
+      type: 'GraphGenomeView',
+      ...(spec as object),
+    }),
+  ).not.toThrow()
+})
+
+test('zoomed out to the coarse tier, the graph genome view launch is disabled', async () => {
+  const { view, display, addedViews } = await shownGraph()
+  view.zoomTo(3_000_000 / WIDTH_PX)
+  await wait(SETTLE_MS)
+  expect(display.cutTier).toBe('coarse')
+
+  const item = graphViewItem(display)!
+  expect(item.disabled).toBe(true)
+  item.onClick()
+  expect(addedViews).toHaveLength(0)
+})