poker-bitvaljs 1.1.0 → 1.1.2

package/bitval-worker.js

@@ -0,0 +1,153 @@
+// Web Worker for parallel matchup evaluation
+// Loads bitval.js to access BitVal class and dependencies
+importScripts('./bitval.js');
+
+/**
+ * Deserializes setup data from main thread (converts string BigInts back to BigInt)
+ */
+function deserializeSetup(setupData) {
+  const setup = {
+    ...setupData,
+    boardMask: BigInt(setupData.boardMask),
+    deadCardsMask: BigInt(setupData.deadCardsMask),
+    comboArray: setupData.comboArray ? setupData.comboArray.map(s => BigInt(s)) : null,
+    // Keep other properties as-is
+    boardCards: setupData.boardCards,
+    numberOfBoardCards: setupData.numberOfBoardCards,
+    iterations: setupData.iterations,
+    isExhaustive: setupData.isExhaustive,
+    numberOfCardsToDeal: setupData.numberOfCardsToDeal
+  };
+  return setup;
+}
+
+/**
+ * Deserializes matchup data (converts string BigInt masks back to BigInt)
+ */
+function deserializeMatchup(matchupData) {
+  return {
+    ...matchupData,
+    heroMask: BigInt(matchupData.heroMask),
+    villainMask: BigInt(matchupData.villainMask)
+  };
+}
+
+/**
+ * Evaluates a single matchup in the worker context
+ * Similar to _evaluateMatchup but without progress callbacks
+ */
+async function evaluateMatchupInWorker(heroMask, villainMask, setup, evalCache, cacheInfo, bitval) {
+  let win = 0, tie = 0, lose = 0;
+  const deadMask = heroMask | villainMask | setup.deadCardsMask;
+  const matchupDeadMask = heroMask | villainMask; // Only matchup-level dead cards (excludes setup.deadCardsMask)
+  
+  // Initialize random number generator for Monte Carlo (not needed for exhaustive)
+  if (!setup.isExhaustive) {
+    bitval.xorShift = new XorShift32();
+  }
+  
+  // Prepare for exhaustive enumeration if applicable
+  let comboArray = null;
+  let iterations = setup.iterations;
+  if (setup.isExhaustive) {
+    // Use comboArray from setup if available, otherwise compute it
+    if (setup.comboArray && setup.comboArray.length > 0) {
+      comboArray = setup.comboArray;
+      iterations = comboArray.length;
+    } else {
+      // Compute comboArray if not provided
+      const availableMasks = bitval._getAvailableCardMasksByLookUp(deadMask);
+      comboArray = bitval._getCombinations(availableMasks, setup.numberOfCardsToDeal);
+      iterations = comboArray.length;
+    }
+  }
+  
+  // Main evaluation loop
+  for (let i = 0; i < iterations; i++) {
+    // Generate board: use pre-computed combo for exhaustive, or deal randomly
+    const board = setup.isExhaustive 
+      ? setup.boardMask | comboArray[i]
+      : bitval.deal(setup.boardMask, deadMask, setup.numberOfCardsToDeal) | setup.boardMask;
+    
+    // Evaluate both hands
+    let hEval, hKick, vEval, vKick;
+    if (cacheInfo && evalCache) {
+      [hEval, hKick] = bitval._getCachedEvaluation(cacheInfo.heroKey, cacheInfo.heroHand, board, evalCache, matchupDeadMask);
+      [vEval, vKick] = bitval._getCachedEvaluation(cacheInfo.villainKey, cacheInfo.villainHand, board, evalCache, matchupDeadMask);
+    } else {
+      [hEval, hKick] = bitval.evaluate(heroMask | board);
+      [vEval, vKick] = bitval.evaluate(villainMask | board);
+    }
+    
+    // Compare and accumulate results
+    if (hEval > vEval || (hEval === vEval && hKick > vKick)) {
+      win++;
+    } else if (vEval > hEval || (vEval === hEval && vKick > hKick)) {
+      lose++;
+    } else {
+      tie++;
+    }
+  }
+  
+  return { matchupWin: win, matchupTie: tie, matchupLose: lose };
+}
+
+// Worker message handler
+self.onmessage = async function(e) {
+  try {
+    const { matchups, setupData, workerId } = e.data;
+    
+    // Deserialize setup
+    const setup = deserializeSetup(setupData);
+    
+    // Create BitVal instance and cache for this worker (reused for all matchups)
+    const bitval = new BitVal();
+    const evalCache = new FastestAutoClearingCache(16000000);
+    
+    const results = [];
+    
+    // Evaluate each matchup in the batch
+    for (const matchupData of matchups) {
+      const matchup = deserializeMatchup(matchupData);
+      
+      // Prepare cache info if available
+      const cacheInfo = matchup.heroKey ? {
+        heroKey: matchup.heroKey,
+        heroHand: matchup.heroHand,
+        villainKey: matchup.villainKey,
+        villainHand: matchup.villainHand
+      } : null;
+      
+      // Evaluate matchup
+      const result = await evaluateMatchupInWorker(
+        matchup.heroMask,
+        matchup.villainMask,
+        setup,
+        evalCache,
+        cacheInfo,
+        bitval
+      );
+      
+      results.push({
+        key: matchup.key,
+        validCount: matchup.validCount,
+        ...result
+      });
+    }
+    
+    // Send results back to main thread
+    self.postMessage({
+      workerId,
+      results,
+      success: true
+    });
+  } catch (error) {
+    // Send error back to main thread
+    self.postMessage({
+      workerId: e.data.workerId,
+      error: error.message,
+      success: false
+    });
+  }
+};
+

package/bitval.js

@@ -672,6 +672,13 @@ class BitVal {
     // Generate valid matchups (always needed)
     const validMatchups = this._generateValidMatchups(heroHands, villainHands, boardCards);
     
+    // Log all valid matchups for debugging
+    console.log(`\n[Valid Matchups] Generated ${validMatchups.length} valid matchups:`);
+    for (let i = 0; i < validMatchups.length; i++) {
+      const m = validMatchups[i];
+      console.log(`  ${i + 1}. Hero: ${m.heroHand} vs Villain: ${m.villainHand}`);
+    }
+    
     // Calculate canonical mappings only if optimization is enabled
     let hCanon = null;
     let vCanon = null;
@@ -786,6 +793,7 @@ class BitVal {
   async _evaluateMatchup(heroMask, villainMask, setup, evalCache = null, progressCallback = null, matchupIndex = 0, totalMatchups = 1) {
     let win = 0, tie = 0, lose = 0;
     const deadMask = heroMask | villainMask | setup.deadCardsMask;
+    const matchupDeadMask = heroMask | villainMask; // Only matchup-level dead cards (excludes setup.deadCardsMask)
     
     // Initialize random number generator for Monte Carlo (not needed for exhaustive)
     if (!setup.isExhaustive) {
@@ -796,8 +804,8 @@ class BitVal {
     let comboArray = null;
     let iterations = setup.iterations;
     if (setup.isExhaustive) {
-      const availableMasks = this._getAvailableCardMasksByLookUp(deadMask);
-      comboArray = this._getCombinations(availableMasks, setup.numberOfCardsToDeal);
+      // Reuse pre-computed comboArray from setup (already computed in _compareRangeSetup)
+      comboArray = setup.comboArray;
       iterations = comboArray.length;
     }
     
@@ -815,8 +823,8 @@ class BitVal {
       // Evaluate both hands - inlined for performance (no function call overhead)
       let hEval, hKick, vEval, vKick;
       if (evalCache) {
-        [hEval, hKick] = this._getCachedEvaluation(evalCache.heroKey, evalCache.heroHand, board, evalCache.cache);
-        [vEval, vKick] = this._getCachedEvaluation(evalCache.villainKey, evalCache.villainHand, board, evalCache.cache);
+        [hEval, hKick] = this._getCachedEvaluation(evalCache.heroKey, evalCache.heroHand, board, evalCache.cache, matchupDeadMask);
+        [vEval, vKick] = this._getCachedEvaluation(evalCache.villainKey, evalCache.villainHand, board, evalCache.cache, matchupDeadMask);
       } else {
         [hEval, hKick] = this.evaluate(heroMask | board);
         [vEval, vKick] = this.evaluate(villainMask | board);
@@ -940,10 +948,10 @@ class BitVal {
       ? this._getBoardSuitCounts(setup.boardCards) 
       : null;
     
-    // Pre-build lookup map: canonical key pair -> valid matchup
-    // This eliminates the O(n) find() call inside nested loops, reducing complexity
-    // from O(heroCanon × villainCanon × validMatchups) to O(validMatchups + heroCanon × villainCanon)
-    const canonicalToMatchup = new Map();
+    // Group validMatchups by canonical key pair
+    // This ensures we only process matchups that actually exist, avoiding Cartesian product issues
+    const matchupGroups = new Map();
+    console.log(`\n[Sequential - Grouping Matchups] Processing ${setup.validMatchups.length} valid matchups:`);
     for (const matchup of setup.validMatchups) {
       const mHKey = this._getCanonicalKey(
         matchup.heroHand, 
@@ -958,89 +966,94 @@ class BitVal {
         boardSuitCounts
       );
       const key = `${mHKey}:${mVKey}`;
-      if (!canonicalToMatchup.has(key)) {
-        canonicalToMatchup.set(key, matchup);
+      
+      console.log(`  Hero: ${matchup.heroHand} (${mHKey}) vs Villain: ${matchup.villainHand} (${mVKey}) -> Key: ${key}`);
+      
+      if (!matchupGroups.has(key)) {
+        matchupGroups.set(key, {
+          heroKey: mHKey,
+          villainKey: mVKey,
+          representative: matchup,
+          count: 0
+        });
       }
+      matchupGroups.get(key).count++;
     }
-    
-    // Calculate accurate total matchups (excluding invalid pairs with validCount=0)
-    let totalMatchups = 0;
-    for (const [hKey] of setup.hCanon.canonicalMap) {
-      for (const [vKey] of setup.vCanon.canonicalMap) {
-        const key = `${hKey}:${vKey}`;
-        if ((setup.validCounts.get(key) || 0) > 0) {
-          totalMatchups++;
-        }
-      }
+    console.log(`\n[Sequential - Matchup Groups] Created ${matchupGroups.size} unique canonical key pairs:`);
+    for (const [key, group] of matchupGroups) {
+      console.log(`  ${key}: ${group.count} matchup(s), example: ${group.representative.heroHand} vs ${group.representative.villainHand}`);
     }
     
+    // Calculate accurate total matchups (number of unique canonical key pairs)
+    const totalMatchups = matchupGroups.size;
+    
     let matchupIndex = 0;
-    for (const [hKey] of setup.hCanon.canonicalMap) {
-      for (const [vKey] of setup.vCanon.canonicalMap) {
-        const key = `${hKey}:${vKey}`;
-        const validCount = setup.validCounts.get(key) || 0;
-        
-        if (validCount === 0) continue;
-        
-        // O(1) lookup instead of O(n) find() - major performance improvement
-        const validPair = canonicalToMatchup.get(key);
-        if (!validPair) {
-          console.error(`[DIAG] ERROR: No valid pair found for ${hKey}:${vKey} despite validCount=${validCount}`);
-          continue;
-        }
-        
-        const cache = { 
-          heroKey: hKey, 
-          heroHand: validPair.heroHand, 
-          villainKey: vKey, 
-          villainHand: validPair.villainHand, 
-          cache: evalCache 
-        };
-        
-        const { matchupWin, matchupTie, matchupLose } = await this._evaluateMatchup(
-          validPair.heroMask, 
-          validPair.villainMask, 
-          setup, 
-          cache, 
-          progressCallback, 
-          matchupIndex, 
-          totalMatchups
-        );
-        
-        win += matchupWin * validCount;
-        tie += matchupTie * validCount;
-        lose += matchupLose * validCount;
+    // Iterate over actual matchup groups (not Cartesian product)
+    console.log(`\n[Sequential - Evaluating Matchups] Starting evaluation of ${totalMatchups} unique matchups:`);
+    for (const [key, group] of matchupGroups) {
+      const validCount = group.count;
+      const validPair = group.representative;
+      
+      // Log hand and canonical key mapping for debugging
+      console.log(`[Matchup] Hero: ${validPair.heroHand} (Key: ${group.heroKey}) vs Villain: ${validPair.villainHand} (Key: ${group.villainKey}) | Count: ${validCount}`);
+      
+      const cache = { 
+        heroKey: group.heroKey, 
+        heroHand: validPair.heroHand, 
+        villainKey: group.villainKey, 
+        villainHand: validPair.villainHand, 
+        cache: evalCache 
+      };
+      
+      const { matchupWin, matchupTie, matchupLose } = await this._evaluateMatchup(
+        validPair.heroMask, 
+        validPair.villainMask, 
+        setup, 
+        cache, 
+        progressCallback, 
+        matchupIndex, 
+        totalMatchups
+      );
+      
+      // Log equity results for this matchup
+      const totalIterations = matchupWin + matchupTie + matchupLose;
+      const equity = totalIterations > 0 ? (matchupWin + matchupTie / 2) / totalIterations * 100 : 0;
+      const weightedEquity = equity * validCount;
+      console.log(`[Equity] ${validPair.heroHand} vs ${validPair.villainHand} (${validCount}x): Win=${matchupWin}, Tie=${matchupTie}, Lose=${matchupLose}, Total=${totalIterations}, Equity=${equity.toFixed(2)}%, Weighted=${weightedEquity.toFixed(2)}%`);
+      
+      win += matchupWin * validCount;
+      tie += matchupTie * validCount;
+      lose += matchupLose * validCount;
+      
+      matchupIndex++;
+      if (progressCallback && matchupIndex % progressInterval === 0) {
+        const now = Date.now();
+        const shouldUpdateProgress = now - lastProgressTime >= progressUpdateInterval;
         
-        matchupIndex++;
-        if (progressCallback && matchupIndex % progressInterval === 0) {
-          const now = Date.now();
-          const shouldUpdateProgress = now - lastProgressTime >= progressUpdateInterval;
-          
-          // Use modern browser APIs for better scheduling when available
-          if (typeof scheduler !== 'undefined' && scheduler.postTask) {
-            await scheduler.postTask(() => {
-              if (shouldUpdateProgress) {
-                progressCallback(matchupIndex, totalMatchups, `Evaluating ${matchupIndex}`);
-                lastProgressTime = now;
-              }
-            }, { priority: 'user-blocking' });
-          } else if (typeof requestIdleCallback !== 'undefined') {
-            await new Promise(resolve => {
-              requestIdleCallback(() => {
-                if (shouldUpdateProgress) {
-                  progressCallback(matchupIndex, totalMatchups, `Evaluating ${matchupIndex}`);
-                  lastProgressTime = now;
-                }
-                resolve();
-              }, { timeout: 1 });
-            });
-          } else {
-            // Fallback to setTimeout
-            await new Promise(resolve => setTimeout(resolve, 0));
+        // Use modern browser APIs for better scheduling when available
+        if (typeof scheduler !== 'undefined' && scheduler.postTask) {
+          await scheduler.postTask(() => {
             if (shouldUpdateProgress) {
               progressCallback(matchupIndex, totalMatchups, `Evaluating ${matchupIndex}`);
               lastProgressTime = now;
             }
+          }, { priority: 'user-blocking' });
+        } else if (typeof requestIdleCallback !== 'undefined') {
+          await new Promise(resolve => {
+            requestIdleCallback(() => {
+              if (shouldUpdateProgress) {
+                progressCallback(matchupIndex, totalMatchups, `Evaluating ${matchupIndex}`);
+                lastProgressTime = now;
+              }
+              resolve();
+            }, { timeout: 1 });
+          });
+        } else {
+          // Fallback to setTimeout
+          await new Promise(resolve => setTimeout(resolve, 0));
+          if (shouldUpdateProgress) {
+            progressCallback(matchupIndex, totalMatchups, `Evaluating ${matchupIndex}`);
+            lastProgressTime = now;
           }
         }
       }
@@ -1061,8 +1074,10 @@ class BitVal {
       ? this._getBoardSuitCounts(setup.boardCards) 
       : null;
     
-    // Pre-build lookup map: canonical key pair -> valid matchup
-    const canonicalToMatchup = new Map();
+    // Group validMatchups by canonical key pair
+    // This ensures we only process matchups that actually exist, avoiding Cartesian product issues
+    const matchupGroups = new Map();
+    console.log(`\n[Parallel - Grouping Matchups] Processing ${setup.validMatchups.length} valid matchups:`);
     for (const matchup of setup.validMatchups) {
       const mHKey = this._getCanonicalKey(
         matchup.heroHand, 
@@ -1077,49 +1092,45 @@ class BitVal {
         boardSuitCounts
       );
       const key = `${mHKey}:${mVKey}`;
-      if (!canonicalToMatchup.has(key)) {
-        canonicalToMatchup.set(key, matchup);
+      
+      console.log(`  Hero: ${matchup.heroHand} (${mHKey}) vs Villain: ${matchup.villainHand} (${mVKey}) -> Key: ${key}`);
+      
+      if (!matchupGroups.has(key)) {
+        matchupGroups.set(key, {
+          heroKey: mHKey,
+          villainKey: mVKey,
+          representative: matchup,
+          count: 0
+        });
       }
+      matchupGroups.get(key).count++;
     }
-    
-    // Calculate accurate total matchups (excluding invalid pairs with validCount=0)
-    let totalMatchups = 0;
-    for (const [hKey] of setup.hCanon.canonicalMap) {
-      for (const [vKey] of setup.vCanon.canonicalMap) {
-        const key = `${hKey}:${vKey}`;
-        if ((setup.validCounts.get(key) || 0) > 0) {
-          totalMatchups++;
-        }
-      }
+    console.log(`\n[Parallel - Matchup Groups] Created ${matchupGroups.size} unique canonical key pairs:`);
+    for (const [key, group] of matchupGroups) {
+      console.log(`  ${key}: ${group.count} matchup(s), example: ${group.representative.heroHand} vs ${group.representative.villainHand}`);
     }
     
-    // Collect all matchups to evaluate
+    // Collect all matchups to evaluate (only those that actually exist)
     const matchupsToEvaluate = [];
-    for (const [hKey] of setup.hCanon.canonicalMap) {
-      for (const [vKey] of setup.vCanon.canonicalMap) {
-        const key = `${hKey}:${vKey}`;
-        const validCount = setup.validCounts.get(key) || 0;
-        
-        if (validCount === 0) continue;
-        
-        const validPair = canonicalToMatchup.get(key);
-        if (!validPair) {
-          console.error(`[DIAG] ERROR: No valid pair found for ${hKey}:${vKey} despite validCount=${validCount}`);
-          continue;
-        }
-        
-        matchupsToEvaluate.push({
-          key,
-          validCount,
-          heroKey: hKey,
-          heroHand: validPair.heroHand,
-          heroMask: validPair.heroMask,
-          villainKey: vKey,
-          villainHand: validPair.villainHand,
-          villainMask: validPair.villainMask
-        });
-      }
+    console.log(`\n[Parallel - Collecting Matchups] Building matchup list from ${matchupGroups.size} groups:`);
+    for (const [key, group] of matchupGroups) {
+      const validPair = group.representative;
+      console.log(`  Adding: ${key} (${group.count}x) - Hero: ${validPair.heroHand} vs Villain: ${validPair.villainHand}`);
+      matchupsToEvaluate.push({
+        key,
+        validCount: group.count,
+        heroKey: group.heroKey,
+        heroHand: validPair.heroHand,
+        heroMask: validPair.heroMask,
+        villainKey: group.villainKey,
+        villainHand: validPair.villainHand,
+        villainMask: validPair.villainMask
+      });
     }
+    console.log(`\n[Parallel - Matchups to Evaluate] Total: ${matchupsToEvaluate.length} unique matchups`);
+    
+    // Calculate total matchups (number of unique canonical key pairs)
+    const totalMatchups = matchupsToEvaluate.length;
     
     // Check if workers should be used
     const shouldUseWorkers = useWorkers && 
@@ -1159,7 +1170,7 @@ class BitVal {
     }, progressUpdateInterval) : null;
     
     for (let i = 0; i < batches.length; i++) {
-      const worker = new Worker('bitval-worker.js');
+      const worker = new Worker('./bitval-worker.js');
       workers.push(worker);
       
       const promise = new Promise((resolve, reject) => {
@@ -1197,6 +1208,18 @@ class BitVal {
       
       for (const batchResults of allResults) {
         for (const result of batchResults) {
+          // Log equity results for this matchup
+          const totalIterations = result.matchupWin + result.matchupTie + result.matchupLose;
+          const equity = totalIterations > 0 ? (result.matchupWin + result.matchupTie / 2) / totalIterations * 100 : 0;
+          const weightedEquity = equity * result.validCount;
+          
+          // Find the matchup details from matchupsToEvaluate
+          const matchup = matchupsToEvaluate.find(m => m.key === result.key);
+          const heroHand = matchup ? matchup.heroHand : 'Unknown';
+          const villainHand = matchup ? matchup.villainHand : 'Unknown';
+          
+          console.log(`[Equity] ${heroHand} vs ${villainHand} (${result.validCount}x): Win=${result.matchupWin}, Tie=${result.matchupTie}, Lose=${result.matchupLose}, Total=${totalIterations}, Equity=${equity.toFixed(2)}%, Weighted=${weightedEquity.toFixed(2)}%`);
+          
           win += result.matchupWin * result.validCount;
           tie += result.matchupTie * result.validCount;
           lose += result.matchupLose * result.validCount;
@@ -1226,12 +1249,34 @@ class BitVal {
     return { win, tie, lose };
   }
 
+  /**
+   * Generates a numeric hash key from canonical key and board for faster cache lookups.
+   * @private
+   */
+  _getCacheKeyHash(canonicalKey, board, matchupDeadMask = 0n) {
+    // Hash the canonical key string
+    let hash = 0;
+    for (let i = 0; i < canonicalKey.length; i++) {
+      hash = ((hash << 5) - hash) + canonicalKey.charCodeAt(i);
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    // Combine with board bits (use lower 32 bits of BigInt for fast XOR)
+    const boardBits = Number(board & 0xFFFFFFFFn);
+    hash = hash ^ boardBits;
+    
+    // Include matchup dead mask to prevent cross-matchup cache collisions
+    // This ensures different matchups (with different dead cards) don't share cache entries
+    const deadBits = Number(matchupDeadMask & 0xFFFFFFFFn);
+    return hash ^ deadBits;
+  }
+
   /**
    * Gets cached evaluation or evaluates and caches the result.
+   * Uses numeric hash keys for faster cache lookups.
    * @private
    */
-  _getCachedEvaluation(canonicalKey, originalHand, completeBoard, evalCache) {
-    const cacheKey = canonicalKey + completeBoard.toString();
+  _getCachedEvaluation(canonicalKey, originalHand, completeBoard, evalCache, matchupDeadMask = 0n) {
+    const cacheKey = this._getCacheKeyHash(canonicalKey, completeBoard, matchupDeadMask);
     if (evalCache.has(cacheKey)) return evalCache.get(cacheKey);
     const handMask = this.getBitMasked(this._handStringToCards(originalHand));
     const evaluation = this.evaluate(handMask | completeBoard);
@@ -1311,13 +1356,24 @@ class BitVal {
     const canonicalMap = new Map();
     const canonicalToHand = new Map();
     const boardSuitCounts = boardCards.length > 0 ? this._getBoardSuitCounts(boardCards) : null;
+    
+    console.log(`\n[Canonical Mapping] Processing ${hands.length} hands:`);
     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);
       }
+      console.log(`  Hand: ${hand} -> Canonical Key: ${key}`);
+    }
+    
+    // Show summary of canonical key groupings
+    console.log(`\n[Canonical Summary] ${canonicalMap.size} unique canonical keys from ${hands.length} hands:`);
+    for (const [key, count] of canonicalMap.entries()) {
+      const representativeHand = canonicalToHand.get(key);
+      console.log(`  ${key}: ${count} hand(s), example: ${representativeHand}`);
     }
+    
     return { canonicalMap, canonicalToHand };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poker-bitvaljs",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "High-performance poker hand evaluator optimized for browser environments, using bitwise operations for rapid poker hand analysis and equity calculations.",
   "main": "bitval.js",
   "scripts": {
@@ -19,10 +19,11 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/DarraghGeo/poker-bitvaljs.git"
+    "url": "git+https://github.com/DarraghGeo/poker-bitvaljs.git"
   },
   "files": [
     "bitval.js",
+    "bitval-worker.js",
     "README.md"
   ]
 }