poker-bitvaljs 1.5.2 → 1.7.0

package/bitval.js

@@ -1,3 +1,16 @@
+// Where bitval-worker.js lives. Resolved against this script's own URL when it
+// is loaded with a <script> tag (so it works from node_modules / a CDN path,
+// not just next to the page); otherwise relative to the page. Override per
+// instance with `bitval.workerUrl = '...'` (e.g. when bundling).
+const _BITVAL_WORKER_URL = (function () {
+  try {
+    if (typeof document !== 'undefined' && document.currentScript && document.currentScript.src) {
+      return new URL('bitval-worker.js', document.currentScript.src).href;
+    }
+  } catch (e) { /* fall through */ }
+  return './bitval-worker.js';
+})();
+
 class XorShift32 {
   constructor(seed = null) {
     this.state = seed !== null ? seed : Math.floor(Math.random() * 2147483647) || 1;
@@ -15,6 +28,14 @@ class XorShift32 {
 
 class BitVal {
   constructor() {
+    this.workerUrl = _BITVAL_WORKER_URL;
+    // Opt-in Monte Carlo mode: sample boards once and evaluate every hand on
+    // each board (see _compareRangeSharedBoards). Off = per-matchup sampling.
+    this.mcSharedBoards = false;
+    // Exact flop/turn jobs at least this big (unique hands x runouts) are split
+    // across workers when workers are enabled.
+    this._EXACT_WORKER_THRESHOLD = 300000;
+
     // Suit constants
     this._DIAMOND = 3n;
     this._HEART = 2n;
@@ -175,10 +196,33 @@ class BitVal {
       if (top < 0 && (m & (1 << 12)) && (m & 0b1111) === 0b1111) top = 3; // wheel
       this._STRAIGHT13[m] = top;
     }
+    // Kicker tables (replace the per-eval "peel the highest bit" loops):
+    // _TOP5V13[m] = top five ranks of m packed as r1*65536+r2*4096+r3*256+r4*16+r5
+    //              (flush / high card value; fewer ranks just sum fewer terms).
+    // _KEEP2_13[m] / _KEEP3_13[m] = m with only its top 2 / top 3 bits kept, so
+    //              _TOP5V13[_KEEP3_13[m]] >> 4 = k1*4096+k2*256+k3*16 (pair kickers).
+    this._TOP5V13 = new Int32Array(8192);
+    this._KEEP2_13 = new Uint16Array(8192);
+    this._KEEP3_13 = new Uint16Array(8192);
+    for (let m = 0; m < 8192; m++) {
+      let v = 0, shift = 65536, n = 0, keep = 0;
+      for (let r = 12; r >= 0 && n < 5; r--) {
+        if (m & (1 << r)) {
+          v += r * shift; shift >>= 4; n++; keep |= 1 << r;
+          if (n === 2) this._KEEP2_13[m] = keep;
+          if (n === 3) this._KEEP3_13[m] = keep;
+        }
+      }
+      if (n < 2) this._KEEP2_13[m] = keep;
+      if (n < 3) this._KEEP3_13[m] = keep;
+      this._TOP5V13[m] = v;
+    }
 
     // Preflop exact-equity table (loaded on demand via loadPreflopTable). The 24
     // suit permutations canonicalize a matchup for lookup (card index = rank*4+suit).
-    this._pfMap = null; this._pfWin = null; this._pfTie = null; this._pfTotal = 0;
+    // Lookup is an open-addressing hash in typed arrays (_pfKeys/_pfSlot).
+    this._pfSlot = null; this._pfKeys = null; this._pfMask = 0; this._pfShift = 0;
+    this._pfWin = null; this._pfTie = null; this._pfTotal = 0;
     this._S4 = (function () { const p = a => a.length <= 1 ? [a] : a.flatMap((x, i) => p(a.slice(0, i).concat(a.slice(i + 1))).map(r => [x, ...r])); return p([0, 1, 2, 3]); })();
   }
 
@@ -301,9 +345,37 @@ class BitVal {
   }
 
   /**
-   * Flattens a BigInt combo array into a single Int32Array of suit rank masks
-   * (4 entries per combo: s, h, d, c). One contiguous buffer instead of N small
-   * arrays — better cache locality, no per-combo GC. Cached on `setup`.
+   * All k-card runouts (k = 0..2) from the cards NOT in `exclude` (a {lo, hi}
+   * card bitset), as one flat Int32Array with 4 suit rank masks per runout
+   * (s, h, d, c) — the layout the exact kernel reads. Built from card indices
+   * directly (no BigInt).
+   * @private
+   */
+  _runoutSuits(exclude, k) {
+    const cards = [];
+    for (let c = 0; c < 52; c++) if (!(c < 32 ? exclude.lo & (1 << c) : exclude.hi & (1 << (c - 32)))) cards.push(c);
+    const n = cards.length;
+    if (k === 0) return new Int32Array(4);
+    if (k === 1) {
+      const out = new Int32Array(n * 4);
+      for (let i = 0; i < n; i++) out[i * 4 + (cards[i] & 3)] = 1 << (cards[i] >> 2);
+      return out;
+    }
+    const out = new Int32Array((n * (n - 1) / 2) * 4);
+    let o = 0;
+    for (let i = 0; i < n; i++) {
+      const ci = cards[i];
+      for (let j = i + 1; j < n; j++, o += 4) {
+        const cj = cards[j];
+        out[o + (ci & 3)] |= 1 << (ci >> 2);
+        out[o + (cj & 3)] |= 1 << (cj >> 2);
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Converts BigInt runout masks to the 4-suit-masks-per-runout layout.
    * @private
    */
   _buildComboSuits(comboArray) {
@@ -362,11 +434,7 @@ class BitVal {
     }
 
     // Flush
-    if (fm) {
-      let m = fm, v = 5 * 1048576, shift = 65536;
-      for (let n = 0; n < 5; n++) { const r = this._high(m); v += r * shift; m &= ~(1 << r); shift >>= 4; }
-      return v;
-    }
+    if (fm) return 5 * 1048576 + this._TOP5V13[fm];
 
     // Straight
     {
@@ -377,10 +445,7 @@ class BitVal {
     // Trips
     if (trips) {
       const t = this._high(trips);
-      let rest = all & ~(1 << t);
-      const k1 = this._high(rest); rest &= ~(1 << k1);
-      const k2 = this._high(rest);
-      return 3 * 1048576 + t * 65536 + k1 * 4096 + k2 * 256;
+      return 3 * 1048576 + t * 65536 + (this._TOP5V13[this._KEEP2_13[all & ~(1 << t)]] >> 4);
     }
 
     // Two pair
@@ -394,19 +459,11 @@ class BitVal {
     // One pair
     if (pairs) {
       const p = this._high(pairs);
-      let rest = all & ~(1 << p);
-      const k1 = this._high(rest); rest &= ~(1 << k1);
-      const k2 = this._high(rest); rest &= ~(1 << k2);
-      const k3 = this._high(rest);
-      return 1 * 1048576 + p * 65536 + k1 * 4096 + k2 * 256 + k3 * 16;
+      return 1 * 1048576 + p * 65536 + (this._TOP5V13[this._KEEP3_13[all & ~(1 << p)]] >> 4);
     }
 
     // High card
-    {
-      let m = all, v = 0, shift = 65536;
-      for (let n = 0; n < 5; n++) { const r = this._high(m); v += r * shift; m &= ~(1 << r); shift >>= 4; }
-      return v;
-    }
+    return this._TOP5V13[all];
   }
 
   /**
@@ -453,15 +510,11 @@ class BitVal {
    * @returns {Object} { win, tie, lose, ...handStrengths } - Results object
    */
   simulate(iterations, numberOfBoardCards = 5, hero = [], villain = [], board = [], deadCards = []) {
-    let numberOfCardsToDeal = (numberOfBoardCards + 2) - (hero.length + board.length);
-    this.xorShift = new XorShift32();
+    const numberOfCardsToDeal = numberOfBoardCards - board.length;
+    const xorShift = this.xorShift = new XorShift32();
 
     const allDeadCards = [...hero, ...villain, ...board, ...deadCards];
-    deadCards = this.getBitMasked(allDeadCards);
-    numberOfCardsToDeal = numberOfBoardCards - board.length;
-    hero = this.getBitMasked(hero);
-    villain = this.getBitMasked(villain);
-    board = this.getBitMasked(board);
+    const deadMask = this.getBitMasked(allDeadCards);
 
     const availableCards = 52 - new Set(allDeadCards).size;
     const exhaustiveCombinations = this.combinations(availableCards, numberOfCardsToDeal);
@@ -473,13 +526,8 @@ class BitVal {
     // for larger (>=3 cards to come) scenarios.
     const isExhaustive = numberOfCardsToDeal >= 0 && numberOfCardsToDeal <= 2;
     iterations = isExhaustive ? exhaustiveCombinations : Math.min(iterations, exhaustiveCombinations);
-    let comboArray = null;
-    if (isExhaustive) {
-      const availableMasks = this._getAvailableCardMasksByLookUp(deadCards);
-      comboArray = this._getCombinations(availableMasks, numberOfCardsToDeal);
-    }
 
-    let result = { 
+    let result = {
       "win": 0,
       "tie": 0,
       "lose": 0,
@@ -494,34 +542,44 @@ class BitVal {
       "Straight Flush": 0
     };
 
-    for (let i = 0; i < iterations; i++) {
-      let _board = isExhaustive && comboArray
-        ? board | comboArray[i]
-        : this.deal(board, deadCards, numberOfCardsToDeal) | board;
-
-      let [hero_eval, hero_tiebreaker] = this.evaluate(hero | _board);
-      let [villain_eval, villain_tiebreaker] = this.evaluate(villain | _board);
+    // BigInt-free hot loop (same engine as compareRange): cards are four 13-bit
+    // suit rank masks and _eval7 orders hands identically to evaluate().
+    const hs = this._suitsOfCards(hero), vs = this._suitsOfCards(villain), bs = this._suitsOfCards(board);
+    const hs0 = hs[0] | bs[0], hs1 = hs[1] | bs[1], hs2 = hs[2] | bs[2], hs3 = hs[3] | bs[3];
+    const vs0 = vs[0] | bs[0], vs1 = vs[1] | bs[1], vs2 = vs[2] | bs[2], vs3 = vs[3] | bs[3];
+    let win = 0, tie = 0, lose = 0;
 
-      if (hero_eval > villain_eval) {
-        result["win"]++;
-        continue;
-      }
-      if (hero_eval < villain_eval) {
-        result["lose"]++;
-        continue;
-      }
-      if (hero_tiebreaker > villain_tiebreaker) {
-        result["win"]++;
-        continue;
+    if (isExhaustive) {
+      const combos = this._runoutSuits(this._cardsBitset(allDeadCards), numberOfCardsToDeal);
+      const n = Math.min(iterations, combos.length >> 2);
+      for (let i = 0; i < n; i++) {
+        const b = i << 2, d0 = combos[b], d1 = combos[b + 1], d2 = combos[b + 2], d3 = combos[b + 3];
+        const hE = this._eval7(hs0 | d0, hs1 | d1, hs2 | d2, hs3 | d3);
+        const vE = this._eval7(vs0 | d0, vs1 | d1, vs2 | d2, vs3 | d3);
+        if (hE > vE) win++; else if (vE > hE) lose++; else tie++;
       }
-      if (hero_tiebreaker < villain_tiebreaker) {
-        result["lose"]++;
-        continue;
+    } else {
+      // Partial Fisher-Yates draw from the packed pool of live cards.
+      const pool = this._availableSuitCards(deadMask), poolLen = pool.length;
+      const nDeal = poolLen < numberOfCardsToDeal ? 0 : numberOfCardsToDeal;
+      let st = xorShift.state;
+      for (let i = 0; i < iterations; i++) {
+        let d0 = 0, d1 = 0, d2 = 0, d3 = 0;
+        for (let k = 0; k < nDeal; k++) {
+          st ^= st << 13; st ^= st >> 17; st ^= st << 5;
+          const j = k + Math.abs(st) % (poolLen - k);
+          const card = pool[j]; pool[j] = pool[k]; pool[k] = card;
+          const bit = card & 0xFFFF, suit = card >> 16;
+          if (suit === 0) d0 |= bit; else if (suit === 1) d1 |= bit; else if (suit === 2) d2 |= bit; else d3 |= bit;
+        }
+        const hE = this._eval7(hs0 | d0, hs1 | d1, hs2 | d2, hs3 | d3);
+        const vE = this._eval7(vs0 | d0, vs1 | d1, vs2 | d2, vs3 | d3);
+        if (hE > vE) win++; else if (vE > hE) lose++; else tie++;
       }
-
-      result["tie"]++
+      xorShift.state = st;
     }
-    
+
+    result.win = win; result.tie = tie; result.lose = lose;
     return result;
   }
 
@@ -551,7 +609,7 @@ class BitVal {
     // Preflop exact fast path: if the preflop equity table is loaded and this is
     // a full-board preflop query with no dead cards, look up every matchup's
     // exact equity instead of Monte Carlo. Instant and exact.
-    if (this._pfMap && boardCards.length === 0 && deadCards.length === 0 && numberOfBoardCards === 5) {
+    if (this._pfSlot && boardCards.length === 0 && deadCards.length === 0 && numberOfBoardCards === 5) {
       const r = this._compareRangePreflopExact(heroHands, villainHands);
       if (progressCallback) progressCallback(1, 1, 'Complete');
       return r;
@@ -579,18 +637,34 @@ class BitVal {
     if (view.getUint32(0, true) !== 0x50464551) throw new Error('invalid preflop table (bad magic)');
     const count = view.getUint32(4, true);
     this._pfTotal = view.getUint32(8, true);
-    this._pfWin = new Uint32Array(count);
-    this._pfTie = new Uint32Array(count);
-    this._pfMap = new Map();
+    const win = new Uint32Array(count), tie = new Uint32Array(count);
+    // Open-addressing hash (linear probing, load factor <= 0.5): key -> row.
+    let bits = 1; while ((1 << bits) < count * 2) bits++;
+    const size = 1 << bits, mask = size - 1, shift = 32 - bits;
+    const keys = new Uint32Array(size), slot = new Int32Array(size).fill(-1);
     for (let i = 0; i < count; i++) {
-      const o = 12 + i * 12;
-      this._pfMap.set(view.getUint32(o, true), i);
-      this._pfWin[i] = view.getUint32(o + 4, true);
-      this._pfTie[i] = view.getUint32(o + 8, true);
-    }
+      const o = 12 + i * 12, key = view.getUint32(o, true);
+      win[i] = view.getUint32(o + 4, true);
+      tie[i] = view.getUint32(o + 8, true);
+      let h = Math.imul(key, 0x9E3779B1) >>> shift;
+      while (slot[h] !== -1) h = (h + 1) & mask;
+      keys[h] = key; slot[h] = i;
+    }
+    this._pfWin = win; this._pfTie = tie;
+    this._pfKeys = keys; this._pfSlot = slot; this._pfMask = mask; this._pfShift = shift;
     return count;
   }
 
+  /** Row index of a canonical preflop key in the loaded table, or -1. @private */
+  _pfLookup(key) {
+    const keys = this._pfKeys, slot = this._pfSlot, mask = this._pfMask;
+    let h = Math.imul(key, 0x9E3779B1) >>> this._pfShift;
+    for (let i = slot[h]; i !== -1; h = (h + 1) & mask, i = slot[h]) {
+      if (keys[h] === key) return i;
+    }
+    return -1;
+  }
+
   /** Card index (0..51) = rankIndex*4 + suitIndex, for a 2-char card string. @private */
   _cardIndex(card) { return this._N_RANK[card[0]] * 4 + this._N_SUIT[card[1]]; }
 
@@ -620,14 +694,39 @@ class BitVal {
     const heroC = [], villC = [];
     for (const h of heroHands) heroC.push(this._cardIndex(h.slice(0, 2)), this._cardIndex(h.slice(2, 4)));
     for (const v of villainHands) villC.push(this._cardIndex(v.slice(0, 2)), this._cardIndex(v.slice(2, 4)));
+    // The canonical key ((a*52+b)*52+c)*52+d is minimized over the 24 suit
+    // permutations; it's lexicographic in (hero part, villain part), so only
+    // the permutations that minimize the hero part can win (2 for offsuit or
+    // pairs, 6 for suited). Find those once per hero, then minimize the villain
+    // part over just them — same key as _preflopCanonKey, ~4-12x less work.
+    const S4 = this._S4, pWin = this._pfWin, pTie = this._pfTie;
+    const perms = new Int32Array(24 * 4); let np = 0;
     let win = 0, tie = 0, lose = 0;
     for (let hi = 0; hi < heroC.length; hi += 2) {
       const h1 = heroC[hi], h2 = heroC[hi + 1];
+      let bestH = Infinity; np = 0;
+      for (let pi = 0; pi < 24; pi++) {
+        const p = S4[pi];
+        const m1 = (h1 & ~3) | p[h1 & 3], m2 = (h2 & ~3) | p[h2 & 3];
+        const hk = m1 < m2 ? m1 * 52 + m2 : m2 * 52 + m1;
+        if (hk > bestH) continue;
+        if (hk < bestH) { bestH = hk; np = 0; }
+        perms[np * 4] = p[0]; perms[np * 4 + 1] = p[1]; perms[np * 4 + 2] = p[2]; perms[np * 4 + 3] = p[3]; np++;
+      }
+      const hBase = bestH * 2704;
       for (let vi = 0; vi < villC.length; vi += 2) {
         const v1 = villC[vi], v2 = villC[vi + 1];
         if (h1 === v1 || h1 === v2 || h2 === v1 || h2 === v2) continue; // conflicting hole cards
-        const idx = this._pfMap.get(this._preflopCanonKey(h1, h2, v1, v2));
-        const w = this._pfWin[idx], t = this._pfTie[idx];
+        let bestV = 2704;
+        const b1 = v1 & ~3, s1 = v1 & 3, b2 = v2 & ~3, s2 = v2 & 3;
+        for (let k = 0; k < np; k++) {
+          const q = k * 4, m1 = b1 | perms[q + s1], m2 = b2 | perms[q + s2];
+          const vk = m1 < m2 ? m1 * 52 + m2 : m2 * 52 + m1;
+          if (vk < bestV) bestV = vk;
+        }
+        const idx = this._pfLookup(hBase + bestV);
+        if (idx < 0) throw new Error('preflop table is missing a matchup (corrupt or incomplete table)');
+        const w = pWin[idx], t = pTie[idx];
         win += w; tie += t; lose += total - w - t;
       }
     }
@@ -888,100 +987,102 @@ class BitVal {
   // PRIVATE - Range Comparison Helpers
   // ============================================
 
+  /**
+   * Parses a 2-card hand string into card indices (0..51, rank*4+suit) and a
+   * split 64-bit card bitset (lo = cards 0..31, hi = cards 32..51) so overlap
+   * tests are plain Number ANDs instead of BigInt work.
+   * @private
+   */
+  _parseHand(hand) {
+    const a = this._cardIndex(hand), b = this._cardIndex(hand.substring(2, 4));
+    const lo = (a < 32 ? 1 << a : 0) | (b < 32 ? 1 << b : 0);
+    const hi = (a >= 32 ? 1 << (a - 32) : 0) | (b >= 32 ? 1 << (b - 32) : 0);
+    return { a, b, lo, hi };
+  }
+
+  /**
+   * Card bitset (lo/hi halves) for an array of card strings.
+   * @private
+   */
+  _cardsBitset(cards) {
+    let lo = 0, hi = 0;
+    for (const c of cards) { const i = this._cardIndex(c); if (i < 32) lo |= 1 << i; else hi |= 1 << (i - 32); }
+    return { lo, hi };
+  }
+
   /**
    * Generates all valid matchups between hero and villain hands, excluding overlaps.
+   * Each hand is parsed once; the O(H*V) overlap test runs on Number bitsets.
    * @private
    */
   _generateValidMatchups(heroHands, villainHands, boardCards = []) {
     const valid = [];
-    const boardMask = boardCards.length > 0 ? this.getBitMasked(boardCards) : 0n;
+    const board = this._cardsBitset(boardCards);
+    const nV = villainHands.length;
+    const vLo = new Int32Array(nV), vHi = new Int32Array(nV), vOk = new Uint8Array(nV), vMask = new Array(nV);
+    for (let j = 0; j < nV; j++) {
+      const p = this._parseHand(villainHands[j]);
+      vLo[j] = p.lo; vHi[j] = p.hi;
+      vOk[j] = ((p.lo & board.lo) | (p.hi & board.hi)) === 0 ? 1 : 0;
+      vMask[j] = vOk[j] ? this.getBitMasked(this._handStringToCards(villainHands[j])) : 0n;
+    }
     for (const h of heroHands) {
+      const p = this._parseHand(h);
+      if ((p.lo & board.lo) | (p.hi & board.hi)) continue;
       const hMask = this.getBitMasked(this._handStringToCards(h));
-      if (boardMask && (hMask & boardMask) !== 0n) continue;
-      for (const v of villainHands) {
-        const vMask = this.getBitMasked(this._handStringToCards(v));
-        if ((vMask & boardMask) !== 0n || (hMask & vMask) !== 0n) continue;
-        valid.push({ heroHand: h, villainHand: v, heroMask: hMask, villainMask: vMask });
+      for (let j = 0; j < nV; j++) {
+        if (!vOk[j] || (p.lo & vLo[j]) | (p.hi & vHi[j])) continue;
+        valid.push({ heroHand: h, villainHand: villainHands[j], heroMask: hMask, villainMask: vMask[j] });
       }
     }
     return valid;
   }
 
   /**
-   * Calculates valid matchup counts per canonical key pair.
-   * @private
-   */
-  _calculateValidCounts(validMatchups, hCanon, vCanon, boardCards, numberOfBoardCards) {
-    const counts = new Map();
-    const boardSuitCounts = boardCards.length > 0 ? this._getBoardSuitCounts(boardCards) : null;
-    for (const { heroHand, villainHand } of validMatchups) {
-      const hKey = this._getCanonicalKey(heroHand, boardCards, numberOfBoardCards, boardSuitCounts);
-      const vKey = this._getCanonicalKey(villainHand, boardCards, numberOfBoardCards, boardSuitCounts);
-      const key = `${hKey}:${vKey}`;
-      counts.set(key, (counts.get(key) || 0) + 1);
-    }
-    return counts;
-  }
-
-  /**
-   * Sets up range comparison by generating valid matchups and canonical mappings.
+   * Sets up range comparison. The per-pair matchup list is only materialized
+   * (lazily, via the `validMatchups` getter) by the paths that need it — the
+   * Monte Carlo and unoptimized paths. The exact exhaustive path works straight
+   * from the hand strings (see _buildExhaustiveWork).
    * @private
    */
   _compareRangeSetup(heroHands, villainHands, boardCards, deadCards, numberOfBoardCards, iterations, optimize) {
-    // Generate valid matchups (always needed)
-    const validMatchups = this._generateValidMatchups(heroHands, villainHands, boardCards);
-    
-    // Calculate canonical mappings only if optimization is enabled
-    let hCanon = null;
-    let vCanon = null;
-    let validCounts = null;
-    if (optimize) {
-      hCanon = this._flattenHandsToCanonical(heroHands, boardCards, numberOfBoardCards);
-      vCanon = this._flattenHandsToCanonical(villainHands, boardCards, numberOfBoardCards);
-      validCounts = this._calculateValidCounts(validMatchups, hCanon, vCanon, boardCards, numberOfBoardCards);
-    }
-    
     // Calculate bitmasks
     const boardMask = this.getBitMasked(boardCards);
     const deadCardsMask = this.getBitMasked([...boardCards, ...deadCards]);
-    
+
     // Calculate cards to deal and determine if exhaustive enumeration is possible.
     // 0 cards to come (a complete board) is exhaustive too: exactly one runout.
     const numberOfCardsToDeal = numberOfBoardCards - boardCards.length;
-    const canBeExhaustive = numberOfCardsToDeal >= 0 && numberOfCardsToDeal <= 2;
-    
-    // Calculate available cards using bitmask (more efficient than Set)
-    const availableCards = 52 - this.countBits(deadCardsMask);
-    
-    // Determine if we should use exhaustive enumeration
-    const exhaustiveCombinations = canBeExhaustive
-      ? this.combinations(availableCards, numberOfCardsToDeal)
-      : Infinity;
+    const isExhaustive = numberOfCardsToDeal >= 0 && numberOfCardsToDeal <= 2;
+
     // For <=2 cards to come the full runout space is tiny (<=1326), so always
     // enumerate it exactly instead of Monte-Carloing a lower requested count.
     // Exhaustive is exact and deterministic; the requested iteration count only
     // matters for larger (>=3 cards to come, e.g. preflop) scenarios.
-    const isExhaustive = canBeExhaustive && exhaustiveCombinations < Infinity;
-    iterations = isExhaustive ? exhaustiveCombinations : Math.min(iterations, exhaustiveCombinations);
-    
-    // Generate combo array only if exhaustive
-    const comboArray = isExhaustive 
-      ? this._getCombinations(this._getAvailableCardMasksByLookUp(deadCardsMask), numberOfCardsToDeal) 
+    // Runouts as suit masks, built from card indices (no BigInt).
+    const comboSuits = isExhaustive
+      ? this._runoutSuits(this._cardsBitset([...boardCards, ...deadCards]), numberOfCardsToDeal)
       : null;
-    
-    return { 
-      hCanon, 
-      vCanon, 
-      boardMask, 
-      deadCardsMask, 
-      iterations, 
-      isExhaustive, 
-      comboArray, 
-      numberOfCardsToDeal, 
-      validMatchups, 
-      validCounts, 
-      boardCards, 
-      numberOfBoardCards 
+    if (isExhaustive) iterations = comboSuits.length >> 2;
+
+    const self = this;
+    return {
+      heroHands,
+      villainHands,
+      boardMask,
+      deadCardsMask,
+      iterations,
+      isExhaustive,
+      comboArray: null,       // BigInt runouts are no longer built; see _comboSuits
+      _comboSuits: comboSuits,
+      numberOfCardsToDeal,
+      boardCards,
+      deadCards,
+      numberOfBoardCards,
+      _validMatchups: null,
+      get validMatchups() {
+        return this._validMatchups || (this._validMatchups = self._generateValidMatchups(heroHands, villainHands, boardCards));
+      }
     };
   }
 
@@ -1001,8 +1102,8 @@ class BitVal {
       isExhaustive: setup.isExhaustive,
       numberOfCardsToDeal: setup.numberOfCardsToDeal,
       mcTarget: setup.mcTarget
-      // Note: hCanon, vCanon, validMatchups, validCounts are not needed in workers
-      // as matchups are pre-serialized and sent separately
+      // Note: validMatchups is not needed in workers; matchups are
+      // pre-serialized and sent separately
     };
   }
 
@@ -1048,7 +1149,76 @@ class BitVal {
    * Optimized for browser performance with adaptive yielding and inlined hot loop.
    * @private
    */
+  /**
+   * Synchronous single-matchup evaluation (no progress / yielding). Used by the
+   * sequential path when there's no progress callback and by the Web Worker,
+   * so both run the same tight loop with the RNG state held in a local.
+   * @private
+   */
+  _evaluateMatchupSync(heroMask, villainMask, setup) {
+    let win = 0, tie = 0, lose = 0;
+    const hs = this._suitsFromBigMask(heroMask), vs = this._suitsFromBigMask(villainMask);
+    const bb = setup._boardSuits || (setup._boardSuits = this._suitsFromBigMask(setup.boardMask));
+    const hs0 = hs[0], hs1 = hs[1], hs2 = hs[2], hs3 = hs[3];
+    const vs0 = vs[0], vs1 = vs[1], vs2 = vs[2], vs3 = vs[3];
+    const bb0 = bb[0], bb1 = bb[1], bb2 = bb[2], bb3 = bb[3];
+
+    if (setup.isExhaustive) {
+      const comboSuits = setup._comboSuits || (setup._comboSuits = this._buildComboSuits(setup.comboArray));
+      const n = comboSuits.length >> 2;
+      const m0 = hs0 | vs0, m1 = hs1 | vs1, m2 = hs2 | vs2, m3 = hs3 | vs3;
+      for (let i = 0; i < n; i++) {
+        const b = i << 2;
+        const c0 = comboSuits[b], c1 = comboSuits[b + 1], c2 = comboSuits[b + 2], c3 = comboSuits[b + 3];
+        if ((c0 & m0) | (c1 & m1) | (c2 & m2) | (c3 & m3)) continue; // runout uses a hole card
+        const d0 = bb0 | c0, d1 = bb1 | c1, d2 = bb2 | c2, d3 = bb3 | c3;
+        const hE = this._eval7(hs0 | d0, hs1 | d1, hs2 | d2, hs3 | d3);
+        const vE = this._eval7(vs0 | d0, vs1 | d1, vs2 | d2, vs3 | d3);
+        if (hE > vE) win++; else if (vE > hE) lose++; else tie++;
+      }
+      return { matchupWin: win, matchupTie: tie, matchupLose: lose };
+    }
+
+    const xorShift = this.xorShift = new XorShift32();
+    const pool = this._availableSuitCards(heroMask | villainMask | setup.deadCardsMask), poolLen = pool.length;
+    const nDeal = setup.numberOfCardsToDeal;
+    const iterations = setup.iterations;
+    const mcTarget = setup.mcTarget > 0 ? setup.mcTarget / 100 : 0;
+    let ran = iterations, st = xorShift.state;
+    for (let i = 0; i < iterations; i++) {
+      let d0 = bb0, d1 = bb1, d2 = bb2, d3 = bb3;
+      for (let k = 0; k < nDeal; k++) {
+        st ^= st << 13; st ^= st >> 17; st ^= st << 5;
+        const j = k + Math.abs(st) % (poolLen - k);
+        const card = pool[j]; pool[j] = pool[k]; pool[k] = card;
+        const bit = card & 0xFFFF, suit = card >> 16;
+        if (suit === 0) d0 |= bit; else if (suit === 1) d1 |= bit; else if (suit === 2) d2 |= bit; else d3 |= bit;
+      }
+      const hE = this._eval7(hs0 | d0, hs1 | d1, hs2 | d2, hs3 | d3);
+      const vE = this._eval7(vs0 | d0, vs1 | d1, vs2 | d2, vs3 | d3);
+      if (hE > vE) win++; else if (vE > hE) lose++; else tie++;
+
+      // Monte Carlo early-stop check (every 4096 draws, past a warm-up).
+      if (mcTarget && (i & 4095) === 4095 && i >= 8191) {
+        const n = i + 1, p = (win + tie * 0.5) / n;
+        if (1.96 * Math.sqrt(p * (1 - p) / n) < mcTarget) { ran = n; break; }
+      }
+    }
+    xorShift.state = st;
+
+    // If early-stopped, scale counts back to the requested iteration count so
+    // every matchup is weighted equally in the aggregate.
+    if (ran < iterations && ran > 0) {
+      const s = iterations / ran;
+      win = Math.round(win * s); tie = Math.round(tie * s); lose = Math.round(lose * s);
+    }
+    return { matchupWin: win, matchupTie: tie, matchupLose: lose };
+  }
+
   async _evaluateMatchup(heroMask, villainMask, setup, progressCallback = null, matchupIndex = 0, totalMatchups = 1) {
+    // No progress reporting: run the tight synchronous loop (no per-iteration
+    // yield checks, RNG in a local).
+    if (!progressCallback) return this._evaluateMatchupSync(heroMask, villainMask, setup);
     let win = 0, tie = 0, lose = 0;
     const deadMask = heroMask | villainMask | setup.deadCardsMask;
 
@@ -1097,10 +1267,13 @@ class BitVal {
     for (let i = 0; i < iterations; i++) {
       // Build the runout as suit rank-masks: precomputed combo (exhaustive) or
       // a Fisher-Yates draw from the available pool (Monte Carlo).
-      let d0, d1, d2, d3;
+      let d0, d1, d2, d3, live = true;
       if (comboSuits) {
         const b = i << 2;
-        d0 = bb0 | comboSuits[b]; d1 = bb1 | comboSuits[b + 1]; d2 = bb2 | comboSuits[b + 2]; d3 = bb3 | comboSuits[b + 3];
+        const c0 = comboSuits[b], c1 = comboSuits[b + 1], c2 = comboSuits[b + 2], c3 = comboSuits[b + 3];
+        // Skip runouts that use a hole card (impossible deals).
+        live = ((c0 & (hs0 | vs0)) | (c1 & (hs1 | vs1)) | (c2 & (hs2 | vs2)) | (c3 & (hs3 | vs3))) === 0;
+        d0 = bb0 | c0; d1 = bb1 | c1; d2 = bb2 | c2; d3 = bb3 | c3;
       } else {
         d0 = bb0; d1 = bb1; d2 = bb2; d3 = bb3;
         for (let k = 0; k < nDeal; k++) {
@@ -1114,11 +1287,13 @@ class BitVal {
         }
       }
 
-      const hE = this._eval7(hs0 | d0, hs1 | d1, hs2 | d2, hs3 | d3);
-      const vE = this._eval7(vs0 | d0, vs1 | d1, vs2 | d2, vs3 | d3);
-      if (hE > vE) win++;
-      else if (vE > hE) lose++;
-      else tie++;
+      if (live) {
+        const hE = this._eval7(hs0 | d0, hs1 | d1, hs2 | d2, hs3 | d3);
+        const vE = this._eval7(vs0 | d0, vs1 | d1, vs2 | d2, vs3 | d3);
+        if (hE > vE) win++;
+        else if (vE > hE) lose++;
+        else tie++;
+      }
 
       // Monte Carlo early-stop check (every 4096 draws, past a warm-up).
       if (mcTarget && (i & 4095) === 4095 && i >= 8191) {
@@ -1228,6 +1403,62 @@ class BitVal {
     return { win, tie, lose };
   }
 
+  /**
+   * Groups the valid (hero, villain) matchups by canonical key pair for the
+   * Monte Carlo path. Canonical keys depend only on the hand (and board), so
+   * they're computed once per hand string, and pairs are enumerated with Number
+   * card bitsets — no per-pair objects or string keys. Each group keeps the
+   * first matchup (hero-major order) as its representative. Cached on `setup`.
+   * @private
+   */
+  _groupMonteCarloMatchups(setup) {
+    if (setup._mcGroups) return setup._mcGroups;
+    const { heroHands, villainHands, boardCards, numberOfBoardCards } = setup;
+    const board = this._cardsBitset(boardCards);
+    const boardSuitCounts = boardCards.length > 0 ? this._getBoardSuitCounts(boardCards) : null;
+    const keyIds = new Map(), keyNames = [];
+    const keyId = (hand) => {
+      const k = this._getCanonicalKey(hand, boardCards, numberOfBoardCards, boardSuitCounts);
+      let id = keyIds.get(k);
+      if (id === undefined) { id = keyNames.length; keyIds.set(k, id); keyNames.push(k); }
+      return id;
+    };
+    const parseSide = (hands) => {
+      const n = hands.length, lo = new Int32Array(n), hi = new Int32Array(n), id = new Int32Array(n), ok = new Uint8Array(n);
+      for (let i = 0; i < n; i++) {
+        const p = this._parseHand(hands[i]);
+        lo[i] = p.lo; hi[i] = p.hi;
+        ok[i] = ((p.lo & board.lo) | (p.hi & board.hi)) === 0 ? 1 : 0;
+        if (ok[i]) id[i] = keyId(hands[i]);
+      }
+      return { lo, hi, id, ok, n };
+    };
+    const H = parseSide(heroHands), V = parseSide(villainHands);
+    const nK = keyNames.length;
+    const groupOf = new Map(), groups = [];
+    for (let h = 0; h < H.n; h++) {
+      if (!H.ok[h]) continue;
+      const hl = H.lo[h], hh = H.hi[h], hk = H.id[h] * nK;
+      for (let v = 0; v < V.n; v++) {
+        if (!V.ok[v] || (hl & V.lo[v]) | (hh & V.hi[v])) continue;
+        const gk = hk + V.id[v];
+        let g = groupOf.get(gk);
+        if (g === undefined) {
+          const heroHand = heroHands[h], villainHand = villainHands[v];
+          const heroKey = keyNames[H.id[h]], villainKey = keyNames[V.id[v]];
+          g = {
+            key: `${heroKey}:${villainKey}`, validCount: 0, heroKey, villainKey, heroHand, villainHand,
+            heroMask: this.getBitMasked(this._handStringToCards(heroHand)),
+            villainMask: this.getBitMasked(this._handStringToCards(villainHand))
+          };
+          groupOf.set(gk, g); groups.push(g);
+        }
+        g.validCount++;
+      }
+    }
+    return (setup._mcGroups = groups);
+  }
+
   /**
    * Compares ranges with canonical key caching optimization (sequential version).
    * @private
@@ -1237,29 +1468,16 @@ class BitVal {
     let lastProgressTime = 0;
     const progressUpdateInterval = 100; // Update progress at most every 100ms
     
-    // Pre-calculate board suit counts once (constant for all matchups)
-    const boardSuitCounts = setup.boardCards.length > 0 
-      ? this._getBoardSuitCounts(setup.boardCards) 
-      : null;
-    
     // Monte Carlo (>=3 cards to come): canonical grouping + independent
     // per-matchup sampling (each matchup deals its own boards, so runouts can't
     // be shared). Grouping only pays off here, where a matchup is expensive.
     if (!setup.isExhaustive) {
-      const matchupGroups = new Map();
-      for (const matchup of setup.validMatchups) {
-        const mHKey = this._getCanonicalKey(matchup.heroHand, setup.boardCards, setup.numberOfBoardCards, boardSuitCounts);
-        const mVKey = this._getCanonicalKey(matchup.villainHand, setup.boardCards, setup.numberOfBoardCards, boardSuitCounts);
-        const key = `${mHKey}:${mVKey}`;
-        let g = matchupGroups.get(key);
-        if (!g) { g = { heroKey: mHKey, villainKey: mVKey, representative: matchup, count: 0 }; matchupGroups.set(key, g); }
-        g.count++;
-      }
-      const totalMatchups = matchupGroups.size;
+      const groups = this._groupMonteCarloMatchups(setup);
+      const totalMatchups = groups.length;
       let matchupIndex = 0;
-      for (const [key, group] of matchupGroups) {
-        const validCount = group.count;
-        const validPair = group.representative;
+      for (const group of groups) {
+        const validCount = group.validCount;
+        const validPair = group;
         const { matchupWin, matchupTie, matchupLose } = await this._evaluateMatchup(
           validPair.heroMask, validPair.villainMask, setup, progressCallback, matchupIndex, totalMatchups
         );
@@ -1285,9 +1503,8 @@ class BitVal {
     }
 
     // Exhaustive: EXACT evaluate-once. Build the shared work structure and run
-    // the kernel over all runouts. The Web Worker path (_compareRangeOptimized)
-    // runs the SAME kernel over runout slices, so workers and sequential agree
-    // byte-for-byte.
+    // the kernel over all runouts (on the main thread for both the worker and
+    // non-worker paths, so they agree byte-for-byte).
     const work = this._buildExhaustiveWork(setup);
     const comboSuits = setup._comboSuits || (setup._comboSuits = this._buildComboSuits(setup.comboArray));
     const nRun = comboSuits.length >> 2;
@@ -1297,72 +1514,183 @@ class BitVal {
   }
 
   /**
-   * Builds the reusable per-run work for the exact exhaustive kernel: unique
-   * concrete hero/villain suit masks, the valid-pair list, and (for large
-   * fields) the card-conflict CSR. Everything is transferable typed arrays so
-   * it can be serialized to workers unchanged.
+   * Builds the reusable per-run work for the exact exhaustive kernel straight
+   * from the hand strings (no per-pair objects, no BigInt). Hands are
+   * deduplicated into a UNION of hero+villain concrete hands — each evaluated
+   * once per runout even when it appears in both ranges — with per-hand hero
+   * and villain multiplicities, so duplicates count exactly as they do in the
+   * per-pair unoptimized computation. Small fields get an explicit valid-pair
+   * list; large fields are resolved by the counting sweep in _runExhaustive.
+   * Everything is typed arrays so it could be shipped to workers unchanged.
    * @private
    */
   _buildExhaustiveWork(setup) {
-    const heroIdx = new Map(), villIdx = new Map();
-    const heroSuit = [], villSuit = [], pairH = [], pairV = [];
-    for (const m of setup.validMatchups) {
-      let hi = heroIdx.get(m.heroMask);
-      if (hi === undefined) { hi = heroSuit.length >> 2; heroIdx.set(m.heroMask, hi); const s = this._suitsFromBigMask(m.heroMask); heroSuit.push(s[0], s[1], s[2], s[3]); }
-      let vi = villIdx.get(m.villainMask);
-      if (vi === undefined) { vi = villSuit.length >> 2; villIdx.set(m.villainMask, vi); const s = this._suitsFromBigMask(m.villainMask); villSuit.push(s[0], s[1], s[2], s[3]); }
-      pairH.push(hi); pairV.push(vi);
-    }
-    const H = heroSuit.length >> 2, V = villSuit.length >> 2, P = pairH.length;
-    const hSuit = Int32Array.from(heroSuit), vSuit = Int32Array.from(villSuit);
-    const pHa = Int32Array.from(pairH), pVa = Int32Array.from(pairV);
+    const board = this._cardsBitset(setup.boardCards);
+    const uIndex = new Int32Array(52 * 52).fill(-1);
+    const uSuitArr = [], uAArr = [], uBArr = [], uLoArr = [], uHiArr = [];
+    const addSide = (hands) => {
+      const u = [];
+      for (const hand of hands) {
+        const p = this._parseHand(hand);
+        if ((p.lo & board.lo) | (p.hi & board.hi)) continue; // conflicts with board
+        const key = p.a < p.b ? p.a * 52 + p.b : p.b * 52 + p.a;
+        let ui = uIndex[key];
+        if (ui < 0) {
+          ui = uIndex[key] = uAArr.length;
+          const s = this._suitsOfCards([hand.substring(0, 2), hand.substring(2, 4)]);
+          uSuitArr.push(s[0], s[1], s[2], s[3]);
+          uAArr.push(p.a); uBArr.push(p.b); uLoArr.push(p.lo); uHiArr.push(p.hi);
+        }
+        u.push(ui);
+      }
+      return u;
+    };
+    const heroU = addSide(setup.heroHands);
+    const villU = addSide(setup.villainHands);
+    const U = uAArr.length;
+    const uSuit = Int32Array.from(uSuitArr), uA = Int32Array.from(uAArr), uB = Int32Array.from(uBArr);
+    const hMult = new Int32Array(U), vMult = new Int32Array(U);
+    for (const u of heroU) hMult[u]++;
+    for (const u of villU) vMult[u]++;
+    const nH = heroU.length, nV = villU.length;
     const bb = setup._boardSuits || (setup._boardSuits = this._suitsFromBigMask(setup.boardMask));
 
-    const useCount = H >= 16 && V >= 16;
-    let confList = null, confOff = null;
+    // cardU[cardUOff[c]..cardUOff[c+1]) = union hands holding card c, used to
+    // drop hands whose hole cards appear in a runout (that deal is impossible).
+    const cardUOff = new Int32Array(53);
+    for (let u = 0; u < U; u++) { cardUOff[uA[u] + 1]++; cardUOff[uB[u] + 1]++; }
+    for (let c = 0; c < 52; c++) cardUOff[c + 1] += cardUOff[c];
+    const cardU = new Int32Array(U * 2), cfill = cardUOff.slice(0, 52);
+    for (let u = 0; u < U; u++) { cardU[cfill[uA[u]]++] = u; cardU[cfill[uB[u]]++] = u; }
+
+    const useCount = nH >= 16 && nV >= 16;
+    let pHa = null, pVa = null, P = 0, cardTotal = null;
     if (useCount) {
-      const confListArr = [];
-      confOff = new Int32Array(H + 1);
-      for (let h = 0; h < H; h++) {
-        const q = h << 2, a0 = hSuit[q], a1 = hSuit[q + 1], a2 = hSuit[q + 2], a3 = hSuit[q + 3];
-        for (let v = 0; v < V; v++) { const r = v << 2; if ((a0 & vSuit[r]) | (a1 & vSuit[r + 1]) | (a2 & vSuit[r + 2]) | (a3 & vSuit[r + 3])) confListArr.push(v); }
-        confOff[h + 1] = confListArr.length;
+      // cardTotal[c] = number of villain entries holding card c.
+      cardTotal = new Int32Array(52);
+      for (let u = 0; u < U; u++) { cardTotal[uA[u]] += vMult[u]; cardTotal[uB[u]] += vMult[u]; }
+    } else {
+      const ph = [], pv = [];
+      for (const h of heroU) {
+        const hl = uLoArr[h], hh = uHiArr[h];
+        for (const v of villU) {
+          if ((hl & uLoArr[v]) | (hh & uHiArr[v])) continue;
+          ph.push(h); pv.push(v);
+        }
       }
-      confList = Int32Array.from(confListArr);
+      pHa = Int32Array.from(ph); pVa = Int32Array.from(pv); P = pHa.length;
     }
-    return { hSuit, vSuit, pHa, pVa, confList, confOff, useCount, bb0: bb[0], bb1: bb[1], bb2: bb[2], bb3: bb[3], H, V, P };
+    return {
+      uSuit, uA, uB, hMult, vMult, U, nH, nV, useCount, pHa, pVa, P, cardTotal, cardUOff, cardU,
+      bb0: bb[0], bb1: bb[1], bb2: bb[2], bb3: bb[3]
+    };
   }
 
   /**
-   * Exact exhaustive kernel over runouts [runStart, runEnd). Evaluates each
-   * unique concrete hand once per runout, then resolves matchups by direct
-   * comparison (small fields) or sorted-villain binary-search counting with
-   * card-conflict correction (large fields). Byte-identical to unoptimized.
+   * Exact exhaustive kernel over runouts [runStart, runEnd). Hands holding a
+   * card dealt in the runout are dropped for that runout; every other unique
+   * concrete hand is evaluated once. Matchups are then resolved by direct
+   * comparison (small fields) or, for large fields, a radix sort of the live
+   * hands by value followed by a linear sweep over equal-value groups that
+   * keeps running villain counts in total and per hole card (to subtract
+   * villains sharing a card with the hero). Byte-identical to unoptimized.
+   * `comboSuits` holds 4 suit rank masks per runout (any number of cards).
    * @private
    */
   _runExhaustive(work, comboSuits, runStart, runEnd) {
-    const { hSuit, vSuit, pHa, pVa, confList, confOff, useCount, bb0, bb1, bb2, bb3, H, V, P } = work;
-    const heroVals = new Int32Array(H), villVals = new Int32Array(V);
-    const sortedV = useCount ? new Int32Array(V) : null;
+    const { uSuit, uA, uB, hMult, vMult, U, nV, useCount, pHa, pVa, P, cardTotal, cardUOff, cardU, bb0, bb1, bb2, bb3 } = work;
+    const uVals = new Int32Array(U);
+    // dead[u] === i  <=>  hand u holds a card dealt in runout i, so it takes no
+    // part in that runout (neither as hero nor as villain).
+    const dead = new Int32Array(U).fill(-1);
+    const cardTot = useCount ? new Int32Array(52) : null;
     let win = 0, tie = 0, lose = 0;
+
+    // Large-field scratch: live hand list, radix-sort buffers and counters,
+    // and per-card villain counts strictly below / equal to the current value.
+    const live = useCount ? new Int32Array(U) : null;
+    const tmp = useCount ? new Int32Array(U) : null;
+    const order = useCount ? new Int32Array(U) : null;
+    const cnt = useCount ? new Int32Array(3 * 257) : null;
+    const lessC = useCount ? new Int32Array(52) : null;
+    const eqC = useCount ? new Int32Array(52) : null;
+
     for (let i = runStart; i < runEnd; i++) {
       const b = i << 2;
+
+      // Mark hands holding a runout card; for counting, also remove those
+      // villains from the field total and the per-card totals.
+      let nVi = nV;
+      if (useCount) cardTot.set(cardTotal);
+      for (let s = 0; s < 4; s++) {
+        let m = comboSuits[b + s];
+        while (m) {
+          const low = m & -m; m ^= low;
+          const c = (31 - Math.clz32(low)) * 4 + s;
+          for (let k = cardUOff[c], e = cardUOff[c + 1]; k < e; k++) {
+            const u = cardU[k];
+            if (dead[u] === i) continue;
+            dead[u] = i;
+            if (useCount) { const vm = vMult[u]; if (vm) { nVi -= vm; cardTot[uA[u]] -= vm; cardTot[uB[u]] -= vm; } }
+          }
+        }
+      }
+
+      // Evaluate the live hands only.
       const d0 = bb0 | comboSuits[b], d1 = bb1 | comboSuits[b + 1], d2 = bb2 | comboSuits[b + 2], d3 = bb3 | comboSuits[b + 3];
-      for (let h = 0; h < H; h++) { const q = h << 2; heroVals[h] = this._eval7(hSuit[q] | d0, hSuit[q + 1] | d1, hSuit[q + 2] | d2, hSuit[q + 3] | d3); }
-      for (let v = 0; v < V; v++) { const q = v << 2; villVals[v] = this._eval7(vSuit[q] | d0, vSuit[q + 1] | d1, vSuit[q + 2] | d2, vSuit[q + 3] | d3); }
-      if (useCount) {
-        sortedV.set(villVals);
-        sortedV.sort();
-        for (let h = 0; h < H; h++) {
-          const x = heroVals[h];
-          let lo = 0, hb = V; while (lo < hb) { const mid = (lo + hb) >> 1; if (sortedV[mid] < x) lo = mid + 1; else hb = mid; }
-          let up = lo; hb = V; while (up < hb) { const mid = (up + hb) >> 1; if (sortedV[mid] <= x) up = mid + 1; else hb = mid; }
-          let wH = lo, tH = up - lo, lH = V - up;
-          for (let ci = confOff[h], end = confOff[h + 1]; ci < end; ci++) { const cv = villVals[confList[ci]]; if (cv < x) wH--; else if (cv === x) tH--; else lH--; }
-          win += wH; tie += tH; lose += lH;
+      for (let u = 0; u < U; u++) {
+        if (dead[u] === i) continue;
+        const q = u << 2;
+        uVals[u] = this._eval7(uSuit[q] | d0, uSuit[q + 1] | d1, uSuit[q + 2] | d2, uSuit[q + 3] | d3);
+      }
+
+      if (!useCount) {
+        for (let p = 0; p < P; p++) {
+          const hu = pHa[p], vu = pVa[p];
+          if (dead[hu] === i || dead[vu] === i) continue;
+          const hv = uVals[hu], vv = uVals[vu]; if (hv > vv) win++; else if (vv > hv) lose++; else tie++;
         }
-      } else {
-        for (let p = 0; p < P; p++) { const hv = heroVals[pHa[p]], vv = villVals[pVa[p]]; if (hv > vv) win++; else if (vv > hv) lose++; else tie++; }
+        continue;
+      }
+
+      // LSD radix sort of the live hands by value (values < 2^24: 3 x 8 bits).
+      let L = 0;
+      cnt.fill(0);
+      for (let u = 0; u < U; u++) {
+        if (dead[u] === i) continue;
+        live[L++] = u;
+        const v = uVals[u];
+        cnt[(v & 255) + 1]++; cnt[257 + ((v >> 8) & 255) + 1]++; cnt[514 + ((v >> 16) & 255) + 1]++;
+      }
+      for (let o = 0; o < 771; o += 257) for (let r = 0; r < 256; r++) cnt[o + r + 1] += cnt[o + r];
+      for (let k = 0; k < L; k++) { const u = live[k]; tmp[cnt[uVals[u] & 255]++] = u; }
+      for (let k = 0; k < L; k++) { const u = tmp[k]; live[cnt[257 + ((uVals[u] >> 8) & 255)]++] = u; }
+      for (let k = 0; k < L; k++) { const u = live[k]; order[cnt[514 + ((uVals[u] >> 16) & 255)]++] = u; }
+      lessC.fill(0);
+
+      let below = 0; // villain entries with value < current group value
+      for (let g = 0; g < L;) {
+        const x = uVals[order[g]];
+        let e = g + 1; while (e < L && uVals[order[e]] === x) e++;
+        // Villain counts at exactly x: total and per card.
+        let eqTotal = 0;
+        for (let k = g; k < e; k++) { const u = order[k], m = vMult[u]; if (m) { eqTotal += m; eqC[uA[u]] += m; eqC[uB[u]] += m; } }
+        const above = nVi - below - eqTotal;
+        // Heroes at x. A villain holding both hero cards (the identical hand)
+        // is subtracted on each card, so add it back once (it ties at x).
+        for (let k = g; k < e; k++) {
+          const u = order[k], m = hMult[u];
+          if (!m) continue;
+          const a = uA[u], c = uB[u];
+          const w = below - lessC[a] - lessC[c];
+          const t = eqTotal - eqC[a] - eqC[c] + vMult[u];
+          const l = above - (cardTot[a] - lessC[a] - eqC[a]) - (cardTot[c] - lessC[c] - eqC[c]);
+          win += w * m; tie += t * m; lose += l * m;
+        }
+        // Fold this group into the running "below" counts.
+        for (let k = g; k < e; k++) { const u = order[k], m = vMult[u]; if (m) { lessC[uA[u]] += m; lessC[uB[u]] += m; eqC[uA[u]] = 0; eqC[uB[u]] = 0; } }
+        below += eqTotal;
+        g = e;
       }
     }
     return { win, tie, lose };
@@ -1374,98 +1702,67 @@ class BitVal {
    * @private
    */
   async _compareRangeOptimized(setup, progressCallback = null, progressInterval = 100, useWorkers = true) {
-    // Exhaustive (flop/turn): run the EXACT kernel on the main thread. It's now
-    // fast enough (~tens of ms) that this is the right choice, and it makes the
-    // worker and non-worker paths agree byte-for-byte (fixes the exact-vs-
-    // approximate split that per-canonical-group workers had). Splitting runouts
-    // across workers was a net loss here (structured-cloning the pair/conflict
-    // work to every worker dwarfs the compute) — true off-thread parallelism of
-    // this path needs SharedArrayBuffer (COOP/COEP), left as a follow-up. The
-    // reusable _runExhaustive / _buildExhaustiveWork are kept for that.
+    // Exhaustive (flop/turn): the EXACT kernel. Large jobs are split by runout
+    // across the worker pool (the work is a few small typed arrays, cheap to
+    // post); small ones stay on the main thread where they're faster than the
+    // messaging. Totals are integer sums, so both agree byte-for-byte.
     if (setup.isExhaustive) {
+      if (useWorkers && typeof Worker !== 'undefined') {
+        const work = this._buildExhaustiveWork(setup);
+        const comboSuits = setup._comboSuits;
+        const nRun = comboSuits.length >> 2;
+        if (work.U * nRun >= this._EXACT_WORKER_THRESHOLD) {
+          const nw = (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) || 4;
+          // Runouts cost about the same, so one chunk per worker (fewer posts).
+          const chunk = Math.max(1, Math.ceil(nRun / nw));
+          let next = 0, done = 0, win = 0, tie = 0, lose = 0;
+          await this._runKernelBatches(work,
+            () => { if (next >= nRun) return null; const a = next; next = Math.min(nRun, next + chunk); return comboSuits.slice(a * 4, next * 4); },
+            (r, n) => { win += r.win; tie += r.tie; lose += r.lose; done += n; if (progressCallback) progressCallback(done, nRun, `Evaluating runouts ${done}/${nRun}`); },
+            true, progressCallback);
+          if (progressCallback) progressCallback(nRun, nRun, 'Complete');
+          return { win, tie, lose };
+        }
+      }
       return await this._compareRangeOptimizedSequential(setup, progressCallback, progressInterval);
     }
 
-    // Pre-calculate board suit counts once (constant for all matchups)
-    const boardSuitCounts = setup.boardCards.length > 0
-      ? this._getBoardSuitCounts(setup.boardCards)
-      : null;
-    
-    // Group validMatchups by canonical key pair
-    // This ensures we only process matchups that actually exist, avoiding Cartesian product issues
-    const matchupGroups = new Map();
-    for (const matchup of setup.validMatchups) {
-      const mHKey = this._getCanonicalKey(
-        matchup.heroHand, 
-        setup.boardCards, 
-        setup.numberOfBoardCards, 
-        boardSuitCounts
-      );
-      const mVKey = this._getCanonicalKey(
-        matchup.villainHand, 
-        setup.boardCards, 
-        setup.numberOfBoardCards, 
-        boardSuitCounts
-      );
-      const key = `${mHKey}:${mVKey}`;
-      
-      if (!matchupGroups.has(key)) {
-        matchupGroups.set(key, {
-          heroKey: mHKey,
-          villainKey: mVKey,
-          representative: matchup,
-          count: 0
-        });
-      }
-      matchupGroups.get(key).count++;
+    // Opt-in shared-board Monte Carlo.
+    if (this.mcSharedBoards) {
+      return await this._compareRangeSharedBoards(setup, progressCallback, useWorkers);
     }
-    
-    // Collect all matchups to evaluate (only those that actually exist)
-    const matchupsToEvaluate = [];
-    for (const [key, group] of matchupGroups) {
-      const validPair = group.representative;
-      matchupsToEvaluate.push({
-        key,
-        validCount: group.count,
-        heroKey: group.heroKey,
-        heroHand: validPair.heroHand,
-        heroMask: validPair.heroMask,
-        villainKey: group.villainKey,
-        villainHand: validPair.villainHand,
-        villainMask: validPair.villainMask
-      });
-    }
-    
-    // Calculate total matchups (number of unique canonical key pairs)
+
+    // Group validMatchups by canonical key pair (only matchups that exist).
+    const matchupsToEvaluate = this._groupMonteCarloMatchups(setup);
     const totalMatchups = matchupsToEvaluate.length;
-    
+
     // Check if workers should be used
-    const shouldUseWorkers = useWorkers && 
-                             typeof Worker !== 'undefined' && 
-                             matchupsToEvaluate.length >= 4;
-    
-    if (!shouldUseWorkers) {
-      // Fallback to sequential execution
+    const shouldUseWorkers = useWorkers &&
+                             typeof Worker !== 'undefined' &&
+                             totalMatchups >= 4;
+    let workers = null;
+    if (shouldUseWorkers) {
+      const numWorkers = Math.min((typeof navigator !== 'undefined' && navigator.hardwareConcurrency) || 4, totalMatchups);
+      // Persistent pool (created once, reused across calls). Creation can throw
+      // synchronously (e.g. a cross-origin worker URL); fall back to sequential.
+      try { workers = this._acquireWorkers(numWorkers); } catch (e) { workers = null; }
+    }
+    if (!workers || workers.length === 0) {
       return await this._compareRangeOptimizedSequential(setup, progressCallback, progressInterval);
     }
-    
-    // Use Web Workers for parallelization
-    const numWorkers = Math.min(navigator.hardwareConcurrency || 4, matchupsToEvaluate.length);
-    const batchSize = Math.ceil(matchupsToEvaluate.length / numWorkers);
-    const batches = [];
-    for (let i = 0; i < matchupsToEvaluate.length; i += batchSize) {
-      batches.push(matchupsToEvaluate.slice(i, i + batchSize));
-    }
+    const numWorkers = workers.length;
 
-    // Serialize setup for workers
+    // Dynamic dispatch: hand out small chunks to whichever worker is free.
+    // With Monte Carlo early-stop, matchup cost varies a lot (lopsided matchups
+    // converge in ~8k draws, close ones run the full count), so equal static
+    // batches left most workers idle behind the slowest one.
+    const chunkSize = Math.max(1, Math.ceil(totalMatchups / (numWorkers * 8)));
     const serializedSetup = this._serializeSetup(setup);
-
-    // Acquire persistent workers from the pool (created once, reused across calls).
-    // Previously a fresh Worker was spawned and terminated per compareRange call,
-    // paying thread-spawn + importScripts('./bitval.js') parse on every query.
-    const workers = this._acquireWorkers(batches.length);
-    const promises = [];
-    let completedMatchups = 0;
+    let next = 0, completedMatchups = 0, win = 0, tie = 0, lose = 0, alive = numWorkers;
+    const addResult = (r) => {
+      win += r.matchupWin * r.validCount; tie += r.matchupTie * r.validCount; lose += r.matchupLose * r.validCount;
+      completedMatchups++;
+    };
 
     // Progress tracking
     let lastProgressTime = 0;
@@ -1478,69 +1775,161 @@ class BitVal {
       }
     }, progressUpdateInterval) : null;
 
-    for (let i = 0; i < batches.length; i++) {
-      const worker = workers[i];
-
-      const promise = new Promise((resolve, reject) => {
-        // One-shot handlers per dispatch; cleared on settle so the pooled worker
-        // is clean for the next call. (Assumes compareRange calls don't overlap.)
-        const cleanup = () => { worker.onmessage = null; worker.onerror = null; };
-        worker.onmessage = (e) => {
-          cleanup();
-          if (e.data.success) {
-            completedMatchups += e.data.results.length;
-            resolve(e.data.results);
-          } else {
-            reject(new Error(e.data.error || 'Worker error'));
+    // Each worker loop pulls the next chunk until none are left. A worker that
+    // crashes is dropped from the pool and its in-flight chunk is evaluated on
+    // the main thread, so one bad worker never loses work or fails the call.
+    const runWorker = (worker, workerId) => new Promise((resolve, reject) => {
+      let current = null;
+      const cleanup = () => { worker.onmessage = null; worker.onerror = null; };
+      const dispatch = () => {
+        if (next >= totalMatchups) { cleanup(); resolve(); return; }
+        const start = next; next = Math.min(totalMatchups, next + chunkSize);
+        current = matchupsToEvaluate.slice(start, next);
+        worker.postMessage({ matchups: current.map(m => this._serializeMatchup(m)), setupData: serializedSetup, workerId });
+      };
+      // One handler set per call; cleared on settle so the pooled worker is
+      // clean for the next call. (Assumes compareRange calls don't overlap.)
+      worker.onmessage = (e) => {
+        if (!e.data.success) { cleanup(); reject(new Error(e.data.error || 'Worker error')); return; }
+        for (const r of e.data.results) addResult(r);
+        current = null;
+        dispatch();
+      };
+      worker.onerror = (error) => {
+        if (error && error.preventDefault) error.preventDefault();
+        cleanup();
+        this._discardWorker(worker);
+        try {
+          if (current) for (const m of current) addResult({ validCount: m.validCount, ...this._evaluateMatchupSync(m.heroMask, m.villainMask, setup) });
+          current = null;
+          // Last worker of this call died: finish the remaining chunks here.
+          if (--alive === 0) {
+            while (next < totalMatchups) { const m = matchupsToEvaluate[next++]; addResult({ validCount: m.validCount, ...this._evaluateMatchupSync(m.heroMask, m.villainMask, setup) }); }
           }
-        };
-        worker.onerror = (error) => {
-          cleanup();
-          // A crashed worker can't be reused - drop it from the pool.
-          this._discardWorker(worker);
-          reject(error);
-        };
-
-        // Serialize matchups for this batch
-        const serializedBatch = batches[i].map(m => this._serializeMatchup(m));
-
-        worker.postMessage({
-          matchups: serializedBatch,
-          setupData: serializedSetup,
-          workerId: i
-        });
-      });
+          resolve();
+        } catch (err) { reject(err); }
+      };
+      dispatch();
+    });
 
-      promises.push(promise);
-    }
-
-    // Wait for all workers and aggregate results
-    let win = 0, tie = 0, lose = 0;
     try {
-      const allResults = await Promise.all(promises);
-
-      for (const batchResults of allResults) {
-        for (const result of batchResults) {
-          win += result.matchupWin * result.validCount;
-          tie += result.matchupTie * result.validCount;
-          lose += result.matchupLose * result.validCount;
-        }
-      }
+      await Promise.all(workers.map((w, i) => runWorker(w, i)));
     } finally {
-      // Clean up progress interval
-      if (progressIntervalId) {
-        clearInterval(progressIntervalId);
-      }
-
+      if (progressIntervalId) clearInterval(progressIntervalId);
       // Workers are NOT terminated - they stay in the pool for the next call.
       // Callers can free them explicitly with terminateWorkerPool().
+      if (progressCallback) progressCallback(totalMatchups, totalMatchups, 'Complete');
+    }
+
+    return { win, tie, lose };
+  }
 
-      // Final progress update
-      if (progressCallback) {
-        progressCallback(totalMatchups, totalMatchups, 'Complete');
+  /**
+   * Runs the exact kernel (_runExhaustive) over batches of runouts — on the
+   * worker pool when allowed and available, otherwise on the main thread.
+   * `nextBatch()` returns an Int32Array of runouts (4 suit masks each) or null
+   * when there's nothing more to do (it may stop early); `onResult(r, n)` gets
+   * each batch's { win, tie, lose } and its runout count. Batches are handed
+   * out to whichever worker is free; a worker that fails is dropped and its
+   * batch (and, if none are left, the rest) runs on the main thread.
+   * @private
+   */
+  async _runKernelBatches(work, nextBatch, onResult, useWorkers, progressCallback = null) {
+    const runLocal = (b) => onResult(this._runExhaustive(work, b, 0, b.length >> 2), b.length >> 2);
+    let workers = null;
+    if (useWorkers && typeof Worker !== 'undefined') {
+      const n = (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) || 4;
+      try { workers = this._acquireWorkers(n); } catch (e) { workers = null; }
+    }
+    if (!workers || workers.length === 0) {
+      let b;
+      while ((b = nextBatch())) {
+        runLocal(b);
+        // Keep the page responsive between batches when someone is watching.
+        if (progressCallback) await new Promise(resolve => setTimeout(resolve, 0));
       }
-    }
+      return;
+    }
+    let alive = workers.length;
+    await Promise.all(workers.map((worker) => new Promise((resolve, reject) => {
+      let current = null;
+      const cleanup = () => { worker.onmessage = null; worker.onerror = null; };
+      const dispatch = () => {
+        current = nextBatch();
+        if (!current) { cleanup(); resolve(); return; }
+        worker.postMessage({ type: 'kernel', work, boards: current });
+      };
+      worker.onmessage = (e) => {
+        if (!e.data.success) { cleanup(); reject(new Error(e.data.error || 'Worker error')); return; }
+        onResult(e.data.result, current.length >> 2);
+        dispatch();
+      };
+      worker.onerror = (error) => {
+        if (error && error.preventDefault) error.preventDefault();
+        cleanup();
+        this._discardWorker(worker);
+        try {
+          if (current) runLocal(current);
+          if (--alive === 0) { let b; while ((b = nextBatch())) runLocal(b); }
+          resolve();
+        } catch (err) { reject(err); }
+      };
+      dispatch();
+    })));
+  }
 
+  /**
+   * Opt-in Monte Carlo (bitval.mcSharedBoards = true): sample boards once from
+   * the live deck and run the exact kernel over them, so every hand is
+   * evaluated once per board and ALL valid pairs are counted on every board.
+   * Hands that collide with a sampled board sit that board out, which is
+   * exactly conditional sampling per matchup, so the equity is unbiased (and
+   * there's no canonical grouping). `iterations` caps the number of boards;
+   * sampling stops early once the batch-means 95% CI half-width of the
+   * aggregate equity is below `mcTarget` percentage points.
+   * @private
+   */
+  async _compareRangeSharedBoards(setup, progressCallback = null, useWorkers = true) {
+    const work = this._buildExhaustiveWork(setup);
+    const ex = this._cardsBitset([...setup.boardCards, ...(setup.deadCards || [])]);
+    const deck = [];
+    for (let c = 0; c < 52; c++) if (!(c < 32 ? ex.lo & (1 << c) : ex.hi & (1 << (c - 32)))) deck.push(c);
+    const pool = Int32Array.from(deck), poolLen = pool.length;
+    const k = setup.numberOfCardsToDeal, total = setup.iterations;
+    if (k > poolLen || total <= 0) return { win: 0, tie: 0, lose: 0 };
+    const batchSize = Math.max(64, Math.min(1024, Math.ceil(total / 16)));
+    const target = setup.mcTarget > 0 ? setup.mcTarget / 100 : 0;
+    let st = new XorShift32().state;
+    let issued = 0, done = 0, stop = false, win = 0, tie = 0, lose = 0;
+    let nb = 0, sumEq = 0, sumEq2 = 0;
+
+    const nextBatch = () => {
+      if (stop || issued >= total) return null;
+      const n = Math.min(batchSize, total - issued);
+      issued += n;
+      const out = new Int32Array(n * 4);
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < k; j++) { // partial Fisher-Yates over the live deck
+          st ^= st << 13; st ^= st >> 17; st ^= st << 5;
+          const r = j + Math.abs(st) % (poolLen - j);
+          const c = pool[r]; pool[r] = pool[j]; pool[j] = c;
+          out[i * 4 + (c & 3)] |= 1 << (c >> 2);
+        }
+      }
+      return out;
+    };
+    const onResult = (r, n) => {
+      win += r.win; tie += r.tie; lose += r.lose; done += n;
+      const t = r.win + r.tie + r.lose;
+      if (t > 0) { const e = (r.win + r.tie / 2) / t; nb++; sumEq += e; sumEq2 += e * e; }
+      if (target && nb >= 8) {
+        const mean = sumEq / nb, v = Math.max(0, (sumEq2 - nb * mean * mean) / (nb - 1));
+        if (1.96 * Math.sqrt(v / nb) < target) stop = true;
+      }
+      if (progressCallback) progressCallback(done, total, `Sampled ${done.toLocaleString()} boards`);
+    };
+    await this._runKernelBatches(work, nextBatch, onResult, useWorkers, progressCallback);
+    if (progressCallback) progressCallback(total, total, 'Complete');
     return { win, tie, lose };
   }
 
@@ -1553,7 +1942,7 @@ class BitVal {
   _acquireWorkers(count) {
     if (!this._workerPool) this._workerPool = [];
     while (this._workerPool.length < count) {
-      this._workerPool.push(new Worker('./bitval-worker.js'));
+      this._workerPool.push(new Worker(this.workerUrl));
     }
     return this._workerPool.slice(0, count);
   }
@@ -1646,26 +2035,6 @@ class BitVal {
     }
   }
 
-  /**
-   * Flattens hands to canonical keys for caching optimization.
-   * @private
-   */
-  _flattenHandsToCanonical(hands, boardCards = [], numberOfBoardCards = 5) {
-    const canonicalMap = new Map();
-    const canonicalToHand = new Map();
-    const boardSuitCounts = boardCards.length > 0 ? this._getBoardSuitCounts(boardCards) : null;
-    
-    for (const hand of hands) {
-      const key = this._getCanonicalKey(hand, boardCards, numberOfBoardCards, boardSuitCounts);
-      canonicalMap.set(key, (canonicalMap.get(key) || 0) + 1);
-      if (!canonicalToHand.has(key)) {
-        canonicalToHand.set(key, hand);
-      }
-    }
-    
-    return { canonicalMap, canonicalToHand };
-  }
-
   /**
    * Gets board suit counts for flush potential calculation.
    * @private