jbrowse-plugin-graphgenomeviewer 7.2.1 → 7.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbrowse-plugin-graphgenomeviewer",
-  "version": "7.2.1",
+  "version": "7.3.0",
   "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/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.test.ts

@@ -11,6 +11,7 @@ import Adapter from './WalkTabixSyntenyAdapter.ts'
 import configSchema from './configSchema.ts'
 import WalkTabixSyntenyAdapterF from './index.ts'
 import {
+  anchorAligner,
   bubblesAsMismatches,
   referenceAligner,
   walkAligner,
@@ -512,6 +513,81 @@ test('an inversion between two lanes is a reverse-strand record of its own when
   ])
 })
 
+// The same shape at a size the multi-way display names: 20 kb flanks around
+// a 15 kb stretch the haplotype runs backwards
+const largeInversionNodes = new Map(
+  [1, 2, 3, 4, 5].map(id => [
+    id,
+    {
+      refName: 'ref',
+      start: id * 100_000,
+      end: id * 100_000 + (id === 1 || id === 5 ? 20_000 : 5000),
+      rank: 0,
+      onWindow: true,
+    },
+  ]),
+)
+
+test('a walk turned against the reference for 10 kb or more gains a reverse-strand record of the turned stretch beside its own', () => {
+  expect(
+    drawn(anchorAligner(largeInversionNodes)(invertedLane, upperLane)),
+  ).toEqual([
+    {
+      query: '0-55000',
+      target: '0-55000',
+      strand: '+',
+      cigar: '20000=15000I15000D20000=',
+    },
+    {
+      query: '20000-35000',
+      target: '20000-35000',
+      strand: '-',
+      cigar: '15000=',
+    },
+  ])
+})
+
+// gfa-to-tabix --walks --refs GRCh38 --chunk 10000 over 20 kb flanks and three
+// 5 kb nodes:
+//   W GRCh38  0 chr1 >1>2>3>4>5
+//   W HG002   1 chr1 >1<4<3<2>5
+//   W HG00097 1 chr1 >1>2>3>4>5
+test('the anchor window answers a haplotype turned against the reference with a reverse-strand record of the turned stretch', async () => {
+  const records = await firstValueFrom(
+    makeAdapter({}, 'walks3_inversion')
+      .getFeatures({ ...window, end: 55_000 }, {})
+      .pipe(toArray()),
+  )
+  expect(
+    records
+      .filter(f => mateOf(f).assemblyName !== 'HG00097#1')
+      .map(f => ({
+        strand: f.get('strand'),
+        start: f.get('start'),
+        end: f.get('end'),
+      })),
+  ).toEqual([
+    { strand: 1, start: 0, end: 55_000 },
+    { strand: -1, start: 20_000, end: 35_000 },
+  ])
+})
+
+test('a walk turned for under 10 kb, or reversed whole, keeps its one record', () => {
+  expect(drawn(anchorAligner(inversionNodes)(invertedLane, upperLane))).toEqual(
+    drawn(referenceAligner(inversionNodes)(invertedLane, upperLane)),
+  )
+  const reversed = fragment('HG002#3#chr1', [
+    [5, 1],
+    [4, 1],
+    [3, 1],
+    [2, 1],
+    [1, 1],
+  ])
+  expect(
+    drawn(anchorAligner(largeInversionNodes)(reversed, upperLane)),
+  ).toEqual(drawn(referenceAligner(largeInversionNodes)(reversed, upperLane)))
+})
+
 test.each([
   ['the whole reference', window],
   ['a window inside it', { ...window, start: 1300, end: 2300 }],

package/src/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.ts

@@ -10,7 +10,7 @@ import { updateStatus } from '@jbrowse/core/util'
 import { ObservableCreate } from '@jbrowse/core/util/rxjs'
 import { walksKept } from '@jbrowse/graph-walks'
 
-import { chainFeature, lanePairAligner, referenceAligner } from './walkLanes.ts'
+import { anchorAligner, chainFeature, lanePairAligner } from './walkLanes.ts'
 import { WalkIndex } from '../RgfaTabixAdapter/walkReader.ts'
 import { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'
 import { ComparativeAdapterBase } from '../synteny/ComparativeAdapterBase.ts'
@@ -168,7 +168,7 @@ export default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<Walk
       opts,
       `Reading walks ${region.refName}:${start.toLocaleString()}-${end.toLocaleString()}`,
     )
-    const align = referenceAligner(graph.nodes)
+    const align = anchorAligner(graph.nodes)
     const asmByPrefix = assemblyByPanSNPrefix(this)
     const references = fragments.filter(f => f.name === refName)
     // lanes come back in the order the fetch names them, which is the order

package/src/WalkTabixSyntenyAdapter/walkLanes.ts

@@ -173,20 +173,9 @@ function singleVisits(fragment: WalkFragment) {
   return rev
 }
 
-/**
- * Aligns one lane's walk fragment to another's. The weighted subsequence
- * (`referenceAligner`) is the fast route and matches through copy-number
- * arrays, but it reads one direction per pair, so an inversion between the
- * lanes comes out as an insertion beside a deletion. A pair sharing 100 bp
- * (MIN_MATCH_BP) or more of singly visited nodes in each direction goes to
- * pair chaining (`walkAligner`) instead, which answers the inverted stretch as
- * a reverse-strand record of its own. Chaining leaves out every node a walk
- * passes twice, so counting singly visited nodes misses no inversion it could
- * draw.
- */
-export function lanePairAligner(nodes: Map<number, WalkNode>) {
-  const subsequence = referenceAligner(nodes)
-  const chained = walkAligner(nodes)
+// The bases on singly visited nodes two walks pass the same way and the
+// opposite way
+function directionShares(nodes: Map<number, WalkNode>) {
   const visits = new Map<WalkFragment, Map<number, number>>()
   const visitsOf = (fragment: WalkFragment) => {
     let found = visits.get(fragment)
@@ -196,7 +185,7 @@ export function lanePairAligner(nodes: Map<number, WalkNode>) {
     }
     return found
   }
-  const inverted = (query: WalkFragment, target: WalkFragment) => {
+  return (query: WalkFragment, target: WalkFragment) => {
     const theirs = visitsOf(target)
     let same = 0
     let opposite = 0
@@ -208,12 +197,60 @@ export function lanePairAligner(nodes: Map<number, WalkNode>) {
         opposite += nodeLength(nodes, id)
       }
     }
-    return same >= MIN_MATCH_BP && opposite >= MIN_MATCH_BP
+    return { same, opposite }
   }
-  return (query: WalkFragment, target: WalkFragment) =>
-    inverted(query, target)
+}
+
+/**
+ * Aligns one lane's walk fragment to another's. The weighted subsequence
+ * (`referenceAligner`) is the fast route and matches through copy-number
+ * arrays, but it reads one direction per pair, so an inversion between the
+ * lanes comes out as an insertion beside a deletion. A pair sharing 100 bp
+ * (MIN_MATCH_BP) or more of singly visited nodes in each direction goes to
+ * pair chaining (`walkAligner`) instead, which answers the inverted stretch as
+ * a reverse-strand record of its own. Chaining leaves out every node a walk
+ * passes twice, so counting singly visited nodes misses no inversion it could
+ * draw.
+ */
+export function lanePairAligner(nodes: Map<number, WalkNode>) {
+  const subsequence = referenceAligner(nodes)
+  const chained = walkAligner(nodes)
+  const shares = directionShares(nodes)
+  return (query: WalkFragment, target: WalkFragment) => {
+    const { same, opposite } = shares(query, target)
+    return same >= MIN_MATCH_BP && opposite >= MIN_MATCH_BP
       ? chained(query, target)
       : subsequence(query, target)
+  }
+}
+
+// The multi-way display's SPLIT_AT_GAP_BP, under which a turned stretch names
+// no inversion there
+const TURNED_MIN_BP = 10_000
+
+/**
+ * Aligns a haplotype's walk fragment to the reference's as `referenceAligner`
+ * does, then adds the stretches it reads the other way. A walk sharing
+ * TURNED_MIN_BP or more of singly visited nodes in each direction is chained
+ * too, and the chained records on the strand the subsequence did not take are
+ * its turned stretches. The subsequence record stays, so a copy-number array,
+ * which chaining leaves out, still matches one pass alike in every lane.
+ */
+export function anchorAligner(nodes: Map<number, WalkNode>) {
+  const subsequence = referenceAligner(nodes)
+  const chained = walkAligner(nodes)
+  const shares = directionShares(nodes)
+  return (query: WalkFragment, target: WalkFragment) => {
+    const records = subsequence(query, target)
+    const taken = records[0]?.strand
+    const { same, opposite } = shares(query, target)
+    return taken === undefined || Math.min(same, opposite) < TURNED_MIN_BP
+      ? records
+      : [
+          ...records,
+          ...chained(query, target).filter(chain => chain.strand !== taken),
+        ]
+  }
 }
 
 /**

package/src/version.ts

@@ -1 +1 @@
-export const version = '7.2.1'
+export const version = '7.3.0'

package/dist/chunks/WalkTabixSyntenyAdapter-I3PY6HJ2.js

@@ -1,2 +0,0 @@
-import{a as V}from"./chunk-YKSUKPYY.js";import{b as X,d as z,e as G,f as O,g as K,h as U}from"./chunk-2O3YVA2I.js";import"./chunk-JCAZTNYG.js";import{a as D}from"./chunk-KOB7YIMR.js";import{p as M,q as _,r as $}from"./chunk-M2D7NUOY.js";import"./chunk-YBLNN5FU.js";import"./chunk-6KUHGRHU.js";import"./chunk-6MUBJVBG.js";import{e as j,p as q,r as H}from"./chunk-B2EP6FOQ.js";import"./chunk-YBLNN5FU.js";import"./chunk-MVVXRZXV.js";import{a as A,c as T,d as P,g as F,h as w,i as x}from"./chunk-7HWHWPRW.js";import"./chunk-T4R3ZVEM.js";import"./chunk-7WIBGKBU.js";import"./chunk-OGQ6OQDN.js";import"./chunk-NDRLCGPC.js";import{o as I}from"./chunk-TENPGIPX.js";var te=50;function ae(i){let o=[];for(let e=0;e<i.length;e++){let[t,n]=i[e],[r,a]=i[e+1]??[];n===a&&n<=te&&(t==="I"&&r==="D"||t==="D"&&r==="I")?(o.push(["X",n]),e++):o.push([t,n])}return o}function E(i){return Array.from(i.ids,(o,e)=>2*o+i.rev[e])}function W(i,o){let e=i.get(o);return e===void 0?0:e.end-e.start}function ne(i){let o=new Map,e=r=>{let a=W(i,r),s=o.get(a);return s===void 0&&(s="N".repeat(a),o.set(a,s)),s},t=new Map,n=r=>{let a=t.get(r);return a===void 0&&(a=E(r),t.set(r,a)),a};return(r,a)=>_({query:n(r),target:n(a),sequenceOf:e,bases:!1})}var B=100;function v(i,o,e){let t=i.at(-1);e>0&&(t?.[0]===o?t[1]+=e:i.push([o,e]))}function C(i){let o=t=>W(i,t>>1),e=t=>{let n=new Float64Array(t.length+1);return t.forEach((r,a)=>{n[a+1]=n[a]+o(r)}),n};return(t,n)=>{let r=E(n),a=E(t),[s,c]=M(a,r,o),[u,h]=M(a.map(b=>b^1).reverse(),r,o),m=h>c,p=m?u:s,g=Math.max(c,h);if(g<B)return[];let d=e(r),f=e(a),N=b=>m?a.length-1-p[b][0]:p[b][0],l=[];p.forEach(([,b],k)=>{if(k>0){let[J,Q]=[N(k-1),N(k)].sort((Y,ee)=>Y-ee);v(l,"I",f[Q]-f[J+1]),v(l,"D",d[b]-d[p[k-1][1]+1])}v(l,"=",o(r[b]))});let[y,S]=[N(0),N(p.length-1)].sort((b,k)=>b-k);return[{queryStart:f[y],queryEnd:f[S+1],targetStart:d[p[0][1]],targetEnd:d[p.at(-1)[1]+1],strand:m?"-":"+",edits:l,sharedBases:g}]}}function se(i){let o=new Map,e=new Set;i.ids.forEach((t,n)=>{o.has(t)?e.add(t):o.set(t,i.rev[n])});for(let t of e)o.delete(t);return o}function Z(i){let o=C(i),e=ne(i),t=new Map,n=a=>{let s=t.get(a);return s===void 0&&(s=se(a),t.set(a,s)),s},r=(a,s)=>{let c=n(s),u=0,h=0;for(let[m,p]of n(a)){let g=c.get(m);g===p?u+=W(i,m):g!==void 0&&(h+=W(i,m))}return u>=B&&h>=B};return(a,s)=>r(a,s)?e(a,s):o(a,s)}function L({chain:i,target:o,query:e,assemblyName:t,refName:n,mateAssemblyName:r}){let a=ae(i.edits);return U({target:{name:o.name,assemblyName:t,refName:n,start:o.hapStart+i.targetStart,end:o.hapStart+i.targetEnd},query:{name:e.name,assemblyName:r,refName:P(e.name),start:e.hapStart+i.queryStart,end:e.hapStart+i.queryEnd},strand:i.strand,cigar:$(a),matches:a.reduce((s,[c,u])=>s+(c==="="?u:0),0),columns:a.reduce((s,[,c])=>s+c,0)})}var re=i=>T(i.name)??i.name,R=class extends X{constructor(){super(...arguments);this.walks=new V(q(this,["walksLocation"],["walksIndex"]),this);this.refNames=new H(this.walks.file,this)}get anchor(){let e=this.getConf("assemblyNames")[0];if(e===void 0)throw new Error("WalkTabixSyntenyAdapter needs assemblyNames: its first entry is the assembly the reference sample is loaded as");return e}async getHaplotypeNames(e={}){return this.walks.haplotypeNames(e)}async getHeader(e={}){let{haplotypes:t}=await this.walks.reader.header(e),{anchor:n}=this,r=w(this,n),a=x(this);return{hasCoarseTier:!1,anchorAssemblyName:n,lanes:t.filter(s=>s!==r&&A(s)!==r).map(s=>({name:O(a,s),label:s,group:A(s)}))}}async getRefNames(e={}){let{assemblyName:t}=e;return t===void 0||t===this.anchor?this.refNames.assemblyRefNames({...e,assemblyName:this.anchor}):[]}async getSubgraph(e,t={}){let n=await this.refNames.resolve(e,{signal:t.signal});if(n===void 0)throw new Error(`${e.assemblyName} ${e.refName} is not in this graph's index; the graph is cut on ${this.anchor}, mapped to its PanSN prefix in assemblyNameToPanSN`);return this.walks.subgraph(n,e,t)}async laneWalks(e,t,n,r,a){return I(a,r.statusCallback,()=>this.walks.reader.cut(e,t,{...this.walks.budgets(),signal:r.signal,keep:j(n,e),links:!1}).catch(s=>{throw K(s,t.end-t.start)}))}async anchorFeatures(e,t,n){let r=n.haplotypes?.length?n.haplotypes.map(l=>w(this,l)):void 0,a=w(this,n.targetAssemblyName),s=a===void 0?r:r===void 0||r.some(l=>F(a,l)||F(l,a))?[a]:[];if(s?.length===0)return[];let{start:c,end:u}=t,{graph:h,fragments:m}=await this.laneWalks(e,t,s,n,`Reading walks ${t.refName}:${c.toLocaleString()}-${u.toLocaleString()}`),p=C(h.nodes),g=x(this),d=m.filter(l=>l.name===e),f=l=>s===void 0?0:s.findIndex(y=>F(l.name,y));return m.filter(l=>l.name!==e&&f(l)>=0).sort((l,y)=>f(l)-f(y)).flatMap(l=>d.flatMap(y=>p(l,y).map(S=>L({chain:S,target:y,query:l,assemblyName:t.assemblyName,refName:t.refName,mateAssemblyName:O(g,re(l))}))))}async pairFeatures(e,t,n,r){let a=n.map(m=>({pair:m,featurePrefix:w(this,m.queryAssemblyName),matePrefix:w(this,m.targetAssemblyName)})),{graph:s,fragments:c}=await this.laneWalks(e,t,a.flatMap(m=>[m.featurePrefix,m.matePrefix]),r,G(n)),u=Z(s.nodes),h=m=>c.filter(p=>F(p.name,m));return a.flatMap(({pair:m,featurePrefix:p,matePrefix:g})=>h(p).flatMap(d=>h(g).flatMap(f=>u(f,d).map(N=>L({chain:N,target:d,query:f,assemblyName:m.queryAssemblyName,refName:P(d.name),mateAssemblyName:m.targetAssemblyName})))))}getFeatures(e,t={}){return D(async n=>{let r=e.assemblyName===this.anchor?await this.refNames.resolve(e,t):void 0;if(r!==void 0){let a=z(t),s=a.length>0?await this.pairFeatures(r,e,a,t):await this.anchorFeatures(r,e,t);for(let c of s)n.next(c)}n.complete()},t.signal)}};export{R as default};
-//# sourceMappingURL=WalkTabixSyntenyAdapter-I3PY6HJ2.js.map

package/dist/chunks/WalkTabixSyntenyAdapter-I3PY6HJ2.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/WalkTabixSyntenyAdapter/walkLanes.ts", "../../src/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.ts"],
-  "sourcesContent": ["import { weightedLcs } from '@gmod/gbz-base/lcs'\nimport { pairAlignments, pairCigar } from '@gmod/gbz-base/pairAlignment'\nimport { panSNContig } from '@jbrowse/bandage-core/pansn'\n\nimport { matchFeature } from '../synteny/matchFeature.ts'\n\nimport type { PairChain, PairEdit } from '@gmod/gbz-base/pairAlignment'\nimport type { WalkFragment, WalkNode } from '@jbrowse/graph-walks'\n\n// The longest bubble with equal bases on both sides that is written as\n// mismatches; a longer one stays an insertion and a deletion\nconst BALANCED_BUBBLE_MAX_BP = 50\n\n/**\n * A chain's edits with each short balanced bubble as `X`. The walks carry no\n * bases, so two walks differ wherever they leave a shared node, and a SNP is\n * one base inserted and one deleted until it is read as the mismatch it is.\n */\nexport function bubblesAsMismatches(edits: PairEdit[]) {\n  const out: PairEdit[] = []\n  for (let i = 0; i < edits.length; i++) {\n    const [op, len] = edits[i]!\n    const [nextOp, nextLen] = edits[i + 1] ?? []\n    if (\n      len === nextLen &&\n      len <= BALANCED_BUBBLE_MAX_BP &&\n      ((op === 'I' && nextOp === 'D') || (op === 'D' && nextOp === 'I'))\n    ) {\n      out.push(['X', len])\n      i++\n    } else {\n      out.push([op, len])\n    }\n  }\n  return out\n}\n\n// A walk's steps as the handles gbz-base reads, 2 * id + reversed\nfunction handlesOf(fragment: WalkFragment) {\n  return Array.from(fragment.ids, (id, i) => 2 * id + fragment.rev[i]!)\n}\n\nfunction nodeLength(nodes: Map<number, WalkNode>, id: number) {\n  const node = nodes.get(id)\n  return node === undefined ? 0 : node.end - node.start\n}\n\n/**\n * Aligns one walk fragment to another on the nodes both visit, from node\n * lengths alone: the fragments' steps as the handles gbz-base's chainer reads,\n * and a stand-in sequence of each node's length.\n */\nexport function walkAligner(nodes: Map<number, WalkNode>) {\n  const standIn = new Map<number, string>()\n  const sequenceOf = (id: number) => {\n    const length = nodeLength(nodes, id)\n    let sequence = standIn.get(length)\n    if (sequence === undefined) {\n      sequence = 'N'.repeat(length)\n      standIn.set(length, sequence)\n    }\n    return sequence\n  }\n  const handles = new Map<WalkFragment, number[]>()\n  const cachedHandles = (fragment: WalkFragment) => {\n    let steps = handles.get(fragment)\n    if (steps === undefined) {\n      steps = handlesOf(fragment)\n      handles.set(fragment, steps)\n    }\n    return steps\n  }\n  return (query: WalkFragment, target: WalkFragment) =>\n    pairAlignments({\n      query: cachedHandles(query),\n      target: cachedHandles(target),\n      sequenceOf,\n      bases: false,\n    })\n}\n\n// The fewest bases on shared nodes a record against the reference keeps,\n// gbz-base's floor for a pair record\nconst MIN_MATCH_BP = 100\n\nfunction appendEdit(edits: PairEdit[], op: PairEdit[0], len: number) {\n  const last = edits.at(-1)\n  if (len > 0) {\n    if (last?.[0] === op) {\n      last[1] += len\n    } else {\n      edits.push([op, len])\n    }\n  }\n}\n\n/**\n * Aligns a haplotype's walk fragment to the reference's as gbz-base aligns a\n * walk to its reference path: the heaviest common subsequence of their steps,\n * each node weighing its length, read in whichever direction shares more. A\n * pair chain leaves out every node either walk passes twice, which is the\n * whole of a collapsed copy-number array (amylase, KIV-2); the subsequence\n * matches one pass over it, and the other copies are insertions.\n */\nexport function referenceAligner(nodes: Map<number, WalkNode>) {\n  const lengthOf = (handle: number) => nodeLength(nodes, handle >> 1)\n  const offsets = (handles: number[]) => {\n    const out = new Float64Array(handles.length + 1)\n    handles.forEach((handle, i) => {\n      out[i + 1] = out[i]! + lengthOf(handle)\n    })\n    return out\n  }\n\n  return (query: WalkFragment, target: WalkFragment): PairChain[] => {\n    const ref = handlesOf(target)\n    const hap = handlesOf(query)\n    const [same, sameWeight] = weightedLcs(hap, ref, lengthOf)\n    const [turned, turnedWeight] = weightedLcs(\n      hap.map(handle => handle ^ 1).reverse(),\n      ref,\n      lengthOf,\n    )\n    const reverse = turnedWeight > sameWeight\n    const pairs = reverse ? turned : same\n    const sharedBases = Math.max(sameWeight, turnedWeight)\n    if (sharedBases < MIN_MATCH_BP) {\n      return []\n    }\n    const refAt = offsets(ref)\n    const hapAt = offsets(hap)\n    // a pair's haplotype step, counted along the haplotype\n    const stepOf = (k: number) =>\n      reverse ? hap.length - 1 - pairs[k]![0] : pairs[k]![0]\n    const edits: PairEdit[] = []\n    pairs.forEach(([, r], k) => {\n      if (k > 0) {\n        const [lo, hi] = [stepOf(k - 1), stepOf(k)].sort((x, y) => x - y)\n        appendEdit(edits, 'I', hapAt[hi!]! - hapAt[lo! + 1]!)\n        appendEdit(edits, 'D', refAt[r]! - refAt[pairs[k - 1]![1] + 1]!)\n      }\n      appendEdit(edits, '=', lengthOf(ref[r]!))\n    })\n    const [lo, hi] = [stepOf(0), stepOf(pairs.length - 1)].sort((x, y) => x - y)\n    return [\n      {\n        queryStart: hapAt[lo!]!,\n        queryEnd: hapAt[hi! + 1]!,\n        targetStart: refAt[pairs[0]![1]]!,\n        targetEnd: refAt[pairs.at(-1)![1] + 1]!,\n        strand: reverse ? '-' : '+',\n        edits,\n        sharedBases,\n      },\n    ]\n  }\n}\n\n// Each node a walk visits once, with the direction it passes it\nfunction singleVisits(fragment: WalkFragment) {\n  const rev = new Map<number, number>()\n  const twice = new Set<number>()\n  fragment.ids.forEach((id, i) => {\n    if (rev.has(id)) {\n      twice.add(id)\n    } else {\n      rev.set(id, fragment.rev[i]!)\n    }\n  })\n  for (const id of twice) {\n    rev.delete(id)\n  }\n  return rev\n}\n\n/**\n * Aligns one lane's walk fragment to another's. The weighted subsequence\n * (`referenceAligner`) is the fast route and matches through copy-number\n * arrays, but it reads one direction per pair, so an inversion between the\n * lanes comes out as an insertion beside a deletion. A pair sharing 100 bp\n * (MIN_MATCH_BP) or more of singly visited nodes in each direction goes to\n * pair chaining (`walkAligner`) instead, which answers the inverted stretch as\n * a reverse-strand record of its own. Chaining leaves out every node a walk\n * passes twice, so counting singly visited nodes misses no inversion it could\n * draw.\n */\nexport function lanePairAligner(nodes: Map<number, WalkNode>) {\n  const subsequence = referenceAligner(nodes)\n  const chained = walkAligner(nodes)\n  const visits = new Map<WalkFragment, Map<number, number>>()\n  const visitsOf = (fragment: WalkFragment) => {\n    let found = visits.get(fragment)\n    if (found === undefined) {\n      found = singleVisits(fragment)\n      visits.set(fragment, found)\n    }\n    return found\n  }\n  const inverted = (query: WalkFragment, target: WalkFragment) => {\n    const theirs = visitsOf(target)\n    let same = 0\n    let opposite = 0\n    for (const [id, rev] of visitsOf(query)) {\n      const other = theirs.get(id)\n      if (other === rev) {\n        same += nodeLength(nodes, id)\n      } else if (other !== undefined) {\n        opposite += nodeLength(nodes, id)\n      }\n    }\n    return same >= MIN_MATCH_BP && opposite >= MIN_MATCH_BP\n  }\n  return (query: WalkFragment, target: WalkFragment) =>\n    inverted(query, target)\n      ? chained(query, target)\n      : subsequence(query, target)\n}\n\n/**\n * One record of a walk aligned to another, with its short balanced bubbles as\n * mismatches\n */\nexport function chainFeature({\n  chain,\n  target,\n  query,\n  assemblyName,\n  refName,\n  mateAssemblyName,\n}: {\n  chain: PairChain\n  target: WalkFragment\n  query: WalkFragment\n  assemblyName: string\n  refName: string\n  mateAssemblyName: string\n}) {\n  const edits = bubblesAsMismatches(chain.edits)\n  return matchFeature({\n    target: {\n      name: target.name,\n      assemblyName,\n      refName,\n      start: target.hapStart + chain.targetStart,\n      end: target.hapStart + chain.targetEnd,\n    },\n    query: {\n      name: query.name,\n      assemblyName: mateAssemblyName,\n      refName: panSNContig(query.name),\n      start: query.hapStart + chain.queryStart,\n      end: query.hapStart + chain.queryEnd,\n    },\n    strand: chain.strand,\n    cigar: pairCigar(edits),\n    matches: edits.reduce((sum, [op, n]) => sum + (op === '=' ? n : 0), 0),\n    columns: edits.reduce((sum, [, n]) => sum + n, 0),\n  })\n}\n", "import {\n  assemblyByPanSNPrefix,\n  panSNContig,\n  panSNHaplotype,\n  panSNMatchesPrefix,\n  panSNSample,\n  resolvePanSNPrefix,\n} from '@jbrowse/bandage-core/pansn'\nimport { updateStatus } from '@jbrowse/core/util'\nimport { ObservableCreate } from '@jbrowse/core/util/rxjs'\nimport { walksKept } from '@jbrowse/graph-walks'\n\nimport { chainFeature, lanePairAligner, referenceAligner } from './walkLanes.ts'\nimport { WalkIndex } from '../RgfaTabixAdapter/walkReader.ts'\nimport { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'\nimport { ComparativeAdapterBase } from '../synteny/ComparativeAdapterBase.ts'\nimport {\n  laneAssemblyName,\n  lanePairsStatus,\n  requestedPairs,\n} from '../synteny/lanePairs.ts'\nimport { laneZoomNotice } from '../synteny/laneZoomNotice.ts'\n\nimport type { WalkTabixSyntenyAdapterConfig } from './configSchema.ts'\nimport type { SubgraphAdapterOptions } from '../GetSubgraph.ts'\nimport type { LaneFeatureOptions, LanePair } from '../synteny/lanePairs.ts'\nimport type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'\nimport type { Feature } from '@jbrowse/core/util'\nimport type { Region } from '@jbrowse/core/util/types'\nimport type { WalkFragment } from '@jbrowse/graph-walks'\n\nconst haplotypeOf = (fragment: WalkFragment) =>\n  panSNHaplotype(fragment.name) ?? fragment.name\n\nexport default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<WalkTabixSyntenyAdapterConfig> {\n  private readonly walks: WalkIndex = new WalkIndex(\n    openTabixSlot(this, ['walksLocation'], ['walksIndex']),\n    this,\n  )\n  private readonly refNames: PanSNRefNames = new PanSNRefNames(\n    this.walks.file,\n    this,\n  )\n\n  private get anchor() {\n    const anchor = this.getConf('assemblyNames')[0]\n    if (anchor === undefined) {\n      throw new Error(\n        'WalkTabixSyntenyAdapter needs assemblyNames: its first entry is the assembly the reference sample is loaded as',\n      )\n    }\n    return anchor\n  }\n\n  /**\n   * The haplotypes the walk file's header names, `sample#haplotype` in byte\n   * order, or undefined when it names none\n   */\n  async getHaplotypeNames(opts: BaseOptions = {}) {\n    return this.walks.haplotypeNames(opts)\n  }\n\n  /**\n   * `lanes` is every haplotype the header names but the anchor's own,\n   * declared up front so the display can offer the whole graph's haplotypes\n   * before a fetch has placed any of them\n   */\n  async getHeader(opts: BaseOptions = {}) {\n    const { haplotypes } = await this.walks.reader.header(opts)\n    const { anchor } = this\n    const anchorPrefix = resolvePanSNPrefix(this, anchor)\n    const asmByPrefix = assemblyByPanSNPrefix(this)\n    return {\n      hasCoarseTier: false,\n      anchorAssemblyName: anchor,\n      lanes: haplotypes\n        .filter(\n          prefix =>\n            prefix !== anchorPrefix && panSNSample(prefix) !== anchorPrefix,\n        )\n        .map(prefix => ({\n          name: laneAssemblyName(asmByPrefix, prefix),\n          label: prefix,\n          group: panSNSample(prefix),\n        })),\n    }\n  }\n\n  // A lane's contigs are named only in its walk rows, so only the anchor's\n  // are listed\n  async getRefNames(opts: BaseOptions = {}) {\n    const { assemblyName } = opts\n    return assemblyName === undefined || assemblyName === this.anchor\n      ? this.refNames.assemblyRefNames({ ...opts, assemblyName: this.anchor })\n      : []\n  }\n\n  /**\n   * The graph display's cut of the window, as RgfaTabixAdapter cuts a\n   * walk-indexed graph: the reference walk first, then the walks `haplotypes`\n   * asks for, and the nodes and links they visit\n   */\n  async getSubgraph(region: Region, opts: SubgraphAdapterOptions = {}) {\n    const refName = await this.refNames.resolve(region, { signal: opts.signal })\n    if (refName === undefined) {\n      throw new Error(\n        `${region.assemblyName} ${region.refName} is not in this graph's index; the graph is cut on ${this.anchor}, mapped to its PanSN prefix in assemblyNameToPanSN`,\n      )\n    }\n    return this.walks.subgraph(refName, region, opts)\n  }\n\n  // The window's walks for the haplotypes named and the reference, with no\n  // link read; a window past a budget fails as a zoom-in notice for lanes\n  private async laneWalks(\n    refName: string,\n    region: Region,\n    prefixes: string[] | undefined,\n    opts: LaneFeatureOptions,\n    status: string,\n  ) {\n    return updateStatus(status, opts.statusCallback, () =>\n      this.walks.reader\n        .cut(refName, region, {\n          ...this.walks.budgets(),\n          signal: opts.signal,\n          keep: walksKept(prefixes, refName),\n          links: false,\n        })\n        .catch((error: unknown) => {\n          throw laneZoomNotice(error, region.end - region.start)\n        }),\n    )\n  }\n\n  /**\n   * One record per stretch a haplotype's walk shares with the reference's,\n   * on the reference with the haplotype as its mate\n   */\n  private async anchorFeatures(\n    refName: string,\n    region: Region,\n    opts: LaneFeatureOptions,\n  ) {\n    const wanted = opts.haplotypes?.length\n      ? opts.haplotypes.map(lane => resolvePanSNPrefix(this, lane))\n      : undefined\n    const target = resolvePanSNPrefix(this, opts.targetAssemblyName)\n    const prefixes =\n      target === undefined\n        ? wanted\n        : wanted === undefined ||\n            wanted.some(\n              prefix =>\n                panSNMatchesPrefix(target, prefix) ||\n                panSNMatchesPrefix(prefix, target),\n            )\n          ? [target]\n          : []\n    if (prefixes?.length === 0) {\n      return []\n    }\n    const { start, end } = region\n    const { graph, fragments } = await this.laneWalks(\n      refName,\n      region,\n      prefixes,\n      opts,\n      `Reading walks ${region.refName}:${start.toLocaleString()}-${end.toLocaleString()}`,\n    )\n    const align = referenceAligner(graph.nodes)\n    const asmByPrefix = assemblyByPanSNPrefix(this)\n    const references = fragments.filter(f => f.name === refName)\n    // lanes come back in the order the fetch names them, which is the order\n    // the display stacks lanes of equal weight in\n    const rank = (fragment: WalkFragment) =>\n      prefixes === undefined\n        ? 0\n        : prefixes.findIndex(prefix =>\n            panSNMatchesPrefix(fragment.name, prefix),\n          )\n    const shown = fragments\n      .filter(fragment => fragment.name !== refName && rank(fragment) >= 0)\n      .sort((a, b) => rank(a) - rank(b))\n    return shown.flatMap(query =>\n      references.flatMap(reference =>\n        align(query, reference).map(chain =>\n          chainFeature({\n            chain,\n            target: reference,\n            query,\n            assemblyName: region.assemblyName,\n            refName: region.refName,\n            mateAssemblyName: laneAssemblyName(asmByPrefix, haplotypeOf(query)),\n          }),\n        ),\n      ),\n    )\n  }\n\n  /**\n   * Each pair's two lanes read out of the anchor window, all pairs in one\n   * read, and each walk of a pair's query lane aligned to each walk of its\n   * target lane. A pair's records sit on its query lane's contigs, the lane\n   * the display draws on top.\n   */\n  private async pairFeatures(\n    refName: string,\n    region: Region,\n    pairs: LanePair[],\n    opts: LaneFeatureOptions,\n  ) {\n    const sides = pairs.map(pair => ({\n      pair,\n      featurePrefix: resolvePanSNPrefix(this, pair.queryAssemblyName),\n      matePrefix: resolvePanSNPrefix(this, pair.targetAssemblyName),\n    }))\n    const { graph, fragments } = await this.laneWalks(\n      refName,\n      region,\n      sides.flatMap(side => [side.featurePrefix, side.matePrefix]),\n      opts,\n      lanePairsStatus(pairs),\n    )\n    const align = lanePairAligner(graph.nodes)\n    const walksOf = (prefix: string) =>\n      fragments.filter(f => panSNMatchesPrefix(f.name, prefix))\n    return sides.flatMap(({ pair, featurePrefix, matePrefix }) =>\n      walksOf(featurePrefix).flatMap(target =>\n        walksOf(matePrefix).flatMap(query =>\n          align(query, target).map(chain =>\n            chainFeature({\n              chain,\n              target,\n              query,\n              assemblyName: pair.queryAssemblyName,\n              refName: panSNContig(target.name),\n              mateAssemblyName: pair.targetAssemblyName,\n            }),\n          ),\n        ),\n      ),\n    )\n  }\n\n  // The files are filed under the reference alone, so a window on a\n  // haplotype lane has no answer: a lane pair is read inside the anchor's\n  getFeatures(region: Region, opts: LaneFeatureOptions = {}) {\n    return ObservableCreate<Feature>(async observer => {\n      const refName =\n        region.assemblyName === this.anchor\n          ? await this.refNames.resolve(region, opts)\n          : undefined\n      if (refName !== undefined) {\n        const pairs = requestedPairs(opts)\n        const features =\n          pairs.length > 0\n            ? await this.pairFeatures(refName, region, pairs, opts)\n            : await this.anchorFeatures(refName, region, opts)\n        for (const feature of features) {\n          observer.next(feature)\n        }\n      }\n      observer.complete()\n    }, opts.signal)\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["BALANCED_BUBBLE_MAX_BP", "bubblesAsMismatches", "edits", "out", "i", "op", "len", "nextOp", "nextLen", "handlesOf", "fragment", "id", "nodeLength", "nodes", "node", "walkAligner", "standIn", "sequenceOf", "length", "sequence", "handles", "cachedHandles", "steps", "query", "target", "pairAlignments", "MIN_MATCH_BP", "appendEdit", "last", "referenceAligner", "lengthOf", "handle", "offsets", "ref", "hap", "same", "sameWeight", "weightedLcs", "turned", "turnedWeight", "reverse", "pairs", "sharedBases", "refAt", "hapAt", "stepOf", "k", "r", "lo", "hi", "x", "y", "singleVisits", "rev", "twice", "lanePairAligner", "subsequence", "chained", "visits", "visitsOf", "found", "inverted", "theirs", "opposite", "other", "chainFeature", "chain", "assemblyName", "refName", "mateAssemblyName", "matchFeature", "panSNContig", "pairCigar", "sum", "n", "haplotypeOf", "fragment", "panSNHaplotype", "WalkTabixSyntenyAdapter", "ComparativeAdapterBase", "WalkIndex", "openTabixSlot", "PanSNRefNames", "anchor", "opts", "haplotypes", "anchorPrefix", "resolvePanSNPrefix", "asmByPrefix", "assemblyByPanSNPrefix", "prefix", "panSNSample", "laneAssemblyName", "assemblyName", "region", "refName", "prefixes", "status", "updateStatus", "walksKept", "error", "laneZoomNotice", "wanted", "lane", "target", "panSNMatchesPrefix", "start", "end", "graph", "fragments", "align", "referenceAligner", "references", "f", "rank", "a", "b", "query", "reference", "chain", "chainFeature", "pairs", "sides", "pair", "side", "lanePairsStatus", "lanePairAligner", "walksOf", "featurePrefix", "matePrefix", "panSNContig", "ObservableCreate", "observer", "requestedPairs", "features", "feature"]
-}