jbrowse-plugin-graphgenomeviewer 7.4.3 → 7.5.0

package/src/LinearGraphDisplay/LinearGraphDisplay.test.ts

@@ -868,8 +868,14 @@ test('walk rows fit their own bars in the track, since a walk can be longer than
   expect(pane.viewportOwner).toBe('fit')
 })
 
-test('walk rows cut every snarl a walk takes past the window, so a walk comes whole', async () => {
-  const { pane, cuts } = await shownGraph({ paths: true })
+test('walk rows cut every snarl a GBZ walk takes past the window, so a walk comes whole', async () => {
+  const { view, cuts } = createEnvironment({ paths: true })
+  view.zoomTo(60_000 / WIDTH_PX)
+  view.scrollTo(1_000_000 / view.bpPerPx)
+  view.showTrack('walks')
+  const pane = view.tracks[0]!.displays[0] as LinearGraphDisplayModel
+  pane.startRenderingBackend(fakeRenderer())
+  await wait(SETTLE_MS)
   await pane.switchLayout('force')
   await wait(SETTLE_MS)
   const before = cuts.length
@@ -884,6 +890,18 @@ test('walk rows cut every snarl a walk takes past the window, so a walk comes wh
   expect(cuts.at(-1)!.snarls).toBeUndefined()
 })
 
+// A walk file cuts the same whatever the snarl option says
+test('walk rows on an rGFA track cut for the step budget, not for snarls', async () => {
+  const { pane, cuts } = await shownGraph({ paths: true })
+  await pane.switchLayout('force')
+  await wait(SETTLE_MS)
+  const before = cuts.length
+  await pane.switchLayout('walkrows')
+  await wait(SETTLE_MS)
+  expect(cuts).toHaveLength(before + 1)
+  expect(cuts.at(-1)!.snarls).toBeUndefined()
+})
+
 test('a launch in the force layout cuts the window alone', async () => {
   const { view, cuts } = createEnvironment()
   view.zoomTo(60_000 / WIDTH_PX)
@@ -1018,9 +1036,11 @@ test('each grammar setter writes the track config, and the pane reads it back',
   display.setLayoutMode('ordered')
   display.setColorScheme('depth')
   display.setNodeWidth('uniform')
+  display.setLinkWidth('walks')
   display.setLayer('bubbles', true)
   display.setFacet('walk')
   display.setWalkRowSamples(['HG1'])
+  display.setWalkRowOrder('shared')
   display.setHover('off')
   const slots = [
     'layoutMode',
@@ -1040,21 +1060,31 @@ test('each grammar setter writes the track config, and the pane reads it back',
   ).toEqual({
     layoutMode: 'ordered',
     color: { field: 'depth' },
-    size: 6,
+    size: { value: 6, links: 'walks' },
     layers: { bubbles: true },
     facet: { field: 'walk', domain: [] },
-    rows: { kept: ['HG1'] },
+    rows: { kept: ['HG1'], order: 'shared' },
     hover: 'off',
   })
   expect([
     display.chosenLayoutMode,
     display.chosenColorScheme,
     display.nodeWidth,
+    display.linkWidth,
     display.showBubbles,
     display.facetSetting.field,
     display.walkRowSamples,
     display.chosenHover,
-  ]).toEqual(['ordered', 'depth', 'uniform', true, 'walk', ['HG1'], 'off'])
+  ]).toEqual([
+    'ordered',
+    'depth',
+    'uniform',
+    'walks',
+    true,
+    'walk',
+    ['HG1'],
+    'off',
+  ])
 })
 
 // Reset track settings, undo and the config editor write the slot without

package/src/LinearGraphDisplay/components/GraphStatusChrome.test.tsx

@@ -39,6 +39,24 @@ test('a drawn graph sits in the chrome with its readiness attributes', () => {
   expect(screen.getByTestId('graph-canvas')).toBeTruthy()
 })
 
+// GraphCanvas shows it, with the retry that rebuilds the backend
+test('a render error alone is left to the canvas', () => {
+  render(
+    <GraphStatusChrome
+      model={model({ renderError: new Error('context lost') })}
+      phase="error"
+      drawn={false}
+      testid="linear-graph-display"
+    >
+      <canvas />
+    </GraphStatusChrome>,
+  )
+  expect(screen.queryByText(/context lost/)).toBeNull()
+  expect(screen.getByTestId('linear-graph-display').dataset.displayPhase).toBe(
+    'error',
+  )
+})
+
 test('a refused cut shows its notice over the graph', () => {
   const error = Object.assign(
     new Error('Zoom in to about 54Kbp to see the graph'),

package/src/LinearGraphDisplay/components/GraphStatusChrome.tsx

@@ -31,7 +31,7 @@ const FORCE_LOAD_ADVICE =
 // read `model` and `visible`; later hosts read values and callbacks. Each
 // overlay gets both, so one build runs on either.
 function overlayProps(model: LinearGraphDisplayModel) {
-  const error = model.error ?? model.renderError
+  const { error } = model
   const regionTooLarge =
     error instanceof Error &&
     (error as { regionTooLarge?: unknown }).regionTooLarge === true
@@ -128,7 +128,9 @@ export default observer(function GraphStatusChrome({
         {children}
       </BottomRightCornerContext>
       <TrackOverlayPortal>
-        {phase === 'error' ? (
+        {/* a backend's render error is the canvas's banner, whose retry
+        rebuilds the backend */}
+        {phase === 'error' && model.error !== undefined ? (
           <ErrorBar model={model} visible {...props.error} />
         ) : null}
         <Loading

package/src/LinearGraphDisplay/components/SubgraphHaplotypesField.test.tsx

@@ -1,4 +1,5 @@
-import { fireEvent, render, screen } from '@testing-library/react'
+import { act, fireEvent, render, screen } from '@testing-library/react'
+import { observable, runInAction } from 'mobx'
 
 import SubgraphHaplotypesField from './SubgraphHaplotypesField'
 
@@ -58,3 +59,42 @@ test('without names the field takes typed ones', () => {
   fireEvent.keyDown(field, { key: 'Enter' })
   expect(m.setSubgraphHaplotypes).toHaveBeenCalledWith(['HG002', 'NA19240#1'])
 })
+
+// A model whose set re-renders the field, as the display's does
+function liveModel(haplotypeNames?: string[]) {
+  const m = observable({
+    sourceAdapter: { type: 'RgfaTabixAdapter', walksUri: 'chr22' },
+    cutHaplotypes: ['HG002'],
+    haplotypeNames,
+    setSubgraphHaplotypes(haplotypes: string[]) {
+      m.cutHaplotypes = haplotypes
+    },
+    recut: vi.fn(),
+  })
+  return m as unknown as LinearGraphCutModel & { cutHaplotypes: string[] }
+}
+
+test('applying from the field keeps its focus', () => {
+  const m = liveModel()
+  render(<SubgraphHaplotypesField model={m} />)
+  const field = screen.getByTestId<HTMLInputElement>('graph-haplotypes-field')
+  field.focus()
+  fireEvent.change(field, { target: { value: 'HG002, NA19240#1' } })
+  fireEvent.keyDown(field, { key: 'Enter' })
+  expect(m.cutHaplotypes).toEqual(['HG002', 'NA19240#1'])
+  expect(screen.getByTestId('graph-haplotypes-field')).toBe(field)
+  expect(document.activeElement).toBe(field)
+})
+
+test('a set changed elsewhere resets the draft', () => {
+  const m = liveModel()
+  render(<SubgraphHaplotypesField model={m} />)
+  act(() => {
+    runInAction(() => {
+      m.cutHaplotypes = ['HG00097#1']
+    })
+  })
+  expect(
+    screen.getByTestId<HTMLInputElement>('graph-haplotypes-field').value,
+  ).toBe('HG00097#1')
+})

package/src/LinearGraphDisplay/components/SubgraphHaplotypesField.tsx

@@ -18,20 +18,39 @@ function parseHaplotypeList(text: string) {
   return text.split(/[\s,]+/).filter(name => name !== '')
 }
 
+const sameList = (a: readonly string[], b: readonly string[]) =>
+  a.join('\n') === b.join('\n')
+
+// The cut's set, and the last one this field saw: an outside change (a
+// restored session, a launch) resets the draft, while the field's own apply
+// records what it set first, so it keeps its focus and draft
+function useCutHaplotypes(model: LinearGraphCutModel, reset: () => void) {
+  const current = model.cutHaplotypes ?? []
+  const [seen, setSeen] = useState(current)
+  if (!sameList(current, seen)) {
+    setSeen(current)
+    reset()
+  }
+  return (haplotypes: string[]) => {
+    if (!sameList(haplotypes, current)) {
+      setSeen(haplotypes)
+      model.setSubgraphHaplotypes(haplotypes)
+      model.recut()
+    }
+  }
+}
+
 const HaplotypeListField = observer(function HaplotypeListField({
   model,
 }: {
   model: LinearGraphCutModel
 }) {
   const [draft, setDraft] = useState(model.cutHaplotypes?.join(', ') ?? '')
+  const setCut = useCutHaplotypes(model, () => {
+    setDraft(model.cutHaplotypes?.join(', ') ?? '')
+  })
   const apply = () => {
-    const parsed = parseHaplotypeList(draft)
-    const unchanged =
-      parsed.join('\n') === (model.cutHaplotypes ?? []).join('\n')
-    if (!unchanged) {
-      model.setSubgraphHaplotypes(parsed)
-      model.recut()
-    }
+    setCut(parseHaplotypeList(draft))
   }
   return (
     <TextField
@@ -72,12 +91,10 @@ const HaplotypePickField = observer(function HaplotypePickField({
   const draftRef = useRef(draft)
   const typed = useRef('')
   const [open, setOpen] = useState(false)
-  const apply = (haplotypes: string[]) => {
-    if (haplotypes.join('\n') !== (model.cutHaplotypes ?? []).join('\n')) {
-      model.setSubgraphHaplotypes(haplotypes)
-      model.recut()
-    }
-  }
+  const apply = useCutHaplotypes(model, () => {
+    draftRef.current = model.cutHaplotypes ?? []
+    setDraft(draftRef.current)
+  })
   return (
     <Autocomplete
       multiple
@@ -126,9 +143,7 @@ const HaplotypePickField = observer(function HaplotypePickField({
   )
 })
 
-// Only a GBZ cut and a walk-indexed rGFA cut read the set. The inner field is
-// keyed on it so an outside change (a restored session, a launch) resets the
-// draft rather than fighting it.
+// Only a GBZ cut and a walk-indexed rGFA cut read the set
 const SubgraphHaplotypesField = observer(function SubgraphHaplotypesField({
   model,
 }: {
@@ -136,14 +151,13 @@ const SubgraphHaplotypesField = observer(function SubgraphHaplotypesField({
 }) {
   const { classes } = useStyles()
   const names = model.haplotypeNames
-  const key = model.cutHaplotypes?.join(',') ?? ''
   const adapter = model.sourceAdapter
   return adapter && cutsByHaplotype(adapter) ? (
     <div className={classes.section}>
       {names ? (
-        <HaplotypePickField key={key} model={model} names={names} />
+        <HaplotypePickField model={model} names={names} />
       ) : (
-        <HaplotypeListField key={key} model={model} />
+        <HaplotypeListField model={model} />
       )}
       <Typography variant="caption" component="div" color="text.secondary">
         {names

package/src/LinearGraphDisplay/configSchema.ts

@@ -44,7 +44,8 @@ export function configSchemaFactory() {
        * #slot
        * the node thickness: a px number draws every node that thick;
        * `{ field: 'depth', value }` thickens a node the more paths carry it,
-       * around `value` px
+       * around `value` px; `links: 'walks'` thickens a link the more walks
+       * take it
        */
       size: {
         type: 'frozen',
@@ -54,8 +55,8 @@ export function configSchemaFactory() {
       /**
        * #slot
        * what the drawing adds over its nodes and edges, stated as changes to
-       * the defaults: `paths`, `bubbles` and `walkStrip` are off, `deletions`,
-       * `genes` and `referenceStrip` on
+       * the defaults: `paths`, `bubbles`, `walkStrip` and `walkRibbons` are
+       * off, `deletions`, `genes` and `referenceStrip` on
        * ```js
        * { layers: { bubbles: true, genes: false } }
        * ```

package/src/RgfaTabixAdapter/RgfaTabixAdapter.ts

@@ -4,11 +4,7 @@ import { ObservableCreate } from '@jbrowse/core/util/rxjs'
 import { parseSegmentRow, rgfaCut, segmentSamples } from '@jbrowse/graph-walks'
 
 import { locationIsSet } from '../locationName.ts'
-import {
-  PanSNRefNames,
-  openTabixSlot,
-  unmappedRegionMessage,
-} from '../panSNTabix.ts'
+import { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'
 import { getLines } from '../tabixRange.ts'
 import { WalkIndex } from './walkReader.ts'
 
@@ -194,10 +190,7 @@ export default class RgfaTabixAdapter extends BaseFeatureDataAdapter<RgfaTabixAd
   ): Promise<string | WalkCut> {
     const { hops, signal, tier } = opts
     const index = this.index(tier)
-    const tabixRefName = await index.refNames.resolve(region, { signal })
-    if (tabixRefName === undefined) {
-      throw new Error(unmappedRegionMessage(region))
-    }
+    const tabixRefName = await index.refNames.resolveForCut(region, { signal })
     if (index.walks) {
       return index.walks.subgraph(tabixRefName, region, opts)
     }

package/src/RgfaTabixAdapter/configSchema.ts

@@ -30,8 +30,8 @@ import type { Instance } from '@jbrowse/mobx-state-tree'
  * `walksUri` takes the prefix of a walk file in place of `uri`, and resolves
  * `<walksUri>.walks.bed.gz` and its `.tbi`. `gfa-to-tabix --walks -o <prefix>`
  * writes one per reference sample, so a track names one as
- * `<prefix>.<sample>`. The adapter reads walk format 4, which gfa-to-tabix
- * writes from 1.2, through @jbrowse/graph-walks. Such a graph's cut carries
+ * `<prefix>.<sample>`. The adapter reads walk format 5, which gfa-to-tabix
+ * writes from 1.4, through @jbrowse/graph-walks. Such a graph's cut carries
  * the haplotypes' walks, and `defaultHaplotypes` names the ones it is cut for
  * until the user picks others.
  *
@@ -152,7 +152,7 @@ const RgfaTabixAdapter = ConfigurationSchema(
     ),
     /**
      * #slot
-     * a `gfa-to-tabix --walks` file in walk format 4: per reference chunk,
+     * a `gfa-to-tabix --walks` file in walk format 5: per reference chunk,
      * the reference's path, the ways haplotypes leave it and each haplotype's
      * piece. Unset means the graph has no walks.
      */

package/src/RgfaTabixAdapter/walkFiles.test.ts

@@ -35,27 +35,27 @@ const fixture = (name: string) =>
 //   W HG002   1 chr1 >1>2>7>4>5>6   7 replaces 3
 //   W HG002   2 chr1 >1>2>3>4>8>6   8 replaces 5
 //   W HG00097 1 chr1 >1>2>3>4>5>6
-const headerPrefix = fixture('walks4_header')
+const headerPrefix = fixture('walks5_header')
 
-// walks4_header's walks with the reference named as pggb names a P-line,
+// walks5_header's walks with the reference named as pggb names a P-line,
 // GRCh38#chr1
-const twoPartPrefix = fixture('walks4_twopart')
+const twoPartPrefix = fixture('walks5_twopart')
 
 // An unchopped graph, node 1 spanning 0-2600 and filed under chunk 0 alone:
 //   W GRCh38 0 chr1 >1>2>4
 //   W HG002  1 chr1 >1>3>4   3 replaces 2
-const maxNodePrefix = fixture('walks4_maxnode')
+const maxNodePrefix = fixture('walks5_maxnode')
 
 // Twelve 500 bp reference nodes over chr1:0-6000 in one 10 kb chunk:
 //   W GRCh38  0 chr1 >1>2>3>4>5>6>7>8>9>10>11>12
 //   W HG002   1 chr1 >1>2>3>20>21>9>10>11>12   20 and 21, 2 kb each, replace 4-8
 //   W HG002   2 chr1 >1>2>3>4>5>6>7>8>9>10>11>12
 //   W HG003   1 chr1 >1>2>3>22                 the contig ends on 22, 300 bp
-const rejoinPrefix = fixture('walks4_rejoin')
+const rejoinPrefix = fixture('walks5_rejoin')
 
 // The same graph in 1 kb chunks, whose rows name the chunks their path goes on
 // in: HG002#1 leaves chunk 1000 for 20 and 21 and rejoins at 9, in chunk 4000
-const followPrefix = fixture('walks4_follow')
+const followPrefix = fixture('walks5_follow')
 
 function makeAdapter(prefix: string, slots = {}) {
   const local = (path: string) => ({

package/src/WalkFormsAdapter/WalkFormsAdapter.test.ts

@@ -0,0 +1,204 @@
+import PluginManager from '@jbrowse/core/PluginManager'
+import { ExpansionTooLargeError, formsCut } from '@jbrowse/graph-walks'
+import { firstValueFrom } from 'rxjs'
+import { toArray } from 'rxjs/operators'
+
+import Adapter from './WalkFormsAdapter.ts'
+import configSchema from './configSchema.ts'
+import WalkFormsAdapterF from './index.ts'
+
+import type * as GraphWalks from '@jbrowse/graph-walks'
+
+vi.mock('@jbrowse/graph-walks', async importOriginal => {
+  const actual = await importOriginal<typeof GraphWalks>()
+  return { ...actual, formsCut: vi.fn(actual.formsCut) }
+})
+
+// Four walks over a 3.6 kb reference of six 600 bp nodes, in 1 kb chunks
+// (RgfaTabixAdapter/walkFiles.test.ts builds on the same file):
+//   W GRCh38  0 chr1 >1>2>3>4>5>6
+//   W HG002   1 chr1 >1>2>7>4>5>6   7 (550 bp) replaces 3
+//   W HG002   2 chr1 >1>2>3>4>8>6   8 (20 bp) replaces 5
+//   W HG00097 1 chr1 >1>2>3>4>5>6
+const walks =
+  require.resolve('../RgfaTabixAdapter/test_data/walks5_header.GRCh38.walks.bed.gz')
+
+const local = (path: string) => ({
+  localPath: path,
+  locationType: 'LocalPathLocation',
+})
+
+// Each test pins its own window, since the cut cache outlives an adapter
+function makeAdapter(slots: Record<string, unknown>) {
+  return new Adapter(
+    configSchema.create({
+      walksLocation: local(walks),
+      walksIndex: { location: local(`${walks}.tbi`) },
+      ...slots,
+    }),
+  )
+}
+
+const pinned = (start: number) => ({ refName: 'chr1', start, end: 3600 })
+
+const region = (start: number, end: number, refName = 'chr1') => ({
+  refName,
+  assemblyName: 'hg38',
+  start,
+  end,
+})
+
+const featuresOf = (adapter: Adapter, query = region(0, 3600)) =>
+  firstValueFrom(adapter.getFeatures(query).pipe(toArray()))
+
+const placeholders = (features: Awaited<ReturnType<typeof featuresOf>>) =>
+  features
+    .filter(f => f.id().startsWith('forms-reference-'))
+    .map(f => ({
+      start: f.get('start'),
+      end: f.get('end'),
+      genotypes: f.get('genotypes'),
+    }))
+
+test('registers the adapter type', () => {
+  const pm = new PluginManager()
+  WalkFormsAdapterF(pm)
+  pm.createPluggableElements()
+  expect(pm.getAdapterType('WalkFormsAdapter').name).toBe('WalkFormsAdapter')
+})
+
+test('names the reference sample contigs as the assembly does', async () => {
+  expect(await makeAdapter({ pinned: pinned(0) }).getRefNames()).toEqual([
+    'chr1',
+  ])
+})
+
+test('one source per form, labelled by share and change', async () => {
+  const adapter = makeAdapter({ pinned: pinned(1) })
+  expect(await adapter.getSourcesAndWarnings()).toEqual({
+    sources: [
+      { name: 'F1', label: '33% · ref', haplotypes: 1, forms: 1 },
+      {
+        name: 'F2',
+        label: '33% · repl 600bp->550bp',
+        haplotypes: 1,
+        forms: 1,
+      },
+      { name: 'F3', label: '33% · del 580bp', haplotypes: 1, forms: 1 },
+    ],
+    warnings: [],
+  })
+})
+
+test('features are the pinned window changes, with a genotype per form', async () => {
+  const features = await featuresOf(makeAdapter({ pinned: pinned(2) }))
+  expect(
+    features.map(f => ({
+      start: f.get('start'),
+      end: f.get('end'),
+      consequence: f.get('consequence'),
+      svType: f.get('svType'),
+      type: f.get('type'),
+      genotypes: f.get('genotypes'),
+    })),
+  ).toEqual([
+    {
+      start: 1200,
+      end: 1800,
+      consequence: 'loss',
+      svType: 'CPX',
+      type: 'complex_substitution',
+      genotypes: { F1: '0', F2: '1', F3: '0' },
+    },
+    {
+      start: 2400,
+      end: 3000,
+      consequence: 'loss',
+      svType: 'DEL',
+      type: 'deletion',
+      genotypes: { F1: '0', F2: '0', F3: '1' },
+    },
+  ])
+})
+
+test('a query with no change gives one reference placeholder', async () => {
+  const adapter = makeAdapter({ pinned: pinned(3) })
+  expect(placeholders(await featuresOf(adapter, region(1900, 2300)))).toEqual([
+    { start: 1900, end: 1901, genotypes: { F1: '0', F2: '0', F3: '0' } },
+  ])
+  expect(
+    placeholders(await featuresOf(adapter, region(0, 3600, 'chr2'))),
+  ).toHaveLength(1)
+  expect(
+    placeholders(await featuresOf(adapter, region(2900, 3600))),
+  ).toHaveLength(0)
+})
+
+test('a floor change regroups the cut without cutting again', async () => {
+  vi.mocked(formsCut).mockClear()
+  const fine = makeAdapter({ pinned: pinned(4), floorBp: 50 })
+  const coarse = makeAdapter({ pinned: pinned(4), floorBp: 1000 })
+  expect((await fine.getSourcesAndWarnings()).sources).toHaveLength(3)
+  expect((await coarse.getSourcesAndWarnings()).sources).toEqual([
+    { name: 'F1', label: '100% · ref', haplotypes: 3, forms: 1 },
+  ])
+  expect(placeholders(await featuresOf(coarse))).toEqual([
+    { start: 0, end: 1, genotypes: { F1: '0' } },
+  ])
+  expect(formsCut).toHaveBeenCalledTimes(1)
+})
+
+test('exclude leaves samples out of every form', async () => {
+  const adapter = makeAdapter({ pinned: pinned(5), exclude: ['HG002'] })
+  expect((await adapter.getSourcesAndWarnings()).sources).toEqual([
+    { name: 'F1', label: '100% · ref', haplotypes: 1, forms: 1 },
+  ])
+})
+
+test('maxForms gives the smaller forms one empty row', async () => {
+  const adapter = makeAdapter({ pinned: pinned(6), maxForms: 1 })
+  const { sources, warnings } = await adapter.getSourcesAndWarnings()
+  expect(sources.map(s => s.label)).toEqual(['33% · ref', 'other forms · 67%'])
+  expect(warnings).toEqual([
+    expect.stringMatching(/^Forms of chr1:7-3,600: 2 smaller forms/),
+  ])
+  expect(placeholders(await featuresOf(adapter))).toEqual([
+    { start: 0, end: 1, genotypes: { F1: '0' } },
+  ])
+})
+
+test('a pinned window past walkByteBudget says so, without a zoom-in notice', async () => {
+  const error = await makeAdapter({ pinned: pinned(7), walkByteBudget: 1 })
+    .getSourcesAndWarnings()
+    .catch((e: unknown) => e)
+  expect(error).toBeInstanceOf(Error)
+  expect(error).not.toHaveProperty('regionTooLarge')
+  expect(`${error}`).toMatch(
+    /^Error: The pinned window chr1:8-3,600 is too large to cut for structural forms: .*walkByteBudget, 0\.0 MB\. .*Raise walkByteBudget$/,
+  )
+})
+
+test('a window whose walks are too many to read in full says so', async () => {
+  vi.mocked(formsCut).mockClear()
+  vi.mocked(formsCut).mockRejectedValueOnce(
+    new ExpansionTooLargeError(24_000_000, 16_000_000, 3592),
+  )
+  const error = await makeAdapter({ pinned: pinned(9) })
+    .getSourcesAndWarnings()
+    .catch((e: unknown) => e)
+  expect(formsCut).toHaveBeenCalledWith(
+    expect.anything(),
+    expect.anything(),
+    expect.objectContaining({ partial: false }),
+  )
+  expect(error).not.toHaveProperty('regionTooLarge')
+  expect(`${error}`).toBe(
+    'Error: The pinned window chr1:10-3,600 is too large to read every walk in full for structural forms: its walks take 24.0 M steps, over the 16.0 M step budget, and about 2.39Kbp of it fits. Pin a narrower window',
+  )
+})
+
+test('an adapter with no pinned window says so', async () => {
+  await expect(makeAdapter({}).getSourcesAndWarnings()).rejects.toThrow(
+    /needs `pinned`/,
+  )
+})