jbrowse-plugin-graphgenomeviewer 4.0.11 → 4.0.13

package/src/GraphGenomeView/components/referenceRampCss.ts

@@ -0,0 +1,39 @@
+import { REFERENCE_RAMP_MAX_HUE } from '@jbrowse/bandage-core/renderer/GeometryBuilder'
+
+// The reference-position ramp in CSS, from the same three numbers
+// `getNodeColor` paints with (hue 0 to REFERENCE_RAMP_MAX_HUE at 70%/50%), so
+// a key or an overlay cannot come to describe a ramp the canvas stopped using.
+
+export function rampHueCss(hue: number) {
+  return `hsl(${hue}, 70%, 50%)`
+}
+
+export function rampHue(bp: number, domain: { start: number; end: number }) {
+  const frac = (bp - domain.start) / (domain.end - domain.start)
+  return Math.max(0, Math.min(1, frac)) * REFERENCE_RAMP_MAX_HUE
+}
+
+// hue degrees one gradient stop spans, since SVG interpolates stops in RGB
+const HUE_STOP_DEG = 30
+
+// The hues a gradient across `bp` of reference paints, evenly spaced along it
+// and walked from `to`'s end when reversed. One hue means the span reads flat.
+export function rampStops(
+  { start, bp, reversed }: { start: number; bp: number; reversed?: boolean },
+  domain: { start: number; end: number },
+) {
+  const low = rampHue(start, domain)
+  const high = rampHue(start + bp, domain)
+  if (high - low < 1) {
+    return [(low + high) / 2]
+  }
+  const n = Math.ceil((high - low) / HUE_STOP_DEG)
+  return Array.from({ length: n + 1 }, (_, i) =>
+    rampHue(start + (bp * (reversed ? n - i : i)) / n, domain),
+  )
+}
+
+export const RAMP_GRADIENT_CSS = `linear-gradient(to right, ${Array.from(
+  { length: 7 },
+  (_, i) => `${rampHueCss((i / 6) * REFERENCE_RAMP_MAX_HUE)} ${(i / 6) * 100}%`,
+).join(', ')})`

package/src/GraphGenomeView/genes/genes.test.ts

@@ -1,6 +1,10 @@
 import { genePins } from '@jbrowse/bandage-core/genes/genePins'
 import { convertGFAToGraph } from '@jbrowse/bandage-core/gfa/gfaConverter'
 import { parseGFA } from '@jbrowse/bandage-core/gfa-core/index'
+import {
+  featuresOnBackbone,
+  graphBackbone,
+} from '@jbrowse/bandage-core/reference'
 
 import { geneModelsFrom, pickGeneTrack } from './geneFeatures'
 
@@ -93,11 +97,14 @@ test('exons land on the backbone stretch they cover, and the name at the midpoin
   expect(pin!.covered).toBe(1)
 })
 
-test('a PanSN-named backbone still carries a gene named by its contig', () => {
+test('a PanSN-named backbone carries a gene named by its contig once renamed onto it', () => {
   const pansn = convertGFAToGraph(
     parseGFA(GFA.replaceAll('SN:Z:chr1', 'SN:Z:GRCh38#0#chr1')),
   )
-  expect(genePins(pansn, geneModelsFrom([gene]), positions)).toHaveLength(1)
+  const genes = geneModelsFrom([gene])
+  expect(genePins(pansn, genes, positions)).toEqual([])
+  const renamed = featuresOnBackbone(genes, graphBackbone(pansn)!)
+  expect(genePins(pansn, renamed, positions)).toHaveLength(1)
 })
 
 test('a gene on another sequence pins nothing', () => {

package/src/GraphGenomeView/host.test.ts

@@ -1,6 +1,6 @@
-import { cutHolds, hostCut } from './host'
+import { cutHolds, hostCut, hostFrame } from './host'
 
-import type { HostWindow } from './host'
+import type { HostWindow, LinearHost } from './host'
 
 const window: HostWindow = {
   refName: 'chr1',
@@ -39,3 +39,26 @@ test('a cut trimmed to a cap the window fills still holds that window', () => {
   expect(cut.end - cut.start).toBeLessThanOrEqual(60_000)
   expect(cutHolds(cut, window)).toBe(true)
 })
+
+test('a reversed block runs bp right to left from the same screen edge', () => {
+  const block = {
+    refName: 'chr1',
+    assemblyName: 'hg38',
+    start: 1000,
+    end: 2000,
+    offsetPx: 500,
+  }
+  const view = (reversed: boolean) =>
+    ({
+      bpPerPx: 2,
+      offsetPx: 400,
+      dynamicBlocks: { contentBlocks: [{ ...block, reversed }] },
+    }) as unknown as LinearHost
+  const region = { refName: 'chr1', assemblyName: 'hg38', start: 0, end: 1 }
+  const at = (reversed: boolean, bp: number) => {
+    const frame = hostFrame(view(reversed), region)!
+    return bp * frame.scale + frame.translateX
+  }
+  expect([at(false, 1000), at(false, 2000)]).toEqual([100, 600])
+  expect([at(true, 2000), at(true, 1000)]).toEqual([100, 600])
+})

package/src/GraphGenomeView/host.ts

@@ -65,7 +65,8 @@ export interface HostWindow {
 // x is reference bp on an anchored layout, so the graph shows what the linear
 // view shows when one bp is as many px in both and the cut's refName sits at
 // the same screen x. Undefined when the linear view shows no block of that
-// refName, which is a re-cut's job rather than the frame's.
+// refName, which is a re-cut's job rather than the frame's. A reversed block
+// runs bp right to left, which only the tube map's connectors can draw.
 export function hostFrame(view: LinearHost, region: SubgraphRegion) {
   const block = widest(
     view.dynamicBlocks.contentBlocks.filter(
@@ -74,12 +75,13 @@ export function hostFrame(view: LinearHost, region: SubgraphRegion) {
     ),
   )
   const { bpPerPx } = view
-  return block && bpPerPx > 0
-    ? {
-        scale: 1 / bpPerPx,
-        translateX: block.offsetPx - view.offsetPx - block.start / bpPerPx,
-      }
-    : undefined
+  if (!block || !(bpPerPx > 0)) {
+    return undefined
+  }
+  const left = block.offsetPx - view.offsetPx
+  return block.reversed
+    ? { scale: -1 / bpPerPx, translateX: left + block.end / bpPerPx }
+    : { scale: 1 / bpPerPx, translateX: left - block.start / bpPerPx }
 }
 
 // Read off the LIVE blocks even when the coarse ones woke the caller: those

package/src/GraphGenomeView/model.test.ts

@@ -4,6 +4,7 @@
 // "the submenu is called something else".
 
 import { spreadFor } from '@jbrowse/bandage-core/bubbleSpreads'
+import { rowLabelBox } from '@jbrowse/bandage-core/graphLabels'
 import {
   PROPORTIONAL_LENGTH,
   bandageAutoScale,
@@ -21,6 +22,8 @@ import { applySnapshot, getSnapshot } from '@jbrowse/mobx-state-tree'
 import { MAX_GRAPH_REGION_BP, formatSpanBp } from './model'
 import stateModelFactory from './viewModel'
 
+import type { LayoutModeValue } from '@jbrowse/bandage-core/layoutModes'
+import type { Renderer } from '@jbrowse/bandage-core/renderer/types'
 import type { Graph } from '@jbrowse/bandage-core/types'
 
 const mockRpcCall = vi.fn()
@@ -46,7 +49,14 @@ const mockSession = {
     has: (name: string) => canonicalAssembly(name) !== undefined,
     get: (name: string) => {
       const canonical = canonicalAssembly(name)
-      return canonical === undefined ? undefined : { name: canonical }
+      return canonical === undefined
+        ? undefined
+        : {
+            name: canonical,
+            aliases: Object.keys(mockSession.assemblyAliases).filter(
+              alias => mockSession.assemblyAliases[alias] === canonical,
+            ),
+          }
     },
   },
   views: [] as unknown[],
@@ -134,6 +144,18 @@ function rpcRespond() {
   })
 }
 
+function fakeRenderer() {
+  return {
+    resize: () => {},
+    uploadGeometry: () => {},
+    updateTransform: () => {},
+    render: () => {},
+    setNodeHighlights: () => {},
+    setEdgeHighlight: () => {},
+    dispose: () => {},
+  } as unknown as Renderer
+}
+
 function createModel() {
   return stateModelFactory().create({ type: 'GraphGenomeView' })
 }
@@ -1181,6 +1203,79 @@ describe('canvas height follows the drawing', () => {
   })
 })
 
+// A 22 kb cut of 1,295 nodes fitted whole drew at 3.4%, a strip of 1 px
+// tubes. On its own axis a tube map fits no smaller than 5 px tubes and is
+// panned along, as in sequenceTubeMap.
+describe('zoomToFit on a tube map', () => {
+  // A SNP between each pair of backbone nodes, so the boxes cannot merge
+  function snpChainGfa(snps: number) {
+    const lines = ['H\tVN:Z:1.0', 'S\tb0\t*\tLN:i:1000']
+    const ref = ['b0+']
+    const alt = ['b0+']
+    for (let i = 1; i <= snps; i++) {
+      lines.push(
+        `S\tr${i}\tA`,
+        `S\ta${i}\tC`,
+        `S\tb${i}\t*\tLN:i:1000`,
+        `L\tb${i - 1}\t+\tr${i}\t+\t0M`,
+        `L\tb${i - 1}\t+\ta${i}\t+\t0M`,
+        `L\tr${i}\t+\tb${i}\t+\t0M`,
+        `L\ta${i}\t+\tb${i}\t+\t0M`,
+      )
+      ref.push(`r${i}+`, `b${i}+`)
+      alt.push(`a${i}+`, `b${i}+`)
+    }
+    lines.push(`P\tref\t${ref.join(',')}\t*`, `P\talt\t${alt.join(',')}\t*`)
+    return `${lines.join('\n')}\n`
+  }
+
+  async function tubeMap(snps: number) {
+    const model = stateModelFactory().create({
+      type: 'GraphGenomeView',
+      layoutMode: 'tubemap',
+    })
+    await model.loadGFA(snpChainGfa(snps), `${snps} SNPs`)
+    model.zoomToFit()
+    return model
+  }
+
+  function tubePx(model: Awaited<ReturnType<typeof tubeMap>>) {
+    return model.layoutResult!.tubeMap!.layout.tracks[0]!.width * model.scale
+  }
+
+  test('a cut too long for the pane opens at 5 px tubes, its left end on screen', async () => {
+    const model = await tubeMap(100)
+    const bounds = model.layoutBounds!
+    expect(model.width - 80).toBeLessThan(bounds.w * model.scale)
+
+    expect(tubePx(model)).toBeCloseTo(5, 10)
+    expect(bounds.minX * model.scale + model.translateX).toBeCloseTo(40, 5)
+    expect(model.canvasHeight).toBe(Math.max(160, bounds.h * model.scale + 80))
+  })
+
+  // An action's reads are untracked, so an autorun that called zoomToFit
+  // refitted on a new layout and on nothing else
+  test('a view the user has not moved refits when its pane widens', async () => {
+    const model = await tubeMap(2)
+    model.startRenderingBackend(fakeRenderer())
+    const before = model.scale
+
+    model.setWidth(model.width * 2)
+    expect(model.scale).toBeGreaterThan(before)
+  })
+
+  test('a cut that fits with wider tubes still fits whole', async () => {
+    const model = await tubeMap(2)
+    const bounds = model.layoutBounds!
+
+    expect(tubePx(model)).toBeGreaterThan(5)
+    const left = bounds.minX * model.scale + model.translateX
+    const right = left + bounds.w * model.scale
+    expect(left).toBeGreaterThanOrEqual(40 - 1e-6)
+    expect(right).toBeLessThanOrEqual(model.width - 40 + 1e-6)
+  })
+})
+
 // hoveredEdge is an index into graph.edges, so it addresses the graph it was set
 // against; carrying it across a load pointed the tooltip and the highlight at
 // whatever ended up at that index in the new graph.
@@ -1949,13 +2044,16 @@ describe('a row layout draws y in pixels', () => {
     expect(model.canvasHeight).toBe(600)
     // the vertical fit is the tighter one, and is not the one taken
     expect((model.canvasHeight - 80) / model.layoutBounds!.h).toBeLessThan(
-      (model.width - 80) / model.layoutBounds!.w,
+      (model.width - model.fitPadLeft - 40) / model.layoutBounds!.w,
     )
 
     const xs = Object.values(model.nodePositions!)
       .flat()
       .map(p => p.x * model.scaleX + model.translateX)
-    expect(Math.max(...xs) - Math.min(...xs)).toBeCloseTo(model.width - 80, 5)
+    expect(Math.max(...xs) - Math.min(...xs)).toBeCloseTo(
+      model.width - model.fitPadLeft - 40,
+      5,
+    )
   })
 
   // Rows are a track's row height, so zooming the sequence axis leaves them
@@ -2112,7 +2210,19 @@ describe('what the row axis draws, in pixels', () => {
   // in the path.
   test('the backbone spans the pane', async () => {
     const model = await fitted()
-    expect(spread(render(model).map(p => p.x))).toBeCloseTo(model.width - 80, 5)
+    expect(spread(render(model).map(p => p.x))).toBeCloseTo(
+      model.width - model.fitPadLeft - 40,
+      5,
+    )
+  })
+
+  test('the fit starts the drawing right of the row labels', async () => {
+    const model = await fitted()
+    const labelsEnd = Math.max(
+      ...model.drawnRowLabels.map(r => rowLabelBox(r.label, 0).x1),
+    )
+    expect(labelsEnd).toBeGreaterThan(40)
+    expect(Math.min(...render(model).map(p => p.x))).toBeGreaterThan(labelsEnd)
   })
 
   // Zoom is an x-only gesture on this axis, so afterwards the rows are drawn in
@@ -2495,3 +2605,272 @@ describe('annotation reads beside a cut', () => {
     expect(model.geneFeatures?.map(g => g.name)).toEqual(['XYZ2'])
   })
 })
+
+// GRCh38 and CHM13 walk chr6 at overlapping coordinates, so hg38's HLA-A lies
+// over segment 1 whichever walk x is drawn along. Only GRCh38's is hg38's.
+describe('genes on a backbone of another assembly', () => {
+  const SEGMENTS = [
+    'S\t1\tAAAAAAAAAA',
+    'S\t2\tCCCCCCCCCC',
+    'S\t3\tGGGGGGGGGG',
+    'S\t4\tTTTTTTTTTT',
+    'L\t1\t+\t2\t+\t0M',
+    'L\t1\t+\t3\t+\t0M',
+    'L\t2\t+\t4\t+\t0M',
+    'L\t3\t+\t4\t+\t0M',
+  ]
+  // A gbz-base cut writes the track's reference walk first
+  const gfaOf = (...walks: string[]) => [...SEGMENTS, ...walks, ''].join('\n')
+  const GRCH38 = 'W\tGRCh38\t0\tchr6\t1000\t1030\t>1>2>4'
+  const CHM13 = 'W\tCHM13\t0\tchr6\t1005\t1035\t>1>3>4'
+  const CHR6_WALKS = gfaOf(GRCH38, CHM13)
+  // The same alleles named the way an older graph does, with no PanSN prefix to
+  // say whose chr6 each is
+  const BARE_CHR6_PATHS = gfaOf(
+    'P\tchr6:1000-1030\t1+,2+,4+\t*',
+    'P\tCHM13_chr6:1005-1035\t1+,3+,4+\t*',
+  )
+  const BARE_CHR6_RGFA = [
+    'S\t1\tAAAAAAAAAA\tSN:Z:chr6\tSO:i:1000\tSR:i:0',
+    'S\t2\tCCCCCCCCCC\tSN:Z:chr6\tSO:i:1010\tSR:i:0',
+    'S\t3\tGGGGGGGGGG\tSN:Z:CHM13_chr6\tSO:i:1015\tSR:i:1',
+    'S\t4\tTTTTTTTTTT\tSN:Z:chr6\tSO:i:1020\tSR:i:0',
+    ...SEGMENTS.filter(line => line.startsWith('L')),
+    '',
+  ].join('\n')
+  // chr6 bp that only GRCh38's walk covers, only CHM13's, and both
+  const ON_GRCH38 = { start: 1000, end: 1004 }
+  const ON_CHM13 = { start: 1031, end: 1034 }
+  const ON_BOTH = { start: 1012, end: 1018 }
+
+  let gfa = CHR6_WALKS
+  let geneAt = { refName: 'chr6', start: 1002, end: 1008 }
+  const bySlot = (obj: Record<string, unknown>, key: string) => obj[key]
+  const adapterOnly = (obj: Record<string, unknown>, key: string) =>
+    key === 'adapter' ? obj.adapter : undefined
+
+  function sessionWith(assemblyName: string, graphAdapter = {}) {
+    mockSession.tracks = [
+      { trackId: 'graph', assemblyNames: [], adapter: graphAdapter },
+      {
+        trackId: 'refseq',
+        name: 'RefSeq genes',
+        assemblyNames: [assemblyName],
+        adapter: { type: 'Gff3TabixAdapter' },
+      },
+    ]
+  }
+
+  beforeEach(() => {
+    vi.mocked(readConfObject).mockImplementation(bySlot)
+    sessionWith('hg38')
+    gfa = CHR6_WALKS
+    geneAt = { refName: 'chr6', start: 1002, end: 1008 }
+    mockRpcCall.mockReset()
+    mockRpcCall.mockImplementation((_sid: unknown, method: string) =>
+      method === 'GetSubgraph'
+        ? Promise.resolve(gfa)
+        : method === 'CoreGetFeatures'
+          ? Promise.resolve([{ type: 'gene', name: 'HLA-A', ...geneAt }])
+          : Promise.reject(new Error(`Unexpected RPC: ${method}`)),
+    )
+  })
+
+  afterEach(() => {
+    vi.mocked(readConfObject).mockImplementation(adapterOnly)
+    mockSession.tracks = []
+    mockSession.assemblyNames = []
+    mockSession.assemblyAliases = {}
+  })
+
+  async function cutFor(
+    assemblyName: string,
+    layoutMode: LayoutModeValue = 'auto',
+  ) {
+    const model = stateModelFactory().create({
+      type: 'GraphGenomeView',
+      layoutMode,
+      loadedTrackId: 'graph',
+    })
+    await model.cutSubgraph(
+      {},
+      { refName: geneAt.refName, assemblyName, start: 1000, end: 1035 },
+    )
+    return model
+  }
+
+  type Model = Awaited<ReturnType<typeof cutFor>>
+  const pinned = (model: Model) => model.genePins.map(p => p.gene.name)
+  const tubeMapped = (model: Model) => model.tubeMapGenes.map(g => g.gene.name)
+
+  async function drawAlong(model: Model, path: string) {
+    model.setReferencePath(path)
+    await model.recomputeLayout()
+    expect(model.activeReferencePath).toBe(path)
+  }
+
+  test.each([
+    ['auto', pinned],
+    ['tubemapref', tubeMapped],
+  ] as const)(
+    '%s draws hg38 genes only while x is drawn along the GRCh38 walk',
+    async (layoutMode, drawn) => {
+      const model = await cutFor('hg38', layoutMode)
+      expect(model.activeReferencePath).toBe('GRCh38#0#chr6')
+      expect(drawn(model)).toEqual(['HLA-A'])
+
+      await drawAlong(model, 'CHM13#0#chr6')
+      expect(model.geneFeatures).toHaveLength(1)
+      expect(drawn(model)).toEqual([])
+
+      await drawAlong(model, 'GRCh38#0#chr6')
+      expect(drawn(model)).toEqual(['HLA-A'])
+    },
+  )
+
+  test('an assembly’s session aliases or PanSN prefix put x on its walk', async () => {
+    gfa = gfaOf(CHM13, GRCH38)
+    geneAt = { refName: 'chr6', ...ON_GRCH38 }
+    sessionWith('mine')
+    const unnamed = await cutFor('mine')
+    expect(unnamed.activeReferencePath).toBe('CHM13#0#chr6')
+    expect(pinned(unnamed)).toEqual([])
+
+    mockSession.assemblyNames = ['mine']
+    mockSession.assemblyAliases = { GRCh38: 'mine' }
+    expect(pinned(await cutFor('mine'))).toEqual(['HLA-A'])
+
+    mockSession.assemblyAliases = {}
+    sessionWith('mine', { assemblyNameToPanSN: { mine: 'GRCh38#0' } })
+    expect(pinned(await cutFor('mine'))).toEqual(['HLA-A'])
+  })
+
+  test('an assemblyNameToPanSN keyed by a session alias puts x on its walk', async () => {
+    gfa = gfaOf(CHM13, GRCH38)
+    geneAt = { refName: 'chr6', ...ON_GRCH38 }
+    mockSession.assemblyNames = ['mine']
+    mockSession.assemblyAliases = { 'GRCh38.p14': 'mine' }
+    sessionWith('mine', { assemblyNameToPanSN: { 'GRCh38.p14': 'GRCh38#0' } })
+    const model = await cutFor('mine')
+    expect(model.activeReferencePath).toBe('GRCh38#0#chr6')
+    expect(pinned(model)).toEqual(['HLA-A'])
+  })
+
+  // gbz-base writes a reference path that names no sample as `_gbwt_ref`
+  test('a vg graph’s generic reference takes its track’s genes', async () => {
+    gfa = gfaOf(
+      'W\t_gbwt_ref\t0\tchr6\t1000\t1030\t>1>2>4',
+      'W\tHG002\t1\tchr6\t1005\t1035\t>1>3>4',
+    )
+    const model = await cutFor('hg38')
+    expect(model.activeReferencePath).toBe('_gbwt_ref#0#chr6')
+    expect(pinned(model)).toEqual(['HLA-A'])
+
+    await drawAlong(model, 'HG002#1#chr6')
+    expect(pinned(model)).toEqual([])
+
+    await drawAlong(model, '_gbwt_ref#0#chr6')
+    expect(pinned(model)).toEqual(['HLA-A'])
+  })
+
+  // The adapter cuts along its referenceSample, else along the database's only
+  // reference sample, and names neither after the assembly
+  test.each([
+    [
+      'the referenceSample slot',
+      'T2T-CHM13v2.0',
+      { type: 'GbzBaseSyntenyAdapter', referenceSample: 'CHM13' },
+      gfaOf(CHM13, GRCH38),
+      { refName: 'chr6', ...ON_CHM13 },
+    ],
+    [
+      'the only reference sample',
+      'mm39',
+      { type: 'GbzBaseSyntenyAdapter' },
+      gfaOf(
+        'W\tC57BL_6J\t0\tchr17\t1000\t1030\t>1>2>4',
+        'W\tDBA_2J\t1\tchr17\t1005\t1035\t>1>3>4',
+      ),
+      { refName: 'chr17', ...ON_GRCH38 },
+    ],
+  ])(
+    'the walk a GBZ track cuts along with %s takes its genes',
+    async (_how, assemblyName, adapter, walks, at) => {
+      gfa = walks
+      geneAt = at
+      sessionWith(assemblyName, adapter)
+      const model = await cutFor(assemblyName)
+      expect(pinned(model)).toEqual(['HLA-A'])
+    },
+  )
+
+  test('a re-cut keeps the genes off a walk the user drew x along', async () => {
+    gfa = gfaOf(CHM13, GRCH38)
+    geneAt = { refName: 'chr6', ...ON_BOTH }
+    sessionWith('T2T-CHM13v2.0', {
+      type: 'GbzBaseSyntenyAdapter',
+      referenceSample: 'CHM13',
+    })
+    const model = await cutFor('T2T-CHM13v2.0')
+    expect(pinned(model)).toEqual(['HLA-A'])
+
+    await drawAlong(model, 'GRCh38#0#chr6')
+    expect(pinned(model)).toEqual([])
+
+    const region = model.graphRegion
+    await model.cutSubgraph(
+      {},
+      {
+        refName: 'chr6',
+        assemblyName: 'T2T-CHM13v2.0',
+        start: 1005,
+        end: 1035,
+      },
+    )
+    expect(model.graphRegion).not.toBe(region)
+    expect(model.activeReferencePath).toBe('GRCh38#0#chr6')
+    expect(pinned(model)).toEqual([])
+
+    await drawAlong(model, 'CHM13#0#chr6')
+    expect(pinned(model)).toEqual(['HLA-A'])
+  })
+
+  test('a diploid’s sample-level name leaves the other haplotype bare', async () => {
+    gfa = gfaOf(
+      'W\tHG002\t1\tchr6\t1000\t1030\t>1>2>4',
+      'W\tHG002\t2\tchr6\t1000\t1030\t>1>3>4',
+    )
+    sessionWith('HG002.1', { assemblyNameToPanSN: { 'HG002.1': 'HG002' } })
+    const model = await cutFor('HG002.1')
+    expect(model.activeReferencePath).toBe('HG002#1#chr6')
+    expect(pinned(model)).toEqual(['HLA-A'])
+
+    await drawAlong(model, 'HG002#2#chr6')
+    expect(pinned(model)).toEqual([])
+  })
+
+  test('a bare rGFA takes the assembly its track puts it on', async () => {
+    gfa = BARE_CHR6_RGFA
+    const model = await cutFor('hg38')
+    expect(pinned(model)).toEqual(['HLA-A'])
+
+    model.setReferencePath('CHM13_chr6')
+    await model.recomputeLayout()
+    expect(pinned(model)).toEqual(['HLA-A'])
+  })
+
+  test('a bare path graph takes it only along the path it came with', async () => {
+    gfa = BARE_CHR6_PATHS
+    const model = await cutFor('hg38')
+    expect(model.activeReferencePath).toBe('chr6')
+    expect(pinned(model)).toEqual(['HLA-A'])
+
+    await drawAlong(model, 'CHM13_chr6')
+    expect(model.geneFeatures).toHaveLength(1)
+    expect(model.backboneGenes).toBeUndefined()
+    expect(pinned(model)).toEqual([])
+
+    await drawAlong(model, 'chr6')
+    expect(pinned(model)).toEqual(['HLA-A'])
+  })
+})