@gmod/bam 7.8.1 → 7.9.0

package/src/bai.ts

@@ -33,12 +33,20 @@ const BAI_MAGIC = 21578050 // BAI\1
 // https://github.com/samtools/hts-specs/blob/master/SAMv1.pdf
 const BAI_LINEAR_SHIFT = 14
 const BAI_LINEAR_INTERVAL = 1 << BAI_LINEAR_SHIFT // 16384
+const BAI_DEPTH = 5
+// Highest coordinate the scheme addresses: the deepest level's bins are
+// BAI_LINEAR_INTERVAL wide and there are 8^BAI_DEPTH of them.
+const BAI_MAX_POS = 2 ** (BAI_LINEAR_SHIFT + BAI_DEPTH * 3) // 2^29
 
 function roundDown(n: number, multiple: number) {
   return n - (n % multiple)
 }
+// Note the `rem === 0` case: without it a coordinate already on a window
+// boundary rounds up a whole extra window, which is enough to push indexCov's
+// range past the end of the linear index.
 function roundUp(n: number, multiple: number) {
-  return n - (n % multiple) + multiple
+  const rem = n % multiple
+  return rem === 0 ? n : n - rem + multiple
 }
 
 export interface IndexCovEntry {
@@ -50,6 +58,19 @@ export interface IndexCovEntry {
 // Compute bin ranges that overlap [beg, end). Each level's first-bin offset
 // is (8^L - 1) / 7. See SAMv1.pdf §5.1.1 for the binning derivation.
 function reg2bins(beg: number, end: number) {
+  // Clamp to what the scheme can address, the way CSI's reg2bins clamps to
+  // its own. The shifts below are the `>>` operator, so a coordinate past
+  // 2^31 wraps to a negative bin number and every level yields an empty
+  // range: `getRecordsForRange(chr, 0, 2**32)` — a caller asking for a whole
+  // reference without knowing its length — came back with NO records at all
+  // rather than all of them. Clamping is also what keeps a merely-large end
+  // from walking ~130k absent bin numbers before finding the same chunks.
+  if (beg > BAI_MAX_POS) {
+    beg = BAI_MAX_POS
+  }
+  if (end > BAI_MAX_POS) {
+    end = BAI_MAX_POS
+  }
   end -= 1
   return [
     [0, 0],
@@ -76,8 +97,7 @@ export default class BAI extends IndexFile<BaiParsed> {
     }
 
     const refCount = dataView.getInt32(4, true)
-    const depth = 5
-    const binLimit = ((1 << ((depth + 1) * 3)) - 1) / 7
+    const binLimit = ((1 << ((BAI_DEPTH + 1) * 3)) - 1) / 7
 
     // read the indexes for each reference sequence
     let curr = 8
@@ -100,11 +120,9 @@ export default class BAI extends IndexFile<BaiParsed> {
           throw new Error('bai index contains too many bins, please use CSI')
         } else {
           const chunkCount = dataView.getInt32(curr, true)
-          curr += 4
-          for (let k = 0; k < chunkCount; k++) {
-            curr += 8
-            curr += 8
-          }
+          // 16 bytes per chunk (two virtual offsets); the first pass only
+          // needs to step over them. Same shape as csi.ts's first pass.
+          curr += 4 + 16 * chunkCount
         }
       }
 
@@ -199,7 +217,6 @@ export default class BAI extends IndexFile<BaiParsed> {
     opts?: BaseOpts,
   ): Promise<IndexCovEntry[]> {
     const v = BAI_LINEAR_INTERVAL
-    const range = start !== undefined
     const indexData = await this.parse(opts)
     const seqIdx = indexData.indices(seqId)
 
@@ -211,15 +228,24 @@ export default class BAI extends IndexFile<BaiParsed> {
     if (nintv === 0) {
       return []
     }
-    const e = end === undefined ? (nintv - 1) * v : roundUp(end, v)
-    const s = start === undefined ? 0 : roundDown(start, v)
-    const depths: IndexCovEntry[] = range
-      ? new Array((e - s) / v)
-      : new Array(nintv - 1)
-    const totalSize = linearBlockPositions[nintv - 1]!
-    if (e > (nintv - 1) * v) {
-      throw new Error('query outside of range of linear index')
+    // The linear index describes [0, indexEnd): each window's score is the gap
+    // to the NEXT entry, so the final entry is a boundary rather than a window
+    // of its own. Both ends are clamped to it instead of throwing, so a range
+    // query returns the part of the reference the index covers — asking for the
+    // whole reference by its length (`indexCov(ref, 0, ctgLength)`, the obvious
+    // call, and one where end lands in the last window) used to throw "query
+    // outside of range of linear index" while `indexCov(ref)` answered fine.
+    const indexEnd = (nintv - 1) * v
+    const s =
+      start === undefined
+        ? 0
+        : Math.min(Math.max(roundDown(start, v), 0), indexEnd)
+    const e = end === undefined ? indexEnd : Math.min(roundUp(end, v), indexEnd)
+    if (e <= s) {
+      return []
     }
+    const depths: IndexCovEntry[] = new Array((e - s) / v)
+    const totalSize = linearBlockPositions[nintv - 1]!
     // Scale the block-delta into a read count as we go, rather than building the
     // entries and then rebuilding every one of them to apply the scale. Keep the
     // multiply-then-divide order: hoisting lineCount/totalSize into a factor

package/src/bamFile.ts

@@ -37,10 +37,13 @@ export const BAM_MAGIC = 21840194
 
 const blockLen = 1 << 16
 
-// Ceiling on the header read. A million contigs is roughly 10MB of compressed
-// @SQ lines and ref-seq table, so anything past this is a corrupt header
-// claiming a huge n_ref rather than a real one, and growing the read further
-// just downloads the file.
+// Ceiling on GROWING the header read. A million contigs is roughly 10MB of
+// compressed @SQ lines and ref-seq table, so a read that has doubled past this
+// is chasing a corrupt header claiming a huge n_ref rather than a real one, and
+// growing further just downloads the file. It does not cap the FIRST read: that
+// length comes from the index's firstDataLine, which is a real offset rather
+// than a guess, so a header that genuinely runs past this still gets its one
+// exact read. See getHeaderPre.
 const maxHeaderReadLen = 32 * 1024 * 1024
 
 function resolveFilehandle(
@@ -118,12 +121,24 @@ export const DEFAULT_MAX_CACHE_BYTES = 100 * 1024 * 1024
 const MAX_CONCURRENT_CHUNK_READS = 6
 
 class ChunkFeatureCache<T> {
-  public maxBytes: number
+  private _maxBytes: number
   private entries = new Map<string, ChunkEntry<T>>()
   private bytes = 0
 
   constructor(maxBytes: number) {
-    this.maxBytes = maxBytes
+    this._maxBytes = maxBytes
+  }
+
+  get maxBytes() {
+    return this._maxBytes
+  }
+
+  // Accessor rather than a plain field so lowering the budget frees memory now.
+  // As a field, a caller trimming the cache under memory pressure got nothing
+  // back until the next chunk read happened to call set().
+  set maxBytes(maxBytes: number) {
+    this._maxBytes = maxBytes
+    this.evict()
   }
 
   get size() {
@@ -148,11 +163,15 @@ class ChunkFeatureCache<T> {
     this.delete(key)
     this.entries.set(key, entry)
     this.bytes += entry.bytes
-    // Evict from the least-recently-used end. The size > 1 guard means a single
-    // chunk larger than the whole budget is still kept: the caller needs it for
-    // the query in flight, and dropping it would only force a re-decompress.
+    this.evict()
+  }
+
+  // Evict from the least-recently-used end. The size > 1 guard means a single
+  // chunk larger than the whole budget is still kept: the caller needs it for
+  // the query in flight, and dropping it would only force a re-decompress.
+  private evict() {
     const lru = this.entries.keys()
-    while (this.bytes > this.maxBytes && this.entries.size > 1) {
+    while (this.bytes > this._maxBytes && this.entries.size > 1) {
       this.delete(lru.next().value!)
     }
   }
@@ -285,16 +304,21 @@ export default class BamFile<T extends BamRecordLike = BAMFeature> {
         ? blockLen
         : indexData.firstDataLine.blockPosition + blockLen
 
+    // do/while, so the index-derived length is always read once and only the
+    // doubling is bounded. Testing readLen before the first read instead meant
+    // a BAM whose header genuinely exceeds maxHeaderReadLen — millions of
+    // contigs — was rejected without a single byte being fetched, and reported
+    // as 'Insufficient data for reference sequences' when the data was there.
     let samHeader
-    let atEof = false
-    while (samHeader === undefined && !atEof && readLen <= maxHeaderReadLen) {
+    let atEof: boolean
+    do {
       const buffer = await this.bam.read(readLen, 0, { signal: opts.signal })
       // a short read means readLen ran past the end of the file, so there are
       // no more bytes to grow into
       atEof = buffer.length < readLen
       samHeader = this.applyHeader(await unzip(buffer))
       readLen *= 2
-    }
+    } while (samHeader === undefined && !atEof && readLen <= maxHeaderReadLen)
     if (samHeader === undefined) {
       throw new Error('Insufficient data for reference sequences')
     }
@@ -499,9 +523,7 @@ export default class BamFile<T extends BamRecordLike = BAMFeature> {
       // unbarriered pool exactly as before. That caps the cost of being wrong
       // at 0.92x-0.95x, against 0.82x-0.88x for barriering every wave.
       const batch = Math.min(MAX_CONCURRENT_CHUNK_READS, chunks.length)
-      await Promise.all(
-        Array.from({ length: batch }, (_, ci) => readOne(ci)),
-      )
+      await Promise.all(Array.from({ length: batch }, (_, ci) => readOne(ci)))
       let stopped = false
       for (let ci = 0; ci < batch; ci++) {
         if (isPastQuery(featureLists[ci], chrId, max)) {
@@ -615,9 +637,13 @@ export default class BamFile<T extends BamRecordLike = BAMFeature> {
         const mateRecs = [] as T[]
         for (let i = 0, l = features.length; i < l; i++) {
           const feature = features[i]!
+          // fileOffset first: it is a number already on the record, where
+          // `name` decodes a string per record. A mate chunk usually overlaps
+          // the query region, so this skips the decode for every record the
+          // caller is already holding.
           if (
-            readNameCounts.get(feature.name) === 1 &&
-            !readIds.has(feature.fileOffset)
+            !readIds.has(feature.fileOffset) &&
+            readNameCounts.get(feature.name) === 1
           ) {
             mateRecs.push(feature)
           }
@@ -691,9 +717,9 @@ export default class BamFile<T extends BamRecordLike = BAMFeature> {
           blockEnd,
           hasCpositions
             ? cpositions[pos]! * (1 << 8) +
-              (blockStart - dpositions[pos]!) +
-              chunk.minv.dataPosition +
-              1
+                (blockStart - dpositions[pos]!) +
+                chunk.minv.dataPosition +
+                1
             : crc32(ba.subarray(blockStart, blockEnd)) >>> 0,
           dataView,
         )

package/src/csi.ts

@@ -96,6 +96,20 @@ export default class CSI extends IndexFile {
     this.maxBinNumber = ((1 << ((this.depth + 1) * 3)) - 1) / 7
     const maxBinNumber = this.maxBinNumber
     const auxLength = dataView.getInt32(12, true)
+    // A tabix-only branch, which is why parseAuxData and the parseNameBytes it
+    // calls show as uncovered. CSI is shared between `samtools index -c` and
+    // `tabix -C`, and the aux block is how a tabix index carries what a reader
+    // of bgzipped TEXT needs: which columns hold ref/start/end, the comment
+    // character, lines to skip, and the reference names — which a BAM takes
+    // from its own header instead. So a BAM .csi sets l_aux to 0 and never
+    // reaches here (checked: 0 of the 19 .csi fixtures carry one).
+    //
+    // Kept rather than deleted for two reasons. CSI is exported from
+    // index.ts, so pointing it at a tabix index is reachable (@gmod/tabix is
+    // the right tool, but this would half-work and then silently not).
+    // More importantly parseNameBytes is marked SYNC: with its tabix-js
+    // counterpart, and dropping one side of a deliberately-paired pair of
+    // implementations is exactly what that marker exists to prevent.
     const aux = auxLength >= 30 ? this.parseAuxData(bytes, 16) : undefined
     const refCount = dataView.getInt32(16 + auxLength, true)
 
@@ -200,6 +214,12 @@ export default class CSI extends IndexFile {
     for (; l <= this.depth; s -= 3, t += lshift(1, l * 3), l += 1) {
       const b = t + rshift(beg, s)
       const e = t + rshift(end, s)
+      // Unreachable as long as the clamp above stands, which is why it shows
+      // as uncovered: with end bounded to 2^(minShift + depth*3), level l
+      // spans at most 8^l - 1 bins, so the worst case is 8^depth - 1 + depth
+      // against a maxBinNumber of (8^(depth+1) - 1)/7, i.e. about 1.14 * 8^depth.
+      // Kept as a guard on the arithmetic rather than deleted — reg2bins is
+      // shared with tabix-js, whose callers reach it by other routes.
       if (e - b + bins.length > this.maxBinNumber) {
         throw new Error(
           `query ${beg}-${end} is too large for current binning scheme (shift ${this.minShift}, depth ${this.depth}), try a smaller query or a coarser index binning scheme`,

package/src/index.ts

@@ -4,7 +4,12 @@ export { default as CSI } from './csi.ts'
 export { default as BamRecord } from './record.ts'
 export { default as HtsgetFile } from './htsget.ts'
 
-export type { Bytes } from './record.ts'
+export type { NumericCigar } from './record.ts'
 export type { BamRecordClass, BamRecordLike } from './bamFile.ts'
+// the options every query method takes, and the shapes they hand back. The
+// package has no subpath exports, so a consumer typing a wrapper around
+// getRecordsForRange/indexCov can only name these if they come out of here.
+export type { BamOpts, BaseOpts } from './util.ts'
+export type { IndexCovEntry } from './bai.ts'
 // for typing the HtsgetFile `fetch` option
 export type { Fetcher } from 'generic-filehandle2'

package/src/indexFile.ts

@@ -33,8 +33,11 @@ export function memoizeByRefId<T>(
 ) {
   const cache = new QuickLRU<number, T>({ maxSize })
   return (refId: number) => {
-    if (cache.has(refId)) {
-      return cache.get(refId)
+    // one lookup, not has()+get(): only truthy results are ever cached, so a
+    // miss and a cached value are already distinguishable
+    const cached = cache.get(refId)
+    if (cached !== undefined) {
+      return cached
     }
     const result = getIndices(refId)
     if (result) {

package/src/record.ts

@@ -31,6 +31,41 @@ for (let hi = 0; hi < 16; hi++) {
 // read lengths.
 const SEQ_DECODER_THRESHOLD = 300
 
+// Four bases per entry, indexed by a PAIR of SEQ bytes, so the sub-threshold
+// path halves its concat count: 1.5-1.6x on a short-read query end to end
+// (shortreads_300x 46.5 -> 30.5 ms over 53.6k reads, volvox 4.8 -> 2.9 ms).
+//
+// Built lazily, and only once the short path has been taken enough times to pay
+// for it. Filling 65536 entries costs ~6 ms and retains ~2 MB, so building on
+// first use is a LOSS on a file that decodes only a handful of short reads:
+// long-read fixtures with a short-read tail measured 1.4x slower that way
+// (ecoli_nanopore has 27 sub-300bp reads out of 480, chm1 has 5 of 204). The
+// counter is module-global on purpose — the table is shared, so what has to
+// amortize is the total number of short decodes in the process, not per file.
+const SEQRET_QUAD_WARMUP = 1024
+let seqretShortCalls = 0
+let SEQRET_QUAD_STRINGS: string[] | undefined
+
+// The 4-base table, or undefined while still warming up (caller falls back to
+// the 2-base table).
+function seqretQuads() {
+  if (SEQRET_QUAD_STRINGS === undefined) {
+    if (++seqretShortCalls < SEQRET_QUAD_WARMUP) {
+      return undefined
+    }
+    const quads = new Array<string>(65536)
+    for (let a = 0; a < 256; a++) {
+      const sa = SEQRET_PAIR_STRINGS[a]!
+      const base = a << 8
+      for (let b = 0; b < 256; b++) {
+        quads[base | b] = sa + SEQRET_PAIR_STRINGS[b]!
+      }
+    }
+    SEQRET_QUAD_STRINGS = quads
+  }
+  return SEQRET_QUAD_STRINGS
+}
+
 // Precomputed pair orientation strings, indexed by
 //   ((flags >> 4) & 0x7) | (selfIsLeft ? 8 : 0)
 // bits 0-2 are flag bits 0x10 (self reverse), 0x20 (mate reverse), 0x40 (read1);
@@ -87,9 +122,20 @@ function decodeTagString(ba: Uint8Array, start: number, end: number) {
   return textDecoder.decode(ba.subarray(start, end))
 }
 
-// Bitmask for ops that consume ref: M=0, D=2, N=3, P=6, ==7, X=8
-// Binary: 0b111001101 = 0x1CD
-const CIGAR_CONSUMES_REF_MASK = 0x1cd
+// Bitmask for ops that consume ref: M=0, D=2, N=3, ==7, X=8
+// Binary: 0b110001101 = 0x18D
+//
+// P (=6) is NOT among them. Padding is a silent placeholder against a padded
+// reference and advances neither query nor reference, which is what htslib's
+// bam_cigar_type(P) == 0 says. Including it made every read carrying a P op
+// report an end one base per padded base too far.
+//
+// That said: nobody cares about P. Padded alignments come out of a handful of
+// assembly tools and are effectively absent from real BAMs — this was fixed
+// because it disagreed with htslib, not because it was hurting anyone. It is
+// covered incidentally by samspec.bam in the samtools agreement suite, and
+// that is enough; don't spend a dedicated fixture or test on it.
+const CIGAR_CONSUMES_REF_MASK = 0x18d
 
 // A CIGAR as packed op words. Either a view over (or copy of) the record's own
 // CIGAR field, or the CG tag's array for long-CIGAR records — hence Int32Array
@@ -104,12 +150,6 @@ function isNumericCigar(value: unknown): value is NumericCigar {
   )
 }
 
-export interface Bytes {
-  start: number
-  end: number
-  byteArray: Uint8Array
-}
-
 type BArrayValue =
   | Int8Array
   | Uint8Array
@@ -202,13 +242,20 @@ function decodeBArrayTag(
 }
 
 // Byte span of a 'B' tag's element payload, for advancing the cursor past it.
+// Returns -1 for a subtype outside the spec's cCsSiIf, whose element width is
+// unknowable. Guessing one byte per element (which is what falling through to
+// `limit` did) doesn't skip the tag, it lands the cursor mid-value and decodes
+// the whole rest of the record's tag list out of garbage — where an unknown
+// top-level type has always stopped the walk instead. Same choice here.
 function bArrayByteLength(Btype: number, limit: number) {
   if (Btype === 0x69 || Btype === 0x49 || Btype === 0x66) {
     return limit << 2
   } else if (Btype === 0x73 || Btype === 0x53) {
     return limit << 1
-  } else {
+  } else if (Btype === 0x63 || Btype === 0x43) {
     return limit
+  } else {
+    return -1
   }
 }
 
@@ -242,6 +289,11 @@ function tagValueEnd(
     case 0x5a: // 'Z'
     case 0x48: {
       // 'H'
+      // Stays a plain byte loop. Swapping in Uint8Array.indexOf past a short
+      // inline probe is 2.7x faster on long-read MD (mean 9083 bytes on
+      // jb2bench's 200x.longread) but ~1.13x slower on short-read Z values,
+      // which are 4-13 bytes and are what the dominant case is made of. Measured
+      // both ways against the realistic corpus — see ADR 0012.
       let q = p
       while (q < blockEnd && ba[q] !== 0) {
         q++
@@ -252,7 +304,12 @@ function tagValueEnd(
       // 'B'
       const Btype = ba[p]!
       const limit = dataView.getInt32(p + 1, true)
-      return p + 5 + bArrayByteLength(Btype, limit)
+      const payload = bArrayByteLength(Btype, limit)
+      if (payload < 0) {
+        console.error('Unknown BAM B tag subtype', Btype)
+        return 0
+      }
+      return p + 5 + payload
     }
     default:
       console.error('Unknown BAM tag type', type)
@@ -451,6 +508,60 @@ export default class BamRecord {
     return this._findTag(tagName, true)
   }
 
+  /**
+   * The value of `tagName`, or of `altName` if the record carries no `tagName` —
+   * resolved in ONE pass over the tag block instead of two.
+   *
+   * For the MM/Mm and ML/Ml alias pairs that modified-base callers emit, where
+   * `getTag(a) ?? getTag(b)` walks every tag on the record TWICE whenever
+   * neither is present, which is every read in a file without base
+   * modifications. jbrowse-components issues exactly that lookup per record on
+   * every render (extractModifications runs unconditionally), and on
+   * jb2bench's 1000x.shortread it was 12.9% of the whole query — more than the
+   * CIGAR, SEQ and MD reads the pileup actually uses, spent proving absence.
+   *
+   * `tagName` wins wherever it appears, so the result matches the two-lookup
+   * form even for a (malformed) record carrying both.
+   */
+  getTagAlt(tagName: string, altName: string) {
+    if (this._cachedTags !== undefined) {
+      return this._cachedTags[tagName] ?? this._cachedTags[altName]
+    }
+    const a0 = tagName.charCodeAt(0)
+    const a1 = tagName.charCodeAt(1)
+    const b0 = altName.charCodeAt(0)
+    const b1 = altName.charCodeAt(1)
+    const blockEnd = this._end
+    const ba = this._byteArray
+    let p = this.tagsStart
+    // where the alternate landed, if it turns up before the primary does
+    let altType = -1
+    let altStart = 0
+    let altEnd = 0
+    while (p < blockEnd) {
+      const c0 = ba[p]
+      const c1 = ba[p + 1]
+      const type = ba[p + 2]!
+      const valueStart = p + 3
+      const end = tagValueEnd(ba, this._dataView, type, valueStart, blockEnd)
+      if (end === 0) {
+        break // unknown type: can't compute how far to advance
+      }
+      if (c0 === a0 && c1 === a1) {
+        return decodeTagValue(ba, this._dataView, type, valueStart, end, false)
+      }
+      if (altType < 0 && c0 === b0 && c1 === b1) {
+        altType = type
+        altStart = valueStart
+        altEnd = end
+      }
+      p = end
+    }
+    return altType < 0
+      ? undefined
+      : decodeTagValue(ba, this._dataView, altType, altStart, altEnd, false)
+  }
+
   private _findTag(tagName: string, raw: boolean) {
     const tag1 = tagName.charCodeAt(0)
     const tag2 = tagName.charCodeAt(1)
@@ -622,12 +733,18 @@ export default class BamRecord {
     return lref
   }
 
+  // Unmapped records are not special-cased here, unlike in
+  // _computeLengthOnRef. The spec says no assumptions can be made about an
+  // unmapped read's CIGAR, but "no assumptions" is not "no CIGAR": aligners
+  // emit placed unmapped mates that carry a real one, and htslib prints
+  // whatever is stored. Dropping it lost data the file had — paired.bam's
+  // SRR062635.1831187 at 20:74230 is FLAG 133 with 35M65S.
+  //
+  // Reference span stays 0 for them regardless, since that is a claim about
+  // alignment rather than about the stored bytes, and the query filter reads
+  // it.
   private _computeNumericCigar(): NumericCigar {
     const flag_nc = this._dataView.getInt32(this._start + 16, true)
-    if (flag_nc & (Constants.BAM_FUNMAP << 16)) {
-      return new Uint32Array(0)
-    }
-
     const numCigarOps = flag_nc & 0xffff
     const p = this.b0 + this.read_name_length
 
@@ -664,14 +781,26 @@ export default class BamRecord {
     return this._cachedNumericCigar
   }
 
+  // Two appends per op, NOT `result += length + String.fromCharCode(op)`. The
+  // one-append form builds an intermediate cons string per op just to append it
+  // and drop it; appending each piece straight onto the rope is 1.23-1.35x
+  // faster on long reads, which is where this accessor dominates
+  // (chr22_nanopore_subset 51.2 -> 38.6 ms for 757 reads averaging 2171 ops,
+  // ultra-long-ont 13.2 -> 9.9 ms). Short reads carry 1-3 ops and land inside
+  // this box's noise band either way.
+  //
+  // ADR 0003 rejected two other rewrites of this loop — a precomputed 16-entry
+  // op-char table, and digits into a Uint8Array with one TextDecoder.decode —
+  // and both are still losers. Re-measured here: the op-char table is 1.13x
+  // SLOWER than String.fromCharCode even on top of this change, because V8
+  // already hands back an interned single-character string.
   get CIGAR() {
     const numeric = this.NUMERIC_CIGAR
     let result = ''
     for (let i = 0, l = numeric.length; i < l; i++) {
       const packed = numeric[i]!
-      const length = packed >> 4
-      const opCode = ASCII_CIGAR_CODES[packed & 0xf]!
-      result += length + String.fromCharCode(opCode)
+      result += packed >> 4
+      result += String.fromCharCode(ASCII_CIGAR_CODES[packed & 0xf]!)
     }
     return result
   }
@@ -697,9 +826,10 @@ export default class BamRecord {
     return this._byteArray.subarray(p, p + this.num_seq_bytes)
   }
 
-  // Decode two bases per iteration off a 256-entry table. Building an array of
-  // 1-char strings and join()ing it — the obvious approach — is 3x slower at
-  // 100bp and 35x slower at 15kb.
+  // Decode four bases per iteration off the 65536-entry table (two off the
+  // 256-entry one until that table has warmed up). Building an array of 1-char
+  // strings and join()ing it — the obvious approach — is 3x slower at 100bp and
+  // 35x slower at 15kb.
   get seq() {
     const len = this.seq_length
     const ba = this._byteArray
@@ -707,9 +837,22 @@ export default class BamRecord {
     const nPairs = len >> 1
     let seq: string
     if (len < SEQ_DECODER_THRESHOLD) {
+      const quads = seqretQuads()
       seq = ''
-      for (let j = 0; j < nPairs; j++) {
-        seq += SEQRET_PAIR_STRINGS[ba[p + j]!]!
+      if (quads === undefined) {
+        for (let j = 0; j < nPairs; j++) {
+          seq += SEQRET_PAIR_STRINGS[ba[p + j]!]!
+        }
+      } else {
+        const nQuads = nPairs >> 1
+        for (let j = 0; j < nQuads; j++) {
+          const q = p + 2 * j
+          seq += quads[(ba[q]! << 8) | ba[q + 1]!]!
+        }
+        // odd byte count: two more bases off the 2-base table
+        if (nPairs & 1) {
+          seq += SEQRET_PAIR_STRINGS[ba[p + nPairs - 1]!]!
+        }
       }
       if (len & 1) {
         seq += SEQRET_DECODER[(ba[p + nPairs]! & 0xf0) >> 4]!