poker-irongrid 1.1.0 → 1.2.0

package/README.md

@@ -11,9 +11,9 @@ npm install poker-irongrid
 ## Peer Dependencies
 
 - `svelte`: ^5.0.0
-- `poker-bitvaljs`: ^1.0.1 (for equity evaluation)
-- `poker-extval`: ^3.2.0 (for hand evaluation)
-- `poker-rangeman`: ^3.3.2 (for range parsing and filtering)
+- `poker-bitvaljs`: ^1.13.0 (for equity evaluation)
+- `poker-extval`: ^6.0.0-beta.6 (for hand evaluation)
+- `poker-rangeman`: ^4.0.0-beta.11 (for range parsing and filtering)
 
 ## Quick Start
 
@@ -84,7 +84,8 @@ npm install poker-irongrid
 | `colors` | `Array<string>` | `[]` | Color palette for highlighting hands (HSL format recommended) |
 | `defaultColor` | `string` | `'hsl(0, 0%, 100%)'` | Default background color for uncolored hands |
 | `defaultSelectedColor` | `string` | `'hsl(0, 0%, 85%)'` | Default color for selected hands without explicit color |
-| `evaluator` | `boolean` | `false` | Enable equity evaluation feature (requires hero cards and hands on grid) |
+| `evaluator` | `boolean` | `false` | Show hero's live equity against the hands on the grid (requires hero cards) |
+| `preflopTableUrl` | `string \| null` | `null` | URL of poker-bitvaljs's `bench/preflop-table.bin` for exact preflop equity (Monte Carlo without it) |
 
 #### Initial State Props
 
@@ -216,12 +217,22 @@ The component includes comprehensive filtering options:
 
 ### Equity Evaluation
 
-When `evaluator={true}`:
-- Calculate hero equity vs. villain range
-- Requires: 2 hero cards and hands on grid
-- Uses Monte Carlo simulation (10,000 iterations)
-- Displays results as percentages
-- Progress indicator during evaluation
+When `evaluator={true}`, hero's equity is calculated live (asynchronously) whenever the hero cards,
+board, dead cards or the hands on the grid change; there is no button to press.
+- The summary shows hero vs. villain equity against every selected or colored combo
+- The color buttons' **Eq** mode shows hero's equity against each color's hands
+- Both come from one poker-bitvaljs `compareRangeHands` call: exact on the flop, turn and river
+  (a few ms), Monte Carlo preflop and on 1-2 card boards
+- Pass `preflopTableUrl` for exact, near-instant preflop equity (the table is ~1.1 MB, fetched once):
+
+```svelte
+<script>
+  import PokerGridPanel from 'poker-irongrid';
+  import preflopTableUrl from 'poker-bitvaljs/bench/preflop-table.bin?url'; // Vite
+</script>
+
+<PokerGridPanel evaluator={true} {preflopTableUrl} />
+```
 
 ### Responsive Design
 

package/dist/poker-grid/PokerGridManager.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Loads poker-bitvaljs's preflop table (bench/preflop-table.bin, ~1.1 MB) once, for exact, near-instant
+ * preflop equity; without it preflop equity is a Monte Carlo estimate (within about ±0.3%).
+ * @param {string} url - Where the app serves the table
+ * @returns {Promise<boolean>} Whether the table loaded
+ */
+export function loadPreflopTable(url: string): Promise<boolean>;
 export class PokerGridManager {
     constructor(options?: {});
     hands: any;
@@ -114,6 +121,14 @@ export class PokerGridManager {
      * @returns {Promise<Object>} Filtered hands object
      */
     getFilteredHandsByCriteria(criteria: string[], boardCards?: string[], hands?: any): Promise<any>;
+    /**
+     * Keep the combos of a hands object that pass a test.
+     * @param {Object} hands - Hands object
+     * @param {(c1: string, c2: string) => boolean} test - Gets the two cards of each combo
+     * @param {string[]} deadCards - Combos holding these cards are left out
+     * @returns {Object} Matching hands
+     */
+    filterCombos(hands: any, test: (c1: string, c2: string) => boolean, deadCards?: string[]): any;
     /**
      * Get hands matching a rank.
      * @param {string} rank - Rank (A, K, Q, etc.)
@@ -123,7 +138,7 @@ export class PokerGridManager {
      */
     getHandsByRank(rank: string, hands?: any, deadCards?: string[]): any;
     /**
-     * Get hands matching a suit.
+     * Get hands holding at least one card of a suit.
      * @param {string} suitName - Suit name (clubs, diamonds, hearts, spades)
      * @param {Object} hands - Hands object
      * @param {string[]} deadCards - Dead cards to exclude
@@ -153,7 +168,7 @@ export class PokerGridManager {
      */
     getSuitedHands(hands?: any, deadCards?: string[]): any;
     /**
-     * Get offsuit hands.
+     * Get offsuit hands (different suits; includes pocket pairs).
      * @param {Object} hands - Hands object
      * @param {string[]} deadCards - Dead cards to exclude
      * @returns {Object} Matching hands
@@ -185,6 +200,15 @@ export class PokerGridManager {
      * @returns {string|null} Hand strength type
      */
     getHandStrengthType(hand: string, boardCards?: string[]): string | null;
+    strengthCacheBoard: any;
+    strengthCache: Map<any, any>;
+    /**
+     * Uncached hand strength type (see getHandStrengthType).
+     * @param {string} hand - Hand code
+     * @param {string[]} boardCards - Board cards
+     * @returns {string|null} Hand strength type
+     */
+    computeHandStrengthType(hand: string, boardCards: string[]): string | null;
     /**
      * Get hands by hand strength.
      * @param {string} targetStrength - Strength type
@@ -218,15 +242,29 @@ export class PokerGridManager {
      */
     removeColor(hands: any, color: string): any;
     /**
-     * Calculate color equities.
+     * Hero's equity against the villain hands on the grid, overall and per color, from one
+     * poker-bitvaljs compareRangeHands call (each villain combo's result against hero's hand).
+     * Villain hands are the combos that are selected or colored; hands holding a dead, board or
+     * hero card are left out.
      * @param {Object} hands - Hands object
-     * @param {string[]} heroCards - Hero cards
-     * @param {string[]} boardCards - Board cards
-     * @param {string[]} deadCards - Dead cards
+     * @param {string[]} heroCards - Hero cards (two)
+     * @param {string[]} boardCards - Board cards (0-5)
+     * @param {string[]} deadCards - Dead cards (may include hero and board cards)
      * @param {string[]} colors - Colors array
+     * @returns {Promise<{hero: number|null, villain: number|null, combos: number, byColor: Object}|null>}
+     *   Equities in percent (null when hero meets no villain combo); null without two hero cards.
+     */
+    calculateEquity(hands?: any, heroCards?: string[], boardCards?: string[], deadCards?: string[], colors?: string[]): Promise<{
+        hero: number | null;
+        villain: number | null;
+        combos: number;
+        byColor: any;
+    } | null>;
+    /**
+     * Hero's equity against each color's hands, rounded (0 when a color has no hands).
      * @returns {Promise<Object>} Color equities object
      */
-    calculateColorEquities(hands?: any, heroCards?: string[], boardCards?: string[], deadCards?: string[], colors?: string[]): Promise<any>;
+    calculateColorEquities(hands?: any, heroCards?: any, boardCards?: any, deadCards?: any, colors?: any): Promise<any>;
     /**
      * Apply predefined range.
      * @param {string} rangeName - Range name

package/dist/poker-grid/PokerGridManager.js

@@ -11,6 +11,50 @@ import { SUITS } from './utils/constants.js';
 // Handle CommonJS export
 const BitVal = BitValModule?.default || BitValModule;
 
+/** One shared evaluator: poker-bitvaljs keeps its Web Workers between calls. */
+let sharedBitVal = null;
+function getBitVal() {
+  if (!sharedBitVal) {
+    sharedBitVal = new BitVal();
+    // Monte Carlo spots (preflop, 1-2 card boards) sample boards once for every hand: much faster
+    sharedBitVal.mcSharedBoards = true;
+  }
+  return sharedBitVal;
+}
+
+let preflopTableLoad = null;
+/**
+ * Loads poker-bitvaljs's preflop table (bench/preflop-table.bin, ~1.1 MB) once, for exact, near-instant
+ * preflop equity; without it preflop equity is a Monte Carlo estimate (within about ±0.3%).
+ * @param {string} url - Where the app serves the table
+ * @returns {Promise<boolean>} Whether the table loaded
+ */
+export function loadPreflopTable(url) {
+  if (!url) return Promise.resolve(false);
+  preflopTableLoad ||= fetch(url)
+    .then(response => {
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      return response.arrayBuffer();
+    })
+    .then(buffer => {
+      getBitVal().loadPreflopTable(buffer);
+      return true;
+    })
+    .catch(error => {
+      console.warn('poker-irongrid: preflop table not loaded, using Monte Carlo preflop equity', error);
+      return false;
+    });
+  return preflopTableLoad;
+}
+
+/** Order-independent key for a two-card combo ('AcKd' and 'KdAc' match). */
+const comboKey = (combo) => {
+  const a = combo.substring(0, 2);
+  const b = combo.substring(2, 4);
+  return a < b ? a + b : b + a;
+};
+const isCombo = (hand) => typeof hand === 'string' && hand.length === 4;
+
 // Criteria mappings for RangeManager.hitsHand()
 const strengthCriteriaMap = {
   'onePair': ['Pair'],
@@ -278,9 +322,13 @@ export class PokerGridManager {
    * @returns {Object} Matching hands object
    */
   rangeManagerToMatching(rmResult, hands = this.hands) {
+    // Match by both cards, whatever order poker-rangeman lists them in
+    const keyed = new Map();
+    Object.keys(hands || {}).forEach(h => { if (isCombo(h)) keyed.set(comboKey(h), h); });
     const matching = {};
     rmResult.toArray().forEach(hand => {
-      if (hands[hand]) matching[hand] = hands[hand];
+      const original = keyed.get(comboKey(hand));
+      if (original) matching[original] = hands[original];
     });
     return matching;
   }
@@ -308,6 +356,25 @@ export class PokerGridManager {
     }
   }
 
+  /**
+   * Keep the combos of a hands object that pass a test.
+   * @param {Object} hands - Hands object
+   * @param {(c1: string, c2: string) => boolean} test - Gets the two cards of each combo
+   * @param {string[]} deadCards - Combos holding these cards are left out
+   * @returns {Object} Matching hands
+   */
+  filterCombos(hands, test, deadCards = []) {
+    const matching = {};
+    Object.keys(hands || {}).forEach(h => {
+      if (!isCombo(h)) return;
+      const c1 = h.substring(0, 2);
+      const c2 = h.substring(2, 4);
+      if (deadCards.includes(c1) || deadCards.includes(c2)) return;
+      if (test(c1, c2)) matching[h] = hands[h];
+    });
+    return matching;
+  }
+
   /**
    * Get hands matching a rank.
    * @param {string} rank - Rank (A, K, Q, etc.)
@@ -316,20 +383,11 @@ export class PokerGridManager {
    * @returns {Object} Matching hands
    */
   getHandsByRank(rank, hands = this.hands, deadCards = []) {
-    const allHands = Object.keys(hands);
-    if (allHands.length === 0) return {};
-    try {
-      const rankRange = `${rank}Xs,${rank}Xo`;
-      const currentRm = this.getHandsRangeManager(hands, deadCards);
-      const matched = currentRm.intersect(rankRange);
-      return this.rangeManagerToMatching(matched, hands);
-    } catch (error) {
-      return {};
-    }
+    return this.filterCombos(hands, (c1, c2) => c1[0] === rank || c2[0] === rank, deadCards);
   }
 
   /**
-   * Get hands matching a suit.
+   * Get hands holding at least one card of a suit.
    * @param {string} suitName - Suit name (clubs, diamonds, hearts, spades)
    * @param {Object} hands - Hands object
    * @param {string[]} deadCards - Dead cards to exclude
@@ -338,15 +396,7 @@ export class PokerGridManager {
   getHandsBySuit(suitName, hands = this.hands, deadCards = []) {
     const suitCode = SUITS.find(s => s.name === suitName)?.code;
     if (!suitCode) return {};
-    const allHands = Object.keys(hands);
-    if (allHands.length === 0) return {};
-    try {
-      const currentRm = this.getHandsRangeManager(hands, deadCards);
-      const matched = currentRm.hasSuit(suitCode);
-      return this.rangeManagerToMatching(matched, hands);
-    } catch (error) {
-      return {};
-    }
+    return this.filterCombos(hands, (c1, c2) => c1[1] === suitCode || c2[1] === suitCode, deadCards);
   }
 
   /**
@@ -359,15 +409,7 @@ export class PokerGridManager {
   getHandsByDoubleSuit(suitName, hands = this.hands, deadCards = []) {
     const suitCode = SUITS.find(s => s.name === suitName)?.code;
     if (!suitCode) return {};
-    const allHands = Object.keys(hands);
-    if (allHands.length === 0) return {};
-    try {
-      const currentRm = this.getHandsRangeManager(hands, deadCards);
-      const matched = currentRm.suitedOf(suitCode);
-      return this.rangeManagerToMatching(matched, hands);
-    } catch (error) {
-      return {};
-    }
+    return this.filterCombos(hands, (c1, c2) => c1[1] === suitCode && c2[1] === suitCode, deadCards);
   }
 
   /**
@@ -377,15 +419,7 @@ export class PokerGridManager {
    * @returns {Object} Matching hands
    */
   getPairedHands(hands = this.hands, deadCards = []) {
-    const allHands = Object.keys(hands);
-    if (allHands.length === 0) return {};
-    try {
-      const currentRm = this.getHandsRangeManager(hands, deadCards);
-      const matched = currentRm.intersect('22+');
-      return this.rangeManagerToMatching(matched, hands);
-    } catch (error) {
-      return {};
-    }
+    return this.filterCombos(hands, (c1, c2) => c1[0] === c2[0], deadCards);
   }
 
   /**
@@ -395,46 +429,17 @@ export class PokerGridManager {
    * @returns {Object} Matching hands
    */
   getSuitedHands(hands = this.hands, deadCards = []) {
-    const allHands = Object.keys(hands);
-    if (allHands.length === 0) return {};
-    try {
-      const currentRm = this.getHandsRangeManager(hands, deadCards);
-      // Use method chaining to combine all suited hands
-      let allSuited = new RangeManager([]);
-      ['c', 'd', 'h', 's'].forEach(suit => {
-        allSuited = allSuited.include(currentRm.suitedOf(suit));
-      });
-      return this.rangeManagerToMatching(allSuited, hands);
-    } catch (error) {
-      return {};
-    }
+    return this.filterCombos(hands, (c1, c2) => c1[1] === c2[1], deadCards);
   }
 
   /**
-   * Get offsuit hands.
+   * Get offsuit hands (different suits; includes pocket pairs).
    * @param {Object} hands - Hands object
    * @param {string[]} deadCards - Dead cards to exclude
    * @returns {Object} Matching hands
    */
   getOffsuitHands(hands = this.hands, deadCards = []) {
-    const allHands = Object.keys(hands);
-    if (allHands.length === 0) return {};
-    try {
-      const currentRm = this.getHandsRangeManager(hands, deadCards);
-      // Use method chaining to combine all offsuit hands
-      // For offsuit: get hands that have the suit but exclude suited hands
-      let allOffsuit = new RangeManager([]);
-      ['c', 'd', 'h', 's'].forEach(suit => {
-        // Get hands that have this suit, then exclude suited hands
-        const hasSuit = currentRm.hasSuit(suit);
-        const suited = currentRm.suitedOf(suit);
-        const offsuit = hasSuit.exclude(suited);
-        allOffsuit = allOffsuit.include(offsuit);
-      });
-      return this.rangeManagerToMatching(allOffsuit, hands);
-    } catch (error) {
-      return {};
-    }
+    return this.filterCombos(hands, (c1, c2) => c1[1] !== c2[1], deadCards);
   }
 
   /**
@@ -485,6 +490,24 @@ export class PokerGridManager {
    */
   getHandStrengthType(hand, boardCards = this.boardCards) {
     if (!boardCards || boardCards.length < 3) return null;
+    const boardKey = boardCards.join('');
+    if (this.strengthCacheBoard !== boardKey) {
+      this.strengthCacheBoard = boardKey;
+      this.strengthCache = new Map();
+    }
+    if (this.strengthCache.has(hand)) return this.strengthCache.get(hand);
+    const type = this.computeHandStrengthType(hand, boardCards);
+    this.strengthCache.set(hand, type);
+    return type;
+  }
+
+  /**
+   * Uncached hand strength type (see getHandStrengthType).
+   * @param {string} hand - Hand code
+   * @param {string[]} boardCards - Board cards
+   * @returns {string|null} Hand strength type
+   */
+  computeHandStrengthType(hand, boardCards) {
     try {
       const handCard1 = hand.substring(0, 2);
       const handCard2 = hand.substring(2, 4);
@@ -507,7 +530,6 @@ export class PokerGridManager {
       return null;
     } catch (error) {
       return null;
-      return null;
     }
   }
 
@@ -630,83 +652,79 @@ export class PokerGridManager {
   }
 
   /**
-   * Calculate color equities.
+   * Hero's equity against the villain hands on the grid, overall and per color, from one
+   * poker-bitvaljs compareRangeHands call (each villain combo's result against hero's hand).
+   * Villain hands are the combos that are selected or colored; hands holding a dead, board or
+   * hero card are left out.
    * @param {Object} hands - Hands object
-   * @param {string[]} heroCards - Hero cards
-   * @param {string[]} boardCards - Board cards
-   * @param {string[]} deadCards - Dead cards
+   * @param {string[]} heroCards - Hero cards (two)
+   * @param {string[]} boardCards - Board cards (0-5)
+   * @param {string[]} deadCards - Dead cards (may include hero and board cards)
    * @param {string[]} colors - Colors array
-   * @returns {Promise<Object>} Color equities object
+   * @returns {Promise<{hero: number|null, villain: number|null, combos: number, byColor: Object}|null>}
+   *   Equities in percent (null when hero meets no villain combo); null without two hero cards.
    */
-  async calculateColorEquities(hands = this.hands, heroCards = this.heroCards, boardCards = this.boardCards, deadCards = this.deadCards, colors = this.colors) {
-    if (heroCards?.length !== 2) {
-      return {};
-    }
+  async calculateEquity(hands = this.hands, heroCards = this.heroCards, boardCards = this.boardCards, deadCards = this.deadCards, colors = this.colors) {
+    if (heroCards?.length !== 2) return null;
+    const board = boardCards || [];
+    const otherDead = (deadCards || []).filter(card => !heroCards.includes(card) && !board.includes(card));
+    const blocked = new Set([...heroCards, ...board, ...otherDead]);
+
+    const villainHands = Object.keys(hands || {}).filter(h =>
+      isCombo(h) &&
+      (this.hasExplicitColor(hands[h]) || this.isSelected(hands[h])) &&
+      !blocked.has(h.substring(0, 2)) && !blocked.has(h.substring(2, 4))
+    );
 
-    try {
-      const coloredHands = Object.keys(hands).filter(h => 
-        Array.isArray(hands[h]) && hands[h].some(item => typeof item === 'string' && item.startsWith('hsl('))
-      );
-
-      if (coloredHands.length === 0) {
-        const equities = {};
-        colors.forEach(c => equities[c] = 0);
-        return equities;
-      }
+    const byColor = {};
+    (colors || []).forEach(c => { byColor[c] = null; });
+    if (villainHands.length === 0) return { hero: null, villain: null, combos: 0, byColor };
 
-      const bitval = new BitVal();
-      const heroHand = heroCards[0] + heroCards[1];
-      const heroHands = [heroHand];
-      const numberOfBoardCards = 5;
-      
-      const deadCardsFromInput = (deadCards || []).filter(card => 
-        !(heroCards || []).includes(card) && !(boardCards || []).includes(card)
-      );
-      const deadCardsForBitval = [...heroCards, ...deadCardsFromInput];
-      
-      const boardCardsCount = (boardCards || []).length;
-      const optimize = boardCardsCount < 3;
+    // Preflop, wait for the table if one is loading (otherwise the result would be Monte Carlo)
+    if (board.length === 0 && preflopTableLoad) await preflopTableLoad;
 
-      const equities = {};
-      
-      for (let i = 0; i < colors.length; i++) {
-        const color = colors[i];
-        
-        const colorHands = coloredHands.filter(h => 
-          hands[h].some(item => item === color)
-        );
+    // compareRangeHands(hero, villain, board, dead, numberOfBoardCards, iterations, optimize,
+    // progressCallback, progressInterval, useWorkers): exact on the flop/turn/river, Monte Carlo otherwise
+    const result = await getBitVal().compareRangeHands(
+      [heroCards[0] + heroCards[1]], villainHands, board, otherDead, 5, 20000, true, null, 100, true
+    );
 
-        if (colorHands.length === 0) {
-          equities[color] = 0;
-          continue;
-        }
+    // Villain rows are each villain combo's own win/tie/lose against hero
+    const rowOf = new Map();
+    result.villain.hands.forEach((h, i) => rowOf.set(comboKey(h), i));
+    const heroEquityAgainst = (combos) => {
+      let heroShare = 0;
+      let total = 0;
+      combos.forEach(h => {
+        const i = rowOf.get(comboKey(h));
+        if (i === undefined) return;
+        const win = result.villain.win[i];
+        const tie = result.villain.tie[i];
+        const lose = result.villain.lose[i];
+        heroShare += lose + tie / 2;
+        total += win + tie + lose;
+      });
+      return total > 0 ? (heroShare / total) * 100 : null;
+    };
 
-        try {
-          const result = await bitval.compareRange(
-            heroHands,
-            colorHands,
-            boardCards || [],
-            deadCardsForBitval,
-            numberOfBoardCards,
-            10000,
-            optimize,
-            null
-          );
+    const hero = heroEquityAgainst(villainHands);
+    (colors || []).forEach(color => {
+      const colorHands = villainHands.filter(h => hands[h].includes(color));
+      byColor[color] = colorHands.length > 0 ? heroEquityAgainst(colorHands) : null;
+    });
 
-          const total = result.win + result.tie + result.lose;
-          const heroEquity = total > 0 ? ((result.win + result.tie / 2) / total) * 100 : 0;
-          equities[color] = Math.round(heroEquity);
-        } catch (error) {
-          return;
-          equities[color] = 0;
-        }
-      }
-      
-      return equities;
-    } catch (error) {
-      return;
-      return {};
-    }
+    return { hero, villain: hero === null ? null : 100 - hero, combos: villainHands.length, byColor };
+  }
+
+  /**
+   * Hero's equity against each color's hands, rounded (0 when a color has no hands).
+   * @returns {Promise<Object>} Color equities object
+   */
+  async calculateColorEquities(hands = this.hands, heroCards = this.heroCards, boardCards = this.boardCards, deadCards = this.deadCards, colors = this.colors) {
+    const equity = await this.calculateEquity(hands, heroCards, boardCards, deadCards, colors);
+    const equities = {};
+    (colors || []).forEach(c => { equities[c] = Math.round(equity?.byColor?.[c] ?? 0); });
+    return equities;
   }
 
   // ==================== Range Methods ====================
@@ -1037,47 +1055,24 @@ export class PokerGridManager {
     if (activeHands.length === 0) return false;
     
     try {
-      const activeRm = new RangeManager(activeHands);
-      
+      const active = {};
+      activeHands.forEach(h => { active[h] = hands[h]; });
+      const allMatch = (matching) => Object.keys(matching).length === activeHands.length;
+
       switch (filterType) {
         case 'rank':
-          // Use standard notation: KK,K2s+,K2o+ to check all hands with this rank
-          const rankRange = `${filterValue}${filterValue},${filterValue}2s+,${filterValue}2o+`;
-          return activeRm.intersect(rankRange).size() === activeHands.length;
-        
+          return allMatch(this.getHandsByRank(filterValue, active));
         case 'suit':
-          const suitCode = SUITS.find(s => s.name === filterValue)?.code;
-          if (!suitCode) return false;
-          return activeRm.hasSuit(suitCode).size() === activeHands.length;
-        
+          return allMatch(this.getHandsBySuit(filterValue, active));
         case 'doubleSuit':
-          const doubleSuitCode = SUITS.find(s => s.name === filterValue)?.code;
-          if (!doubleSuitCode) return false;
-          return activeRm.suitedOf(doubleSuitCode).size() === activeHands.length;
-        
+          return allMatch(this.getHandsByDoubleSuit(filterValue, active));
         case 'paired':
-          return activeRm.intersect('22+').size() === activeHands.length;
-        
+          return allMatch(this.getPairedHands(active));
         case 'suited':
-          // Check if all active hands are suited in at least one suit
-          return ['c', 'd', 'h', 's'].some(suit => 
-            activeRm.suitedOf(suit).size() === activeHands.length
-          );
-        
+          return allMatch(this.getSuitedHands(active));
         case 'unsuited':
-          // Check if all active hands are offsuit (have different suits)
-          // For offsuit: get hands that have a suit but exclude suited hands
-          return ['c', 'd', 'h', 's'].some(suit => {
-            try {
-              const hasSuit = activeRm.hasSuit(suit);
-              const suited = activeRm.suitedOf(suit);
-              const offsuit = hasSuit.exclude(suited);
-              return offsuit.size() === activeHands.length;
-            } catch (error) {
-              return false;
-            }
-          });
-        
+          return allMatch(this.getOffsuitHands(active));
+
         case 'colored':
           return activeHands.every(h => 
             Array.isArray(hands[h]) && hands[h].some(item => typeof item === 'string' && item.startsWith('hsl('))
@@ -1123,7 +1118,6 @@ export class PokerGridManager {
       }
     } catch (error) {
       return false;
-      return false;
     }
   }
 

package/dist/poker-grid/components/DeadCardsInput.svelte

@@ -109,10 +109,10 @@
       else if (type === 'board') board = formatted;
       else if (type === 'dead') dead = formatted;
       
-      requestAnimationFrame(() => {
-        const newPos = Math.max(0, Math.min(cursorPos + diff, formatted.length));
-        input.setSelectionRange(newPos, newPos);
-      });
+      // Restore the caret right away: deferring it (e.g. to the next frame) moves it back
+      // after any keys typed in between, so fast typing landed in the wrong place
+      const newPos = Math.max(0, Math.min(cursorPos + diff, formatted.length));
+      input.setSelectionRange(newPos, newPos);
     } else {
       if (type === 'hero') hero = rawValue;
       else if (type === 'board') board = rawValue;

package/dist/poker-grid/components/DeadCardsInput.svelte.d.ts

@@ -1,7 +1,7 @@
 export default DeadCardsInput;
 type DeadCardsInput = SvelteComponent<{
-    deadCards?: any[];
     boardCards?: any[];
+    deadCards?: any[];
     heroCards?: any[];
 }, {
     deadCardsChange: CustomEvent<any>;
@@ -11,8 +11,8 @@ type DeadCardsInput = SvelteComponent<{
     $$bindings?: string;
 };
 declare const DeadCardsInput: $$__sveltets_2_IsomorphicComponent<{
-    deadCards?: any[];
     boardCards?: any[];
+    deadCards?: any[];
     heroCards?: any[];
 }, {
     deadCardsChange: CustomEvent<any>;

package/dist/poker-grid/components/DetailsPanel.svelte.d.ts

@@ -1,8 +1,8 @@
 export default DetailsPanel;
 type DetailsPanel = SvelteComponent<{
+    boardCards?: any[];
     hands?: {};
     deadCards?: any[];
-    boardCards?: any[];
     defaultColor?: string;
     defaultSelectedColor?: string;
     manager?: any;
@@ -14,9 +14,9 @@ type DetailsPanel = SvelteComponent<{
     $$bindings?: string;
 };
 declare const DetailsPanel: $$__sveltets_2_IsomorphicComponent<{
+    boardCards?: any[];
     hands?: {};
     deadCards?: any[];
-    boardCards?: any[];
     defaultColor?: string;
     defaultSelectedColor?: string;
     manager?: any;

package/dist/poker-grid/components/HandSelector.svelte

@@ -6,18 +6,17 @@
    */
   import { createEventDispatcher } from 'svelte';
   import { RANKS, SUITS } from '../utils/index.js';
-  import BitValModule from 'poker-bitvaljs';
 
   const dispatch = createEventDispatcher();
 
-  // Handle CommonJS export
-  const BitVal = BitValModule?.default || BitValModule;
-
   export let hands = {};
   export let boardCards = [];
   export let evaluator = false;
   export let heroCards = [];
-  export let deadCards = [];
+  /** Live equity from PokerGridPanel ({ byColor }), or null. */
+  export let equity = null;
+  /** True while a newer equity result is being calculated. */
+  export let equityPending = false;
   export let colors = [
     'hsl(60, 100%, 70%)',
     'hsl(120, 100%, 70%)',
@@ -113,97 +112,16 @@
   $: colorCounts = colorStats.counts;
   $: colorPercentages = colorStats.percentages;
 
-  /** Calculate equity for each color group. */
-  let colorEquities = {};
-  let isCalculatingEquity = false;
-  let calculatingColors = {}; // Track which colors are currently calculating (object for reactivity)
-  let equityCalculationKey = 0;
-  let lastColorHands = {}; // Track previous color hands to detect changes
-
-  /** Track changes to trigger equity recalculation - only when colors change, not selections */
-  $: if (evaluator && colorDisplayMode === 'equity' && heroCards?.length === 2 && manager) {
-    // Only track colored hands, not selected-only hands
-    const currentColorHands = {};
-    colors.forEach(color => {
-      const coloredHands = Object.keys(hands || {}).filter(h => {
-        const handData = hands[h];
-        if (!Array.isArray(handData)) return false;
-        // Only include if hand has this color (not just selected)
-        return handData.some(item => item === color);
-      });
-      currentColorHands[color] = coloredHands.sort();
-    });
-
-    // Check if any color's hands have changed
-    const hasChanged = colors.some(color => {
-      const current = JSON.stringify(currentColorHands[color] || []);
-      const last = JSON.stringify(lastColorHands[color] || []);
-      return current !== last;
+  /** Hero's equity against each color's hands, from the panel's live calculation. */
+  $: colorEquities = (() => {
+    const equities = {};
+    colors.forEach(c => {
+      const value = equity?.byColor?.[c];
+      equities[c] = value === null || value === undefined ? null : Math.round(value);
     });
-
-    // Also check if board/hero/dead cards changed
-    const boardKey = JSON.stringify((boardCards || []).sort());
-    const heroKey = JSON.stringify((heroCards || []).sort());
-    const deadKey = JSON.stringify((deadCards || []).sort());
-    const lastBoardKey = JSON.stringify((lastBoardCards || []).sort());
-    const lastHeroKey = JSON.stringify((lastHeroCards || []).sort());
-    const lastDeadKey = JSON.stringify((lastDeadCards || []).sort());
-
-    if (hasChanged || boardKey !== lastBoardKey || heroKey !== lastHeroKey || deadKey !== lastDeadKey) {
-      lastColorHands = currentColorHands;
-      lastBoardCards = [...(boardCards || [])];
-      lastHeroCards = [...(heroCards || [])];
-      lastDeadCards = [...(deadCards || [])];
-      
-      // Use requestAnimationFrame to ensure UI updates first, then calculate
-      requestAnimationFrame(() => {
-        setTimeout(() => {
-          calculateColorEquities();
-        }, 0);
-      });
-    }
-  }
-
-  let lastBoardCards = [];
-  let lastHeroCards = [];
-  let lastDeadCards = [];
-
-  async function calculateColorEquities() {
-    if (isCalculatingEquity || !manager) return;
-    if (!evaluator || colorDisplayMode !== 'equity' || heroCards?.length !== 2) {
-      colorEquities = {};
-      return;
-    }
-
-    isCalculatingEquity = true;
-    const currentKey = ++equityCalculationKey;
-    
-    try {
-      const newEquities = await manager.calculateColorEquities(hands, heroCards, boardCards, deadCards, colors);
-        
-        // Check if calculation was invalidated
-        if (currentKey !== equityCalculationKey) {
-          isCalculatingEquity = false;
-          calculatingColors = {};
-          return;
-        }
-
-        colorEquities = newEquities;
-    } catch (error) {
-      colorEquities = {};
-      colors.forEach(c => colorEquities[c] = 0);
-    } finally {
-      if (currentKey === equityCalculationKey) {
-        isCalculatingEquity = false;
-        calculatingColors = {};
-      }
-    }
-  }
-
-  /** Check if a color is currently calculating equity */
-  function isColorCalculating(color) {
-    return calculatingColors[color] === true;
-  }
+    return equities;
+  })();
+  $: equityLoading = evaluator && colorDisplayMode === 'equity' && heroCards?.length === 2 && equityPending;
 
   /** Toggle color display mode: count -> percentage -> equity -> count */
   function toggleColorDisplayMode() {
@@ -229,7 +147,7 @@
       if (colorDisplayMode === 'percentage') {
         texts[color] = `${colorPercentages[color] || 0}%`;
       } else if (colorDisplayMode === 'equity') {
-        texts[color] = `${colorEquities[color] || 0}%`;
+        texts[color] = colorEquities[color] === null ? '–' : `${colorEquities[color]}%`;
       } else {
         texts[color] = colorCounts[color] || 0;
       }
@@ -264,7 +182,7 @@
       </button>
       {#each colors as color}
         <button
-            class="px-2 py-1 rounded border border-gray-300 hover:border-gray-400 transition-colors flex-shrink-0 whitespace-nowrap relative {calculatingColors[color] ? 'pulsing' : ''}"
+            class="px-2 py-1 rounded border border-gray-300 hover:border-gray-400 transition-colors flex-shrink-0 whitespace-nowrap relative {equityLoading && colorCounts[color] ? 'pulsing' : ''}"
           style="--button-color: {color}; background-color: var(--button-color);"
           onclick={(e) => handleColorClick(color, e)}
           title="Apply color to selected hands"

package/dist/poker-grid/components/HandSelector.svelte.d.ts

@@ -1,12 +1,13 @@
 export default HandSelector;
 type HandSelector = SvelteComponent<{
-    hands?: {};
-    deadCards?: any[];
     boardCards?: any[];
+    hands?: {};
     heroCards?: any[];
     colors?: string[];
+    equity?: any;
     manager?: any;
     evaluator?: boolean;
+    equityPending?: boolean;
 }, {
     selectionChange: CustomEvent<any>;
 } & {
@@ -15,13 +16,14 @@ type HandSelector = SvelteComponent<{
     $$bindings?: string;
 };
 declare const HandSelector: $$__sveltets_2_IsomorphicComponent<{
-    hands?: {};
-    deadCards?: any[];
     boardCards?: any[];
+    hands?: {};
     heroCards?: any[];
     colors?: string[];
+    equity?: any;
     manager?: any;
     evaluator?: boolean;
+    equityPending?: boolean;
 }, {
     selectionChange: CustomEvent<any>;
 } & {

package/dist/poker-grid/components/PokerGridPanel.svelte

@@ -6,8 +6,8 @@
    * Purpose: Orchestrates the full poker grid experience (dead inputs, range select, grid, controls, summary)
    * with configurable visibility and two-way bindings for raw and visible hands.
    */
-  import { createEventDispatcher } from 'svelte';
-  import { PokerGridManager } from '../PokerGridManager.js';
+  import { createEventDispatcher, onDestroy } from 'svelte';
+  import { PokerGridManager, loadPreflopTable } from '../PokerGridManager.js';
   import BaseGrid from './Grid.svelte';
   import HandSelector from './HandSelector.svelte';
   import SelectionSummary from './SelectionSummary.svelte';
@@ -29,6 +29,13 @@
   export let defaultColor = 'hsl(0, 0%, 100%)';
   export let defaultSelectedColor = 'hsl(0, 0%, 85%)';
   export let colors = [];
+  /**
+   * Optional URL of poker-bitvaljs's preflop table (bench/preflop-table.bin) for exact preflop equity,
+   * e.g. with Vite: import preflopTableUrl from 'poker-bitvaljs/bench/preflop-table.bin?url'.
+   * Without it, preflop equity is a Monte Carlo estimate.
+   */
+  export let preflopTableUrl = null;
+  $: if (evaluator && preflopTableUrl) loadPreflopTable(preflopTableUrl);
   /** Predefined ranges for range selection. Array of {name: string, abbreviation: string} */
   export let ranges = [];
 
@@ -93,6 +100,48 @@
   /** Derive visible hands (filtered by dead cards). */
   $: visibleHands = manager.filterByDeadCards(internalHands, deadCards);
 
+  /**
+   * Live equity (evaluator mode): recalculated, asynchronously, whenever the hero cards, board,
+   * dead cards or the hands on the grid change. Results that arrive after a newer request are dropped.
+   */
+  let equity = null;
+  let equityPending = false;
+  let equityRequest = 0;
+  let equityTimer = null;
+  let lastEquityKey = '';
+
+  $: equityKey = evaluator
+    ? JSON.stringify({ heroCards, boardCards, deadCards, hands: visibleHands, colors })
+    : '';
+  $: if (equityKey !== lastEquityKey) {
+    lastEquityKey = equityKey;
+    scheduleEquity();
+  }
+
+  function scheduleEquity() {
+    clearTimeout(equityTimer);
+    const request = ++equityRequest;
+    if (!evaluator || heroCards?.length !== 2) {
+      equity = null;
+      equityPending = false;
+      return;
+    }
+    equityPending = true;
+    // A short debounce coalesces bursts (typing cards, dragging across the grid)
+    equityTimer = setTimeout(async () => {
+      try {
+        const result = await manager.calculateEquity(visibleHands, heroCards, boardCards, deadCards, colors);
+        if (request === equityRequest) equity = result;
+      } catch (error) {
+        if (request === equityRequest) equity = null;
+      } finally {
+        if (request === equityRequest) equityPending = false;
+      }
+    }, 50);
+  }
+
+  onDestroy(() => clearTimeout(equityTimer));
+
   /** Highlighted and selected counts for summary. */
   $: highlightedCount = Object.values(visibleHands || {}).filter(v => manager.hasExplicitColor(v)).length;
   $: selectedCount = Object.values(visibleHands || {}).filter(v => manager.isSelected(v)).length;
@@ -228,9 +277,8 @@
       selected={selectedCount}
       {evaluator}
       {heroCards}
-      {boardCards}
-      {deadCards}
-      {hands}
+      {equity}
+      {equityPending}
       {visibleHands}
       {manager}
     />
@@ -256,8 +304,9 @@
       {boardCards}
       {evaluator}
       {heroCards}
-      {deadCards}
       {colors}
+      {equity}
+      {equityPending}
       {manager}
       on:selectionChange={handleSelectionChange}
       on:clearAll={() => {

package/dist/poker-grid/components/PokerGridPanel.svelte.d.ts

@@ -1,8 +1,8 @@
 export default PokerGridPanel;
 type PokerGridPanel = SvelteComponent<{
+    boardCards?: any[];
     hands?: {};
     deadCards?: any[];
-    boardCards?: any[];
     heroCards?: any[];
     colors?: any[];
     defaultColor?: string;
@@ -17,6 +17,7 @@ type PokerGridPanel = SvelteComponent<{
     showRangeSelect?: boolean;
     showControls?: boolean;
     showSummary?: boolean;
+    preflopTableUrl?: any;
     initialHands?: any;
     initialBoard?: any;
     initialDead?: any;
@@ -31,9 +32,9 @@ type PokerGridPanel = SvelteComponent<{
     $$bindings?: string;
 };
 declare const PokerGridPanel: $$__sveltets_2_IsomorphicComponent<{
+    boardCards?: any[];
     hands?: {};
     deadCards?: any[];
-    boardCards?: any[];
     heroCards?: any[];
     colors?: any[];
     defaultColor?: string;
@@ -48,6 +49,7 @@ declare const PokerGridPanel: $$__sveltets_2_IsomorphicComponent<{
     showRangeSelect?: boolean;
     showControls?: boolean;
     showSummary?: boolean;
+    preflopTableUrl?: any;
     initialHands?: any;
     initialBoard?: any;
     initialDead?: any;

package/dist/poker-grid/components/SelectionSummary.svelte

@@ -1,17 +1,13 @@
 <script>
   /** SelectionSummary: display counts for highlighted and selected combos. */
-  import BitValModule from 'poker-bitvaljs';
-
-  // Handle CommonJS export
-  const BitVal = BitValModule?.default || BitValModule;
-
   export let highlighted = 0;
   export let selected = 0;
   export let evaluator = false;
   export let heroCards = [];
-  export let boardCards = [];
-  export let deadCards = [];
-  export let hands = {};
+  /** Live equity from PokerGridPanel: { hero, villain, combos, byColor } or null. */
+  export let equity = null;
+  /** True while a newer equity result is being calculated. */
+  export let equityPending = false;
   export let visibleHands = {};
   export let manager = null; // PokerGridManager instance
 
@@ -49,142 +45,9 @@
     await copyToClipboard(selectedHands);
   }
 
-  /** Evaluation state */
-  let evaluationResults = null;
-  let isEvaluating = false;
-  let evaluationProgress = 0;
-  let evaluationKey = 0;
-  let lastEvaluationKey = '';
-
-  /** Reset results when inputs change */
-  $: {
-    if (evaluator && (heroCards?.length !== 2 || !hasHandsOnGrid)) {
-      evaluationResults = null;
-    }
-    const newKey = JSON.stringify({ heroCards, boardCards, deadCards, visibleHands });
-    if (newKey !== lastEvaluationKey) {
-      evaluationResults = null;
-      lastEvaluationKey = newKey;
-    }
-    evaluationKey = newKey;
-  }
-
-  /** Check if there are hands on the grid to evaluate against */
-  $: hasHandsOnGrid = visibleHands && Object.keys(visibleHands).length > 0;
-  
-  /** Check if button should be enabled */
-  $: isButtonEnabled = evaluator && heroCards?.length === 2 && hasHandsOnGrid && !isEvaluating;
-  
-  /** Check if button should be visible (always show when evaluator is true, even if disabled) */
-  $: showButton = evaluator;
-
-  /** Run equity evaluation */
-  async function runEvaluation() {
-    if (!isButtonEnabled) return;
-    
-    isEvaluating = true;
-    evaluationResults = null;
-    evaluationProgress = 0;
-
-    try {
-      // Get villain hands from visibleHands (already filtered for dead cards)
-      // Only hands that are highlighted (have colors) or selected
-      // A hand is highlighted if its value array contains an HSL color string
-      const hasExplicitColor = (values) => manager ? manager.hasExplicitColor(values) : false;
-      const isSelected = (values) => manager ? manager.isSelected(values) : false;
-      const villainHands = Object.entries(visibleHands || {})
-        .filter(([hand, values]) => 
-          hand && hand.length === 4 && // Valid hand format (e.g., 'AcKd')
-          (hasExplicitColor(values) || isSelected(values)) // Has color or is selected
-        )
-        .map(([hand]) => hand);
-      
-      if (villainHands.length === 0) {
-        isEvaluating = false;
-        evaluationProgress = 0;
-        return;
-      }
-
-      // Create hero hands array (single hand)
-      const heroHand = heroCards[0] + heroCards[1];
-      const heroHands = [heroHand];
-
-      // Initialize BitVal
-      const bitval = new BitVal();
-
-      // numberOfBoardCards should always be 5 (total board cards to be dealt)
-      // For preflop, boardCards is empty but numberOfBoardCards is still 5
-      // For postflop, boardCards has known cards and numberOfBoardCards is 5
-      const numberOfBoardCards = 5;
-      
-      // Dead cards for bitval: hero cards + dead cards from input (exclude board cards)
-      // Hero cards MUST be included so they don't get dealt to villain
-      // Board cards are excluded because bitval adds them internally
-      const deadCardsFromInput = (deadCards || []).filter(card => 
-        !(heroCards || []).includes(card) && !(boardCards || []).includes(card)
-      );
-      const deadCardsForBitval = [...heroCards, ...deadCardsFromInput];
-      
-      // Disable optimize mode when 3 or more board cards are present (flop, turn, river)
-      // Optimize mode uses canonical caching which can introduce ±0.5% margin of error
-      // For 0, 1, or 2 board cards, use optimization for speed
-      // For 3+ board cards, accuracy is more important
-      const boardCardsCount = (boardCards || []).length;
-      const optimize = boardCardsCount < 3;
-      
-      // Progress callback to update progress percentage
-      const progressCallback = (current, total, message) => {
-        const percentage = total > 0 ? Math.round((current / total) * 100) : 0;
-        evaluationProgress = percentage;
-      };
-      
-      // Prepare exact parameters for bitval.compareRange
-      const bitvalParams = {
-        heroHands,
-        villainHands,
-        boardCards: boardCards || [],
-        deadCards: deadCardsForBitval,
-        numberOfBoardCards,
-        iterations: 10000,
-        optimize,
-        progressCallback
-      };
-      
-      // Run evaluation
-      const result = await bitval.compareRange(
-        bitvalParams.heroHands,
-        bitvalParams.villainHands,
-        bitvalParams.boardCards,
-        bitvalParams.deadCards,
-        bitvalParams.numberOfBoardCards,
-        bitvalParams.iterations,
-        bitvalParams.optimize,
-        bitvalParams.progressCallback
-      );
-
-      // Calculate equity
-      const total = result.win + result.tie + result.lose;
-      const heroEquity = total > 0 ? ((result.win + result.tie / 2) / total) * 100 : 0;
-      const villainEquity = 100 - heroEquity;
-
-      evaluationResults = {
-        heroEquity: heroEquity,
-        villainEquity: villainEquity
-      };
-      evaluationProgress = 100;
-    } catch (error) {
-      evaluationResults = null;
-      evaluationProgress = 0;
-    } finally {
-      isEvaluating = false;
-      // Reset progress after a brief delay to show 100%
-      setTimeout(() => {
-        if (!isEvaluating) {
-          evaluationProgress = 0;
-        }
-      }, 500);
-    }
-  }
+  /** Equity display: the panel recalculates it live whenever the inputs change. */
+  $: showEquity = evaluator && heroCards?.length === 2;
+  $: hasEquity = equity && equity.hero !== null && equity.hero !== undefined;
 </script>
 
 <div class="flex items-center justify-between mt-1">
@@ -211,40 +74,32 @@
     </span>
   </span>
   <div class="flex items-center gap-2">
-    {#if evaluator && evaluationResults}
-      <div class="text-xs" style="color: var(--poker-text-secondary);">
-        <span>Hero: {Math.round(evaluationResults.heroEquity)}% vs. Villain: {Math.round(evaluationResults.villainEquity)}%</span>
-      </div>
-    {:else if evaluator && isEvaluating}
-      <div class="text-xs" style="color: var(--poker-text-secondary);">
-        <span>Evaluating: {evaluationProgress}%</span>
-      </div>
-    {:else if showButton}
-      <button
-        type="button"
-        onclick={runEvaluation}
-        disabled={!isButtonEnabled}
-        class="px-2 py-1 text-xs rounded border transition-colors"
-        style="
-          background-color: {isButtonEnabled ? 'var(--irongrid-color-primary)' : 'var(--irongrid-color-bg-disabled)'};
-          color: {isButtonEnabled ? 'var(--irongrid-color-white)' : 'var(--irongrid-color-text-secondary)'};
-          border-color: {isButtonEnabled ? 'var(--irongrid-color-primary)' : 'var(--irongrid-color-bg-disabled)'};
-          cursor: {isButtonEnabled ? 'pointer' : 'not-allowed'};
-          opacity: {isButtonEnabled ? '1' : 'var(--irongrid-opacity-disabled)'};
-        "
-        onmouseover={(e) => {
-          if (isButtonEnabled) e.target.style.opacity = '0.9';
-        }}
-        onmouseout={(e) => {
-          if (isButtonEnabled) e.target.style.opacity = '1';
-        }}
+    {#if showEquity}
+      <div
+        class="text-xs equity-readout"
+        class:equity-pending={equityPending}
+        style="color: var(--irongrid-color-text-secondary);"
+        aria-live="polite"
+        title={hasEquity ? `Hero's equity against ${equity.combos} villain combos (selected or colored)` : ''}
       >
-        Evaluate
-      </button>
+        {#if hasEquity}
+          <span>Hero: {Math.round(equity.hero)}% vs. Villain: {Math.round(equity.villain)}%</span>
+        {:else if equityPending}
+          <span>Calculating…</span>
+        {:else}
+          <span>Select villain hands for equity</span>
+        {/if}
+      </div>
     {/if}
   </div>
 </div>
 
 <style>
+  .equity-readout {
+    transition: opacity 120ms ease;
+  }
+  .equity-pending {
+    opacity: 0.55;
+  }
 </style>
 

package/dist/poker-grid/components/SelectionSummary.svelte.d.ts

@@ -1,12 +1,11 @@
 export default SelectionSummary;
 type SelectionSummary = SvelteComponent<{
-    hands?: {};
-    deadCards?: any[];
-    boardCards?: any[];
     heroCards?: any[];
     selected?: number;
+    equity?: any;
     manager?: any;
     evaluator?: boolean;
+    equityPending?: boolean;
     highlighted?: number;
     visibleHands?: {};
 }, {
@@ -15,13 +14,12 @@ type SelectionSummary = SvelteComponent<{
     $$bindings?: string;
 };
 declare const SelectionSummary: $$__sveltets_2_IsomorphicComponent<{
-    hands?: {};
-    deadCards?: any[];
-    boardCards?: any[];
     heroCards?: any[];
     selected?: number;
+    equity?: any;
     manager?: any;
     evaluator?: boolean;
+    equityPending?: boolean;
     highlighted?: number;
     visibleHands?: {};
 }, {

package/dist/poker-grid/index.d.ts

@@ -1 +1,2 @@
+export { loadPreflopTable } from "./PokerGridManager.js";
 export { default as PokerGridPanel, default } from "./components/PokerGridPanel.svelte";

package/dist/poker-grid/index.js

@@ -5,6 +5,7 @@
  */
 export { default as PokerGridPanel } from './components/PokerGridPanel.svelte';
 export { default } from './components/PokerGridPanel.svelte';
+export { loadPreflopTable } from './PokerGridManager.js';
 
 // Export theme CSS for consumers to import
 import './theme.css';

package/package.json

@@ -1,6 +1,10 @@
 {
 	"name": "poker-irongrid",
-	"version": "1.1.0",
+	"version": "1.2.0",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/DarraghGeo/poker-irongrid.git"
+	},
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -31,9 +35,9 @@
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {
-		"poker-bitvaljs": "^1.0.1",
-		"poker-extval": "^3.2.0",
-		"poker-rangeman": "^3.3.2"
+		"poker-bitvaljs": "^1.13.0",
+		"poker-extval": "^6.0.0-beta.6",
+		"poker-rangeman": "^4.0.0-beta.11"
 	},
 	"devDependencies": {
 		"@eslint/compat": "^1.4.0",