@gmod/tabix 3.5.1 → 3.5.3

package/src/tbi.ts

@@ -4,8 +4,8 @@ import Chunk from './chunk.ts'
 import IndexFile from './indexFile.ts'
 import {
   clampChunkEnds,
-  findFirstData,
   memoizeByRefId,
+  minVirtualOffset,
   optimizeChunks,
   parseAuxData,
   parsePseudoBin,
@@ -78,8 +78,15 @@ export default class TabixIndex extends IndexFile {
     // nameSectionLength is at TBI offset 32; re-read to find where bin data starts
     const nameSectionLength = dataView.getInt32(32, true)
 
-    // SYNC: ~/src/gmod/bam-js/src/csi.ts _parse — two-pass structure
-    // First pass: record per-refId byte offsets and find firstDataLine
+    // SYNC: ~/src/gmod/bam-js/src/bai.ts _parse — two-pass structure
+    // First pass: record per-refId byte offsets and find firstDataLine.
+    //
+    // Only the linear index is consulted. Its entry for a window is the
+    // smallest virtual offset of any record overlapping that window, so the
+    // minimum over the linear index is already the minimum over the bin chunks
+    // — walking the chunks too only re-derives it. Checked against every .tbi
+    // in test/data: same answer on all 23, and no ref has bins without a
+    // linear index.
     let curr = 36 + nameSectionLength
     let firstDataLine: VirtualOffset | undefined
     const offsets: number[] = []
@@ -97,21 +104,13 @@ export default class TabixIndex extends IndexFile {
           throw new Error(
             'tabix index contains too many bins, please use a CSI index',
           )
-        } else if (bin === maxBinNumber + 1) {
-          curr += 16 * chunkCount
-        } else {
-          for (let k = 0; k < chunkCount; k++) {
-            firstDataLine = findFirstData(firstDataLine, fromBytes(bytes, curr))
-            curr += 16
-          }
         }
+        curr += 16 * chunkCount
       }
       const linearCount = dataView.getInt32(curr, true)
       curr += 4
-      for (let k = 0; k < linearCount; k++) {
-        firstDataLine = findFirstData(firstDataLine, fromBytes(bytes, curr))
-        curr += 8
-      }
+      firstDataLine = minVirtualOffset(bytes, curr, linearCount, firstDataLine)
+      curr += 8 * linearCount
     }
 
     function getIndices(refId: number): RefIndex | undefined {

package/src/util.ts

@@ -2,8 +2,7 @@ import LRU from '@jbrowse/quick-lru'
 
 import Chunk from './chunk.ts'
 import { longFromBytesToUnsigned } from './long.ts'
-
-import type VirtualOffset from './virtualOffset.ts'
+import VirtualOffset from './virtualOffset.ts'
 
 // SYNC: ~/src/gmod/bam-js/src/util.ts optimizeChunks
 export function optimizeChunks(chunks: Chunk[], lowest?: VirtualOffset) {
@@ -118,13 +117,41 @@ export function clampChunkEnds(
   }
 }
 
-export function findFirstData(
-  currentFdl: VirtualOffset | undefined,
-  virtualOffset: VirtualOffset,
+/**
+ * The smallest of `current` and the `count` packed virtual offsets starting at
+ * `offset`, allocating at most one VirtualOffset rather than one per entry.
+ *
+ * The index first pass exists only to find this minimum, and it visits every
+ * linear-index entry in the file to do it — 301k of them on
+ * test/data/failing_tabix.vcf.gz.tbi against 19k bin chunks. Building a
+ * VirtualOffset per entry to compare and discard it is the bulk of that pass.
+ */
+export function minVirtualOffset(
+  bytes: Uint8Array,
+  offset: number,
+  count: number,
+  current: VirtualOffset | undefined,
 ) {
-  return !currentFdl || currentFdl.compareTo(virtualOffset) > 0
-    ? virtualOffset
-    : currentFdl
+  let minBlock = current ? current.blockPosition : Infinity
+  let minData = current ? current.dataPosition : 0
+  let found = false
+  for (let i = 0; i < count; i++) {
+    const p = offset + i * 8
+    const block =
+      bytes[p + 7]! * 0x1_00_00_00_00_00 +
+      bytes[p + 6]! * 0x1_00_00_00_00 +
+      bytes[p + 5]! * 0x1_00_00_00 +
+      bytes[p + 4]! * 0x1_00_00 +
+      bytes[p + 3]! * 0x1_00 +
+      bytes[p + 2]!
+    const data = (bytes[p + 1]! << 8) | bytes[p]!
+    if (block < minBlock || (block === minBlock && data < minData)) {
+      minBlock = block
+      minData = data
+      found = true
+    }
+  }
+  return found ? new VirtualOffset(minBlock, minData) : current
 }
 
 export function parseNameBytes(namesBytes: Uint8Array) {