slot-server 1.0.0

package/dist/index.js

@@ -0,0 +1,2897 @@
+// src/ConfigBuilder.ts
+var ConfigBuilder = class {
+  config = {};
+  setGameId(id) {
+    this.config.gameId = id;
+    return this;
+  }
+  setReelCount(count) {
+    this.config.reelCount = count;
+    return this;
+  }
+  setRowCount(count) {
+    this.config.rowCount = count;
+    return this;
+  }
+  setSymbolMap(map) {
+    this.config.symbolMap = map;
+    return this;
+  }
+  setPaytableData(data) {
+    this.config.paytableData = data;
+    return this;
+  }
+  setReelStrips(strips) {
+    this.config.reelStrips = strips;
+    return this;
+  }
+  setLinePatterns(patterns) {
+    this.config.linePatterns = patterns;
+    return this;
+  }
+  setCurrency(code, symbol, decimalSeparator = ".", thousandSeparator = ",", minDecimalPlaces = 2) {
+    this.config.currency = { code, symbol, decimalSeparator, thousandSeparator, minDecimalPlaces };
+    return this;
+  }
+  setFeatures(features) {
+    this.config.features = features;
+    return this;
+  }
+  setBetRange(min, max, step, defaultBet) {
+    this.config.minBet = min;
+    this.config.maxBet = max;
+    this.config.betStep = step;
+    this.config.defaultBet = defaultBet ?? min;
+    return this;
+  }
+  build() {
+    const required = [
+      "gameId",
+      "reelCount",
+      "rowCount",
+      "symbolMap",
+      "paytableData",
+      "reelStrips",
+      "linePatterns"
+    ];
+    for (const key of required) {
+      if (this.config[key] === void 0) {
+        throw new Error(`ConfigBuilder: Missing required field "${key}"`);
+      }
+    }
+    return {
+      ...this.config,
+      gameId: this.config.gameId,
+      // Assert that gameId is definitely present after validation
+      reelCount: this.config.reelCount,
+      rowCount: this.config.rowCount,
+      symbolMap: this.config.symbolMap,
+      paytableData: this.config.paytableData,
+      reelStrips: this.config.reelStrips,
+      linePatterns: this.config.linePatterns,
+      currency: this.config.currency || { code: "USD", symbol: "$", decimalSeparator: ".", thousandSeparator: ",", minDecimalPlaces: 2 },
+      features: this.config.features || { autoplay: true, fastSpin: true, realityCheck: true, fullscreen: true },
+      defaultBet: this.config.defaultBet ?? 1,
+      minBet: this.config.minBet ?? 0.1,
+      maxBet: this.config.maxBet ?? 100,
+      betStep: this.config.betStep ?? 0.1,
+      defaultLines: this.config.defaultLines ?? this.config.linePatterns.length,
+      rtp: this.config.rtp ?? 96.5,
+      volatility: this.config.volatility ?? "medium"
+    };
+  }
+};
+
+// src/Random.ts
+var Random = class {
+  seed;
+  constructor(seed) {
+    this.seed = seed;
+  }
+  next() {
+    if (this.seed !== void 0) {
+      this.seed = (this.seed * 9301 + 49297) % 233280;
+      return this.seed / 233280;
+    }
+    return Math.random();
+  }
+  nextInt(min, max) {
+    return Math.floor(this.next() * (max - min)) + min;
+  }
+  pick(arr) {
+    return arr[this.nextInt(0, arr.length)];
+  }
+  shuffle(arr) {
+    for (let i = arr.length - 1; i > 0; i--) {
+      const j = this.nextInt(0, i + 1);
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return arr;
+  }
+};
+
+// src/SpinEvaluator.ts
+var SpinEvaluator = class {
+  config;
+  rng;
+  constructor(config, rng) {
+    this.config = config;
+    this.rng = rng;
+  }
+  /**
+   * Generate a random spin result (visible symbols for each reel).
+   * Returns a 2D array: [reelIndex][rowIndex]
+   */
+  generateResult() {
+    const { reelCount, rowCount, reelStrips } = this.config;
+    const result = [];
+    for (let r = 0; r < reelCount; r++) {
+      const strip = reelStrips[r];
+      const offset = this.rng.nextInt(0, strip.length - rowCount);
+      const row = [];
+      for (let i = 0; i < rowCount; i++) {
+        row.push(strip[offset + i]);
+      }
+      result.push(row);
+    }
+    return result;
+  }
+  /**
+   * Evaluate the result against all paylines and the paytable.
+   * Returns win lines and total win amount.
+   */
+  // FIXED: Added stakePerLine as a parameter since it belongs to the request payload, not the class instance
+  evaluateResult(result, stakePerLine) {
+    const { linePatterns, paytableData } = this.config;
+    const winLines = [];
+    let totalWin = 0;
+    for (let li = 0; li < linePatterns.length; li++) {
+      const pattern = linePatterns[li];
+      const symbols = pattern.map((pos) => result[pos.reel]?.[pos.row]);
+      if (symbols.some((s) => s === void 0)) continue;
+      const firstSymbol = symbols[0];
+      let count = 1;
+      for (let i = 1; i < symbols.length; i++) {
+        if (symbols[i] === firstSymbol) {
+          count++;
+        } else {
+          break;
+        }
+      }
+      const symbolPaytable = paytableData[firstSymbol];
+      if (!symbolPaytable) continue;
+      const multiplierKey = `x${count}`;
+      const multiplier = symbolPaytable[multiplierKey];
+      if (!multiplier || multiplier === 0) continue;
+      const winAmount = (stakePerLine || 1) * multiplier;
+      totalWin += winAmount;
+      winLines.push({
+        lineIndex: li,
+        symbolId: firstSymbol,
+        multiplier,
+        winAmount,
+        positions: pattern.slice(0, count)
+      });
+    }
+    return { winLines, totalWin };
+  }
+  /**
+   * Full spin processing: generate result, evaluate, build response.
+   */
+  // FIXED: Swapped the messy inline type for the clean, updated ISpinRequestData interface
+  spin(request) {
+    const result = this.generateResult();
+    const stakePerLine = request.stakePerLine;
+    const { winLines, totalWin } = this.evaluateResult(result, stakePerLine);
+    return {
+      result,
+      totalWin,
+      stakePerLine: request.stakePerLine,
+      totalStake: request.totalStake,
+      gameMode: request.gameMode,
+      winLines: winLines.length > 0 ? winLines : void 0
+    };
+  }
+};
+
+// src/BonusManager.ts
+var BonusManager = class {
+  rng;
+  bonusState = null;
+  constructor(rng) {
+    this.rng = rng;
+  }
+  /**
+   * Check if a spin result should trigger a bonus.
+   * This is a simple example: trigger on 3+ scatter symbols (e.g., symbol ID 9).
+   */
+  checkTrigger(result) {
+    const scatterId = 9;
+    let count = 0;
+    for (const row of result) {
+      for (const symbol of row) {
+        if (symbol === scatterId) count++;
+      }
+    }
+    if (count >= 3) {
+      return {
+        triggered: true,
+        data: { scatterCount: count, freeSpins: count * 2 }
+      };
+    }
+    return { triggered: false };
+  }
+  /**
+   * Start a free spin bonus.
+   */
+  startFreeSpins(spins, multiplier = 1, bet) {
+    this.bonusState = {
+      type: "freespin",
+      spinsRemaining: spins,
+      multiplier,
+      totalWin: 0,
+      bet
+    };
+    return this.bonusState;
+  }
+  /**
+   * Start a pick bonus (e.g., pick items for prizes).
+   */
+  startPickBonus(items) {
+    this.bonusState = {
+      type: "pick",
+      items,
+      pickedIds: [],
+      totalWin: 0
+    };
+    return this.bonusState;
+  }
+  /**
+   * Process a pick action.
+   */
+  pickItem(itemId) {
+    const state = this.bonusState;
+    if (!state || state.type !== "pick") {
+      throw new Error("No active pick bonus");
+    }
+    const item = state.items.find((i) => i.id === itemId);
+    if (!item) throw new Error("Invalid item");
+    if (state.pickedIds.includes(itemId)) throw new Error("Item already picked");
+    state.pickedIds.push(itemId);
+    state.totalWin += item.value;
+    const remaining = state.items.filter((i) => !state.pickedIds.includes(i.id));
+    return { win: item.value, remaining };
+  }
+  /**
+   * Process a free spin: deduct one spin, return the spin result.
+   * The spin result is generated by the SpinEvaluator, but we need to apply the multiplier.
+   */
+  processFreeSpin(spinResult) {
+    const state = this.bonusState;
+    if (!state || state.type !== "freespin") {
+      throw new Error("No active free spin bonus");
+    }
+    if (state.spinsRemaining <= 0) {
+      throw new Error("No free spins remaining");
+    }
+    state.spinsRemaining--;
+    const multiplier = state.multiplier || 1;
+    const totalWin = (spinResult.totalWin || 0) * multiplier;
+    state.totalWin += totalWin;
+    return {
+      ...spinResult,
+      totalWin,
+      spinsRemaining: state.spinsRemaining
+    };
+  }
+  /**
+   * Check if a bonus is active.
+   */
+  isActive() {
+    return this.bonusState !== null && (this.bonusState.type === "freespin" && this.bonusState.spinsRemaining > 0 || this.bonusState.type === "pick" && this.bonusState.items.length > this.bonusState.pickedIds.length);
+  }
+  /**
+   * Get the current bonus state.
+   */
+  getState() {
+    return this.bonusState;
+  }
+  /**
+   * End the current bonus.
+   */
+  endBonus() {
+    this.bonusState = null;
+  }
+};
+
+// src/HistoryManager.ts
+var HistoryManager = class {
+  history = [];
+  maxEntries;
+  constructor(maxEntries = 100) {
+    this.maxEntries = maxEntries;
+  }
+  /**
+   * Add a spin result to history.
+   */
+  addEntry(result, bet, win, balance, gameMode) {
+    const entry = {
+      time: Date.now(),
+      bet,
+      win,
+      balance,
+      result: result.map((row) => [...row]),
+      // deep copy
+      gameMode
+    };
+    this.history.push(entry);
+    if (this.history.length > this.maxEntries) {
+      this.history.shift();
+    }
+  }
+  /**
+   * Get all history entries.
+   */
+  getEntries() {
+    return this.history.slice();
+  }
+  /**
+   * Get the last N entries.
+   */
+  getLast(n) {
+    return this.history.slice(-n);
+  }
+  /**
+   * Clear history.
+   */
+  clear() {
+    this.history = [];
+  }
+};
+
+// src/GameSession.ts
+var GameSession = class {
+  config;
+  playerId;
+  balanceProvider;
+  state;
+  spinEvaluator;
+  bonusManager;
+  historyManager;
+  rng;
+  constructor(config, playerId, balanceProvider, seed) {
+    this.config = config;
+    this.playerId = playerId;
+    this.balanceProvider = balanceProvider;
+    this.rng = new Random(seed);
+    this.spinEvaluator = new SpinEvaluator(config, this.rng);
+    this.bonusManager = new BonusManager(this.rng);
+    this.historyManager = new HistoryManager(100);
+    const initialBalance = balanceProvider.getBalance(playerId);
+    this.state = {
+      balance: initialBalance,
+      bet: config.defaultBet || 1,
+      gameMode: 0,
+      freeSpinsRemaining: 0,
+      bonusActive: false,
+      history: []
+    };
+  }
+  /**
+   * Get the current full player state.
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Build the INIT response for the client.
+   */
+  getInitResponse() {
+    return {
+      balance: this.state.balance,
+      bet: this.state.bet,
+      config: this.config,
+      bonusOffers: null,
+      // you can add offers here
+      state: {
+        gameMode: this.state.gameMode,
+        freeSpinsRemaining: this.state.freeSpinsRemaining,
+        bonusActive: this.state.bonusActive
+      }
+    };
+  }
+  /**
+   * Set the player's bet.
+   */
+  setBet(bet) {
+    if (bet < this.config.minBet || bet > this.config.maxBet) {
+      throw new Error(`Bet must be between ${this.config.minBet} and ${this.config.maxBet}`);
+    }
+    this.state.bet = bet;
+  }
+  /**
+   * Process a spin request.
+   */
+  spin(request) {
+    const totalStake = request.totalStake;
+    const stakePerLine = request.stakePerLine;
+    if (this.state.balance < totalStake) {
+      return { ...this.createErrorResponse("Insufficient balance"), balanceAfter: this.state.balance };
+    }
+    this.state.balance -= totalStake;
+    this.balanceProvider.setBalance(this.playerId, this.state.balance);
+    let spinResult;
+    let isBonusSpin = false;
+    if (this.bonusManager.isActive() && this.bonusManager.getState()?.type === "freespin") {
+      const rawResult = this.spinEvaluator.generateResult();
+      const evaluated = this.spinEvaluator.spin({
+        action: request.action,
+        stakePerLine: request.stakePerLine,
+        selectedLines: request.selectedLines,
+        totalStake: request.totalStake,
+        gameMode: 1
+      });
+      const bonusSpinResult = this.bonusManager.processFreeSpin(evaluated);
+      spinResult = bonusSpinResult;
+      isBonusSpin = true;
+    } else {
+      spinResult = this.spinEvaluator.spin(request);
+    }
+    let bonusTriggered = false;
+    let bonusData = null;
+    if (!isBonusSpin) {
+      const trigger = this.bonusManager.checkTrigger(spinResult.result);
+      if (trigger.triggered) {
+        bonusTriggered = true;
+        bonusData = trigger.data;
+        const freeSpins = bonusData.freeSpins || 5;
+        const multiplier = bonusData.multiplier || 1;
+        this.bonusManager.startFreeSpins(freeSpins, multiplier, request.stakePerLine);
+        this.state.bonusActive = true;
+        this.state.freeSpinsRemaining = freeSpins;
+        spinResult.freeSpinsRemaining = freeSpins;
+        spinResult.bonusTriggered = true;
+        spinResult.bonusData = bonusData;
+      }
+    }
+    const winAmount = spinResult.totalWin || 0;
+    if (winAmount > 0) {
+      this.state.balance += winAmount;
+      this.balanceProvider.setBalance(this.playerId, this.state.balance);
+    }
+    if (spinResult.freeSpinsRemaining !== void 0) {
+      this.state.freeSpinsRemaining = spinResult.freeSpinsRemaining;
+      if (this.state.freeSpinsRemaining <= 0) {
+        this.state.bonusActive = false;
+        this.bonusManager.endBonus();
+      }
+    }
+    this.historyManager.addEntry(
+      spinResult.result,
+      request.totalStake,
+      winAmount,
+      this.state.balance,
+      request.gameMode
+    );
+    const response = {
+      ...spinResult,
+      balanceAfter: this.state.balance
+    };
+    if (spinResult.winLines) {
+      response.winLines = spinResult.winLines;
+    }
+    return response;
+  }
+  /**
+   * Get history.
+   */
+  getHistory(limit = 20) {
+    const entries = this.historyManager.getLast(limit);
+    return {
+      entries,
+      total: this.historyManager.getEntries().length
+    };
+  }
+  /**
+   * Process a bonus action (e.g., pick).
+   */
+  bonusAction(action, payload) {
+    if (action === "pick" && payload?.itemId) {
+      const result = this.bonusManager.pickItem(payload.itemId);
+      const win = result.win;
+      if (win > 0) {
+        this.state.balance += win;
+        this.balanceProvider.setBalance(this.playerId, this.state.balance);
+      }
+      const remaining = result.remaining;
+      if (remaining.length === 0) {
+        this.bonusManager.endBonus();
+        this.state.bonusActive = false;
+        return {
+          state: "COMPLETE",
+          data: { totalWin: this.bonusManager.getState()?.totalWin || 0 }
+        };
+      }
+      return {
+        state: "ACTIVE",
+        data: { remaining, lastWin: win }
+      };
+    }
+    throw new Error(`Unknown bonus action: ${action}`);
+  }
+  /**
+   * Helper to create an error response.
+   */
+  createErrorResponse(error) {
+    return {
+      result: [],
+      totalWin: 0,
+      stakePerLine: 0,
+      totalStake: 0,
+      gameMode: 0,
+      error
+    };
+  }
+};
+
+// src/JackpotManager.ts
+var JackpotManager = class {
+  config;
+  rng;
+  tiers;
+  constructor(config, rng) {
+    this.config = config;
+    this.rng = rng;
+    this.tiers = /* @__PURE__ */ new Map();
+    if (config.enabled && config.tiers) {
+      for (const tier of config.tiers) {
+        this.tiers.set(tier.id, { ...tier });
+      }
+    }
+  }
+  /**
+   * Calculate jackpot contribution from a bet.
+   * Returns contributions for each tier.
+   */
+  calculateContribution(totalStake) {
+    const contributions = [];
+    if (!this.config.enabled) {
+      return contributions;
+    }
+    for (const [tierId, tier] of this.tiers.entries()) {
+      const contributedAmount = totalStake * (tier.contributionRate / 100);
+      tier.currentAmount += contributedAmount;
+      contributions.push({
+        tierId,
+        contributedAmount,
+        newJackpotAmount: tier.currentAmount
+      });
+    }
+    return contributions;
+  }
+  /**
+   * Check if a jackpot was triggered.
+   * Uses probability-based triggering.
+   */
+  checkTrigger() {
+    if (!this.config.enabled) {
+      return null;
+    }
+    for (const [tierId, tier] of this.tiers.entries()) {
+      const roll = this.rng.next();
+      if (roll < tier.triggerProbability) {
+        const winAmount = tier.currentAmount;
+        tier.currentAmount = tier.seedAmount;
+        return {
+          tierId,
+          tierName: tier.name,
+          winAmount,
+          timestamp: Date.now()
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * Get current jackpot amounts for all tiers.
+   */
+  getCurrentAmounts() {
+    const amounts = {};
+    for (const [tierId, tier] of this.tiers.entries()) {
+      amounts[tierId] = tier.currentAmount;
+    }
+    return amounts;
+  }
+  /**
+   * Get a specific tier's current amount.
+   */
+  getTierAmount(tierId) {
+    const tier = this.tiers.get(tierId);
+    return tier?.currentAmount;
+  }
+  /**
+   * Update a tier's current amount (for external sync).
+   */
+  updateTierAmount(tierId, amount) {
+    const tier = this.tiers.get(tierId);
+    if (tier) {
+      tier.currentAmount = amount;
+    }
+  }
+  /**
+   * Check if a bet is eligible for jackpot (based on minBetRequired).
+   */
+  isBetEligible(totalStake) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    for (const tier of this.tiers.values()) {
+      if (tier.minBetRequired !== void 0 && totalStake < tier.minBetRequired) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get configuration for a specific tier.
+   */
+  getTierConfig(tierId) {
+    return this.tiers.get(tierId);
+  }
+  /**
+   * Get all tier configurations.
+   */
+  getAllTiers() {
+    return Array.from(this.tiers.values());
+  }
+  /**
+   * Reset all tiers to seed amounts.
+   */
+  resetAll() {
+    for (const tier of this.tiers.values()) {
+      tier.currentAmount = tier.seedAmount;
+    }
+  }
+};
+
+// src/WaysEvaluator.ts
+var WaysEvaluator = class {
+  config;
+  paytableData;
+  reelCount;
+  rowCount;
+  constructor(config, paytableData, reelCount, rowCount) {
+    this.config = config;
+    this.paytableData = paytableData;
+    this.reelCount = reelCount;
+    this.rowCount = rowCount;
+  }
+  /**
+   * Evaluate a spin result for ways-to-win.
+   * Returns win lines and total win amount.
+   */
+  evaluate(result, stakePerLine) {
+    const { minMatches, direction } = this.config;
+    const winLines = [];
+    let totalWin = 0;
+    let totalWays = 0;
+    const symbolCountsPerReel = /* @__PURE__ */ new Map();
+    for (let r = 0; r < this.reelCount; r++) {
+      const reelSymbols = result[r] || [];
+      for (const symbolId of reelSymbols) {
+        if (!symbolCountsPerReel.has(symbolId)) {
+          symbolCountsPerReel.set(symbolId, new Array(this.reelCount).fill(0));
+        }
+        const counts = symbolCountsPerReel.get(symbolId);
+        counts[r]++;
+      }
+    }
+    for (const [symbolId, counts] of symbolCountsPerReel.entries()) {
+      const symbolPaytable = this.paytableData[symbolId];
+      if (!symbolPaytable) continue;
+      let consecutiveReels = 0;
+      const positions = [];
+      for (let r = 0; r < this.reelCount; r++) {
+        if (counts[r] > 0) {
+          consecutiveReels++;
+          const reelSymbols = result[r] || [];
+          for (let row = 0; row < reelSymbols.length; row++) {
+            if (reelSymbols[row] === symbolId) {
+              positions.push({ reel: r, row });
+            }
+          }
+        } else {
+          break;
+        }
+      }
+      if (consecutiveReels >= minMatches) {
+        const multiplierKey = `x${consecutiveReels}`;
+        const multiplier = symbolPaytable[multiplierKey];
+        if (multiplier && multiplier > 0) {
+          let ways = 1;
+          for (let r = 0; r < consecutiveReels; r++) {
+            ways *= counts[r];
+          }
+          if (direction === "bothDirections") {
+            let consecutiveFromRight = 0;
+            for (let r = this.reelCount - 1; r >= 0; r--) {
+              if (counts[r] > 0) {
+                consecutiveFromRight++;
+              } else {
+                break;
+              }
+            }
+            if (consecutiveFromRight >= minMatches && consecutiveFromRight > consecutiveReels) {
+              ways = 1;
+              for (let r = this.reelCount - consecutiveFromRight; r < this.reelCount; r++) {
+                ways *= counts[r];
+              }
+              consecutiveReels = consecutiveFromRight;
+            }
+          }
+          const winAmount = stakePerLine * multiplier * ways;
+          totalWin += winAmount;
+          totalWays += ways;
+          winLines.push({
+            lineIndex: symbolId,
+            // Use symbol ID as line index for ways
+            symbolId,
+            multiplier,
+            winAmount,
+            positions: positions.slice(0, consecutiveReels * this.rowCount),
+            wayIndex: totalWays
+          });
+        }
+      }
+    }
+    return { winLines, totalWin, ways: totalWays };
+  }
+  /**
+   * Get the maximum possible ways for this configuration.
+   */
+  getMaxWays() {
+    return Math.pow(this.rowCount, this.reelCount);
+  }
+  /**
+   * Check if ways-to-win is enabled.
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+};
+
+// src/GambleManager.ts
+var GambleManager = class {
+  config;
+  rng;
+  consecutiveGambles = 0;
+  currentGambleWin = 0;
+  constructor(config, rng) {
+    this.config = config;
+    this.rng = rng;
+  }
+  /**
+   * Check if gamble feature is enabled and available.
+   */
+  canGamble(currentWin) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (currentWin <= 0) {
+      return false;
+    }
+    if (this.config.maxGambleAmount !== void 0 && currentWin > this.config.maxGambleAmount) {
+      return false;
+    }
+    if (this.consecutiveGambles >= this.config.maxConsecutiveGambles) {
+      return false;
+    }
+    if (this.config.autoCollectAt !== void 0 && currentWin >= this.config.autoCollectAt) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Process a gamble request.
+   */
+  processGamble(request) {
+    const { gambleType, currentWin, choice } = request;
+    if (!this.canGamble(currentWin)) {
+      return {
+        result: "lose",
+        winAmount: 0,
+        canGambleAgain: false,
+        consecutiveGambles: this.consecutiveGambles
+      };
+    }
+    let result;
+    let winAmount = 0;
+    switch (gambleType) {
+      case "card":
+        result = this.playCardGame(choice);
+        winAmount = result === "win" ? currentWin * 2 : 0;
+        break;
+      case "ladder":
+        result = this.playLadderGame(choice);
+        winAmount = result === "win" ? currentWin * 1.5 : 0;
+        break;
+      case "wheel":
+        result = this.playWheelGame(choice);
+        winAmount = result === "win" ? currentWin * this.rng.nextInt(2, 5) : 0;
+        break;
+      default:
+        result = "lose";
+        winAmount = 0;
+    }
+    if (result === "win") {
+      this.consecutiveGambles++;
+      this.currentGambleWin = winAmount;
+    } else if (result === "lose") {
+      this.consecutiveGambles = 0;
+      this.currentGambleWin = 0;
+    }
+    return {
+      result,
+      winAmount,
+      canGambleAgain: this.canGamble(winAmount),
+      consecutiveGambles: this.consecutiveGambles
+    };
+  }
+  /**
+   * Card game: guess if card is red or black (50/50 chance).
+   */
+  playCardGame(choice) {
+    const isRed = this.rng.next() < 0.5;
+    const playerChoosesRed = choice === "red" || choice === 0 || choice === void 0;
+    if (playerChoosesRed && isRed || !playerChoosesRed && !isRed) {
+      return "win";
+    }
+    return "lose";
+  }
+  /**
+   * Ladder game: 60% chance to win, 40% to lose.
+   */
+  playLadderGame(choice) {
+    const winChance = 0.6;
+    return this.rng.next() < winChance ? "win" : "lose";
+  }
+  /**
+   * Wheel game: multiple outcomes based on wheel segments.
+   */
+  playWheelGame(choice) {
+    const segments = [
+      { value: 0, weight: 20 },
+      // Lose
+      { value: 1, weight: 30 },
+      // Push (get bet back)
+      { value: 2, weight: 30 },
+      // 2x win
+      { value: 3, weight: 15 },
+      // 3x win
+      { value: 5, weight: 5 }
+      // 5x win (jackpot)
+    ];
+    const totalWeight = segments.reduce((sum, s) => sum + s.weight, 0);
+    let roll = this.rng.next() * totalWeight;
+    for (const segment of segments) {
+      roll -= segment.weight;
+      if (roll <= 0) {
+        if (segment.value === 0) return "lose";
+        if (segment.value === 1) return "push";
+        return "win";
+      }
+    }
+    return "lose";
+  }
+  /**
+   * Get current consecutive gamble count.
+   */
+  getConsecutiveGambles() {
+    return this.consecutiveGambles;
+  }
+  /**
+   * Reset gamble state (e.g., after collecting winnings).
+   */
+  reset() {
+    this.consecutiveGambles = 0;
+    this.currentGambleWin = 0;
+  }
+  /**
+   * Get the current gamble win amount.
+   */
+  getCurrentGambleWin() {
+    return this.currentGambleWin;
+  }
+  /**
+   * Get gamble configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+};
+
+// src/BuyBonusManager.ts
+var BuyBonusManager = class {
+  config;
+  purchasesThisSession = 0;
+  lastPurchaseTime = 0;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Check if buying bonus is enabled and available.
+   */
+  canBuyBonus(currentBet) {
+    if (!this.config.enabled) {
+      return { canBuy: false, reason: "Buy bonus feature is disabled" };
+    }
+    if (this.config.minBetRequired !== void 0 && currentBet < this.config.minBetRequired) {
+      return {
+        canBuy: false,
+        reason: `Minimum bet of ${this.config.minBetRequired} required`
+      };
+    }
+    if (this.config.maxPurchasesPerSession !== void 0 && this.purchasesThisSession >= this.config.maxPurchasesPerSession) {
+      return {
+        canBuy: false,
+        reason: `Maximum purchases (${this.config.maxPurchasesPerSession}) reached for this session`
+      };
+    }
+    if (this.config.cooldownMs !== void 0) {
+      const timeSinceLastPurchase = Date.now() - this.lastPurchaseTime;
+      if (timeSinceLastPurchase < this.config.cooldownMs) {
+        const remainingCooldown = this.config.cooldownMs - timeSinceLastPurchase;
+        return {
+          canBuy: false,
+          reason: `Please wait ${Math.ceil(remainingCooldown / 1e3)} seconds before purchasing again`
+        };
+      }
+    }
+    const cost = currentBet * this.config.costMultiplier;
+    return { canBuy: true, cost };
+  }
+  /**
+   * Calculate the cost to buy bonus.
+   */
+  calculateCost(currentBet) {
+    return currentBet * this.config.costMultiplier;
+  }
+  /**
+   * Record a bonus purchase.
+   */
+  recordPurchase() {
+    this.purchasesThisSession++;
+    this.lastPurchaseTime = Date.now();
+  }
+  /**
+   * Get the number of purchases made this session.
+   */
+  getPurchasesThisSession() {
+    return this.purchasesThisSession;
+  }
+  /**
+   * Reset session tracking.
+   */
+  resetSession() {
+    this.purchasesThisSession = 0;
+    this.lastPurchaseTime = 0;
+  }
+  /**
+   * Get configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Create a spin response that triggers bonus (for buy bonus feature).
+   * This marks the spin as having triggered the bonus.
+   */
+  createBonusTriggerSpin(baseSpinResult, bonusData) {
+    return {
+      ...baseSpinResult,
+      bonusTriggered: true,
+      bonusData,
+      freeSpinsRemaining: bonusData?.freeSpins || 0
+    };
+  }
+};
+
+// src/CascadingReelsManager.ts
+var CascadingReelsManager = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Execute a full cascade sequence until no more wins occur
+   */
+  executeCascade(gameState, initialWins) {
+    const cascadeResults = [];
+    let currentGameState = { ...gameState };
+    let remainingWins = [...initialWins];
+    let totalMultiplier = this.config.initialMultiplier || 1;
+    let cascadeCount = 0;
+    const maxCascades = this.config.maxCascades || Infinity;
+    while (remainingWins.length > 0 && cascadeCount < maxCascades) {
+      cascadeCount++;
+      const removedPositions = this.removeWinningSymbols(
+        currentGameState.grid,
+        remainingWins
+      );
+      const dropResult = this.applyGravity(currentGameState.grid, removedPositions);
+      const newSymbols = this.fillEmptyPositions(dropResult.grid);
+      if (this.config.multiplierIncrement) {
+        totalMultiplier += this.config.multiplierIncrement;
+      }
+      const newWins = this.evaluateWins(newSymbols.grid);
+      cascadeResults.push({
+        cascadeNumber: cascadeCount,
+        removedPositions,
+        droppedSymbols: dropResult.droppedSymbols,
+        newSymbols: newSymbols.addedSymbols,
+        resultingGrid: newSymbols.grid,
+        winsInStep: newWins,
+        multiplier: totalMultiplier
+      });
+      currentGameState.grid = newSymbols.grid;
+      remainingWins = newWins;
+      if (this.config.stopOnNoWinIncrease && newWins.length === 0) {
+        break;
+      }
+    }
+    return {
+      success: cascadeCount > 0,
+      totalCascades: cascadeCount,
+      steps: cascadeResults,
+      finalGrid: currentGameState.grid,
+      finalMultiplier: totalMultiplier,
+      totalWinsFromCascades: cascadeResults.reduce(
+        (sum, step) => sum + step.winsInStep.length,
+        0
+      )
+    };
+  }
+  /**
+   * Remove symbols that are part of winning combinations
+   */
+  removeWinningSymbols(grid, wins) {
+    const removedPositions = [];
+    const positionsToRemove = /* @__PURE__ */ new Set();
+    wins.forEach((win) => {
+      win.positions.forEach((pos) => {
+        const key = `${pos.reel}-${pos.row}`;
+        if (!positionsToRemove.has(key)) {
+          positionsToRemove.add(key);
+          removedPositions.push({
+            reel: pos.reel,
+            row: pos.row,
+            symbol: grid[pos.reel][pos.row]
+          });
+        }
+      });
+    });
+    positionsToRemove.forEach((key) => {
+      const [reelStr, rowStr] = key.split("-");
+      const reel = parseInt(reelStr, 10);
+      const row = parseInt(rowStr, 10);
+      grid[reel][row] = {
+        id: "EMPTY",
+        value: 0,
+        isWild: false,
+        isScatter: false
+      };
+    });
+    return removedPositions;
+  }
+  /**
+   * Apply gravity to make symbols fall down into empty positions
+   */
+  applyGravity(grid, removedPositions) {
+    const droppedSymbols = [];
+    const numRows = grid.length > 0 ? grid[0].length : 0;
+    for (let reel = 0; reel < grid.length; reel++) {
+      const column = [];
+      for (let row = numRows - 1; row >= 0; row--) {
+        if (grid[reel][row].id !== "EMPTY") {
+          column.push(grid[reel][row]);
+        }
+      }
+      while (column.length < numRows) {
+        column.push({
+          id: "EMPTY",
+          value: 0,
+          isWild: false,
+          isScatter: false
+        });
+      }
+      column.reverse();
+      for (let row = 0; row < numRows; row++) {
+        const originalSymbol = grid[reel][row];
+        const newSymbol = column[row];
+        if (originalSymbol.id !== "EMPTY" && newSymbol.id !== "EMPTY" && originalSymbol.id !== newSymbol.id) {
+          for (let origRow = row + 1; origRow < numRows; origRow++) {
+            if (grid[reel][origRow].id === newSymbol.id) {
+              droppedSymbols.push({
+                symbol: newSymbol,
+                fromRow: origRow,
+                toRow: row,
+                reel
+              });
+              break;
+            }
+          }
+        }
+      }
+      grid[reel] = column;
+    }
+    return { grid, droppedSymbols };
+  }
+  /**
+   * Fill empty positions at the top with new random symbols
+   */
+  fillEmptyPositions(grid) {
+    const addedSymbols = [];
+    const symbolPool = this.config.symbolPool || [];
+    if (symbolPool.length === 0) {
+      throw new Error("Symbol pool must be provided for cascade filling");
+    }
+    for (let reel = 0; reel < grid.length; reel++) {
+      for (let row = 0; row < grid[reel].length; row++) {
+        if (grid[reel][row].id === "EMPTY") {
+          const newSymbol = this.generateWeightedSymbol(symbolPool);
+          grid[reel][row] = newSymbol;
+          addedSymbols.push({
+            symbol: newSymbol,
+            position: { reel, row }
+          });
+        }
+      }
+    }
+    return { grid, addedSymbols };
+  }
+  /**
+   * Generate a symbol based on weighted probabilities
+   */
+  generateWeightedSymbol(symbolPool) {
+    const totalWeight = symbolPool.reduce((sum, sym) => sum + (sym.weight || 1), 0);
+    let random = Math.random() * totalWeight;
+    for (const symbol of symbolPool) {
+      random -= symbol.weight || 1;
+      if (random <= 0) {
+        return { ...symbol };
+      }
+    }
+    return { ...symbolPool[symbolPool.length - 1] };
+  }
+  /**
+   * Evaluate wins on the current grid state
+   * This is a simplified version - in production you'd integrate with your WinEvaluator
+   */
+  evaluateWins(grid) {
+    return [];
+  }
+  /**
+   * Check if a cascade sequence should trigger special features
+   */
+  checkCascadeTriggers(cascadeResult) {
+    const triggers = [];
+    if (cascadeResult.totalCascades >= (this.config.triggerOnCascadeCount || Infinity)) {
+      triggers.push("CASCADE_COUNT_ACHIEVED");
+    }
+    if (cascadeResult.finalMultiplier >= (this.config.triggerOnMultiplier || Infinity)) {
+      triggers.push("MULTIPLIER_THRESHOLD");
+    }
+    const consecutiveWins = cascadeResult.steps.filter((step) => step.winsInStep.length > 0).length;
+    if (consecutiveWins >= (this.config.triggerOnConsecutiveWins || Infinity)) {
+      triggers.push("CONSECUTIVE_WINS");
+    }
+    return { triggers };
+  }
+};
+
+// src/ExpandingWildsManager.ts
+var ExpandingWildsManager = class {
+  expandConfig;
+  stickyConfig;
+  constructor(expandConfig, stickyConfig) {
+    this.expandConfig = expandConfig;
+    this.stickyConfig = stickyConfig || {
+      enabled: false,
+      persistSpins: 0,
+      maxStickyWilds: Infinity
+    };
+  }
+  /**
+   * Process expanding wilds on the current grid
+   */
+  processExpandingWilds(gameState) {
+    const expandedReels = [];
+    const expandedPositions = [];
+    let modifiedGrid = gameState.grid.map((reel) => [...reel]);
+    for (let reel = 0; reel < modifiedGrid.length; reel++) {
+      const shouldExpand = this.shouldReelExpand(modifiedGrid[reel], reel);
+      if (shouldExpand) {
+        expandedReels.push(reel);
+        const rowsToExpand = this.expandConfig.expandToRows || modifiedGrid[reel].length;
+        for (let row = 0; row < rowsToExpand; row++) {
+          const originalSymbol = modifiedGrid[reel][row];
+          if (!originalSymbol.isWild) {
+            expandedPositions.push({ reel, row });
+            modifiedGrid[reel][row] = {
+              ...originalSymbol,
+              isWild: true,
+              wildMultiplier: this.expandConfig.wildMultiplier || 1,
+              expandedFrom: originalSymbol.id
+            };
+          }
+        }
+      }
+    }
+    return {
+      success: expandedReels.length > 0,
+      expandedReels,
+      expandedPositions,
+      modifiedGrid,
+      totalExpanded: expandedPositions.length,
+      appliedMultiplier: this.expandConfig.wildMultiplier || 1
+    };
+  }
+  /**
+   * Determine if a reel should expand based on configuration
+   */
+  shouldReelExpand(reel, reelIndex) {
+    const wildCount = reel.filter((sym) => sym.isWild).length;
+    if (wildCount === 0) {
+      return false;
+    }
+    switch (this.expandConfig.triggerCondition) {
+      case "any_wild":
+        return true;
+      case "multiple_wilds":
+        return wildCount >= (this.expandConfig.minWildsForExpand || 2);
+      case "specific_positions":
+        return this.hasWildInSpecificPositions(reel);
+      case "random":
+        const probability = this.expandConfig.expansionProbability || 0.5;
+        return Math.random() < probability;
+      default:
+        return wildCount > 0;
+    }
+  }
+  /**
+   * Check if wilds exist in specific configured positions
+   */
+  hasWildInSpecificPositions(reel) {
+    const positions = this.expandConfig.specificPositions || [];
+    return positions.some((pos) => reel[pos] && reel[pos].isWild);
+  }
+  /**
+   * Apply sticky wilds logic for persistent wilds across spins
+   */
+  processStickyWilds(gameState, existingStickyWilds) {
+    const updatedStickyWilds = [];
+    const removedStickyWilds = [];
+    let modifiedGrid = gameState.grid.map((reel) => [...reel]);
+    existingStickyWilds.forEach((sticky) => {
+      const remainingSpins = sticky.remainingSpins - 1;
+      if (remainingSpins <= 0) {
+        removedStickyWilds.push({ reel: sticky.reel, row: sticky.row });
+        modifiedGrid[sticky.reel][sticky.row] = {
+          ...modifiedGrid[sticky.reel][sticky.row],
+          isSticky: false,
+          isWild: false
+        };
+      } else {
+        updatedStickyWilds.push({
+          reel: sticky.reel,
+          row: sticky.row,
+          remainingSpins
+        });
+      }
+    });
+    const currentStickyCount = modifiedGrid.reduce(
+      (sum, reel) => sum + reel.filter((sym) => sym.isSticky).length,
+      0
+    );
+    return {
+      success: updatedStickyWilds.length > 0 || removedStickyWilds.length > 0,
+      activeStickyWilds: updatedStickyWilds,
+      removedStickyWilds,
+      modifiedGrid,
+      totalActive: updatedStickyWilds.length,
+      totalRemoved: removedStickyWilds.length,
+      canAddMore: currentStickyCount < (this.stickyConfig.maxStickyWilds || Infinity)
+    };
+  }
+  /**
+   * Add new sticky wilds to the grid
+   */
+  addStickyWilds(gameState, positions, persistSpins) {
+    const newStickyWilds = [];
+    let modifiedGrid = gameState.grid.map((reel) => [...reel]);
+    const spinsToPersist = persistSpins || this.stickyConfig.persistSpins || 3;
+    positions.forEach((pos) => {
+      if (pos.reel >= 0 && pos.reel < modifiedGrid.length && pos.row >= 0 && pos.row < modifiedGrid[pos.reel].length) {
+        const currentSymbol = modifiedGrid[pos.reel][pos.row];
+        modifiedGrid[pos.reel][pos.row] = {
+          ...currentSymbol,
+          isWild: true,
+          isSticky: true,
+          remainingSpins: spinsToPersist,
+          stickyId: `sticky_${pos.reel}_${pos.row}_${Date.now()}`
+        };
+        newStickyWilds.push({
+          reel: pos.reel,
+          row: pos.row,
+          remainingSpins: spinsToPersist
+        });
+      }
+    });
+    return {
+      success: newStickyWilds.length > 0,
+      activeStickyWilds: newStickyWilds,
+      removedStickyWilds: [],
+      modifiedGrid,
+      totalActive: newStickyWilds.length,
+      totalRemoved: 0,
+      canAddMore: newStickyWilds.length < (this.stickyConfig.maxStickyWilds || Infinity)
+    };
+  }
+  /**
+   * Calculate multiplier effect from wilds in a win line
+   */
+  calculateWildMultiplier(winPositions, grid) {
+    let totalMultiplier = 1;
+    winPositions.forEach((pos) => {
+      const symbol = grid[pos.reel][pos.row];
+      if (symbol.isWild) {
+        const wildMult = symbol.wildMultiplier || this.expandConfig.wildMultiplier || 1;
+        if (this.expandConfig.multiplierStacking === "multiply") {
+          totalMultiplier *= wildMult;
+        } else if (this.expandConfig.multiplierStacking === "add") {
+          totalMultiplier += wildMult - 1;
+        } else {
+          totalMultiplier = Math.max(totalMultiplier, wildMult);
+        }
+      }
+    });
+    return totalMultiplier;
+  }
+  /**
+   * Check for special wild interactions (e.g., expanding wild meeting sticky wild)
+   */
+  checkWildInteractions(grid) {
+    const interactions = [];
+    const expandedReels = [];
+    const stickyPositions = [];
+    grid.forEach((reel, reelIndex) => {
+      if (reel.some((sym) => sym.expandedFrom)) {
+        expandedReels.push(reelIndex);
+      }
+    });
+    grid.forEach((reel, reelIndex) => {
+      reel.forEach((sym, rowIndex) => {
+        if (sym.isSticky) {
+          stickyPositions.push({ reel: reelIndex, row: rowIndex });
+        }
+      });
+    });
+    if (expandedReels.length > 0 && stickyPositions.length > 0) {
+      const overlappingReels = expandedReels.filter(
+        (reel) => stickyPositions.some((pos) => pos.reel === reel)
+      );
+      if (overlappingReels.length > 0) {
+        interactions.push("EXPANDING_STICKY_OVERLAP");
+      }
+    }
+    const fullScreenWild = grid.every((reel) => reel.every((sym) => sym.isWild));
+    if (fullScreenWild) {
+      interactions.push("FULL_SCREEN_WILDS");
+    }
+    return { interactions };
+  }
+};
+
+// src/ScatterEnhancementsManager.ts
+var ScatterEnhancementsManager = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Evaluate scatter symbols on the current grid
+   */
+  evaluateScatters(gameState) {
+    const scatterPositions = [];
+    let totalScatterCount = 0;
+    let totalScatterValue = 0;
+    gameState.grid.forEach((reel, reelIndex) => {
+      reel.forEach((symbol, rowIndex) => {
+        if (symbol.isScatter) {
+          scatterPositions.push({
+            reel: reelIndex,
+            row: rowIndex,
+            symbol
+          });
+          totalScatterCount++;
+          totalScatterValue += symbol.value || 0;
+        }
+      });
+    });
+    const triggers = this.checkTriggerConditions(totalScatterCount, scatterPositions);
+    const scatterPays = this.calculateScatterPays(totalScatterCount, totalScatterValue);
+    return {
+      success: scatterPositions.length > 0,
+      scatterCount: totalScatterCount,
+      scatterValue: totalScatterValue,
+      positions: scatterPositions,
+      triggers,
+      scatterPays,
+      collectedScatters: 0
+      // Updated by collection system
+    };
+  }
+  /**
+   * Check if scatter conditions trigger bonus features
+   */
+  checkTriggerConditions(scatterCount, positions) {
+    const triggers = [];
+    if (scatterCount >= (this.config.minScattersForTrigger || 3)) {
+      triggers.push({
+        type: "BONUS_TRIGGER",
+        triggered: true,
+        scatterCount,
+        featureType: this.config.triggeredFeature || "FREE_SPINS",
+        awardedSpins: this.calculateAwardedSpins(scatterCount)
+      });
+    }
+    if (this.config.requireSpecificReels) {
+      const reelSet = new Set(positions.map((p) => p.reel));
+      const requiredReels = this.config.requiredReels || [];
+      const hasAllRequired = requiredReels.every((reel) => reelSet.has(reel));
+      if (hasAllRequired) {
+        triggers.push({
+          type: "REEL_COMBINATION_TRIGGER",
+          triggered: true,
+          scatterCount,
+          featureType: "ENHANCED_BONUS",
+          awardedSpins: this.calculateAwardedSpins(scatterCount) * 2
+        });
+      }
+    }
+    if (this.config.enableClusterTriggers) {
+      const clusters = this.findScatterClusters(positions);
+      clusters.forEach((cluster) => {
+        if (cluster.size >= (this.config.clusterSizeForTrigger || 4)) {
+          triggers.push({
+            type: "CLUSTER_TRIGGER",
+            triggered: true,
+            scatterCount: cluster.size,
+            featureType: "CLUSTER_BONUS",
+            clusterPositions: cluster.positions
+          });
+        }
+      });
+    }
+    if (this.config.enableProgressiveTrigger) {
+    }
+    return triggers;
+  }
+  /**
+   * Calculate number of spins awarded based on scatter count
+   */
+  calculateAwardedSpins(scatterCount) {
+    const spinTable = this.config.spinAwardTable || {
+      3: 10,
+      4: 15,
+      5: 20,
+      6: 25
+    };
+    const matchingKey = Object.keys(spinTable).map(Number).filter((key) => scatterCount >= key).sort((a, b) => b - a)[0];
+    return matchingKey ? spinTable[matchingKey] : 0;
+  }
+  /**
+   * Calculate immediate scatter payouts
+   */
+  calculateScatterPays(count, totalValue) {
+    if (!this.config.enableScatterPays) {
+      return 0;
+    }
+    const payTable = this.config.scatterPayTable || {};
+    const basePay = payTable[count] || 0;
+    const multiplier = this.config.scatterMultiplier || 1;
+    return (basePay + totalValue) * multiplier;
+  }
+  /**
+   * Find clusters of adjacent scatter symbols
+   */
+  findScatterClusters(positions) {
+    const clusters = [];
+    const visited = /* @__PURE__ */ new Set();
+    positions.forEach((pos) => {
+      const key = `${pos.reel}-${pos.row}`;
+      if (!visited.has(key)) {
+        const cluster = this.floodFillCluster(pos, positions, visited);
+        if (cluster.length > 1) {
+          clusters.push({
+            size: cluster.length,
+            positions: cluster
+          });
+        }
+      }
+    });
+    return clusters;
+  }
+  /**
+   * Flood fill algorithm to find connected scatter positions
+   */
+  floodFillCluster(start, allPositions, visited) {
+    const cluster = [];
+    const queue = [start];
+    const positionSet = new Set(allPositions.map((p) => `${p.reel}-${p.row}`));
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const key = `${current.reel}-${current.row}`;
+      if (visited.has(key)) {
+        continue;
+      }
+      visited.add(key);
+      cluster.push(current);
+      const adjacentOffsets = [
+        [-1, -1],
+        [-1, 0],
+        [-1, 1],
+        [0, -1],
+        [0, 1],
+        [1, -1],
+        [1, 0],
+        [1, 1]
+      ];
+      adjacentOffsets.forEach(([dReel, dRow]) => {
+        const neighbor = {
+          reel: current.reel + dReel,
+          row: current.row + dRow
+        };
+        const neighborKey = `${neighbor.reel}-${neighbor.row}`;
+        if (positionSet.has(neighborKey) && !visited.has(neighborKey)) {
+          queue.push(neighbor);
+        }
+      });
+    }
+    return cluster;
+  }
+  /**
+   * Manage scatter collection system (collect scatters over multiple spins)
+   */
+  manageScatterCollection(currentScatters, collectedData) {
+    const updated = { ...collectedData };
+    updated.count += currentScatters.scatterCount;
+    currentScatters.positions.forEach((pos) => {
+      updated.values.push(pos.symbol.value || 0);
+    });
+    let collectionTrigger;
+    const targetCount = this.config.collectionTarget || 10;
+    if (updated.count >= targetCount) {
+      collectionTrigger = {
+        type: "COLLECTION_COMPLETE",
+        triggered: true,
+        scatterCount: updated.count,
+        featureType: "COLLECTION_BONUS",
+        awardedSpins: this.config.collectionBonusSpins || 10,
+        collectedValue: updated.values.reduce((sum, val) => sum + val, 0)
+      };
+      updated.count = 0;
+      updated.values = [];
+    }
+    updated.spinsRemaining--;
+    if (updated.spinsRemaining <= 0 && updated.count > 0 && this.config.autoTriggerOnExpiry) {
+      collectionTrigger = {
+        type: "COLLECTION_EXPIRY_TRIGGER",
+        triggered: true,
+        scatterCount: updated.count,
+        featureType: "MINI_BONUS",
+        awardedSpins: Math.floor(updated.count / 2)
+      };
+      updated.count = 0;
+      updated.values = [];
+    }
+    return { updated, collectionTrigger };
+  }
+  /**
+   * Apply scatter transformation mechanics (e.g., scatters becoming wilds)
+   */
+  transformScatters(gameState, scatterPositions) {
+    const transformed = [];
+    const modifiedGrid = gameState.grid.map((reel) => [...reel]);
+    if (!this.config.enableTransformation) {
+      return { modifiedGrid, transformed };
+    }
+    scatterPositions.forEach((pos) => {
+      if (pos.reel >= 0 && pos.reel < modifiedGrid.length && pos.row >= 0 && pos.row < modifiedGrid[pos.reel].length) {
+        const transformType = this.config.transformationType || "to_wild";
+        if (transformType === "to_wild") {
+          modifiedGrid[pos.reel][pos.row] = {
+            ...modifiedGrid[pos.reel][pos.row],
+            isWild: true,
+            isScatter: false,
+            wildMultiplier: this.config.transformedWildMultiplier || 1
+          };
+          transformed.push(pos);
+        } else if (transformType === "to_multiplier") {
+          modifiedGrid[pos.reel][pos.row] = {
+            ...modifiedGrid[pos.reel][pos.row],
+            isScatter: false,
+            value: (modifiedGrid[pos.reel][pos.row].value || 1) * 2
+          };
+          transformed.push(pos);
+        }
+      }
+    });
+    return { modifiedGrid, transformed };
+  }
+  /**
+   * Check for scatter in multiplier zones (special grid areas)
+   */
+  checkMultiplierZones(scatterPositions) {
+    const zoneHits = [];
+    let totalMultiplier = 1;
+    const zones = this.config.multiplierZones || [];
+    scatterPositions.forEach((pos) => {
+      zones.forEach((zone) => {
+        if (pos.reel >= zone.reelStart && pos.reel <= zone.reelEnd && pos.row >= zone.rowStart && pos.row <= zone.rowEnd) {
+          zoneHits.push({
+            reel: pos.reel,
+            row: pos.row,
+            multiplier: zone.multiplier
+          });
+          if (this.config.zoneMultiplierStacking === "multiply") {
+            totalMultiplier *= zone.multiplier;
+          } else {
+            totalMultiplier += zone.multiplier - 1;
+          }
+        }
+      });
+    });
+    return { totalMultiplier, zoneHits };
+  }
+  /**
+   * Implement progressive scatter trigger (accumulates across game session)
+   */
+  updateProgressiveScatter(currentCount, progressiveState) {
+    const updated = { ...progressiveState };
+    updated.accumulated += currentCount;
+    let triggered = false;
+    let reward;
+    if (updated.accumulated >= updated.threshold) {
+      triggered = true;
+      reward = {
+        type: "PROGRESSIVE_SCATTER_BONUS",
+        level: updated.level,
+        accumulatedCount: updated.accumulated,
+        awardedSpins: this.config.progressiveBonusSpins || updated.level * 10,
+        multiplier: this.config.progressiveMultiplier || updated.level
+      };
+      if (this.config.progressiveResetOnTrigger) {
+        updated.accumulated = 0;
+        updated.level = 1;
+        updated.threshold = this.config.baseProgressiveThreshold || 20;
+      } else {
+        updated.level++;
+        updated.threshold = Math.floor(updated.threshold * 1.5);
+      }
+    }
+    return { updated, triggered, reward };
+  }
+};
+
+// src/RespinsManager.ts
+var RespinsManager = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Check if respin feature should be triggered
+   */
+  checkTrigger(gameState) {
+    const { triggerType, minTriggerSymbols } = this.config;
+    if (triggerType === "symbol_count") {
+      const specialSymbols = this.countSpecialSymbols(gameState);
+      return specialSymbols >= minTriggerSymbols;
+    }
+    if (triggerType === "specific_positions") {
+      return this.checkSpecificPositions(gameState);
+    }
+    return false;
+  }
+  /**
+   * Count special symbols (money, reset, jackpot) on the grid
+   */
+  countSpecialSymbols(gameState) {
+    let count = 0;
+    const rows = gameState.grid.length;
+    const cols = rows > 0 ? gameState.grid[0].length : 0;
+    for (let row = 0; row < rows; row++) {
+      for (let col = 0; col < cols; col++) {
+        const symbol = gameState.grid[row][col];
+        if (this.isSpecialSymbol(symbol)) {
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+  /**
+   * Check if special symbols are in required positions
+   */
+  checkSpecificPositions(gameState) {
+    const { triggerPositions } = this.config;
+    if (!triggerPositions) return false;
+    for (const pos of triggerPositions) {
+      const { row, col, symbolId } = pos;
+      if (row >= gameState.grid.length || col >= gameState.grid[0].length) {
+        continue;
+      }
+      const symbol = gameState.grid[row][col];
+      if (symbol.id === symbolId || this.isSpecialSymbol(symbol)) {
+        continue;
+      }
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if a symbol is a special respin symbol
+   */
+  isSpecialSymbol(symbol) {
+    const moneySymbol = symbol;
+    return moneySymbol.isMoneySymbol === true || moneySymbol.isResetSymbol === true || moneySymbol.isJackpotSymbol === true;
+  }
+  /**
+   * Execute the respins feature
+   */
+  execute(gameState) {
+    const steps = [];
+    let remainingRespins = this.config.initialRespins || 3;
+    const lockedPositions = [];
+    let totalValue = 0;
+    let jackpotsCollected = [];
+    const rows = gameState.grid.length;
+    const cols = rows > 0 ? gameState.grid[0].length : 0;
+    for (let row = 0; row < rows; row++) {
+      for (let col = 0; col < cols; col++) {
+        const symbol = gameState.grid[row][col];
+        if (this.isSpecialSymbol(symbol)) {
+          lockedPositions.push({ row, col });
+          const moneySymbol = symbol;
+          if (moneySymbol.value) {
+            totalValue += moneySymbol.value;
+          }
+          if (moneySymbol.jackpotType) {
+            jackpotsCollected.push(moneySymbol.jackpotType);
+          }
+        }
+      }
+    }
+    steps.push({
+      respinsRemaining: remainingRespins,
+      lockedPositions: [...lockedPositions],
+      newSymbols: [],
+      valuesAdded: totalValue,
+      jackpotsAwarded: [...jackpotsCollected],
+      reason: "initial_trigger"
+    });
+    while (remainingRespins > 0 && lockedPositions.length < rows * cols) {
+      remainingRespins--;
+      const newSymbols = [];
+      let stepValueAdded = 0;
+      let stepJackpots = [];
+      for (let row = 0; row < rows; row++) {
+        for (let col = 0; col < cols; col++) {
+          const isLocked = lockedPositions.some(
+            (pos) => pos.row === row && pos.col === col
+          );
+          if (!isLocked) {
+            const newSymbol = this.generateRespinsSymbol();
+            newSymbols.push({ row, col, symbol: newSymbol });
+            if (this.isSpecialSymbol(newSymbol)) {
+              lockedPositions.push({ row, col });
+              const moneySymbol = newSymbol;
+              if (moneySymbol.value) {
+                stepValueAdded += moneySymbol.value;
+                totalValue += moneySymbol.value;
+              }
+              if (moneySymbol.jackpotType) {
+                stepJackpots.push(moneySymbol.jackpotType);
+                jackpotsCollected.push(moneySymbol.jackpotType);
+              }
+              if (moneySymbol.isResetSymbol === true) {
+                remainingRespins = this.config.initialRespins || 3;
+              }
+            }
+          }
+        }
+      }
+      steps.push({
+        respinsRemaining: remainingRespins,
+        lockedPositions: [...lockedPositions],
+        newSymbols: newSymbols.map((ns) => ({
+          row: ns.row,
+          col: ns.col,
+          symbolId: ns.symbol.id
+        })),
+        valuesAdded: stepValueAdded,
+        jackpotsAwarded: stepJackpots,
+        reason: stepJackpots.length > 0 ? "jackpot_collected" : newSymbols.length > 0 ? "respins" : "no_new_symbols"
+      });
+      if (newSymbols.every((ns) => !this.isSpecialSymbol(ns.symbol))) {
+        if (this.config.endOnNoSpecial) {
+          break;
+        }
+      }
+      if (lockedPositions.length === rows * cols && this.config.fullScreenBonus) {
+        totalValue *= this.config.fullScreenBonus.multiplier;
+        steps[steps.length - 1].reason = "full_screen_bonus";
+        steps[steps.length - 1].valuesAdded = totalValue;
+        break;
+      }
+    }
+    return {
+      triggered: true,
+      steps,
+      finalValue: totalValue,
+      jackpotsCollected,
+      lockedPositions,
+      totalRespinsUsed: (this.config.initialRespins || 3) - remainingRespins
+    };
+  }
+  /**
+   * Generate a special symbol for respins (weighted random)
+   * In production, this should use a certified RNG with configurable weights
+   */
+  generateRespinsSymbol() {
+    const { symbolWeights } = this.config;
+    const rand = Math.random();
+    let cumulative = 0;
+    if (symbolWeights) {
+      for (const weight of symbolWeights) {
+        cumulative += weight.probability;
+        if (rand <= cumulative) {
+          const symbol = {
+            id: weight.symbolId,
+            value: weight.baseValue || 0,
+            isWild: false,
+            isScatter: false,
+            isMoneySymbol: weight.isMoneySymbol,
+            isResetSymbol: weight.isResetSymbol,
+            isJackpotSymbol: weight.isJackpotSymbol,
+            jackpotType: weight.jackpotType
+          };
+          return symbol;
+        }
+      }
+    }
+    return {
+      id: "regular",
+      value: 0,
+      isWild: false,
+      isScatter: false
+    };
+  }
+  /**
+   * Calculate potential payout for respins feature
+   */
+  calculatePotentialPayout(betAmount) {
+    const { initialRespins, symbolWeights, fullScreenBonus } = this.config;
+    if (!symbolWeights) return 0;
+    let expectedValue = 0;
+    const totalProbability = symbolWeights.reduce((sum, w) => sum + w.probability, 0);
+    for (const weight of symbolWeights) {
+      const symbolValue = weight.baseValue || 0;
+      const probability = weight.probability / totalProbability;
+      expectedValue += symbolValue * probability;
+    }
+    let expectedTotal = expectedValue * (initialRespins || 3);
+    if (fullScreenBonus) {
+      expectedTotal *= 1 + (fullScreenBonus.multiplier - 1) * 0.01;
+    }
+    return expectedTotal * betAmount;
+  }
+  /**
+   * Get configuration for client-side preview
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/WalletManager.ts
+var InMemoryWalletStorage = class {
+  balances = /* @__PURE__ */ new Map();
+  transactions = /* @__PURE__ */ new Map();
+  async getBalance(userId) {
+    return this.balances.get(userId) || null;
+  }
+  async updateBalance(userId, amount, version) {
+    const current = this.balances.get(userId);
+    if (current && current.version !== version) {
+      return null;
+    }
+    const newBalance = current ? parseFloat(current.amount) + parseFloat(amount) : parseFloat(amount);
+    const updatedBalance = {
+      userId,
+      amount: newBalance.toFixed(4),
+      // Adjust precision as needed
+      version: (current?.version || 0) + 1,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.balances.set(userId, updatedBalance);
+    return updatedBalance;
+  }
+  async recordTransaction(transaction) {
+    const userTxns = this.transactions.get(transaction.userId) || [];
+    userTxns.push(transaction);
+    this.transactions.set(transaction.userId, userTxns);
+  }
+  async getTransactionHistory(userId, limit = 50) {
+    const userTxns = this.transactions.get(userId) || [];
+    return userTxns.slice(-limit);
+  }
+};
+var WalletManager = class {
+  storage;
+  config;
+  constructor(storage, config) {
+    this.storage = storage;
+    this.config = config;
+  }
+  /**
+   * Place a bet (deduct funds)
+   */
+  async placeBet(userId, amount, gameId, roundId) {
+    return this.executeTransaction(userId, -amount, "bet", { gameId, roundId });
+  }
+  /**
+   * Credit winnings
+   */
+  async creditWin(userId, amount, gameId, roundId, winType = "normal") {
+    let type = "payout";
+    if (winType === "bonus") type = "bonus_payout";
+    if (winType === "jackpot") type = "jackpot_win";
+    return this.executeTransaction(userId, amount, type, { gameId, roundId });
+  }
+  /**
+   * Core transaction logic with optimistic locking
+   */
+  async executeTransaction(userId, amount, type, metadata) {
+    const maxRetries = 3;
+    let attempt = 0;
+    while (attempt < maxRetries) {
+      try {
+        const currentBalance = await this.storage.getBalance(userId);
+        const currentAmount = currentBalance ? parseFloat(currentBalance.amount) : 0;
+        const version = currentBalance?.version || 0;
+        if (amount < 0 && currentAmount + amount < 0) {
+          return { success: false, error: "Insufficient funds", code: "INSUFFICIENT_FUNDS" };
+        }
+        const newAmount = currentAmount + amount;
+        const updatedBalance = await this.storage.updateBalance(userId, amount.toString(), version);
+        if (!updatedBalance) {
+          attempt++;
+          continue;
+        }
+        const transaction = {
+          id: crypto.randomUUID(),
+          userId,
+          type,
+          amount: amount.toString(),
+          balanceBefore: currentAmount.toString(),
+          balanceAfter: newAmount.toString(),
+          referenceId: metadata.roundId,
+          metadata: { gameId: metadata.gameId },
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        await this.storage.recordTransaction(transaction);
+        return {
+          success: true,
+          balance: updatedBalance.amount,
+          transactionId: transaction.id
+        };
+      } catch (error) {
+        return { success: false, error: error.message, code: "INTERNAL_ERROR" };
+      }
+    }
+    return { success: false, error: "Transaction failed after retries", code: "CONFLICT" };
+  }
+  /**
+   * Transfer funds between users (e.g., P2P features)
+   */
+  async transfer(fromId, toId, amount) {
+    const debit = await this.placeBet(fromId, amount, "transfer", `tx-${Date.now()}`);
+    if (!debit.success) return debit;
+    const credit = await this.creditWin(toId, amount, "transfer", `tx-${Date.now()}`, "normal");
+    if (!credit.success) {
+      return { success: false, error: "Transfer partial failure", code: "ROLLBACK_REQUIRED" };
+    }
+    return { success: true, message: "Transfer complete" };
+  }
+};
+
+// src/AuditManager.ts
+var InMemoryAuditStorage = class {
+  records = /* @__PURE__ */ new Map();
+  playerIndex = /* @__PURE__ */ new Map();
+  async save(record) {
+    this.records.set(record.spinId, record);
+    if (!this.playerIndex.has(record.playerId)) {
+      this.playerIndex.set(record.playerId, /* @__PURE__ */ new Set());
+    }
+    this.playerIndex.get(record.playerId).add(record.spinId);
+  }
+  async findByPlayer(playerId, startTime, endTime) {
+    const spinIds = this.playerIndex.get(playerId) || /* @__PURE__ */ new Set();
+    const results = [];
+    for (const spinId of spinIds) {
+      const record = this.records.get(spinId);
+      if (record && record.timestamp >= startTime && record.timestamp <= endTime) {
+        results.push(record);
+      }
+    }
+    return results.sort((a, b) => a.timestamp - b.timestamp);
+  }
+  async findById(spinId) {
+    return this.records.get(spinId) || null;
+  }
+  async getSummary(playerId, startTime, endTime) {
+    const records = await this.findByPlayer(playerId, startTime, endTime);
+    const summary = {
+      playerId,
+      periodStart: startTime,
+      periodEnd: endTime,
+      totalSpins: records.length,
+      totalStaked: 0,
+      totalWon: 0,
+      netResult: 0,
+      biggestWin: 0,
+      bonusTriggers: 0,
+      jackpotWins: 0,
+      sessionCount: 0,
+      averageSessionDuration: 0
+    };
+    const sessions = /* @__PURE__ */ new Set();
+    for (const record of records) {
+      summary.totalStaked += record.stake;
+      summary.totalWon += record.win;
+      if (record.win > summary.biggestWin) {
+        summary.biggestWin = record.win;
+      }
+      if (record.bonusTriggered) {
+        summary.bonusTriggers++;
+      }
+      if (record.jackpotWins.length > 0) {
+        summary.jackpotWins += record.jackpotWins.length;
+      }
+      sessions.add(record.sessionId);
+    }
+    summary.netResult = summary.totalWon - summary.totalStaked;
+    summary.sessionCount = sessions.size;
+    if (summary.sessionCount > 0) {
+      summary.averageSessionDuration = (endTime - startTime) / summary.sessionCount / 6e4;
+    }
+    return summary;
+  }
+  /**
+   * Clear all records (for testing).
+   */
+  clear() {
+    this.records.clear();
+    this.playerIndex.clear();
+  }
+  /**
+   * Get total record count.
+   */
+  getCount() {
+    return this.records.size;
+  }
+};
+var AuditManager = class {
+  storage;
+  gameId;
+  operatorId;
+  constructor(gameId, storage, operatorId) {
+    this.gameId = gameId;
+    this.storage = storage || new InMemoryAuditStorage();
+    this.operatorId = operatorId;
+  }
+  /**
+   * Record a spin for audit purposes.
+   */
+  async recordSpin(params) {
+    const record = {
+      spinId: params.spinId,
+      playerId: params.playerId,
+      gameId: this.gameId,
+      timestamp: Date.now(),
+      stake: params.stake,
+      win: params.win,
+      balanceBefore: params.balanceBefore,
+      balanceAfter: params.balanceAfter,
+      rngSeed: params.rngSeed,
+      result: params.result,
+      gameMode: params.gameMode,
+      bonusTriggered: params.bonusTriggered,
+      jackpotContributions: params.jackpotContributions,
+      jackpotWins: params.jackpotWins,
+      ipAddress: params.ipAddress,
+      sessionId: params.sessionId,
+      deviceInfo: params.deviceInfo,
+      location: params.location,
+      operatorId: this.operatorId,
+      platform: params.platform
+    };
+    await this.storage.save(record);
+    return record;
+  }
+  /**
+   * Get audit records for a player within a time range.
+   */
+  async getPlayerRecords(playerId, startTime, endTime) {
+    return this.storage.findByPlayer(playerId, startTime, endTime);
+  }
+  /**
+   * Get a specific spin record by ID.
+   */
+  async getSpinRecord(spinId) {
+    return this.storage.findById(spinId);
+  }
+  /**
+   * Get player activity summary for a period.
+   */
+  async getPlayerSummary(playerId, startTime, endTime) {
+    return this.storage.getSummary(playerId, startTime, endTime);
+  }
+  /**
+   * Export records for regulatory reporting.
+   */
+  async exportRecords(playerId, startTime, endTime, format = "json") {
+    const records = await this.getPlayerRecords(playerId, startTime, endTime);
+    if (format === "json") {
+      return JSON.stringify(records, null, 2);
+    }
+    const headers = [
+      "spinId",
+      "playerId",
+      "timestamp",
+      "stake",
+      "win",
+      "balanceBefore",
+      "balanceAfter",
+      "gameMode",
+      "bonusTriggered"
+    ].join(",");
+    const rows = records.map((r) => [
+      r.spinId,
+      r.playerId,
+      r.timestamp,
+      r.stake,
+      r.win,
+      r.balanceBefore,
+      r.balanceAfter,
+      r.gameMode,
+      r.bonusTriggered
+    ].join(","));
+    return [headers, ...rows].join("\n");
+  }
+  /**
+   * Verify game integrity by checking RNG seed chain.
+   */
+  async verifyRngChain(spinIds) {
+    const errors = [];
+    for (let i = 1; i < spinIds.length; i++) {
+      const prevRecord = await this.getSpinRecord(spinIds[i - 1]);
+      const currRecord = await this.getSpinRecord(spinIds[i]);
+      if (!prevRecord || !currRecord) {
+        errors.push(`Missing record for spin ${spinIds[i]}`);
+        continue;
+      }
+      if (currRecord.timestamp <= prevRecord.timestamp) {
+        errors.push(`Timestamp order violation: ${spinIds[i]} <= ${spinIds[i - 1]}`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+
+// src/DebugManager.ts
+var DebugManager = class {
+  config;
+  spinCount = 0;
+  lastRngSeed = "";
+  forcedOutcomesApplied = 0;
+  logs = {
+    errors: [],
+    warnings: [],
+    infoLogs: [],
+    debugLogs: []
+  };
+  constructor(config) {
+    this.config = {
+      enabled: config?.enabled ?? false,
+      logSpins: config?.logSpins ?? false,
+      logRngSeeds: config?.logRngSeeds ?? false,
+      forcedOutcomes: config?.forcedOutcomes ?? [],
+      skipBalanceChecks: config?.skipBalanceChecks ?? false,
+      verboseLevel: config?.verboseLevel ?? "warnings",
+      outputFormat: config?.outputFormat ?? "console",
+      logFilePath: config?.logFilePath
+    };
+  }
+  /**
+   * Update debug configuration.
+   */
+  configure(config) {
+    this.config = { ...this.config, ...config };
+    this.log("info", "config", "Debug configuration updated", { config });
+  }
+  /**
+   * Check if debug mode is enabled.
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Get current debug state.
+   */
+  getState() {
+    return {
+      enabled: this.config.enabled,
+      spinCount: this.spinCount,
+      lastRngSeed: this.lastRngSeed,
+      forcedOutcomesApplied: this.forcedOutcomesApplied,
+      errors: this.logs.errors,
+      warnings: this.logs.warnings,
+      infoLogs: this.logs.infoLogs
+    };
+  }
+  /**
+   * Reset debug state and logs.
+   */
+  reset() {
+    this.spinCount = 0;
+    this.lastRngSeed = "";
+    this.forcedOutcomesApplied = 0;
+    this.logs = {
+      errors: [],
+      warnings: [],
+      infoLogs: [],
+      debugLogs: []
+    };
+    this.log("info", "system", "Debug state reset");
+  }
+  /**
+   * Log a message at specified level.
+   */
+  log(level, category, message, data) {
+    if (!this.config.enabled) return;
+    const shouldLog = this.shouldLogLevel(level);
+    if (!shouldLog) return;
+    const entry = {
+      timestamp: Date.now(),
+      level,
+      category,
+      message,
+      data
+    };
+    switch (level) {
+      case "error":
+        this.logs.errors.push(entry);
+        break;
+      case "warning":
+        this.logs.warnings.push(entry);
+        break;
+      case "info":
+        this.logs.infoLogs.push(entry);
+        break;
+      case "debug":
+        this.logs.debugLogs.push(entry);
+        break;
+    }
+    this.outputLog(entry);
+  }
+  /**
+   * Log a spin result.
+   */
+  logSpin(spinId, result, rngSeed) {
+    if (!this.config.enabled || !this.config.logSpins) return;
+    this.spinCount++;
+    this.lastRngSeed = rngSeed;
+    this.log("debug", "spin", `Spin #${this.spinCount}`, {
+      spinId,
+      totalWin: result.totalWin,
+      bonusTriggered: result.bonusTriggered,
+      cascadeLevel: result.cascadeLevel,
+      rngSeed
+    });
+    if (this.config.logRngSeeds) {
+      this.log("debug", "rng", `RNG Seed for spin #${this.spinCount}`, { seed: rngSeed });
+    }
+  }
+  /**
+   * Check and apply forced outcome if conditions match.
+   */
+  checkForcedOutcome(params) {
+    if (!this.config.enabled || !this.config.forcedOutcomes) return null;
+    for (const forced of this.config.forcedOutcomes) {
+      let matches = false;
+      switch (forced.condition.type) {
+        case "spinNumber":
+          matches = forced.condition.value === params.spinNumber;
+          break;
+        case "randomSeed":
+          matches = forced.condition.value === params.rngSeed;
+          break;
+        case "betAmount":
+          matches = forced.condition.value === params.betAmount;
+          break;
+        case "playerId":
+          matches = forced.condition.value === params.playerId;
+          break;
+      }
+      if (matches && forced.result) {
+        this.forcedOutcomesApplied++;
+        this.log("warning", "forced", `Forced outcome applied for spin #${params.spinNumber}`, {
+          condition: forced.condition,
+          result: forced.result
+        });
+        return {
+          result: forced.result.symbols || [],
+          totalWin: forced.result.winAmount || 0,
+          stakePerLine: 0,
+          totalStake: 0,
+          gameMode: 0,
+          balanceAfter: 0,
+          bonusTriggered: forced.result.bonusTriggered ?? false
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if balance checks should be skipped.
+   */
+  shouldSkipBalanceCheck() {
+    return this.config.enabled && this.config.skipBalanceChecks;
+  }
+  /**
+   * Get all logs (optionally filtered by level).
+   */
+  getLogs(level) {
+    if (!level) {
+      return [
+        ...this.logs.errors,
+        ...this.logs.warnings,
+        ...this.logs.infoLogs,
+        ...this.logs.debugLogs
+      ].sort((a, b) => a.timestamp - b.timestamp);
+    }
+    switch (level) {
+      case "error":
+        return this.logs.errors;
+      case "warning":
+        return this.logs.warnings;
+      case "info":
+        return this.logs.infoLogs;
+      case "debug":
+        return this.logs.debugLogs;
+    }
+  }
+  /**
+   * Export logs as JSON.
+   */
+  exportLogs() {
+    return JSON.stringify(this.getLogs(), null, 2);
+  }
+  /**
+   * Clear all logs.
+   */
+  clearLogs() {
+    this.logs = {
+      errors: [],
+      warnings: [],
+      infoLogs: [],
+      debugLogs: []
+    };
+  }
+  /**
+   * Determine if a log level should be output based on verboseLevel config.
+   */
+  shouldLogLevel(level) {
+    const levels = ["none", "errors", "warnings", "info", "debug"];
+    const currentIndex = levels.indexOf(this.config.verboseLevel);
+    const levelIndex = levels.indexOf(level);
+    return levelIndex <= currentIndex && levelIndex > 0;
+  }
+  /**
+   * Output log entry based on outputFormat config.
+   */
+  outputLog(entry) {
+    if (this.config.outputFormat === "console") {
+      const prefix = `[${new Date(entry.timestamp).toISOString()}] [${entry.level.toUpperCase()}] ${entry.category}:`;
+      switch (entry.level) {
+        case "error":
+          console.error(prefix, entry.message, entry.data || "");
+          break;
+        case "warning":
+          console.warn(prefix, entry.message, entry.data || "");
+          break;
+        case "info":
+          console.info(prefix, entry.message, entry.data || "");
+          break;
+        case "debug":
+          console.log(prefix, entry.message, entry.data || "");
+          break;
+      }
+    } else if (this.config.outputFormat === "json") {
+      console.log(JSON.stringify(entry));
+    }
+  }
+  /**
+   * Get statistics about logged events.
+   */
+  getStatistics() {
+    return {
+      totalLogs: this.logs.errors.length + this.logs.warnings.length + this.logs.infoLogs.length + this.logs.debugLogs.length,
+      errorCount: this.logs.errors.length,
+      warningCount: this.logs.warnings.length,
+      infoCount: this.logs.infoLogs.length,
+      debugCount: this.logs.debugLogs.length,
+      spinsTracked: this.spinCount,
+      forcedOutcomesApplied: this.forcedOutcomesApplied
+    };
+  }
+};
+
+// src/ResponsibleGamingManager.ts
+var ResponsibleGamingManager = class {
+  limits;
+  playerState;
+  alerts = [];
+  realityCheckCounter = 0;
+  lastRealityCheckTime = 0;
+  constructor(limits, playerState) {
+    this.limits = limits;
+    this.playerState = playerState;
+    if (!playerState.sessionStartTime && limits.sessionTimeLimit) {
+      playerState.sessionStartTime = Date.now();
+    }
+  }
+  /**
+   * Update player state (call after each spin).
+   */
+  updatePlayerState(state) {
+    this.playerState = { ...this.playerState, ...state };
+    this.checkAllLimits();
+  }
+  /**
+   * Update responsible gaming limits (e.g., player changed their limits).
+   */
+  updateLimits(newLimits) {
+    this.limits = { ...this.limits, ...newLimits };
+    this.validateLimits();
+    this.checkAllLimits();
+  }
+  /**
+   * Check if player can place a bet of the given amount.
+   */
+  canPlaceBet(betAmount) {
+    const selfExclusion = this.getSelfExclusionStatus();
+    if (selfExclusion.isExcluded) {
+      return {
+        success: false,
+        error: `Player is self-excluded until ${selfExclusion.exclusionUntil?.toISOString()}`
+      };
+    }
+    if (this.limits.maxBetLimit && betAmount > this.limits.maxBetLimit) {
+      return {
+        success: false,
+        error: `Bet amount ${betAmount} exceeds maximum allowed bet of ${this.limits.maxBetLimit}`
+      };
+    }
+    const lossInfo = this.getLossTrackingInfo();
+    if (lossInfo.isLimitReached) {
+      return {
+        success: false,
+        error: `Session loss limit of ${this.limits.lossLimit} has been reached`
+      };
+    }
+    const timeInfo = this.getSessionTimeInfo();
+    if (timeInfo.isLimitReached) {
+      return {
+        success: false,
+        error: `Session time limit of ${this.limits.sessionTimeLimit} minutes has been reached`
+      };
+    }
+    return { success: true, data: true };
+  }
+  /**
+   * Check if player can continue playing (general eligibility).
+   */
+  canContinuePlaying() {
+    return this.canPlaceBet(0);
+  }
+  /**
+   * Get session time tracking information.
+   */
+  getSessionTimeInfo() {
+    const startTime = this.playerState.sessionStartTime || Date.now();
+    const elapsedMs = Date.now() - startTime;
+    const elapsedMinutes = Math.floor(elapsedMs / 6e4);
+    const limitMinutes = this.limits.sessionTimeLimit;
+    const isLimitReached = limitMinutes ? elapsedMinutes >= limitMinutes : false;
+    const warningThreshold = limitMinutes ? limitMinutes * 0.8 : 0;
+    const warningThresholdReached = limitMinutes ? elapsedMinutes >= warningThreshold : false;
+    return {
+      sessionStartTime: startTime,
+      elapsedMinutes,
+      limitMinutes,
+      isLimitReached,
+      warningThresholdReached
+    };
+  }
+  /**
+   * Get loss tracking information.
+   */
+  getLossTrackingInfo() {
+    const sessionLoss = this.playerState.sessionLoss || 0;
+    const lossLimit = this.limits.lossLimit;
+    const isLimitReached = lossLimit ? sessionLoss >= lossLimit : false;
+    const warningThreshold = lossLimit ? lossLimit * 0.8 : 0;
+    const warningThresholdReached = lossLimit ? sessionLoss >= warningThreshold : false;
+    return {
+      sessionLoss,
+      lossLimit,
+      isLimitReached,
+      warningThresholdReached
+    };
+  }
+  /**
+   * Get win tracking information.
+   */
+  getWinTrackingInfo() {
+    const sessionWin = this.playerState.sessionWin || 0;
+    const winGoal = this.limits.winGoal;
+    const isGoalReached = winGoal ? sessionWin >= winGoal : false;
+    const notificationSent = isGoalReached && this.alerts.some(
+      (a) => a.type === "win_goal" && !a.actionRequired
+    );
+    return {
+      sessionWin,
+      winGoal,
+      isGoalReached,
+      notificationSent
+    };
+  }
+  /**
+   * Get self-exclusion status.
+   */
+  getSelfExclusionStatus() {
+    const exclusionUntil = this.limits.selfExclusionUntil;
+    if (!exclusionUntil) {
+      return { isExcluded: false };
+    }
+    const exclusionDate = new Date(exclusionUntil);
+    const now = /* @__PURE__ */ new Date();
+    const isExcluded = now < exclusionDate;
+    if (!isExcluded) {
+      return { isExcluded: false };
+    }
+    const remainingDays = Math.ceil((exclusionDate.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
+    return {
+      isExcluded: true,
+      exclusionUntil: exclusionDate,
+      remainingDays
+    };
+  }
+  /**
+   * Check if reality check is due.
+   */
+  shouldShowRealityCheck() {
+    const interval = this.limits.realityCheckInterval;
+    if (!interval || !this.playerState.sessionStartTime) {
+      return false;
+    }
+    const elapsedMinutes = this.getSessionTimeInfo().elapsedMinutes;
+    const checksDue = Math.floor(elapsedMinutes / interval);
+    return checksDue > this.realityCheckCounter;
+  }
+  /**
+   * Generate reality check event.
+   */
+  generateRealityCheck() {
+    if (!this.shouldShowRealityCheck()) {
+      return null;
+    }
+    this.realityCheckCounter++;
+    this.lastRealityCheckTime = Date.now();
+    const elapsedMinutes = this.getSessionTimeInfo().elapsedMinutes;
+    const totalSpins = this.playerState.history?.length || 0;
+    const totalStaked = this.playerState.history?.reduce((sum, entry) => sum + entry.bet, 0) || 0;
+    const totalWon = this.playerState.history?.reduce((sum, entry) => sum + entry.win, 0) || 0;
+    const netResult = totalWon - totalStaked;
+    const event = {
+      timestamp: Date.now(),
+      elapsedMinutes,
+      totalSpins,
+      totalStaked,
+      totalWon,
+      netResult,
+      message: `Reality Check: You've been playing for ${elapsedMinutes} minutes. Total staked: ${totalStaked}, Total won: ${totalWon}, Net: ${netResult}`
+    };
+    this.addAlert({
+      type: "reality_check",
+      severity: "info",
+      message: event.message,
+      timestamp: event.timestamp
+    });
+    return event;
+  }
+  /**
+   * Check all limits and generate alerts.
+   */
+  checkAllLimits() {
+    const timeInfo = this.getSessionTimeInfo();
+    if (timeInfo.isLimitReached) {
+      this.addAlert({
+        type: "session_time",
+        severity: "critical",
+        message: `Session time limit of ${this.limits.sessionTimeLimit} minutes reached. Play suspended.`,
+        timestamp: Date.now(),
+        actionRequired: true,
+        suggestedAction: "Please take a break or end your session."
+      });
+    } else if (timeInfo.warningThresholdReached) {
+      this.addAlert({
+        type: "session_time",
+        severity: "warning",
+        message: `You've been playing for ${timeInfo.elapsedMinutes} minutes. Limit is ${this.limits.sessionTimeLimit} minutes.`,
+        timestamp: Date.now(),
+        actionRequired: false
+      });
+    }
+    const lossInfo = this.getLossTrackingInfo();
+    if (lossInfo.isLimitReached) {
+      this.addAlert({
+        type: "loss_limit",
+        severity: "critical",
+        message: `Session loss limit of ${this.limits.lossLimit} reached. Play suspended.`,
+        timestamp: Date.now(),
+        actionRequired: true,
+        suggestedAction: "Please end your session or wait until tomorrow."
+      });
+    } else if (lossInfo.warningThresholdReached) {
+      this.addAlert({
+        type: "loss_limit",
+        severity: "warning",
+        message: `Your session losses are ${lossInfo.sessionLoss}. Limit is ${this.limits.lossLimit}.`,
+        timestamp: Date.now(),
+        actionRequired: false
+      });
+    }
+    const winInfo = this.getWinTrackingInfo();
+    if (winInfo.isGoalReached && !winInfo.notificationSent) {
+      this.addAlert({
+        type: "win_goal",
+        severity: "info",
+        message: `Congratulations! You've reached your win goal of ${this.limits.winGoal}.`,
+        timestamp: Date.now(),
+        actionRequired: false,
+        suggestedAction: "Consider cashing out your winnings."
+      });
+    }
+  }
+  /**
+   * Add an alert to the list.
+   */
+  addAlert(alert) {
+    this.alerts.push(alert);
+    if (this.alerts.length > 100) {
+      this.alerts = this.alerts.slice(-100);
+    }
+  }
+  /**
+   * Get all active alerts.
+   */
+  getAlerts() {
+    return [...this.alerts];
+  }
+  /**
+   * Clear alerts (call after player acknowledges them).
+   */
+  clearAlerts() {
+    this.alerts = [];
+  }
+  /**
+   * Get player activity statistics.
+   */
+  getPlayerActivityStats() {
+    const history = this.playerState.history || [];
+    const totalStaked = history.reduce((sum, entry) => sum + entry.bet, 0);
+    const totalWon = history.reduce((sum, entry) => sum + entry.win, 0);
+    let totalTimePlayed = 0;
+    if (this.playerState.sessionStartTime) {
+      totalTimePlayed = this.getSessionTimeInfo().elapsedMinutes;
+    }
+    return {
+      totalSessions: 1,
+      // In production, track across multiple sessions
+      totalTimePlayed,
+      totalStaked,
+      totalWon,
+      netResult: totalWon - totalStaked,
+      averageSessionDuration: totalTimePlayed,
+      longestSession: totalTimePlayed,
+      biggestLoss: Math.min(0, totalWon - totalStaked),
+      biggestWin: Math.max(0, ...history.map((h) => h.win)),
+      lastSessionDate: this.playerState.sessionStartTime
+    };
+  }
+  /**
+   * Validate limits configuration.
+   */
+  validateLimits() {
+    const errors = [];
+    if (this.limits.sessionTimeLimit && this.limits.sessionTimeLimit <= 0) {
+      errors.push("Session time limit must be positive");
+    }
+    if (this.limits.lossLimit && this.limits.lossLimit <= 0) {
+      errors.push("Loss limit must be positive");
+    }
+    if (this.limits.winGoal && this.limits.winGoal <= 0) {
+      errors.push("Win goal must be positive");
+    }
+    if (this.limits.maxBetLimit && this.limits.maxBetLimit <= 0) {
+      errors.push("Max bet limit must be positive");
+    }
+    if (this.limits.realityCheckInterval && this.limits.realityCheckInterval <= 0) {
+      errors.push("Reality check interval must be positive");
+    }
+    if (this.limits.selfExclusionUntil) {
+      const exclusionDate = new Date(this.limits.selfExclusionUntil);
+      if (isNaN(exclusionDate.getTime())) {
+        errors.push("Invalid self-exclusion date format");
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`Invalid RG limits configuration: ${errors.join(", ")}`);
+    }
+  }
+  /**
+   * Reset session tracking (call when player starts new session).
+   */
+  resetSession() {
+    this.playerState.sessionStartTime = Date.now();
+    this.playerState.sessionLoss = 0;
+    this.playerState.sessionWin = 0;
+    this.realityCheckCounter = 0;
+    this.clearAlerts();
+  }
+  /**
+   * Apply a win/loss result to session tracking.
+   */
+  applyResult(stake, win) {
+    const netResult = win - stake;
+    if (netResult < 0) {
+      this.playerState.sessionLoss = (this.playerState.sessionLoss || 0) + Math.abs(netResult);
+    }
+    if (netResult > 0) {
+      this.playerState.sessionWin = (this.playerState.sessionWin || 0) + netResult;
+    }
+    this.checkAllLimits();
+  }
+  /**
+   * Export responsible gaming report for player download.
+   */
+  exportRGReport() {
+    const stats = this.getPlayerActivityStats();
+    const selfExclusion = this.getSelfExclusionStatus();
+    const report = {
+      reportGenerated: (/* @__PURE__ */ new Date()).toISOString(),
+      playerLimits: this.limits,
+      selfExclusionStatus: selfExclusion,
+      activityStatistics: stats,
+      recentAlerts: this.alerts.slice(-20)
+    };
+    return JSON.stringify(report, null, 2);
+  }
+};
+
+// src/sampleData.ts
+var sampleConfig = {
+  gameId: "fruit-slot",
+  reelCount: 5,
+  rowCount: 3,
+  symbolMap: {
+    0: "cherry",
+    1: "lemon",
+    2: "orange",
+    3: "plum",
+    4: "grape",
+    5: "watermelon",
+    6: "star",
+    7: "bell",
+    8: "seven",
+    9: "diamond"
+  },
+  paytableData: {
+    0: { x3: 10, x4: 20, x5: 50 },
+    1: { x3: 5, x4: 15, x5: 30 },
+    2: { x3: 4, x4: 10, x5: 25 },
+    3: { x3: 3, x4: 8, x5: 20 },
+    4: { x3: 2, x4: 5, x5: 15 },
+    5: { x3: 1, x4: 3, x5: 10 },
+    6: { x3: 0, x4: 2, x5: 8 },
+    7: { x3: 0, x4: 1, x5: 5 },
+    8: { x3: 0, x4: 0, x5: 2 },
+    9: { x3: 0, x4: 0, x5: 1 }
+  },
+  reelStrips: [
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0],
+    [2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1],
+    [3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2],
+    [4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3]
+  ],
+  linePatterns: [
+    [{ reel: 0, row: 1 }, { reel: 1, row: 1 }, { reel: 2, row: 1 }, { reel: 3, row: 1 }, { reel: 4, row: 1 }],
+    [{ reel: 0, row: 0 }, { reel: 1, row: 0 }, { reel: 2, row: 0 }, { reel: 3, row: 0 }, { reel: 4, row: 0 }],
+    [{ reel: 0, row: 2 }, { reel: 1, row: 2 }, { reel: 2, row: 2 }, { reel: 3, row: 2 }, { reel: 4, row: 2 }],
+    [{ reel: 0, row: 0 }, { reel: 1, row: 1 }, { reel: 2, row: 2 }, { reel: 3, row: 1 }, { reel: 4, row: 0 }],
+    [{ reel: 0, row: 2 }, { reel: 1, row: 1 }, { reel: 2, row: 0 }, { reel: 3, row: 1 }, { reel: 4, row: 2 }]
+  ],
+  currency: {
+    code: "USD",
+    symbol: "$",
+    decimalSeparator: ".",
+    thousandSeparator: ",",
+    minDecimalPlaces: 2
+  },
+  features: {
+    autoplay: true,
+    fastSpin: true,
+    realityCheck: true,
+    fullscreen: true
+  },
+  defaultBet: 1,
+  minBet: 0.1,
+  maxBet: 100,
+  betStep: 0.1,
+  defaultLines: 5,
+  rtp: 96.5,
+  volatility: "medium"
+};
+export {
+  AuditManager,
+  BonusManager,
+  BuyBonusManager,
+  CascadingReelsManager,
+  ConfigBuilder,
+  DebugManager,
+  ExpandingWildsManager,
+  GambleManager,
+  GameSession,
+  HistoryManager,
+  InMemoryAuditStorage,
+  InMemoryWalletStorage,
+  JackpotManager,
+  Random,
+  RespinsManager,
+  ResponsibleGamingManager,
+  ScatterEnhancementsManager,
+  SpinEvaluator,
+  WalletManager,
+  WaysEvaluator,
+  sampleConfig
+};