jbrowse-plugin-graphgenomeviewer 8.7.1 → 8.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbrowse-plugin-graphgenomeviewer",
-  "version": "8.7.1",
+  "version": "8.7.2",
   "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": {

package/src/GraphAddTrackWorkflow/AddTrackWorkflow.test.tsx

@@ -77,10 +77,10 @@ test('switching the file type forgets the index chosen for the last one', async
   expect(added[0]!.adapter).not.toHaveProperty('haplotypeIndexLocation')
 })
 
-test('a walk file adds a walk-indexed rGFA track for the haplotypes typed', async () => {
+test('a walk file adds a track with lanes, cut for the haplotypes typed', async () => {
   added.length = 0
   picks.set(
-    GRAPH_FILE_FIELDS.RgfaTabixWalks,
+    GRAPH_FILE_FIELDS.WalkTabixSyntenyAdapter,
     'https://example.com/chr22.GRCh38.walks.bed.gz',
   )
   render(
@@ -93,8 +93,10 @@ test('a walk file adds a walk-indexed rGFA track for the haplotypes typed', asyn
       }
     />,
   )
-  fireEvent.click(screen.getByLabelText(GRAPH_FILE_LABELS.RgfaTabixWalks))
-  fireEvent.click(screen.getByText(GRAPH_FILE_FIELDS.RgfaTabixWalks))
+  fireEvent.click(
+    screen.getByLabelText(GRAPH_FILE_LABELS.WalkTabixSyntenyAdapter),
+  )
+  fireEvent.click(screen.getByText(GRAPH_FILE_FIELDS.WalkTabixSyntenyAdapter))
   fireEvent.change(screen.getByTestId('graph-haplotypes-input'), {
     target: { value: 'HG002, HG00733#1' },
   })
@@ -103,7 +105,7 @@ test('a walk file adds a walk-indexed rGFA track for the haplotypes typed', asyn
     expect(added).toHaveLength(1)
   })
   expect(added[0]!.adapter).toEqual({
-    type: 'RgfaTabixAdapter',
+    type: 'WalkTabixSyntenyAdapter',
     walksLocation: {
       uri: 'https://example.com/chr22.GRCh38.walks.bed.gz',
       locationType: 'UriLocation',

package/src/GraphAddTrackWorkflow/AddTrackWorkflow.tsx

@@ -54,7 +54,7 @@ const useStyles = makeStyles()(theme => ({
 
 const CHOICES: GraphFileChoice[] = [
   'RgfaTabixAdapter',
-  'RgfaTabixWalks',
+  'WalkTabixSyntenyAdapter',
   'GbzBaseSyntenyAdapter',
   'MinigraphBubbleAdapter',
 ]
@@ -72,7 +72,7 @@ const GraphAddTrackWidget = observer(function GraphAddTrackWidget({
   const [indexLoc, setIndexLoc] = useState<FileLocation>()
   const [readsLoc, setReadsLoc] = useState<FileLocation>()
   const gbz = choice === 'GbzBaseSyntenyAdapter'
-  const walks = choice === 'RgfaTabixWalks'
+  const walks = choice === 'WalkTabixSyntenyAdapter'
   const [sample, setSample] = useState('')
   const [haplotypes, setHaplotypes] = useState('')
   const [trackName, setTrackName] = useState('Pangenome graph')

package/src/GraphAddTrackWorkflow/buildTrackConfig.ts

@@ -14,25 +14,31 @@ import {
 import type { GraphManifest } from './graphManifest'
 import type { FileLocation } from '@jbrowse/core/util'
 
-// 'RgfaTabixWalks' is an RgfaTabixAdapter read from a walk file
+// 'RgfaTabixWalks' is an RgfaTabixAdapter read from a walk file, which draws
+// the graph without haplotype lanes
 export type GraphFileChoice =
   | 'RgfaTabixAdapter'
   | 'RgfaTabixWalks'
+  | 'WalkTabixSyntenyAdapter'
   | 'GbzBaseSyntenyAdapter'
   | 'MinigraphBubbleAdapter'
 
 export const GRAPH_FILE_LABELS: Record<GraphFileChoice, string> = {
   RgfaTabixAdapter: 'Indexed GFA (gfa-to-tabix .segs.bed.gz or .graph.bed.gz)',
-  RgfaTabixWalks: 'Haplotype walks (.walks.bed.gz)',
+  RgfaTabixWalks: 'Haplotype walks without lanes (.walks.bed.gz)',
+  WalkTabixSyntenyAdapter: 'Haplotype walks (.walks.bed.gz)',
   GbzBaseSyntenyAdapter: 'GBZ database (.gbz.db)',
   MinigraphBubbleAdapter: 'Minigraph bubbles (tabix BED)',
 }
 
+const WALKS_FIELD =
+  'Path to a walk file (<prefix>.<sample>.walks.bed.gz from gfa-to-tabix --walks, for the sample this assembly is)'
+
 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), 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)',
+  RgfaTabixWalks: WALKS_FIELD,
+  WalkTabixSyntenyAdapter: WALKS_FIELD,
   GbzBaseSyntenyAdapter: 'Path to the .gbz.db written by gbz-base construct',
   MinigraphBubbleAdapter: 'Path to bubbles BED (.bed.gz from gfatools bubble)',
 }
@@ -43,6 +49,7 @@ const TABIX_INDEX_FIELD =
 export const GRAPH_INDEX_FIELDS: Record<GraphFileChoice, string> = {
   RgfaTabixAdapter: TABIX_INDEX_FIELD,
   RgfaTabixWalks: TABIX_INDEX_FIELD,
+  WalkTabixSyntenyAdapter: TABIX_INDEX_FIELD,
   GbzBaseSyntenyAdapter:
     'Path to the haplotype index (optional; graph.haplotype-index.db beside the database is assumed)',
   MinigraphBubbleAdapter: TABIX_INDEX_FIELD,
@@ -167,14 +174,14 @@ export function buildAdapterConfig({
   // a walk file's haplotypes to cut for until the user picks others
   haplotypes?: string[]
 }) {
-  if (choice === 'RgfaTabixWalks') {
+  if (choice === 'RgfaTabixWalks' || choice === 'WalkTabixSyntenyAdapter') {
     if (!locationName(loc).endsWith(WALKS_SUFFIX)) {
       throw new Error(
         `Expected a walk file ending in ${WALKS_SUFFIX}, got ${locationName(loc)}`,
       )
     }
     return {
-      type: 'RgfaTabixAdapter',
+      type: choice === 'RgfaTabixWalks' ? 'RgfaTabixAdapter' : choice,
       walksLocation: loc,
       walksIndex: tabixIndex(loc, indexLoc),
       ...referencePanSN(assembly, sample, walkFileSample(loc)),

package/src/GraphTrack/GraphTrack.test.ts

@@ -0,0 +1,68 @@
+import PluginManager from '@jbrowse/core/PluginManager'
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes'
+import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType'
+import { types } from '@jbrowse/mobx-state-tree'
+
+import GraphTrackF, { SYNTENY_DISPLAYS } from './index'
+import GbzBaseSyntenyAdapterF from '../GbzBaseSyntenyAdapter/index'
+import RgfaTabixAdapterF from '../RgfaTabixAdapter/index'
+import WalkTabixSyntenyAdapterF from '../WalkTabixSyntenyAdapter/index'
+
+function displayStub(name: string) {
+  const configSchema = ConfigurationSchema(
+    name,
+    {},
+    { explicitlyTyped: true, explicitIdentifier: 'displayId' },
+  )
+  return new DisplayType({
+    name,
+    configSchema,
+    stateModel: types.compose(
+      name,
+      BaseDisplay,
+      types.model({ type: types.literal(name) }),
+    ),
+    // core's own displays belong to other track types, and GraphTrack picks
+    // them up by name
+    trackType: 'FeatureTrack',
+    viewType: 'LinearGenomeView',
+    ReactComponent: () => null,
+  })
+}
+
+function displaysFor() {
+  const pluginManager = new PluginManager()
+  for (const name of [
+    'LinearGraphDisplay',
+    'LinearBasicDisplay',
+    ...SYNTENY_DISPLAYS,
+  ]) {
+    pluginManager.addDisplayType(() => displayStub(name))
+  }
+  RgfaTabixAdapterF(pluginManager)
+  GbzBaseSyntenyAdapterF(pluginManager)
+  WalkTabixSyntenyAdapterF(pluginManager)
+  GraphTrackF(pluginManager)
+  pluginManager.createPluggableElements()
+  const track = pluginManager.getTrackType('GraphTrack')
+  return (adapter: string) => {
+    const has = new Set(
+      pluginManager.getAdapterType(adapter).adapterCapabilities,
+    )
+    return track.displayTypes
+      .filter(d => d.adapterCapabilities.every(c => has.has(c)))
+      .map(d => d.name)
+  }
+}
+
+test('the segments lane is offered only where getFeatures gives reference segments', () => {
+  const offered = displaysFor()
+  expect(offered('RgfaTabixAdapter')).toEqual([
+    'LinearGraphDisplay',
+    'LinearBasicDisplay',
+  ])
+  for (const lanes of ['WalkTabixSyntenyAdapter', 'GbzBaseSyntenyAdapter']) {
+    expect(offered(lanes)).toEqual(['LinearGraphDisplay', ...SYNTENY_DISPLAYS])
+  }
+})

package/src/GraphTrack/index.ts

@@ -9,7 +9,10 @@ import type PluginManager from '@jbrowse/core/PluginManager'
 import type DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType'
 
 // core's synteny displays, copied to ask for headerLanes so only the gbz-base
-// and walk-tabix adapters open in a synteny, dotplot or circular view
+// and walk-tabix adapters open in a synteny, dotplot or circular view.
+// LinearBasicDisplay is copied to ask for referenceSegments: a lanes adapter
+// answers getFeatures with every haplotype's lane features, which the segments
+// lane can only offer to force-load
 export const SYNTENY_DISPLAYS = [
   'MultiWaySyntenyDisplay',
   'LinearSyntenyDisplay',
@@ -22,15 +25,15 @@ function displaysInOrder(pluginManager: PluginManager): DisplayType[] {
     'display',
   ) as DisplayType[]
   const named = (name: string) => displays.find(d => d.name === name)
-  const needsLanes = (display: DisplayType | undefined) =>
+  const needs = (capability: string, display: DisplayType | undefined) =>
     display &&
     Object.assign(Object.create(display) as DisplayType, {
-      adapterCapabilities: ['headerLanes'],
+      adapterCapabilities: [capability],
     })
   return [
     named('LinearGraphDisplay'),
-    named('LinearBasicDisplay'),
-    ...SYNTENY_DISPLAYS.map(name => needsLanes(named(name))),
+    needs('referenceSegments', named('LinearBasicDisplay')),
+    ...SYNTENY_DISPLAYS.map(name => needs('headerLanes', named(name))),
   ].filter((d): d is DisplayType => d !== undefined)
 }
 

package/src/RgfaTabixAdapter/index.ts

@@ -11,8 +11,9 @@ export default function RgfaTabixAdapterF(pluginManager: PluginManager) {
         name: 'RgfaTabixAdapter',
         displayName: 'Indexed rGFA adapter',
         configSchema,
-        // what a graph display needs of its track's adapter
-        adapterCapabilities: ['getSubgraph'],
+        // what a graph display needs of its track's adapter, and the
+        // reference's segments that its getFeatures gives the segments lane
+        adapterCapabilities: ['getSubgraph', 'referenceSegments'],
         adapterMetadata: {
           category: 'Graph adapters',
         },

package/src/graphTrackDefaults/graphTrackDefaults.test.ts

@@ -119,15 +119,85 @@ test("a walk lanes adapter naming no assemblies takes the track's", () => {
   })
 })
 
-test('a walk file guesses a walk-indexed rGFA adapter', () => {
+test('a walk file guesses the lanes adapter, so the track has graph and lanes', () => {
   const walks = uri('https://example.com/chr22.GRCh38.walks.bed.gz?sig=1')
-  expect(guessers().adapter(walks)).toEqual({
-    type: 'RgfaTabixAdapter',
+  const expected = {
     walksLocation: walks,
     walksIndex: {
       indexType: 'TBI',
       location: uri('https://example.com/chr22.GRCh38.walks.bed.gz.tbi?sig=1'),
     },
+  }
+  const { adapter, trackType } = guessers()
+  expect(adapter(walks)).toEqual({
+    type: 'WalkTabixSyntenyAdapter',
+    ...expected,
+  })
+  expect(adapter(walks, undefined, 'WalkTabixSyntenyAdapter')).toEqual({
+    type: 'WalkTabixSyntenyAdapter',
+    ...expected,
+  })
+  expect(adapter(walks, undefined, 'RgfaTabixAdapter')).toEqual({
+    type: 'RgfaTabixAdapter',
+    ...expected,
+  })
+  expect(trackType('WalkTabixSyntenyAdapter')).toBe('GraphTrack')
+})
+
+test('a walk file picked in the browser needs its index picked too', () => {
+  const picked = (name: string) => ({
+    name,
+    blobId: name,
+    locationType: 'BlobLocation' as const,
+  })
+  const { adapter } = guessers()
+  expect(adapter(picked('g.GRCh38.walks.bed.gz'))).toEqual({
+    type: 'Fallback',
+  })
+  expect(
+    adapter(picked('g.GRCh38.walks.bed.gz'), picked('g.walks.bed.gz.csi')),
+  ).toMatchObject({
+    type: 'WalkTabixSyntenyAdapter',
+    walksIndex: { indexType: 'CSI' },
+  })
+})
+
+test("gfa-to-tabix's bubbles file guesses a bubble feature track", () => {
+  const bubbles = uri('https://example.com/hprc.bubbles.bed.gz')
+  const { adapter, trackType } = guessers()
+  expect(adapter(bubbles)).toEqual({
+    type: 'MinigraphBubbleAdapter',
+    bubblesLocation: bubbles,
+    index: {
+      indexType: 'TBI',
+      location: uri('https://example.com/hprc.bubbles.bed.gz.tbi'),
+    },
+  })
+  expect(
+    adapter(
+      uri('https://example.com/b.bed.gz'),
+      undefined,
+      'MinigraphBubbleAdapter',
+    ),
+  ).toMatchObject({ type: 'MinigraphBubbleAdapter' })
+  expect(adapter(bubbles, undefined, 'BedTabixAdapter')).toEqual({
+    type: 'Fallback',
+  })
+  expect(trackType('MinigraphBubbleAdapter')).toBe('FeatureTrack')
+})
+
+test('a CSI beside the segments implies one beside the links', () => {
+  expect(
+    guessers().adapter(
+      uri('https://example.com/hprc.segs.bed.gz'),
+      uri('https://example.com/hprc.segs.bed.gz.CSI'),
+    ),
+  ).toMatchObject({
+    segmentsIndex: { indexType: 'CSI' },
+    linksIndex: {
+      indexType: 'CSI',
+      location: { uri: 'https://example.com/hprc.links.bed.gz.csi' },
+    },
   })
 })
 
@@ -150,4 +220,11 @@ test("a walk file with no PanSN map reads as its name's sample on the track's as
   expect(withWalkReference(mapped)).toBe(mapped)
   const same = { ...track, assemblyNames: ['GRCh38'] }
   expect(withWalkReference(same)).toBe(same)
+  const lanes = {
+    ...track,
+    adapter: { ...track.adapter, type: 'WalkTabixSyntenyAdapter' },
+  }
+  expect(withWalkReference(lanes).adapter).toMatchObject({
+    assemblyNameToPanSN: { hg38: 'GRCh38' },
+  })
 })

package/src/graphTrackDefaults/guessAdapter.ts

@@ -0,0 +1,62 @@
+import { buildAdapterConfig } from '../GraphAddTrackWorkflow/buildTrackConfig'
+import { isGraphIndexLocation } from '../GraphAddTrackWorkflow/graphManifest'
+import { WALKS_SUFFIX, locationName, readsSiblings } from '../locationName'
+
+import type { GraphFileChoice } from '../GraphAddTrackWorkflow/buildTrackConfig'
+import type { FileLocation } from '@jbrowse/core/util'
+
+const BUBBLES_SUFFIX = '.bubbles.bed.gz'
+
+function isGbzLocation(loc: FileLocation) {
+  return locationName(loc).toLowerCase().endsWith('.gbz.db')
+}
+
+function guessChoice(
+  file: FileLocation,
+  index: FileLocation | undefined,
+  adapterHint: string | undefined,
+): GraphFileChoice | undefined {
+  const name = locationName(file)
+  const allows = (type: GraphFileChoice) => !adapterHint || adapterHint === type
+  // a file picked in the browser has no index beside it to assume
+  const indexReachable = index !== undefined || readsSiblings(file)
+  return isGbzLocation(file)
+    ? allows('GbzBaseSyntenyAdapter')
+      ? 'GbzBaseSyntenyAdapter'
+      : undefined
+    : isGraphIndexLocation(file)
+      ? allows('RgfaTabixAdapter')
+        ? 'RgfaTabixAdapter'
+        : undefined
+      : !indexReachable
+        ? undefined
+        : name.endsWith(WALKS_SUFFIX)
+          ? // lanes beside the graph, unless the hint asks for the rGFA
+            // adapter, which reads the file without them
+            adapterHint === 'RgfaTabixAdapter'
+            ? 'RgfaTabixWalks'
+            : allows('WalkTabixSyntenyAdapter')
+              ? 'WalkTabixSyntenyAdapter'
+              : undefined
+          : allows('MinigraphBubbleAdapter') &&
+              (name.endsWith(BUBBLES_SUFFIX) || adapterHint !== undefined)
+            ? 'MinigraphBubbleAdapter'
+            : undefined
+}
+
+export function guessGraphAdapter(
+  file: FileLocation,
+  index?: FileLocation,
+  adapterHint?: string,
+) {
+  const choice = guessChoice(file, index, adapterHint)
+  return choice
+    ? buildAdapterConfig({
+        choice,
+        loc: file,
+        indexLoc: index,
+        assembly: '',
+        sample: '',
+      })
+    : undefined
+}

package/src/graphTrackDefaults/index.ts

@@ -1,14 +1,7 @@
-import { buildAdapterConfig } from '../GraphAddTrackWorkflow/buildTrackConfig'
-import { isGraphIndexLocation } from '../GraphAddTrackWorkflow/graphManifest'
-import {
-  WALKS_SUFFIX,
-  locationName,
-  readsSiblings,
-  walkFileSample,
-} from '../locationName'
+import { guessGraphAdapter } from './guessAdapter'
+import { walkFileSample } from '../locationName'
 import { LANE_ADAPTERS } from '../panSNAliases/trackAdapterConfig'
 
-import type { GraphFileChoice } from '../GraphAddTrackWorkflow/buildTrackConfig'
 import type PluginManager from '@jbrowse/core/PluginManager'
 import type { FileLocation } from '@jbrowse/core/util'
 import type {
@@ -18,14 +11,14 @@ import type {
 
 type TrackConfigSnapshot = Record<string, unknown>
 
-const GRAPH_ADAPTERS = new Set(['RgfaTabixAdapter', 'GbzBaseSyntenyAdapter'])
-
-export function isGbzLocation(loc: FileLocation) {
-  return locationName(loc).toLowerCase().endsWith('.gbz.db')
-}
+const GRAPH_ADAPTERS = new Set([
+  'RgfaTabixAdapter',
+  'GbzBaseSyntenyAdapter',
+  'WalkTabixSyntenyAdapter',
+])
 
 // A lanes adapter cuts on the first assembly it names. A track added through
-// Add track names that assembly on the track alone.
+// Open track names that assembly on the track alone.
 export function withLaneAnchor(snap: TrackConfigSnapshot) {
   const adapter = snap.adapter as
     { type?: string; assemblyNames?: unknown[] } | undefined
@@ -38,6 +31,8 @@ export function withLaneAnchor(snap: TrackConfigSnapshot) {
     : snap
 }
 
+const WALK_ADAPTERS = new Set(['RgfaTabixAdapter', 'WalkTabixSyntenyAdapter'])
+
 // A walk file opened with no PanSN map reads as the sample its name gives, on
 // the track's assembly; a guessed adapter had no assembly to key that by
 export function withWalkReference(snap: TrackConfigSnapshot) {
@@ -52,7 +47,9 @@ export function withWalkReference(snap: TrackConfigSnapshot) {
     ? (snap.assemblyNames as string[])
     : []
   const sample =
-    adapter?.type === 'RgfaTabixAdapter' && adapter.walksLocation
+    adapter?.type !== undefined &&
+    WALK_ADAPTERS.has(adapter.type) &&
+    adapter.walksLocation
       ? walkFileSample(adapter.walksLocation)
       : undefined
   return assembly &&
@@ -66,40 +63,6 @@ export function withWalkReference(snap: TrackConfigSnapshot) {
     : snap
 }
 
-export function guessGraphAdapter(
-  file: FileLocation,
-  index?: FileLocation,
-  adapterHint?: string,
-) {
-  const guess = (choice: GraphFileChoice) =>
-    buildAdapterConfig({
-      choice,
-      loc: file,
-      indexLoc: index,
-      assembly: '',
-      sample: '',
-    })
-  if (
-    (!adapterHint || adapterHint === 'GbzBaseSyntenyAdapter') &&
-    isGbzLocation(file)
-  ) {
-    return guess('GbzBaseSyntenyAdapter')
-  }
-  if (!adapterHint || adapterHint === 'RgfaTabixAdapter') {
-    if (isGraphIndexLocation(file)) {
-      return guess('RgfaTabixAdapter')
-    }
-    // a file picked in the browser has no index beside it to assume
-    if (
-      locationName(file).endsWith(WALKS_SUFFIX) &&
-      (index !== undefined || readsSiblings(file))
-    ) {
-      return guess('RgfaTabixWalks')
-    }
-  }
-  return undefined
-}
-
 export default function GraphTrackDefaultsF(pluginManager: PluginManager) {
   pluginManager.addToExtensionPoint(
     'Core-preProcessTrackConfig',
@@ -122,6 +85,8 @@ export default function GraphTrackDefaultsF(pluginManager: PluginManager) {
       (adapterName, file) =>
         GRAPH_ADAPTERS.has(adapterName)
           ? 'GraphTrack'
-          : next(adapterName, file),
+          : adapterName === 'MinigraphBubbleAdapter'
+            ? 'FeatureTrack'
+            : next(adapterName, file),
   )
 }

package/src/panSNAliases/panSNAliases.test.ts

@@ -50,12 +50,33 @@ describe('the map a track sends', () => {
   test('a bare sample, a contig name or a non-numeric haplotype is not read', () => {
     const config = withPanSNAliases(GBZ, [
       { name: 'hg38', aliases: ['GRCh38', 'hg38.p14'] },
-      { name: 'HG002.1', aliases: ['HG002#1#chr6'] },
+      { name: 'HG002', aliases: ['HG002#1#chr6'] },
       { name: 'odd', aliases: ['odd#a', '#1', 'odd#'] },
+      { name: 'hg38.p14', aliases: [] },
     ])
     expect(config).toBe(GBZ)
   })
 
+  test('an assembly named sample.haplotype maps to that haplotype, its alias first', () => {
+    expect(
+      withPanSNAliases(GBZ, [
+        { name: 'HG00621.1', aliases: [] },
+        { name: 'HG00621.2', aliases: ['HG00438#1'] },
+        { name: 'HG00438.1', aliases: [] },
+      ]).assemblyNameToPanSN,
+    ).toEqual({ 'HG00621.1': 'HG00621#1', 'HG00621.2': 'HG00438#1' })
+  })
+
+  test("the anchor's own name is not read as a haplotype", () => {
+    expect(
+      withPanSNAliases(
+        { ...GBZ, assemblyNames: ['GCA_000001405.15'] },
+        [{ name: 'GCA_000001405.15', aliases: [] }],
+        'GCA_000001405.15',
+      ),
+    ).toEqual({ ...GBZ, assemblyNames: ['GCA_000001405.15'] })
+  })
+
   test("the config's own entry wins for its assembly and for its prefix", () => {
     const config = withPanSNAliases(
       { ...GBZ, assemblyNameToPanSN: { hg38: 'GRCh38#0', mine: 'HG00621#1' } },
@@ -72,9 +93,9 @@ describe('the map a track sends', () => {
     })
   })
 
-  test('an assembly with no PanSN alias leaves the config as it was', () => {
+  test('an assembly with no PanSN alias or haplotype name leaves the config as it was', () => {
     const config = { ...GBZ, assemblyNameToPanSN: { hg38: 'GRCh38#0' } }
-    expect(withPanSNAliases(config, [{ name: 'HG00621.1', aliases: [] }])).toBe(
+    expect(withPanSNAliases(config, [{ name: 'HG00621', aliases: [] }])).toBe(
       config,
     )
   })
@@ -260,10 +281,18 @@ describe('the lanes the adapter reads with that map', () => {
     expect(await laneNamed(adapter, 'HG00621#1')).toBe('HG00621#1')
   })
 
-  test('an assembly with neither keeps its lane at the PanSN prefix', async () => {
+  test('an assembly named sample.haplotype names the lane and reads its contigs', async () => {
     const adapter = lanesAdapter([{ name: 'HG00621.1', aliases: [] }])
+    expect(await laneNamed(adapter, 'HG00621#1')).toBe('HG00621.1')
+    expect(
+      await adapter.getRefNames({ assemblyName: 'HG00621.1' }),
+    ).not.toEqual([])
+  })
+
+  test('an assembly with neither keeps its lane at the PanSN prefix', async () => {
+    const adapter = lanesAdapter([{ name: 'mine', aliases: [] }])
     expect(await laneNamed(adapter, 'HG00621#1')).toBe('HG00621#1')
-    expect(await adapter.getRefNames({ assemblyName: 'HG00621.1' })).toEqual([])
+    expect(await adapter.getRefNames({ assemblyName: 'mine' })).toEqual([])
   })
 })
 
@@ -337,7 +366,11 @@ test.each(['GbzBaseSyntenyAdapter', 'WalkTabixSyntenyAdapter'])(
       .volatile(() => ({
         rpcManager: {},
         assemblyManager: {
-          assemblyList: [{ name: 'hg38', aliases: ['GRCh38'] }, HG00621_1],
+          assemblyList: [
+            { name: 'hg38', aliases: ['GRCh38'] },
+            HG00621_1,
+            { name: 'HG00438.1', aliases: [] },
+          ],
           get: () => undefined,
           has: () => true,
           isValidRefName: () => true,
@@ -367,6 +400,7 @@ test.each(['GbzBaseSyntenyAdapter', 'WalkTabixSyntenyAdapter'])(
     expect(display.adapterConfig.assemblyNames).toEqual(['hg38'])
     expect(display.adapterConfig.assemblyNameToPanSN).toEqual({
       'HG00621.1': 'HG00621#1',
+      'HG00438.1': 'HG00438#1',
       hg38: 'GRCh38#0',
     })
   },