jbrowse-plugin-graphgenomeviewer 3.0.3 → 3.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbrowse-plugin-graphgenomeviewer",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "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": {
@@ -25,7 +25,7 @@
   ],
   "private": false,
   "dependencies": {
-    "@gmod/gbz-base": "^2.6.5",
+    "@gmod/gbz-base": "^2.7.0",
     "@gmod/tabix": "^3.8.2",
     "@jbrowse/cigar-utils": "^5.0.0-beta.9",
     "@jbrowse/core": "^5.0.0-beta.9",

package/src/GbzBaseSyntenyAdapter/GbzBaseSyntenyAdapter.test.ts

@@ -3,6 +3,7 @@ import { toArray } from 'rxjs/operators'
 
 import Adapter, {
   NoReferenceSampleError,
+  PairTargetError,
   laneAssemblyName,
 } from './GbzBaseSyntenyAdapter.ts'
 import configSchema from './configSchema.ts'
@@ -420,6 +421,265 @@ test('getSubgraph refuses a window on a haplotype lane with a message naming the
   ).rejects.toThrow(/cut on its reference, hg38; a window on HG01106#1/)
 })
 
+// the bases each side of a record walks, in JBrowse's convention: the feature
+// side takes D, the mate side I
+function cigarSpans(cigar: string) {
+  let feature = 0
+  let mate = 0
+  for (const [, n, op] of cigar.matchAll(/(\d+)([MIDX=])/g)) {
+    feature += op === 'I' ? 0 : +n
+    mate += op === 'D' ? 0 : +n
+  }
+  return { feature, mate }
+}
+
+const largestGap = (cigar: string) =>
+  Math.max(0, ...[...cigar.matchAll(/(\d+)[ID]/g)].map(([, n]) => Number(n)))
+
+// HG01361#2 and HG02145#2 each carry a ~170 bp insertion against GRCh38 at
+// 31,498,602, which a band composed through GRCh38 draws as nothing
+const insertionWindow = { ...window, start: 31498400, end: 31498900 }
+const pair = {
+  queryAssemblyName: 'HG01361#2',
+  targetAssemblyName: 'HG02145#2',
+}
+
+// the companion carries anchor rows, the one cut that holds a walk whole
+const anchoredAdapter = (conf: Record<string, unknown> = {}) =>
+  makeAdapter({
+    haplotypeIndexLocation: {
+      localPath: require.resolve('./test_data/micb-kir3dl1.haplotype-index.db'),
+      locationType: 'LocalPathLocation',
+    },
+    ...conf,
+  })
+
+const spanOf = (intervals: { start: number; end: number }[]) => ({
+  start: Math.min(...intervals.map(i => i.start)),
+  end: Math.max(...intervals.map(i => i.end)),
+})
+
+// HG00673#1's insertion is 16 bp longer than HG01361#2's, so that pair holds
+// an indel, which pins which side of the record its CIGAR walks. HG00438#1 is
+// assembled reverse to GRCh38. Each pair covers the stretch of each haplotype
+// that its own alignment to GRCh38 does, which pairAlignments never reads
+test.each(['HG02145#2', 'HG00673#1', 'HG00438#1'])(
+  'a lane pair on an anchor window answers HG01361#2 aligned to %s, on HG01361#2',
+  async lower => {
+    const adapter = anchoredAdapter()
+    const records = await feats(adapter, insertionWindow, {
+      queryAssemblyName: 'HG01361#2',
+      targetAssemblyName: lower,
+    })
+    expect(records.length).toBeGreaterThan(0)
+    for (const f of records) {
+      expect(f.get('assemblyName')).toBe('HG01361#2')
+      const mate = mateOf(f)
+      expect(mate.assemblyName).toBe(lower)
+      expect(cigarSpans(f.get('CIGAR'))).toEqual({
+        feature: f.get('end') - f.get('start'),
+        mate: mate.end - mate.start,
+      })
+    }
+    const onReference = async (lane: string) =>
+      (await feats(adapter, insertionWindow, { targetAssemblyName: lane })).map(
+        f => mateOf(f),
+      )
+    const [upper] = await onReference('HG01361#2')
+    const [mate] = await onReference(lower)
+    expect(new Set(records.map(f => f.get('refName')))).toEqual(
+      new Set([upper!.refName]),
+    )
+    expect(
+      spanOf(records.map(f => ({ start: f.get('start'), end: f.get('end') }))),
+    ).toEqual(spanOf([upper!]))
+    expect(new Set(records.map(f => mateOf(f).refName))).toEqual(
+      new Set([mate!.refName]),
+    )
+    expect(spanOf(records.map(f => mateOf(f)))).toEqual(spanOf([mate!]))
+  },
+)
+
+// the same 179 bp allele assembled forward (HG01928#2) and reverse
+// (HG00438#1): a `-` record's CIGAR reads along the query lane, as a `+`
+// record's does, so the one difference from HG01361#2 sits at the same place
+test('a reverse-strand pair writes its CIGAR along the query lane', async () => {
+  const adapter = anchoredAdapter()
+  const pairWith = async (lower: string) =>
+    (
+      await feats(adapter, insertionWindow, {
+        queryAssemblyName: 'HG01361#2',
+        targetAssemblyName: lower,
+      })
+    )[0]!
+  const reverse = await pairWith('HG00438#1')
+  const forward = await pairWith('HG01928#2')
+  expect(reverse.get('strand')).toBe(-1)
+  expect(forward.get('strand')).toBe(1)
+  expect(largestGap(forward.get('CIGAR'))).toBeGreaterThan(0)
+  expect(reverse.get('CIGAR')).toBe(forward.get('CIGAR'))
+})
+
+test('the pair with an indel between its lanes writes it', async () => {
+  const records = await feats(anchoredAdapter(), insertionWindow, {
+    queryAssemblyName: 'HG01361#2',
+    targetAssemblyName: 'HG00673#1',
+  })
+  expect(records.some(f => largestGap(f.get('CIGAR')) > 0)).toBe(true)
+})
+
+test('sequence both lanes carry and GRCh38 lacks aligns inside the pair record', async () => {
+  const adapter = anchoredAdapter()
+  const againstReference = await feats(adapter, insertionWindow, {
+    targetAssemblyName: 'HG01361#2',
+  })
+  expect(
+    Math.max(...againstReference.map(f => largestGap(f.get('CIGAR')))),
+  ).toBeGreaterThan(150)
+  const records = await feats(adapter, insertionWindow, pair)
+  for (const f of records) {
+    expect(largestGap(f.get('CIGAR'))).toBeLessThan(50)
+  }
+  const aligned = records.reduce(
+    (sum, f) => sum + f.get('end') - f.get('start'),
+    0,
+  )
+  expect(aligned).toBeGreaterThan(
+    insertionWindow.end - insertionWindow.start + 150,
+  )
+})
+
+test('a lane pair walks only its two lanes', async () => {
+  const adapter = anchoredAdapter()
+  const { db } = await (
+    adapter as unknown as {
+      graph: () => Promise<{ db: { getSubgraphForRange: unknown } }>
+    }
+  ).graph()
+  const cut = vi.spyOn(db, 'getSubgraphForRange')
+  await feats(adapter, insertionWindow, pair)
+  const { keep } = cut.mock.calls.at(-1)![3] as {
+    keep: (name: { sample: string; haplotype: number }) => boolean
+  }
+  const named = (sample: string, haplotype: number) => ({
+    sample,
+    haplotype,
+    contig: '',
+    fragment: 0,
+  })
+  expect(keep(named('HG01361', 2))).toBe(true)
+  expect(keep(named('HG02145', 2))).toBe(true)
+  expect(keep(named('HG01361', 1))).toBe(false)
+  expect(keep(named('HG00438', 1))).toBe(false)
+  cut.mockRestore()
+})
+
+test('lane pair ids are the same across two fetches of one window', async () => {
+  const adapter = anchoredAdapter()
+  const ids = async () =>
+    (await feats(adapter, insertionWindow, pair)).map(f => f.id()).sort()
+  const a = await ids()
+  expect(new Set(a).size).toBe(a.length)
+  expect(await ids()).toEqual(a)
+})
+
+test('a lane pair names its lanes the way the header does, through assemblyNameToPanSN', async () => {
+  const adapter = anchoredAdapter({
+    assemblyNameToPanSN: {
+      hg38: 'GRCh38#0',
+      'HG01361.2': 'HG01361#2',
+      'HG02145.2': 'HG02145#2',
+    },
+  })
+  const records = await feats(adapter, insertionWindow, {
+    queryAssemblyName: 'HG01361.2',
+    targetAssemblyName: 'HG02145.2',
+  })
+  expect(records.length).toBeGreaterThan(0)
+  for (const f of records) {
+    expect(f.get('assemblyName')).toBe('HG01361.2')
+    expect(mateOf(f).assemblyName).toBe('HG02145.2')
+  }
+})
+
+// the anchor window's numbers are no coordinates on a lane's contig, so a
+// clip against them would cut the records to nothing
+test('clipToRegion keeps a lane pair whole and drops its CIGAR', async () => {
+  const adapter = anchoredAdapter()
+  const whole = await feats(adapter, insertionWindow, pair)
+  const clippedPairs = await firstValueFrom(
+    adapter
+      .getFeaturesInMultipleRegions([insertionWindow] as never, {
+        ...pair,
+        clipToRegion: true,
+        splitAtGapBp: 10_000,
+      })
+      .pipe(toArray()),
+  )
+  expect(clippedPairs.map(f => [f.get('start'), f.get('end')])).toEqual(
+    whole.map(f => [f.get('start'), f.get('end')]),
+  )
+  for (const f of clippedPairs) {
+    expect(f.get('CIGAR')).toBeUndefined()
+  }
+})
+
+// CHM13's contigs are several fragments each in HPRC v2.1, and a cut takes the
+// fragment its window starts in alone; this fixture's are whole, so a second
+// GRCh38 chr6 fragment is reported starting mid-window
+test('a lane pair across a reference fragment boundary is cut once per fragment', async () => {
+  const adapter = anchoredAdapter()
+  const { db } = await (
+    adapter as unknown as {
+      graph: () => Promise<{
+        db: {
+          paths: () => Promise<
+            {
+              isIndexed: boolean
+              name: { sample: string; contig: string; fragment: number }
+            }[]
+          >
+          getSubgraphForRange: unknown
+        }
+      }>
+    }
+  ).graph()
+  const paths = await db.paths()
+  const grch38 = paths.find(
+    p => p.isIndexed && p.name.sample === 'GRCh38' && p.name.contig === 'chr6',
+  )!
+  const boundary = 31498700
+  const listed = vi
+    .spyOn(db, 'paths')
+    .mockResolvedValue([
+      ...paths,
+      { ...grch38, name: { ...grch38.name, fragment: boundary } },
+    ])
+  const cut = vi.spyOn(db, 'getSubgraphForRange')
+  const records = await feats(adapter, insertionWindow, pair)
+  expect(cut.mock.calls.map(([, start, end]) => [start, end]).sort()).toEqual([
+    [insertionWindow.start, boundary],
+    [boundary, insertionWindow.end],
+  ])
+  expect(records.length).toBeGreaterThan(1)
+  cut.mockRestore()
+  listed.mockRestore()
+})
+
+test('a lane pair without its target lane is refused', async () => {
+  await expect(
+    feats(anchoredAdapter(), insertionWindow, {
+      queryAssemblyName: 'HG01361#2',
+    }),
+  ).rejects.toThrow(PairTargetError)
+})
+
+// the micb database's own side tables hold no anchor rows, and at context 0
+// its sampled cut leaves both walks in pieces around the insertion
+test('without anchor rows a lane pair answers nothing, which the display composes through the reference', async () => {
+  expect(await feats(makeAdapter(), insertionWindow, pair)).toEqual([])
+})
+
 test('getSubgraph outside every reference fragment is empty', async () => {
   expect(
     await makeAdapter().getSubgraph({ ...window, start: 100, end: 200 }),

package/src/GbzBaseSyntenyAdapter/GbzBaseSyntenyAdapter.ts

@@ -15,7 +15,13 @@ import SyntenyFeature from '../synteny/SyntenyFeature.ts'
 
 import type { GbzBaseSyntenyAdapterConfig } from './configSchema.ts'
 import type { SubgraphAdapterOptions } from '../GetSubgraph.ts'
-import type { HaplotypeAlignment, PathName, PathQuery } from '@gmod/gbz-base'
+import type {
+  HaplotypeAlignment,
+  HaplotypeRef,
+  PairAlignment,
+  PathName,
+  PathQuery,
+} from '@gmod/gbz-base'
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'
 import type { Feature, SimpleFeatureSerialized } from '@jbrowse/core/util'
 import type { FileLocation, Region } from '@jbrowse/core/util/types'
@@ -71,9 +77,23 @@ export interface GbzHeaderLane {
  * `haplotypes` narrows a fetch to the lanes listed: PanSN prefixes at sample
  * (`HG002`) or haplotype (`HG002#1`) depth, or assembly names the config maps
  * to one; undefined is every haplotype.
+ *
+ * `queryAssemblyName` with `targetAssemblyName`, on a window of the anchor,
+ * asks for that pair of lanes aligned to each other inside the window.
  */
 export interface GbzFeatureOptions extends ComparativeOptions {
   haplotypes?: string[]
+  queryAssemblyName?: string
+}
+
+export class PairTargetError extends Error {
+  override name = 'PairTargetError'
+
+  constructor(queryAssemblyName: string) {
+    super(
+      `a pair query names both lanes: queryAssemblyName ${queryAssemblyName} came without a targetAssemblyName`,
+    )
+  }
 }
 
 function haplotypeWanted(name: PathName, wanted: string[] | undefined) {
@@ -213,6 +233,44 @@ export function fragmentFeature({
   }
 }
 
+/**
+ * One record of a lane pair, on the target walk's own contig with the query
+ * walk as its mate. gbz-base writes the CIGAR along the target, a `D` being
+ * target bases the query lacks, which is the side a JBrowse feature is, so it
+ * passes through unchanged.
+ */
+export function pairFeature({
+  pair,
+  lane,
+  mateLane,
+}: {
+  pair: PairAlignment
+  lane: string
+  mateLane: string
+}) {
+  const id = `${haplotypePrefix(pair.target)}#${pair.target.contig}:${pair.targetStart}-${pair.targetEnd}|${haplotypePrefix(pair.query)}#${pair.query.contig}:${pair.queryStart}-${pair.queryEnd}`
+  return new SyntenyFeature({
+    uniqueId: id,
+    assemblyName: lane,
+    refName: pair.target.contig,
+    start: pair.targetStart,
+    end: pair.targetEnd,
+    type: 'match',
+    strand: pair.strand === '-' ? -1 : 1,
+    CIGAR: pair.cigar,
+    syntenyId: id,
+    identity: pair.matches / Math.max(pair.columns, 1),
+    numMatches: pair.matches,
+    blockLen: pair.columns,
+    mate: {
+      refName: pair.query.contig,
+      start: pair.queryStart,
+      end: pair.queryEnd,
+      assemblyName: mateLane,
+    },
+  })
+}
+
 export default class GbzBaseSyntenyAdapter extends ComparativeAdapterBase<GbzBaseSyntenyAdapterConfig> {
   private graph = cachedSetup({
     label: 'Opening pangenome database',
@@ -408,51 +466,180 @@ export default class GbzBaseSyntenyAdapter extends ComparativeAdapterBase<GbzBas
     return subgraph ? subgraph.toGFA({ names: 'resolved' }) : ''
   }
 
+  private async laneHaplotypes(
+    assemblyName: string,
+    opts: BaseOptions,
+  ): Promise<HaplotypeRef[]> {
+    const prefix = resolvePanSNPrefix(this, assemblyName)
+    return (await this.getHaplotypes(opts)).filter(haplotype =>
+      panSNMatchesPrefix(haplotype.prefix, prefix),
+    )
+  }
+
+  /**
+   * The window split wherever the reference sample's contig starts another
+   * fragment, so each piece lies inside one: getSubgraphForRange cuts the
+   * first fragment alone, where getAlignmentsForRange walks them all
+   */
+  private async referencePieces(
+    refName: string,
+    start: number,
+    end: number,
+    opts: BaseOptions,
+  ) {
+    const { db, referenceSample } = await this.graph(opts)
+    const inside = (await db.paths())
+      .filter(
+        path =>
+          path.isIndexed &&
+          path.name.sample === referenceSample &&
+          path.name.contig === refName &&
+          path.name.fragment > start &&
+          path.name.fragment < end,
+      )
+      .map(path => path.name.fragment)
+    const bounds = [start, ...[...new Set(inside)].sort((a, b) => a - b), end]
+    return bounds.slice(1).map((pieceEnd, i) => ({
+      start: bounds[i]!,
+      end: pieceEnd,
+    }))
+  }
+
+  private async anchorFeatures(region: Region, opts: GbzFeatureOptions) {
+    const { db } = await this.graph(opts)
+    const { assemblyName, refName, start, end } = region
+    const targetPrefix = resolvePanSNPrefix(this, opts.targetAssemblyName)
+    const asmByPrefix = assemblyByPanSNPrefix(this)
+    const keep = this.keepPredicate(opts.haplotypes, targetPrefix)
+    const query = await this.referenceQuery(refName, opts)
+    const nodeLimit: number = this.getConf('nodeLimit')
+    const alignments = query
+      ? await updateStatus(
+          `Reading graph ${refName}:${start.toLocaleString()}-${end.toLocaleString()}`,
+          opts.statusCallback,
+          () =>
+            db
+              .getAlignmentsForRange(query, start, end, {
+                context: this.getConf('context'),
+                haplotypes: 'all',
+                limit: nodeLimit,
+                signal: opts.signal,
+                ...(keep === undefined ? {} : { keep }),
+              })
+              .catch((error: unknown) => {
+                throw nodeLimitError(error, nodeLimit, end - start) ?? error
+              }),
+        )
+      : []
+    return alignments.flatMap(alignment => {
+      const feature = alignment.resolved
+        ? fragmentFeature({
+            alignment,
+            assemblyName,
+            refName,
+            lane: laneAssemblyName(asmByPrefix, alignment.name),
+          })
+        : undefined
+      return feature === undefined ? [] : [feature]
+    })
+  }
+
+  /**
+   * The two lanes' walks cut out of the anchor window alone, and each walk
+   * of the query lane aligned to each walk of the target lane. The records
+   * sit on the query lane's contigs, the lane the display draws on top.
+   *
+   * Only a cut walked from the haplotype index's anchor rows holds each walk
+   * whole. The sampled cut leaves a walk in pieces wherever it strays past the
+   * context, and pieces align only in part, so without anchor rows, or when
+   * the anchor walk of any reference fragment in the window fell back, the
+   * pair answers nothing and the display composes it through the reference.
+   */
+  private async pairFeatures(
+    region: Region,
+    queryAssemblyName: string,
+    opts: GbzFeatureOptions,
+  ) {
+    const { targetAssemblyName } = opts
+    if (targetAssemblyName === undefined) {
+      throw new PairTargetError(queryAssemblyName)
+    }
+    const { db } = await this.graph(opts)
+    const { refName, start, end } = region
+    const featureSide = await this.laneHaplotypes(queryAssemblyName, opts)
+    const mateSide = await this.laneHaplotypes(targetAssemblyName, opts)
+    const kept = [...featureSide, ...mateSide]
+    const query = await this.referenceQuery(refName, opts)
+    const nodeLimit: number = this.getConf('nodeLimit')
+    const anchored = (await db.haplotypeAnchorSpacing()) !== undefined
+    const cut = (reference: PathQuery, piece: { start: number; end: number }) =>
+      db
+        .getSubgraphForRange(reference, piece.start, piece.end, {
+          context: this.getConf('context'),
+          haplotypes: 'all',
+          limit: nodeLimit,
+          signal: opts.signal,
+          keep: name =>
+            kept.some(
+              haplotype =>
+                haplotype.sample === name.sample &&
+                haplotype.haplotype === name.haplotype,
+            ),
+        })
+        .catch((error: unknown) => {
+          throw nodeLimitError(error, nodeLimit, end - start) ?? error
+        })
+    const subgraphs =
+      query && anchored && featureSide.length > 0 && mateSide.length > 0
+        ? (
+            await updateStatus(
+              `Aligning ${queryAssemblyName} to ${targetAssemblyName}`,
+              opts.statusCallback,
+              async () =>
+                Promise.all(
+                  (await this.referencePieces(refName, start, end, opts)).map(
+                    piece => cut(query, piece),
+                  ),
+                ),
+            )
+          ).filter(subgraph => subgraph !== undefined)
+        : []
+    const whole = subgraphs.every(subgraph => {
+      const walk = subgraph.stats.anchorWalk
+      return walk !== undefined && walk.fallback === undefined
+    })
+    return whole
+      ? subgraphs.flatMap(subgraph =>
+          featureSide.flatMap(target =>
+            mateSide.flatMap(mate =>
+              subgraph.pairAlignments({ target, query: mate }).map(pair =>
+                pairFeature({
+                  pair,
+                  lane: queryAssemblyName,
+                  mateLane: targetAssemblyName,
+                }),
+              ),
+            ),
+          ),
+        )
+      : []
+  }
+
   getFeatures(region: Region, opts: GbzFeatureOptions = {}) {
     return ObservableCreate<Feature>(async observer => {
       const { db, anchor } = await this.graph(opts)
       if (!db.hasHaplotypeIndex) {
         throw new NoHaplotypeIndexError()
       }
-      const { assemblyName, refName, start, end } = region
-      // a window on a haplotype lane has no direct answer: the display
-      // composes lane-to-lane links through the anchor
-      if (assemblyName === anchor) {
-        const targetPrefix = resolvePanSNPrefix(this, opts.targetAssemblyName)
-        const asmByPrefix = assemblyByPanSNPrefix(this)
-        const keep = this.keepPredicate(opts.haplotypes, targetPrefix)
-        const query = await this.referenceQuery(refName, opts)
-        const nodeLimit: number = this.getConf('nodeLimit')
-        const alignments = query
-          ? await updateStatus(
-              `Reading graph ${refName}:${start.toLocaleString()}-${end.toLocaleString()}`,
-              opts.statusCallback,
-              () =>
-                db
-                  .getAlignmentsForRange(query, start, end, {
-                    context: this.getConf('context'),
-                    haplotypes: 'all',
-                    limit: nodeLimit,
-                    signal: opts.signal,
-                    ...(keep === undefined ? {} : { keep }),
-                  })
-                  .catch((error: unknown) => {
-                    throw nodeLimitError(error, nodeLimit, end - start) ?? error
-                  }),
-            )
-          : []
-        for (const alignment of alignments) {
-          if (alignment.resolved) {
-            const feature = fragmentFeature({
-              alignment,
-              assemblyName,
-              refName,
-              lane: laneAssemblyName(asmByPrefix, alignment.name),
-            })
-            if (feature !== undefined) {
-              observer.next(feature)
-            }
-          }
+      // the graph is indexed on its reference alone, so a window on a
+      // haplotype lane has no answer: a lane pair is read inside the anchor's
+      if (region.assemblyName === anchor) {
+        const features =
+          opts.queryAssemblyName === undefined
+            ? await this.anchorFeatures(region, opts)
+            : await this.pairFeatures(region, opts.queryAssemblyName, opts)
+        for (const feature of features) {
+          observer.next(feature)
         }
       }
       observer.complete()

package/src/GbzBaseSyntenyAdapter/index.ts

@@ -15,8 +15,15 @@ export default function GbzBaseSyntenyAdapterF(pluginManager: PluginManager) {
         // launch menu offers this track too (launchSubgraph/subgraphTracks).
         // headerLanes: getHeader declares every haplotype as a lane, which is
         // what makes MultiWaySyntenyDisplay read the header of an untiered
-        // adapter and offer its lane picker over the whole graph
-        adapterCapabilities: ['getSubgraph', 'headerLanes'],
+        // adapter and offer its lane picker over the whole graph.
+        // lanePairsOnAnchor: a window of the anchor answers any two lanes'
+        // alignment to each other, so the display fetches each adjacent pair
+        // rather than composing it through the reference
+        adapterCapabilities: [
+          'getSubgraph',
+          'headerLanes',
+          'lanePairsOnAnchor',
+        ],
         adapterMetadata: {
           category: 'Synteny adapters',
         },

package/src/synteny/ComparativeAdapterBase.ts

@@ -41,7 +41,10 @@ export abstract class ComparativeAdapterBase<
 
   /**
    * `clipToRegion` and `splitAtGapBp` are honoured here and nowhere below:
-   * `getFeatures` never sees them.
+   * `getFeatures` never sees them. A record on another assembly than the
+   * region's, such as a lane pair read inside an anchor window, is in no
+   * coordinates the region states, so it is split at its gaps and clipped to
+   * its own extent.
    *
    * Emission is in region order, not arrival order, as core's base does: the
    * multi-way display's lane sort tie-breaks on first appearance in this list,
@@ -59,7 +62,13 @@ export abstract class ComparativeAdapterBase<
         this.getFeatures(region, { ...rest, statusCallback: slot() }).pipe(
           mergeMap((feature): Feature[] =>
             clip
-              ? clipFeatureToRegion(feature, region, splitAtGapBp)
+              ? clipFeatureToRegion(
+                  feature,
+                  feature.get('assemblyName') === region.assemblyName
+                    ? region
+                    : { start: feature.get('start'), end: feature.get('end') },
+                  splitAtGapBp,
+                )
               : [feature],
           ),
           toArray(),

package/src/version.ts

@@ -1 +1 @@
-export const version = '3.0.3'
+export const version = '3.0.4'