jbrowse-plugin-graphgenomeviewer 7.1.0 → 7.1.2

package/src/LinearGraphDisplay/model.ts

@@ -26,25 +26,18 @@ import { reaction } from 'mobx'
 import { denseCovers, isNodeLimitError } from './denseWindow'
 import { cutHolds, hostCut, hostWindow } from '../GraphGenomeView/host'
 import { lenientOptionalEnum } from '../GraphGenomeView/lenientEnum'
-import {
-  GraphPaneMixin,
-  MAX_GRAPH_REGION_BP,
-  formatSpanBp,
-} from '../GraphGenomeView/model'
+import { GraphPane, formatSpanBp } from '../GraphGenomeView/model'
 import { FACET_KEY_PX } from '../GraphGenomeView/pane/fitViews'
+import { paneBase } from '../GraphGenomeView/pane/paneBase'
 import {
   configHaplotypes,
   cutsByHaplotype,
-  graphReferenceAssembly,
-  offReferenceProblem,
   trackLanes,
   walkIndexed,
 } from '../graphTrackConfig'
 import { pushLaunchItem } from '../launchFromGraph/pushLaunchItem'
-import { trackAdapterConfig } from '../panSNAliases/trackAdapterConfig'
 
 import type { LinearGraphDisplayConfigModel } from './configSchema'
-import type { DenseWindow } from './denseWindow'
 import type { SubgraphRegion, SubgraphTier } from '../GetSubgraph'
 import type { GraphLayers } from '../GraphGenomeView/graphLayers'
 import type { HostWindow } from '../GraphGenomeView/host'
@@ -53,11 +46,27 @@ import type { LaunchGraphGenomeViewArgs } from '../LaunchGraphGenomeView'
 import type { LayoutModeValue } from '@jbrowse/bandage-core/layoutModes'
 import type { MenuItem } from '@jbrowse/core/ui'
 import type { ExportSvgDisplayOptions } from '@jbrowse/display-kit/types'
-import type { Instance } from '@jbrowse/mobx-state-tree'
+import type { Instance, SnapshotOut } from '@jbrowse/mobx-state-tree'
 import type { DisplayStatusPhase } from '@jbrowse/render-core/displayPhase'
 
 type GraphViewSpec = Omit<LaunchGraphGenomeViewArgs, 'session'>
 
+// the pane's viewport, which a new graph view fits to its drawing
+const VIEWPORT_PROPS = new Set(['scale', 'translateX', 'translateY'])
+
+type PaneSettings = Omit<
+  SnapshotOut<typeof paneBase>,
+  'scale' | 'translateX' | 'translateY'
+>
+
+function paneSettings(pane: Instance<typeof paneBase>) {
+  return Object.fromEntries(
+    Object.keys(paneBase.properties)
+      .filter(key => !VIEWPORT_PROPS.has(key))
+      .map(key => [key, pane[key as keyof typeof pane]]),
+  ) as PaneSettings
+}
+
 // A variant under this many of the linear view's pixels folds into the
 // reference before layout, so the drawing gains detail as the view zooms in.
 // It is the width `gfa-to-tabix build` gives a backbone node at the zoom a
@@ -89,7 +98,7 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
       'LinearGraphDisplay',
       BaseDisplay,
       TrackHeightMixin(),
-      GraphPaneMixin(),
+      GraphPane,
       types.model({
         type: types.literal('LinearGraphDisplay'),
         configuration: ConfigurationReference(configSchema),
@@ -102,35 +111,20 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
         // whether that cut came from the track's coarse pair
         // (RgfaTabixAdapter), on which no bp cap applies
         coarseCut: types.optional(types.boolean, false),
-        // The bp ceiling on a fine cut, a proxy for node count that only
-        // holds at fine granularity; `maxGraphNodes` counts what came back.
-        maxRegionBp: types.optional(types.number, MAX_GRAPH_REGION_BP),
-        // How far the cut follows links past the region's own segments. At
-        // 0 a detour that leaves the backbone before the window and rejoins
-        // after it arrives as a fragment, since its interior is indexed only
-        // under its own sequence, so one bubble draws as two unrelated
-        // insertions. A hop follows alleles only, so it never walks the
-        // backbone out of the window.
-        subgraphContext: types.optional(types.number, 1),
-        // the haplotypes a GBZ or walk-indexed cut is for; unset is the
-        // config's defaultHaplotypes, else the lanes the track names
-        subgraphHaplotypes: types.maybe(types.frozen<string[]>()),
       }),
     )
     .volatile(() => ({
       recuts: 0,
       // the host window the settle clock last woke on
       settledWindow: undefined as HostWindow | undefined,
-      dense: undefined as DenseWindow | undefined,
+      // where a cut came back over its node limit (denseCovers)
+      dense: undefined as SubgraphRegion | undefined,
       // the haplotypes a walk-indexed graph's header names, once read
       haplotypeNames: undefined as string[] | undefined,
       // the fold the latest cut asked for
       cutFoldBp: 0,
     }))
     .views(self => ({
-      get adapterConfig() {
-        return trackAdapterConfig(self, self.parentTrack.configuration)
-      },
       get grammar(): GraphGrammar {
         return {
           layoutMode: getConf(self, 'layoutMode'),
@@ -152,17 +146,18 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
       get canRetryLoad() {
         return self.cutRegion !== undefined
       },
-      get cutHaplotypes() {
+      // the config's defaultHaplotypes, else the lanes the track names
+      get trackHaplotypes() {
+        const adapter = self.sourceAdapter
+        const track = self.sourceTrack
         return (
-          self.subgraphHaplotypes ??
-          configHaplotypes(this.adapterConfig) ??
-          trackLanes(self.parentTrack.configuration)
+          (adapter && configHaplotypes(adapter)) ?? (track && trackLanes(track))
         )
       },
       // the linear view's zoom past which the track's coarse pair is cut, or
       // undefined for a track with none
       get coarseAboveBpPerPx() {
-        return coarseHandover(self.adapterConfig.coarse)
+        return coarseHandover(self.sourceAdapter?.coarse)
       },
     }))
     .views(self => ({
@@ -175,13 +170,13 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
       },
       // Whether a zoom has moved far enough from the one the drawing was
       // folded for that folding again would show or hide more. A graph with
-      // walks is never folded.
+      // walks is never folded, and a fold rounded to 0 bp counts as 1 bp.
       foldDrifted(bpPerPx: number) {
         const want = FOLD_PX * bpPerPx
         const had = self.cutFoldBp
         return (
           !self.graph?.paths?.length &&
-          (want >= 2 * had ||
+          (want >= 2 * Math.max(had, 1) ||
             (self.foldedBelowBp !== undefined && want <= had / 2))
         )
       },
@@ -267,15 +262,16 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
           setConf(self, slot as keyof GraphGrammar, value)
         }
       },
-      // The setters describe the next cut; the caller re-cuts.
+      // The setters describe the next cut, which recut makes
       setSubgraphContext(hops: number) {
         self.subgraphContext = hops
+        self.dense = undefined
       },
       setSubgraphHaplotypes(haplotypes: string[] | undefined) {
         self.subgraphHaplotypes = haplotypes
         self.dense = undefined
       },
-      setDense(window: DenseWindow | undefined) {
+      setDense(window: SubgraphRegion | undefined) {
         self.dense = window
       },
       setHaplotypeNames(names: string[] | undefined) {
@@ -288,13 +284,11 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
       // a fine one does, since a tier is the same graph folded.
       cut() {
         const region = self.cutRegion
-        if (!region) {
+        const adapterConfig = self.sourceAdapter
+        if (!region || !adapterConfig) {
           return
         }
-        const problem = offReferenceProblem(
-          graphReferenceAssembly(self.parentTrack.configuration),
-          region.assemblyName,
-        )
+        const problem = self.offReference(region)
         if (problem) {
           self.clearGraph()
           self.setError(new Error(problem))
@@ -305,17 +299,9 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
           FOLD_PX * (self.settledWindow?.bpPerPx ?? self.host?.bpPerPx ?? 0),
         )
         return self.cutSubgraph(
-          self.adapterConfig,
+          adapterConfig,
           region,
-          {
-            hops: self.subgraphContext,
-            haplotypes: self.cutHaplotypes,
-            tier: coarse ? 'coarse' : undefined,
-            ...(self.chosenLayoutMode === 'walkrows' ? { walkRows: true } : {}),
-            ...(layoutModeByValue(self.chosenLayoutMode).wholeWalks
-              ? { snarls: 'overlapping' as const }
-              : {}),
-          },
+          { ...self.cutOptions, tier: coarse ? 'coarse' : undefined },
           self.cutFoldBp,
         )
       },
@@ -353,10 +339,16 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
         ) {
           return false
         }
-        // The error is the latest cut's, since a cut clears it as it
-        // starts and an outrun cut sets nothing
-        void Promise.resolve(self.recutAt(seen)).then(() => {
-          if (isAlive(self) && isNodeLimitError(self.error)) {
+        // An outrun cut resolves without touching the error, so the error
+        // is this cut's only while no later one has started
+        const cut = self.recutAt(seen)
+        const recut = self.recuts
+        void Promise.resolve(cut).then(() => {
+          if (
+            isAlive(self) &&
+            self.recuts === recut &&
+            isNodeLimitError(self.error)
+          ) {
             this.refuseDenseCut(seen)
           }
         })
@@ -369,16 +361,23 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
         self.cutRegion = undefined
         this.settleOn(self.settledWindow ?? seen)
       },
-      relayoutFrom(fromMode: LayoutModeValue) {
-        const from = layoutModeByValue(fromMode)
-        const to = layoutModeByValue(self.chosenLayoutMode)
+      // Cut the region again with the current options, or the window on
+      // screen where a refused cut left no region
+      recut() {
+        if (self.cutRegion) {
+          void self.cut()
+        } else if (self.settledWindow) {
+          this.settleOn(self.settledWindow)
+        }
+      },
+      relayoutFrom(from: LayoutModeValue) {
         const seen = self.host ? hostWindow(self.host) : undefined
         if (
           seen &&
           !self.regionTooLarge &&
-          (to.cutMargins !== from.cutMargins ||
-            to.wholeWalks !== from.wholeWalks ||
-            (from.value === 'walkrows') !== (to.value === 'walkrows'))
+          (self.cutChangedFrom(from) ||
+            layoutModeByValue(from).cutMargins !==
+              layoutModeByValue(self.chosenLayoutMode).cutMargins)
         ) {
           return self.recutAt(seen)
         }
@@ -396,18 +395,23 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
     }))
     .actions(self => ({
       // A failed read leaves the picker taking typed names
-      async fetchHaplotypeNames(adapterConfig: Record<string, unknown>) {
+      async fetchHaplotypeNames(
+        adapterConfig: Record<string, unknown>,
+        signal?: AbortSignal,
+      ) {
         try {
           const names = await getSession(self).rpcManager.call(
             getRpcSessionId(self),
             'GetGraphHaplotypes',
-            { adapterConfig },
+            { adapterConfig, signal },
           )
-          if (isAlive(self) && self.adapterConfig === adapterConfig) {
+          if (isAlive(self) && self.sourceAdapter === adapterConfig) {
             self.setHaplotypeNames(names)
           }
         } catch (e) {
-          console.warn('[LinearGraphDisplay] no haplotype names', e)
+          if (!signal?.aborted) {
+            console.warn('[LinearGraphDisplay] no haplotype names', e)
+          }
         }
       },
     }))
@@ -456,15 +460,24 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
         if (self.cutRegion && !self.graph) {
           void self.cut()
         }
+        let namesRead: AbortController | undefined
+        addDisposer(self, () => {
+          namesRead?.abort()
+        })
         addDisposer(
           self,
           reaction(
-            () =>
-              walkIndexed(self.adapterConfig) ? self.adapterConfig : undefined,
+            () => {
+              const adapter = self.sourceAdapter
+              return adapter && walkIndexed(adapter) ? adapter : undefined
+            },
             adapterConfig => {
+              namesRead?.abort()
+              namesRead = undefined
               self.setHaplotypeNames(undefined)
               if (adapterConfig) {
-                void self.fetchHaplotypeNames(adapterConfig)
+                namesRead = new AbortController()
+                void self.fetchHaplotypeNames(adapterConfig, namesRead.signal)
               }
             },
             { fireImmediately: true, name: 'GraphHaplotypeNames' },
@@ -579,6 +592,7 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
         const start = Math.floor(seen.start)
         const end = Math.ceil(seen.end)
         return {
+          ...paneSettings(self),
           loadedTrackId: trackId,
           loadedRegion: {
             refName: seen.refName,
@@ -586,19 +600,10 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
             start,
             end,
           },
-          subgraphContext: self.subgraphContext,
           subgraphHaplotypes: self.cutHaplotypes,
           maxRegionBp: Math.max(self.maxRegionBp, end - start),
           ...self.grammar,
           layoutMode: self.chosenLayoutMode,
-          referencePath: self.referencePath,
-          geneTrackId: self.geneTrackId,
-          walkLayers: self.walkLayers,
-          layoutEngine: self.layoutEngine,
-          layoutQuality: self.layoutQuality,
-          bubbleSpread: self.bubbleSpread,
-          linearLayout: self.linearLayout,
-          maxGraphNodes: self.maxGraphNodes,
           connectedViewId: self.host?.id,
         } satisfies GraphViewSpec
       },
@@ -616,16 +621,18 @@ export function stateModelFactory(configSchema: LinearGraphDisplayConfigModel) {
       // graph, the config's default set or the assemblies the track names,
       // or a list chosen in Graph settings
       cutMenuItems(): MenuItem[] {
-        if (!cutsByHaplotype(self.adapterConfig)) {
+        const adapter = self.sourceAdapter
+        const track = self.sourceTrack
+        if (!adapter || !track || !cutsByHaplotype(adapter)) {
           return []
         }
-        const defaults = configHaplotypes(self.adapterConfig)
-        const lanes = trackLanes(self.parentTrack.configuration)
+        const defaults = configHaplotypes(adapter)
+        const lanes = trackLanes(track)
         const names = self.haplotypeNames
         const chosen = self.subgraphHaplotypes
         const recut = (haplotypes: string[] | undefined) => {
           self.setSubgraphHaplotypes(haplotypes)
-          void self.cut()
+          self.recut()
         }
         return [
           { type: 'subHeader', label: 'Load' },

package/src/MinigraphBubbleAdapter/MinigraphBubbleAdapter.test.ts

@@ -4,11 +4,13 @@ import {
   bubbleLabel,
   parseBubbleLine,
 } from '@jbrowse/bandage-core/bubbles/bubbleLine'
+import PluginManager from '@jbrowse/core/PluginManager'
 import { firstValueFrom } from 'rxjs'
 import { toArray } from 'rxjs/operators'
 
 import Adapter from './MinigraphBubbleAdapter.ts'
 import configSchema from './configSchema.ts'
+import MinigraphBubbleAdapterF from './index.ts'
 
 // Unmodified `gfatools bubble` output cut to chr6:32.4-32.7 Mb, so the column
 // order here is the real one. Its stable names are bare (`chr6`) rather than
@@ -36,6 +38,12 @@ const mhc = {
   end: 32420000,
 }
 
+test("the byte gate measures a region from the bubble file's index", async () => {
+  const adapter = makeAdapter()
+  expect(await adapter.getRegionByteSize([mhc])).toBeGreaterThan(0)
+  expect(await adapter.getRegionByteSize([{ ...mhc, refName: 'chr7' }])).toBe(0)
+})
+
 test('getRefNames lists the sequences the bubbles sit on', async () => {
   expect(await makeAdapter().getRefNames()).toEqual(['chr6'])
 })
@@ -155,3 +163,16 @@ test('reports assembly-facing contigs for a PanSN-named file', async () => {
   const adapter = makeAdapter()
   expect(await adapter.getRefNames({ assemblyName: 'hg38' })).toEqual(['chr6'])
 })
+
+test("the adapter type expands the uri shorthand with the schema's preprocessor", () => {
+  const pluginManager = new PluginManager()
+  MinigraphBubbleAdapterF(pluginManager)
+  pluginManager.createPluggableElements()
+  const { normalizeSnapshot } = pluginManager.getAdapterType(
+    'MinigraphBubbleAdapter',
+  )
+  expect(normalizeSnapshot?.({ uri: 'bb.bed.gz' })).toMatchObject({
+    bubblesLocation: { uri: 'bb.bed.gz' },
+    index: { location: { uri: 'bb.bed.gz.tbi' } },
+  })
+})

package/src/MinigraphBubbleAdapter/MinigraphBubbleAdapter.ts

@@ -11,36 +11,28 @@ import { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'
 import { getLines } from '../tabixRange.ts'
 
 import type { MinigraphBubbleAdapterConfig } from './configSchema.ts'
-import type PluginManager from '@jbrowse/core/PluginManager'
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'
-import type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache'
 import type { Feature } from '@jbrowse/core/util'
 import type { Region } from '@jbrowse/core/util/types'
 
 export default class MinigraphBubbleAdapter extends BaseFeatureDataAdapter<MinigraphBubbleAdapterConfig> {
   public static capabilities = ['getFeatures', 'getRefNames']
 
-  private readonly bubbles
+  private readonly bubbles = openTabixSlot(this, ['bubblesLocation'], ['index'])
   // `gfatools bubble` names each row after the graph's stable sequence, so a
   // Minigraph-Cactus graph produces PanSN rows (`GRCh38#0#chr6`) where a plain
   // minigraph graph produces bare ones (`chr6`). Same resolution the segment
   // adapter does, through the same `assemblyNameToPanSN` slot.
-  private readonly refNames
-
-  public constructor(
-    config: MinigraphBubbleAdapterConfig,
-    getSubAdapter?: getSubAdapterType,
-    pluginManager?: PluginManager,
-  ) {
-    super(config, getSubAdapter, pluginManager)
-    this.bubbles = openTabixSlot(this, ['bubblesLocation'], ['index'])
-    this.refNames = new PanSNRefNames(this.bubbles, this)
-  }
+  private readonly refNames = new PanSNRefNames(this.bubbles, this)
 
   async getRefNames(opts: BaseOptions = {}) {
     return this.refNames.assemblyRefNames(opts)
   }
 
+  async getRegionByteSize(regions: Region[], opts: BaseOptions = {}) {
+    return this.refNames.regionBytes(regions, opts)
+  }
+
   public async hasDataForRefName() {
     return true
   }

package/src/MinigraphBubbleAdapter/configSchema.ts

@@ -1,6 +1,6 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration'
 
-import { tabixIndexSchema, tbiBeside } from '../panSNTabix.ts'
+import { fileLocationSlot, tabixIndexSchema, tbiBeside } from '../panSNTabix.ts'
 
 import type { Instance } from '@jbrowse/mobx-state-tree'
 
@@ -25,7 +25,7 @@ import type { Instance } from '@jbrowse/mobx-state-tree'
  * ```
  */
 
-export function normalizeSnapshot(snap: Record<string, unknown>) {
+function normalizeSnapshot(snap: Record<string, unknown>) {
   const { uri, baseUri, csi } = snap
   return typeof uri === 'string'
     ? {
@@ -42,13 +42,7 @@ const MinigraphBubbleAdapter = ConfigurationSchema(
     /**
      * #slot
      */
-    bubblesLocation: {
-      type: 'fileLocation',
-      defaultValue: {
-        uri: '/path/to/graph.bb.bed.gz',
-        locationType: 'UriLocation',
-      },
-    },
+    bubblesLocation: fileLocationSlot('/path/to/graph.bb.bed.gz'),
     /**
      * #slot
      */

package/src/MinigraphBubbleAdapter/index.ts

@@ -1,6 +1,6 @@
 import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType'
 
-import configSchema, { normalizeSnapshot } from './configSchema.ts'
+import configSchema from './configSchema.ts'
 
 import type PluginManager from '@jbrowse/core/PluginManager'
 
@@ -10,7 +10,6 @@ export default function MinigraphBubbleAdapterF(pluginManager: PluginManager) {
       new AdapterType({
         name: 'MinigraphBubbleAdapter',
         displayName: 'Minigraph bubble BED adapter',
-        normalizeSnapshot,
         configSchema,
         adapterMetadata: {
           category: 'Graph adapters',

package/src/RgfaTabixAdapter/RgfaTabixAdapter.test.ts

@@ -1,14 +1,19 @@
-import { readFileSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+import { mkdtempSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import { gunzipSync } from 'node:zlib'
 
 import { TabixIndexedFile } from '@gmod/tabix'
 import { parseGFA } from '@jbrowse/bandage-core/gfa-core/index'
+import PluginManager from '@jbrowse/core/PluginManager'
 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 RgfaTabixAdapterF from './index.ts'
 import { linkKey, parseLinkLine } from './rgfaBed.ts'
 
 import type { WalkCut } from './walkRowRuns.ts'
@@ -79,6 +84,16 @@ test('getFeatures returns the segments on a stable sequence', async () => {
   ])
 })
 
+test("the byte gate measures a region from the segment file's index", async () => {
+  const bytes = vi.spyOn(TabixIndexedFile.prototype, 'bytesForRegions')
+  const size = await makeAdapter().getRegionByteSize([k12])
+  expect(size).toBeGreaterThan(0)
+  expect(bytes.mock.calls.map(call => call[0])).toEqual([
+    [{ refName: 'K12#1#chr', start: k12.start, end: k12.end }],
+  ])
+  bytes.mockRestore()
+})
+
 test('getFeatures resolves a PanSN name given unqualified', async () => {
   const qualified = await firstValueFrom(
     makeAdapter()
@@ -119,6 +134,24 @@ test('getSubgraph reaches off-reference neighbours', async () => {
   )
 })
 
+// node runs the script with type stripping, which refuses a parameter property
+// or an enum anywhere among the cut's imports
+test('scripts/dump-subgraph.ts writes the cut getSubgraph makes', async () => {
+  const out = join(mkdtempSync(join(tmpdir(), 'dump-subgraph-')), 'cut.gfa')
+  const window = { ...k12, start: 1_000_000, end: 1_100_000 }
+  execFileSync(process.execPath, [
+    require.resolve('../../scripts/dump-subgraph.ts'),
+    prefix,
+    'K12',
+    'chr',
+    String(window.start),
+    String(window.end),
+    out,
+  ])
+  const cut = gfaText(await makeAdapter().getSubgraph(window, { hops: 1 }))
+  expect(readFileSync(out, 'utf8')).toBe(`${cut}\n`)
+})
+
 test('getSubgraph is byte-identical across calls', async () => {
   const adapter = makeAdapter()
   expect(await adapter.getSubgraph(k12)).toBe(await adapter.getSubgraph(k12))
@@ -407,6 +440,17 @@ test("getSubgraph with tier: 'coarse' cuts the coarse pair", async () => {
   expect(bubbles.every(n => fineIds.has(n.id))).toBe(true)
 })
 
+test("the adapter type expands the uri shorthand with the schema's preprocessor", () => {
+  const pluginManager = new PluginManager()
+  RgfaTabixAdapterF(pluginManager)
+  pluginManager.createPluggableElements()
+  const { normalizeSnapshot } = pluginManager.getAdapterType('RgfaTabixAdapter')
+  expect(normalizeSnapshot?.({ uri: 'hprc', walksUri: 'w' })).toMatchObject({
+    segmentsLocation: { uri: 'hprc.segs.bed.gz' },
+    walksLocation: { uri: 'w.walks.bed.gz' },
+  })
+})
+
 test('the coarse uri shorthand resolves a pair against the adapter baseUri', () => {
   const config = configSchema.create({
     uri: 'hprc',