@slot-engine/core 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2874 @@
+// src/GameConfig.ts
+var GameConfig = class _GameConfig {
+  config;
+  constructor(opts) {
+    this.config = {
+      id: opts.id,
+      name: opts.name,
+      providerNumber: opts.providerNumber,
+      gameModes: opts.gameModes,
+      symbols: /* @__PURE__ */ new Map(),
+      padSymbols: opts.padSymbols || 0,
+      scatterToFreespins: opts.scatterToFreespins,
+      anticipationTriggers: {
+        [_GameConfig.SPIN_TYPE.BASE_GAME]: getAnticipationTrigger(
+          _GameConfig.SPIN_TYPE.BASE_GAME
+        ),
+        [_GameConfig.SPIN_TYPE.FREE_SPINS]: getAnticipationTrigger(
+          _GameConfig.SPIN_TYPE.FREE_SPINS
+        )
+      },
+      maxWinX: opts.maxWinX,
+      hooks: opts.hooks,
+      userState: opts.userState,
+      outputDir: "__build__"
+    };
+    for (const symbol of opts.symbols) {
+      if (!this.config.symbols.has(symbol.id)) {
+        this.config.symbols.set(symbol.id, symbol);
+      } else {
+        console.warn(
+          `Symbol with id "${symbol.id}" already exists in the game config. Skipping duplicate. This is probably not intentional.`
+        );
+      }
+    }
+    function getAnticipationTrigger(spinType) {
+      return Math.min(...Object.keys(opts.scatterToFreespins[spinType]).map(Number)) - 1;
+    }
+  }
+  /**
+   * Generates reelset CSV files for all game modes.
+   */
+  generateReelsetFiles() {
+    for (const mode of Object.values(this.config.gameModes)) {
+      if (mode.reelSets && mode.reelSets.length > 0) {
+        for (const reelGenerator of Object.values(mode.reelSets)) {
+          reelGenerator.associatedGameModeName = mode.name;
+          reelGenerator.outputDir = this.config.outputDir;
+          reelGenerator.generateReels(this);
+        }
+      } else {
+        throw new Error(
+          `Game mode "${mode.name}" has no reel sets defined. Cannot generate reelset files.`
+        );
+      }
+    }
+  }
+  /**
+   * Retrieves a reel set by its ID within a specific game mode.
+   */
+  getReelsetById(gameMode, id) {
+    const reelSet = this.config.gameModes[gameMode].reelSets.find((rs) => rs.id === id);
+    if (!reelSet) {
+      throw new Error(
+        `Reel set with id "${id}" not found in game mode "${gameMode}". Available reel sets: ${this.config.gameModes[gameMode].reelSets.map((rs) => rs.id).join(", ")}`
+      );
+    }
+    return reelSet;
+  }
+  /**
+   * Retrieves the number of free spins awarded for a given spin type and scatter count.
+   */
+  getFreeSpinsForScatters(spinType, scatterCount) {
+    const freespinsConfig = this.config.scatterToFreespins[spinType];
+    if (!freespinsConfig) {
+      throw new Error(
+        `No free spins configuration found for spin type "${spinType}". Please check your game configuration.`
+      );
+    }
+    return freespinsConfig[scatterCount] || 0;
+  }
+  /**
+   * Retrieves a result set by its criteria within a specific game mode.
+   */
+  getGameModeCriteria(mode, criteria) {
+    const gameMode = this.config.gameModes[mode];
+    if (!gameMode) {
+      throw new Error(`Game mode "${mode}" not found in game config.`);
+    }
+    const resultSet = gameMode.resultSets.find((rs) => rs.criteria === criteria);
+    if (!resultSet) {
+      throw new Error(
+        `Criteria "${criteria}" not found in game mode "${mode}". Available criteria: ${gameMode.resultSets.map((rs) => rs.criteria).join(", ")}`
+      );
+    }
+    return resultSet;
+  }
+  /**
+   * Returns all configured symbols as an array.
+   */
+  getSymbolArray() {
+    return Array.from(this.config.symbols).map(([n, v]) => v);
+  }
+  static SPIN_TYPE = {
+    BASE_GAME: "basegame",
+    FREE_SPINS: "freespins"
+  };
+};
+
+// src/GameMode.ts
+var GameMode = class {
+  name;
+  reelsAmount;
+  symbolsPerReel;
+  cost;
+  rtp;
+  reelSets;
+  resultSets;
+  isBonusBuy;
+  constructor(opts) {
+    this.name = opts.name;
+    this.reelsAmount = opts.reelsAmount;
+    this.symbolsPerReel = opts.symbolsPerReel;
+    this.cost = opts.cost;
+    this.rtp = opts.rtp;
+    this.reelSets = opts.reelSets;
+    this.resultSets = opts.resultSets;
+    this.isBonusBuy = opts.isBonusBuy;
+    if (this.symbolsPerReel.length !== this.reelsAmount) {
+      throw new Error(
+        `symbolsPerReel length (${this.symbolsPerReel.length}) must match reelsAmount (${this.reelsAmount}).`
+      );
+    }
+    if (this.resultSets.length == 0) {
+      throw new Error("GameMode must have at least one ResultSet defined.");
+    }
+  }
+};
+
+// src/GameSymbol.ts
+var GameSymbol = class _GameSymbol {
+  id;
+  pays;
+  properties;
+  constructor(opts) {
+    this.id = opts.id;
+    this.pays = opts.pays;
+    this.properties = new Map(Object.entries(opts.properties || {}));
+    if (this.pays && Object.keys(this.pays).length === 0) {
+      throw new Error(`GameSymbol "${this.id}" must have pays defined.`);
+    }
+  }
+  /**
+   * Compares this symbol to another symbol or a set of properties.
+   */
+  compare(symbolOrProperties) {
+    if (!symbolOrProperties) {
+      console.warn("No symbol or properties provided for comparison.");
+      return false;
+    }
+    if (symbolOrProperties instanceof _GameSymbol) {
+      return this.id === symbolOrProperties.id;
+    } else {
+      for (const [key, value] of Object.entries(symbolOrProperties)) {
+        if (!this.properties.has(key) || this.properties.get(key) !== value) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+};
+
+// src/ReelGenerator.ts
+import fs2 from "fs";
+import path from "path";
+
+// utils.ts
+import fs from "fs";
+function weightedRandom(weights, rng) {
+  const totalWeight = Object.values(weights).reduce(
+    (sum, weight) => sum + weight,
+    0
+  );
+  const randomValue = rng.randomFloat(0, 1) * totalWeight;
+  let cumulativeWeight = 0;
+  for (const [key, weight] of Object.entries(weights)) {
+    cumulativeWeight += weight;
+    if (randomValue < cumulativeWeight) {
+      return key;
+    }
+  }
+  throw new Error("No item selected in weighted random selection.");
+}
+function randomItem(array, rng) {
+  if (array.length === 0) {
+    throw new Error("Cannot select a random item from an empty array.");
+  }
+  const randomIndex = Math.floor(rng.randomFloat(0, 1) * array.length);
+  return array[randomIndex];
+}
+function createDirIfNotExists(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function shuffle(array, rng) {
+  const newArray = [...array];
+  let currentIndex = newArray.length, randomIndex;
+  while (currentIndex != 0) {
+    randomIndex = Math.floor(rng.randomFloat(0, 1) * currentIndex);
+    currentIndex--;
+    [newArray[currentIndex], newArray[randomIndex]] = [
+      newArray[randomIndex],
+      newArray[currentIndex]
+    ];
+  }
+  return newArray;
+}
+function writeJsonFile(filePath, data) {
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+      encoding: "utf8"
+    });
+  } catch (error) {
+    throw new Error(`Failed to write JSON file at ${filePath}: ${error}`);
+  }
+}
+function writeFile(filePath, data) {
+  try {
+    fs.writeFileSync(filePath, data, { encoding: "utf8" });
+  } catch (error) {
+    throw new Error(`Failed to write file at ${filePath}: ${error}`);
+  }
+}
+var RandomNumberGenerator = class {
+  mIdum;
+  mIy;
+  mIv;
+  NTAB;
+  IA;
+  IM;
+  IQ;
+  IR;
+  NDIV;
+  AM;
+  RNMX;
+  _currentSeed = 0;
+  constructor() {
+    this.mIdum = 0;
+    this.mIy = 0;
+    this.mIv = [];
+    this.NTAB = 32;
+    this.IA = 16807;
+    this.IM = 2147483647;
+    this.IQ = 127773;
+    this.IR = 2836;
+    this.NDIV = 1 + (this.IM - 1) / this.NTAB;
+    this.AM = 1 / this.IM;
+    this.RNMX = 1 - 12e-8;
+  }
+  getCurrentSeed() {
+    return this._currentSeed;
+  }
+  setCurrentSeed(seed) {
+    this._currentSeed = seed;
+  }
+  setSeed(seed) {
+    this.mIdum = seed;
+    this.setCurrentSeed(seed);
+    if (seed >= 0) {
+      this.mIdum = -seed;
+    }
+    this.mIy = 0;
+  }
+  setSeedIfDifferent(seed) {
+    if (this.getCurrentSeed() !== seed) {
+      this.setSeed(seed);
+    }
+  }
+  generateRandomNumber() {
+    let k;
+    let j;
+    if (this.mIdum <= 0 || this.mIy === 0) {
+      if (-this.mIdum < 1) {
+        this.mIdum = 1;
+      } else {
+        this.mIdum = -this.mIdum;
+      }
+      for (j = this.NTAB + 7; j >= 0; j -= 1) {
+        k = Math.floor(this.mIdum / this.IQ);
+        this.mIdum = Math.floor(this.IA * (this.mIdum - k * this.IQ) - this.IR * k);
+        if (this.mIdum < 0) {
+          this.mIdum += this.IM;
+        }
+        if (j < this.NTAB) {
+          this.mIv[j] = this.mIdum;
+        }
+      }
+      ;
+      [this.mIy] = this.mIv;
+    }
+    k = Math.floor(this.mIdum / this.IQ);
+    this.mIdum = Math.floor(this.IA * (this.mIdum - k * this.IQ) - this.IR * k);
+    if (this.mIdum < 0) {
+      this.mIdum += this.IM;
+    }
+    j = Math.floor(this.mIy / this.NDIV);
+    this.mIy = Math.floor(this.mIv[j]);
+    this.mIv[j] = this.mIdum;
+    return this.mIy;
+  }
+  randomFloat(low, high) {
+    let float = this.AM * this.generateRandomNumber();
+    if (float > this.RNMX) {
+      float = this.RNMX;
+    }
+    return float * (high - low) + low;
+  }
+};
+function copy(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+var JSONL = class {
+  static stringify(array) {
+    return array.map((object) => JSON.stringify(object)).join("\n");
+  }
+  static parse(jsonl) {
+    return jsonl.split("\n").filter((s) => s !== "").map((str) => JSON.parse(str));
+  }
+};
+
+// src/ReelGenerator.ts
+import { isMainThread } from "worker_threads";
+var ReelGenerator = class {
+  id;
+  associatedGameModeName = "";
+  symbolWeights = /* @__PURE__ */ new Map();
+  rowsAmount;
+  reels = [];
+  limitSymbolsToReels;
+  spaceBetweenSameSymbols;
+  spaceBetweenSymbols;
+  preferStackedSymbols;
+  symbolStacks;
+  symbolQuotas;
+  outputDir = "";
+  csvPath = "";
+  overrideExisting;
+  rng;
+  constructor(opts) {
+    this.id = opts.id;
+    this.symbolWeights = new Map(Object.entries(opts.symbolWeights));
+    this.rowsAmount = opts.rowsAmount || 250;
+    this.outputDir = opts.outputDir;
+    if (opts.limitSymbolsToReels) this.limitSymbolsToReels = opts.limitSymbolsToReels;
+    this.overrideExisting = opts.overrideExisting || false;
+    this.spaceBetweenSameSymbols = opts.spaceBetweenSameSymbols;
+    this.spaceBetweenSymbols = opts.spaceBetweenSymbols;
+    this.preferStackedSymbols = opts.preferStackedSymbols;
+    this.symbolStacks = opts.symbolStacks;
+    this.symbolQuotas = opts.symbolQuotas;
+    if (typeof this.spaceBetweenSameSymbols == "number" && (this.spaceBetweenSameSymbols < 1 || this.spaceBetweenSameSymbols > 8) || typeof this.spaceBetweenSameSymbols == "object" && Object.values(this.spaceBetweenSameSymbols).some((v) => v < 1 || v > 8)) {
+      throw new Error(
+        `spaceBetweenSameSymbols must be between 1 and 8, got ${this.spaceBetweenSameSymbols}.`
+      );
+    }
+    if (Object.values(this.spaceBetweenSymbols || {}).some(
+      (o) => Object.values(o).some((v) => v < 1 || v > 8)
+    )) {
+      throw new Error(
+        `spaceBetweenSymbols must be between 1 and 8, got ${this.spaceBetweenSymbols}.`
+      );
+    }
+    if (this.preferStackedSymbols && (this.preferStackedSymbols < 0 || this.preferStackedSymbols > 100)) {
+      throw new Error(
+        `preferStackedSymbols must be between 0 and 100, got ${this.preferStackedSymbols}.`
+      );
+    }
+    this.rng = new RandomNumberGenerator();
+    this.rng.setSeed(opts.seed ?? 0);
+  }
+  validateConfig({ config }) {
+    config.symbols.forEach((symbol) => {
+      if (!this.symbolWeights.has(symbol.id)) {
+        throw new Error(
+          [
+            `Symbol "${symbol.id}" is not defined in the symbol weights of the reel generator ${this.id} for mode ${this.associatedGameModeName}.`,
+            `Please ensure all symbols have weights defined.
+`
+          ].join(" ")
+        );
+      }
+    });
+    for (const [symbolId, weight] of this.symbolWeights.entries()) {
+      if (!config.symbols.has(symbolId)) {
+        throw new Error(
+          [
+            `Symbol "${symbolId}" is defined in the reel generator's symbol weights, but does not exist in the game config.`,
+            `Please ensure all symbols in the reel generator are defined in the game config.
+`
+          ].join(" ")
+        );
+      }
+    }
+    if (this.limitSymbolsToReels && Object.keys(this.limitSymbolsToReels).length == 0) {
+      this.limitSymbolsToReels = void 0;
+    }
+    if (this.outputDir === "") {
+      throw new Error("Output directory must be specified for the ReelGenerator.");
+    }
+  }
+  isSymbolAllowedOnReel(symbolId, reelIdx) {
+    if (!this.limitSymbolsToReels) return true;
+    const allowedReels = this.limitSymbolsToReels[symbolId];
+    if (!allowedReels || allowedReels.length === 0) return true;
+    return allowedReels.includes(reelIdx);
+  }
+  resolveStacking(symbolId, reelIdx) {
+    const cfg = this.symbolStacks?.[symbolId];
+    if (!cfg) return null;
+    const STACKING_MIN = 1;
+    const STACKING_MAX = 4;
+    const chance = typeof cfg.chance === "number" ? cfg.chance : cfg.chance?.[reelIdx] ?? 0;
+    if (chance <= 0) return null;
+    let min = typeof cfg.min === "number" ? cfg.min : cfg.min?.[reelIdx] ?? STACKING_MIN;
+    let max = typeof cfg.max === "number" ? cfg.max : cfg.max?.[reelIdx] ?? STACKING_MAX;
+    return { chance, min, max };
+  }
+  tryPlaceStack(reel, gameConf, reelIdx, symbolId, startIndex, maxStack) {
+    if (!this.isSymbolAllowedOnReel(symbolId, reelIdx)) return 0;
+    let canPlace = 0;
+    for (let j = 0; j < maxStack; j++) {
+      const idx = (startIndex + j) % this.rowsAmount;
+      if (reel[idx] !== null) break;
+      canPlace++;
+    }
+    if (canPlace === 0) return 0;
+    const symObj = gameConf.config.symbols.get(symbolId);
+    if (!symObj) {
+      throw new Error(
+        `Symbol with id "${symbolId}" not found in the game config symbols map.`
+      );
+    }
+    for (let j = 0; j < canPlace; j++) {
+      const idx = (startIndex + j) % reel.length;
+      reel[idx] = symObj;
+    }
+    return canPlace;
+  }
+  /**
+   * Checks if a symbol can be placed at the target index without violating spacing rules.
+   */
+  violatesSpacing(reel, symbolId, targetIndex) {
+    const circDist = (a, b) => {
+      const diff = Math.abs(a - b);
+      return Math.min(diff, this.rowsAmount - diff);
+    };
+    const spacingType = this.spaceBetweenSameSymbols ?? void 0;
+    const sameSpacing = typeof spacingType === "number" ? spacingType : spacingType?.[symbolId] ?? 0;
+    for (let i = 0; i <= reel.length; i++) {
+      const placed = reel[i];
+      if (!placed) continue;
+      const dist = circDist(targetIndex, i);
+      if (sameSpacing >= 1 && placed.id === symbolId) {
+        if (dist <= sameSpacing) return true;
+      }
+      if (this.spaceBetweenSymbols) {
+        const forward = this.spaceBetweenSymbols[symbolId]?.[placed.id] ?? 0;
+        if (forward >= 1 && dist <= forward) return true;
+        const reverse = this.spaceBetweenSymbols[placed.id]?.[symbolId] ?? 0;
+        if (reverse >= 1 && dist <= reverse) return true;
+      }
+    }
+    return false;
+  }
+  generateReels(gameConf) {
+    this.validateConfig(gameConf);
+    const gameMode = gameConf.config.gameModes[this.associatedGameModeName];
+    if (!gameMode) {
+      throw new Error(
+        `Error generating reels for game mode "${this.associatedGameModeName}". It's not defined in the game config.`
+      );
+    }
+    const filePath = path.join(
+      gameConf.config.outputDir,
+      `reels_${this.associatedGameModeName}-${this.id}.csv`
+    );
+    this.csvPath = filePath;
+    const exists = fs2.existsSync(filePath);
+    const reelsAmount = gameMode.reelsAmount;
+    const weightsObj = Object.fromEntries(this.symbolWeights);
+    for (let ridx = 0; ridx < reelsAmount; ridx++) {
+      const reel = new Array(this.rowsAmount).fill(null);
+      const reelQuotas = {};
+      const quotaCounts = {};
+      let totalReelsQuota = 0;
+      for (const [sym, quotaConf] of Object.entries(this.symbolQuotas || {})) {
+        const q = typeof quotaConf === "number" ? quotaConf : quotaConf[ridx];
+        if (!q) continue;
+        reelQuotas[sym] = q;
+        totalReelsQuota += q;
+      }
+      if (totalReelsQuota > 100) {
+        throw new Error(
+          `Total symbol quotas for reel ${ridx} exceed 100%. Adjust your configuration on ReelGenerator "${this.id}".`
+        );
+      }
+      if (totalReelsQuota > 0) {
+        for (const [sym, quota] of Object.entries(reelQuotas)) {
+          const quotaCount = Math.max(1, Math.floor(this.rowsAmount * quota / 100));
+          quotaCounts[sym] = quotaCount;
+        }
+      }
+      for (const [sym, targetCount] of Object.entries(quotaCounts)) {
+        let remaining = targetCount;
+        let attempts = 0;
+        while (remaining > 0) {
+          if (attempts++ > this.rowsAmount * 10) {
+            throw new Error(
+              `Failed to place ${targetCount} of symbol ${sym} on reel ${ridx} (likely spacing/stacking too strict).`
+            );
+          }
+          const pos = Math.round(this.rng.randomFloat(0, this.rowsAmount - 1));
+          const stackCfg = this.resolveStacking(sym, ridx);
+          let placed = 0;
+          if (stackCfg && Math.round(this.rng.randomFloat(1, 100)) <= stackCfg.chance) {
+            const stackSize = Math.max(
+              0,
+              Math.round(this.rng.randomFloat(stackCfg.min, stackCfg.max))
+            );
+            const toPlace = Math.min(stackSize, remaining);
+            placed = this.tryPlaceStack(reel, gameConf, ridx, sym, pos, toPlace);
+          }
+          if (placed === 0 && reel[pos] === null && this.isSymbolAllowedOnReel(sym, ridx) && !this.violatesSpacing(reel, sym, pos)) {
+            reel[pos] = gameConf.config.symbols.get(sym);
+            placed = 1;
+          }
+          remaining -= placed;
+        }
+      }
+      for (let r = 0; r < this.rowsAmount; r++) {
+        if (reel[r] !== null) continue;
+        let chosenSymbolId = weightedRandom(weightsObj, this.rng);
+        const nextHasStackCfg = !!this.resolveStacking(chosenSymbolId, ridx);
+        if (!nextHasStackCfg && this.preferStackedSymbols && reel.length > 0) {
+          const prevSymbol = r - 1 >= 0 ? reel[r - 1] : reel[reel.length - 1];
+          if (prevSymbol && Math.round(this.rng.randomFloat(1, 100)) <= this.preferStackedSymbols && (!this.spaceBetweenSameSymbols || !this.violatesSpacing(reel, prevSymbol.id, r))) {
+            chosenSymbolId = prevSymbol.id;
+          }
+        }
+        if (this.preferStackedSymbols && reel.length > 0) {
+          const prevSymbol = r - 1 >= 0 ? reel[r - 1] : reel[reel.length - 1];
+          if (Math.round(this.rng.randomFloat(1, 100)) <= this.preferStackedSymbols && (!this.spaceBetweenSameSymbols || !this.violatesSpacing(reel, prevSymbol.id, r))) {
+            chosenSymbolId = prevSymbol.id;
+          }
+        }
+        const stackCfg = this.resolveStacking(chosenSymbolId, ridx);
+        if (stackCfg && this.isSymbolAllowedOnReel(chosenSymbolId, ridx)) {
+          const roll = Math.round(this.rng.randomFloat(1, 100));
+          if (roll <= stackCfg.chance) {
+            const desiredSize = Math.max(
+              1,
+              Math.round(this.rng.randomFloat(stackCfg.min, stackCfg.max))
+            );
+            const placed = this.tryPlaceStack(
+              reel,
+              gameConf,
+              ridx,
+              chosenSymbolId,
+              r,
+              desiredSize
+            );
+            if (placed > 0) {
+              r += placed - 1;
+              continue;
+            }
+          }
+        }
+        let tries = 0;
+        const maxTries = 2500;
+        while (!this.isSymbolAllowedOnReel(chosenSymbolId, ridx) || this.violatesSpacing(reel, chosenSymbolId, r)) {
+          if (++tries > maxTries) {
+            throw new Error(
+              [
+                `Failed to place a symbol on reel ${ridx} at position ${r} after ${maxTries} attempts.
+`,
+                "Try to change the seed or adjust your configuration.\n"
+              ].join(" ")
+            );
+          }
+          chosenSymbolId = weightedRandom(weightsObj, this.rng);
+          const hasStackCfg = !!this.resolveStacking(chosenSymbolId, ridx);
+          if (!hasStackCfg && this.preferStackedSymbols && reel.length > 0) {
+            const prevSymbol = r - 1 >= 0 ? reel[r - 1] : reel[reel.length - 1];
+            if (prevSymbol && Math.round(this.rng.randomFloat(1, 100)) <= this.preferStackedSymbols && (!this.spaceBetweenSameSymbols || !this.violatesSpacing(reel, prevSymbol.id, r))) {
+              chosenSymbolId = prevSymbol.id;
+            }
+          }
+        }
+        const symbol = gameConf.config.symbols.get(chosenSymbolId);
+        if (!symbol) {
+          throw new Error(
+            `Symbol with id "${chosenSymbolId}" not found in the game config symbols map.`
+          );
+        }
+        reel[r] = symbol;
+      }
+      if (reel.some((s) => s === null)) {
+        throw new Error(`Reel ${ridx} has unfilled positions after generation.`);
+      }
+      this.reels.push(reel);
+    }
+    const csvRows = Array.from(
+      { length: this.rowsAmount },
+      () => Array.from({ length: reelsAmount }, () => "")
+    );
+    for (let ridx = 0; ridx < reelsAmount; ridx++) {
+      for (let r = 0; r < this.rowsAmount; r++) {
+        csvRows[r][ridx] = this.reels[ridx][r].id;
+      }
+    }
+    const csvString = csvRows.map((row) => row.join(",")).join("\n");
+    if (isMainThread) {
+      createDirIfNotExists(this.outputDir);
+      fs2.writeFileSync(filePath, csvString);
+      this.reels = this.parseReelsetCSV(filePath, gameConf);
+      console.log(
+        `Generated reelset ${this.id} for game mode ${this.associatedGameModeName}`
+      );
+    }
+    if (exists) {
+      this.reels = this.parseReelsetCSV(filePath, gameConf);
+    }
+  }
+  /**
+   * Reads a reelset CSV file and returns the reels as arrays of GameSymbols.
+   */
+  parseReelsetCSV(reelSetPath, { config }) {
+    const csvData = fs2.readFileSync(reelSetPath, "utf8");
+    const rows = csvData.split("\n").filter((line) => line.trim() !== "");
+    const reels = Array.from(
+      { length: config.gameModes[this.associatedGameModeName].reelsAmount },
+      () => []
+    );
+    rows.forEach((row) => {
+      const symsInRow = row.split(",").map((symbolId) => {
+        const symbol = config.symbols.get(symbolId.trim());
+        if (!symbol) {
+          throw new Error(`Symbol with id "${symbolId}" not found in game config.`);
+        }
+        return symbol;
+      });
+      symsInRow.forEach((symbol, ridx) => {
+        reels[ridx].push(symbol);
+      });
+    });
+    return reels;
+  }
+};
+
+// src/ResultSet.ts
+var ResultSet = class {
+  criteria;
+  quota;
+  multiplier;
+  reelWeights;
+  userData;
+  forceMaxWin;
+  forceFreespins;
+  evaluate;
+  constructor(opts) {
+    this.criteria = opts.criteria;
+    this.quota = opts.quota;
+    this.multiplier = opts.multiplier;
+    this.reelWeights = opts.reelWeights;
+    this.userData = opts.userData;
+    this.forceMaxWin = opts.forceMaxWin;
+    this.forceFreespins = opts.forceFreespins;
+    this.evaluate = opts.evaluate;
+    if (this.quota < 0 || this.quota > 1) {
+      throw new Error(`Quota must be a float between 0 and 1, got ${this.quota}.`);
+    }
+  }
+  static assignCriteriaToSimulations(ctx, gameModeName) {
+    const rng = new RandomNumberGenerator();
+    rng.setSeed(0);
+    if (!ctx.simRunsAmount) {
+      throw new Error("Simulation configuration is not set.");
+    }
+    const simNums = ctx.simRunsAmount[gameModeName];
+    const resultSets = ctx.gameConfig.config.gameModes[gameModeName]?.resultSets;
+    if (!resultSets || resultSets.length === 0) {
+      throw new Error(`No ResultSets found for game mode: ${gameModeName}.`);
+    }
+    if (simNums === void 0 || simNums <= 0) {
+      throw new Error(`No simulations configured for game mode "${gameModeName}".`);
+    }
+    const numberOfSimsForCriteria = Object.fromEntries(
+      resultSets.map((rs) => [rs.criteria, Math.max(Math.floor(rs.quota * simNums), 1)])
+    );
+    let totalSims = Object.values(numberOfSimsForCriteria).reduce(
+      (sum, num) => sum + num,
+      0
+    );
+    let reduceSims = totalSims > simNums;
+    const criteriaToWeights = Object.fromEntries(
+      resultSets.map((rs) => [rs.criteria, rs.quota])
+    );
+    while (totalSims != simNums) {
+      const rs = weightedRandom(criteriaToWeights, rng);
+      if (reduceSims && numberOfSimsForCriteria[rs] > 1) {
+        numberOfSimsForCriteria[rs] -= 1;
+      } else if (!reduceSims) {
+        numberOfSimsForCriteria[rs] += 1;
+      }
+      totalSims = Object.values(numberOfSimsForCriteria).reduce(
+        (sum, num) => sum + num,
+        0
+      );
+      reduceSims = totalSims > simNums;
+    }
+    let allCriteria = [];
+    const simNumsToCriteria = {};
+    Object.entries(numberOfSimsForCriteria).forEach(([criteria, num]) => {
+      for (let i = 0; i <= num; i++) {
+        allCriteria.push(criteria);
+      }
+    });
+    allCriteria = shuffle(allCriteria, rng);
+    for (let i = 1; i <= Math.min(simNums, allCriteria.length); i++) {
+      simNumsToCriteria[i] = allCriteria[i];
+    }
+    return simNumsToCriteria;
+  }
+  /**
+   * Checks if core criteria is met, e.g. target multiplier or max win.
+   */
+  meetsCriteria(ctx) {
+    const customEval = this.evaluate?.(copy(ctx));
+    const freespinsMet = this.forceFreespins ? ctx.state.triggeredFreespins : true;
+    const multiplierMet = this.multiplier !== void 0 ? ctx.wallet.getCurrentWin() === this.multiplier && !this.forceMaxWin : ctx.wallet.getCurrentWin() > 0 && (!this.forceMaxWin || true);
+    const maxWinMet = this.forceMaxWin ? ctx.wallet.getCurrentWin() >= ctx.config.maxWinX : true;
+    const coreCriteriaMet = freespinsMet && multiplierMet && maxWinMet;
+    const finalResult = customEval !== void 0 ? coreCriteriaMet && customEval === true : coreCriteriaMet;
+    if (this.forceMaxWin && maxWinMet) {
+      ctx.record({
+        maxwin: true
+      });
+    }
+    return finalResult;
+  }
+};
+
+// src/Wallet.ts
+var Wallet = class {
+  /**
+   * Total win amount (as the bet multiplier) from all simulations.
+   */
+  cumulativeWins = 0;
+  /**
+   * Total win amount (as the bet multiplier) per spin type.
+   *
+   * @example
+   * ```ts
+   * {
+   *   basegame: 50,
+   *   freespins: 100,
+   *   superfreespins: 200,
+   * }
+   * ```
+   */
+  cumulativeWinsPerSpinType = {
+    [GameConfig.SPIN_TYPE.BASE_GAME]: 0,
+    [GameConfig.SPIN_TYPE.FREE_SPINS]: 0
+  };
+  /**
+   * Current win amount (as the bet multiplier) for the ongoing simulation.
+   */
+  currentWin = 0;
+  /**
+   * Current win amount (as the bet multiplier) for the ongoing simulation per spin type.
+   *
+   * @example
+   * ```ts
+   * {
+   *   basegame: 50,
+   *   freespins: 100,
+   *   superfreespins: 200,
+   * }
+   * ```
+   */
+  currentWinPerSpinType = {
+    [GameConfig.SPIN_TYPE.BASE_GAME]: 0,
+    [GameConfig.SPIN_TYPE.FREE_SPINS]: 0
+  };
+  /**
+   * Holds the current win amount for a single (free) spin.\
+   * After each spin, this amount is added to `currentWinPerSpinType` and then reset to zero.
+   */
+  currentSpinWin = 0;
+  /**
+   * Current win amount (as the bet multiplier) for the ongoing tumble sequence.
+   */
+  currentTumbleWin = 0;
+  constructor() {
+  }
+  /**
+   * Updates the win for the current spin.
+   *
+   * Should be called after each tumble event, if applicable.\
+   * Or generally call this to add wins during a spin.
+   *
+   * After each (free) spin, this amount should be added to `currentWinPerSpinType` via `confirmSpinWin()`
+   */
+  addSpinWin(amount) {
+    this.currentSpinWin += amount;
+  }
+  /**
+   * Assigns a win amount to the given spin type.
+   *
+   * Should be called after `addSpinWin()`, and after your tumble events are played out,\
+   * and after a (free) spin is played out to finalize the win.
+   */
+  confirmSpinWin(spinType) {
+    if (!Object.keys(this.currentWinPerSpinType).includes(spinType)) {
+      throw new Error(`Spin type "${spinType}" does not exist in the wallet.`);
+    }
+    this.currentWinPerSpinType[spinType] += this.currentSpinWin;
+    this.currentWin += this.currentSpinWin;
+    this.currentSpinWin = 0;
+  }
+  /**
+   * Returns the accumulated win amount (as the bet multiplier) from all simulations.
+   */
+  getCumulativeWins() {
+    return this.cumulativeWins;
+  }
+  /**
+   * Returns the accumulated win amount (as the bet multiplier) per spin type from all simulations.
+   */
+  getCumulativeWinsPerSpinType() {
+    return this.cumulativeWinsPerSpinType;
+  }
+  /**
+   * Returns the current win amount (as the bet multiplier) for the ongoing simulation.
+   */
+  getCurrentWin() {
+    return this.currentWin;
+  }
+  /**
+   * Returns the current win amount (as the bet multiplier) per spin type for the ongoing simulation.
+   */
+  getCurrentWinPerSpinType() {
+    return this.currentWinPerSpinType;
+  }
+  /**
+   * Adds a win to `currentSpinWin` and `currentTumbleWin`.
+   *
+   * After each (free) spin, this amount should be added to `currentWinPerSpinType` via `confirmSpinWin()`
+   */
+  addTumbleWin(amount) {
+    this.currentTumbleWin += amount;
+    this.addSpinWin(amount);
+  }
+  /**
+   * Resets the current win amounts to zero.
+   */
+  resetCurrentWin() {
+    this.currentWin = 0;
+    this.currentSpinWin = 0;
+    this.currentTumbleWin = 0;
+    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
+      this.currentWinPerSpinType[spinType] = 0;
+    }
+  }
+  /**
+   * Adds current wins to cumulative wins and resets current wins to zero.
+   */
+  confirmWins(ctx) {
+    function process2(number) {
+      return Math.round(Math.min(number, ctx.config.maxWinX) * 100) / 100;
+    }
+    ctx.state.book.writePayout(ctx);
+    this.currentWin = process2(this.currentWin);
+    this.cumulativeWins += this.currentWin;
+    let spinTypeWins = 0;
+    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
+      const st = spinType;
+      const spinTypeWin = process2(this.currentWinPerSpinType[st]);
+      this.cumulativeWinsPerSpinType[st] += spinTypeWin;
+      spinTypeWins += spinTypeWin;
+    }
+    if (process2(spinTypeWins) !== this.currentWin) {
+      throw new Error(
+        `Inconsistent wallet state: currentWin (${this.currentWin}) does not equal spinTypeWins (${spinTypeWins}).`
+      );
+    }
+    this.resetCurrentWin();
+  }
+  serialize() {
+    return {
+      cumulativeWins: this.cumulativeWins,
+      cumulativeWinsPerSpinType: this.cumulativeWinsPerSpinType,
+      currentWin: this.currentWin,
+      currentWinPerSpinType: this.currentWinPerSpinType,
+      currentSpinWin: this.currentSpinWin,
+      currentTumbleWin: this.currentTumbleWin
+    };
+  }
+  merge(wallet) {
+    this.cumulativeWins += wallet.getCumulativeWins();
+    const otherWinsPerSpinType = wallet.getCumulativeWinsPerSpinType();
+    for (const spinType of Object.keys(this.cumulativeWinsPerSpinType)) {
+      this.cumulativeWinsPerSpinType[spinType] += otherWinsPerSpinType[spinType] || 0;
+    }
+  }
+  mergeSerialized(data) {
+    this.cumulativeWins += data.cumulativeWins;
+    for (const spinType of Object.keys(this.cumulativeWinsPerSpinType)) {
+      this.cumulativeWinsPerSpinType[spinType] += data.cumulativeWinsPerSpinType[spinType] || 0;
+    }
+    this.currentWin += data.currentWin;
+    this.currentSpinWin += data.currentSpinWin;
+    this.currentTumbleWin += data.currentTumbleWin;
+    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
+      this.currentWinPerSpinType[spinType] += data.currentWinPerSpinType[spinType] || 0;
+    }
+  }
+};
+
+// src/Book.ts
+var Book = class _Book {
+  id;
+  criteria = "N/A";
+  events = [];
+  payout = 0;
+  basegameWins = 0;
+  freespinsWins = 0;
+  constructor(opts) {
+    this.id = opts.id;
+  }
+  /**
+   * Adds an event to the book.
+   */
+  addEvent(event) {
+    const index = this.events.length + 1;
+    this.events.push({ index, ...event });
+  }
+  /**
+   * Transfers the win data from the wallet to the book.
+   */
+  writePayout(ctx) {
+    function process2(number) {
+      return Math.round(Math.min(number, ctx.config.maxWinX) * 100) / 100;
+    }
+    this.payout = Math.round(process2(ctx.wallet.getCurrentWin()) * 100);
+    this.basegameWins = process2(
+      ctx.wallet.getCurrentWinPerSpinType()[GameConfig.SPIN_TYPE.BASE_GAME] || 0
+    );
+    this.freespinsWins = process2(
+      ctx.wallet.getCurrentWinPerSpinType()[GameConfig.SPIN_TYPE.FREE_SPINS] || 0
+    );
+  }
+  getPayout() {
+    return this.payout;
+  }
+  getBasegameWins() {
+    return this.basegameWins;
+  }
+  getFreespinsWins() {
+    return this.freespinsWins;
+  }
+  serialize() {
+    return {
+      id: this.id,
+      criteria: this.criteria,
+      events: this.events,
+      payout: this.payout,
+      basegameWins: this.basegameWins,
+      freespinsWins: this.freespinsWins
+    };
+  }
+  static fromSerialized(data) {
+    const book = new _Book({ id: data.id });
+    book.criteria = data.criteria;
+    book.events = data.events;
+    book.payout = data.payout;
+    book.basegameWins = data.basegameWins;
+    book.freespinsWins = data.freespinsWins;
+    return book;
+  }
+};
+
+// src/GameState.ts
+var GameState = class extends GameConfig {
+  state;
+  /**
+   * The wallet stores win data for the current and all simulations, respectively.
+   */
+  wallet;
+  /**
+   * Recorder for statistical analysis (e.g. symbol occurrences, etc.).
+   */
+  recorder;
+  constructor(opts) {
+    super(opts);
+    this.state = {
+      currentSpinType: GameConfig.SPIN_TYPE.BASE_GAME,
+      library: /* @__PURE__ */ new Map(),
+      book: new Book({ id: 0 }),
+      currentGameMode: "N/A",
+      currentSimulationId: 0,
+      isCriteriaMet: false,
+      currentFreespinAmount: 0,
+      totalFreespinAmount: 0,
+      rng: new RandomNumberGenerator(),
+      userData: opts.userState || {},
+      triggeredMaxWin: false,
+      triggeredFreespins: false,
+      // This is a placeholder ResultSet to avoid null checks elsewhere.
+      currentResultSet: new ResultSet({
+        criteria: "N/A",
+        quota: 0,
+        reelWeights: {
+          [GameConfig.SPIN_TYPE.BASE_GAME]: {},
+          [GameConfig.SPIN_TYPE.FREE_SPINS]: {}
+        }
+      })
+    };
+    this.wallet = new Wallet();
+    this.recorder = {
+      pendingRecords: [],
+      records: []
+    };
+  }
+  /**
+   * Gets the configuration for the current game mode.
+   */
+  getCurrentGameMode() {
+    return this.config.gameModes[this.state.currentGameMode];
+  }
+  resetState() {
+    this.state.rng.setSeedIfDifferent(this.state.currentSimulationId);
+    this.state.book = new Book({ id: this.state.currentSimulationId });
+    this.state.currentSpinType = GameConfig.SPIN_TYPE.BASE_GAME;
+    this.state.currentFreespinAmount = 0;
+    this.state.totalFreespinAmount = 0;
+    this.state.triggeredMaxWin = false;
+    this.state.triggeredFreespins = false;
+    this.wallet.resetCurrentWin();
+    this.clearPendingRecords();
+    this.state.userData = this.config.userState || {};
+  }
+  /**
+   * Checks if a max win is reached by comparing `wallet.currentWin` to `config.maxWin`.
+   *
+   * Should be called after `wallet.confirmSpinWin()`.
+   */
+  isMaxWinTriggered() {
+  }
+  /**
+   * Empties the list of pending records in the recorder.
+   */
+  clearPendingRecords() {
+    this.recorder.pendingRecords = [];
+  }
+  /**
+   * Confirms all pending records and adds them to the main records list.
+   */
+  confirmRecords() {
+    for (const pendingRecord of this.recorder.pendingRecords) {
+      const search = Object.entries(pendingRecord.properties).map(([name, value]) => ({ name, value })).sort((a, b) => a.name.localeCompare(b.name));
+      let record = this.recorder.records.find((r) => {
+        if (r.search.length !== search.length) return false;
+        for (let i = 0; i < r.search.length; i++) {
+          if (r.search[i].name !== search[i].name) return false;
+          if (r.search[i].value !== search[i].value) return false;
+        }
+        return true;
+      });
+      if (!record) {
+        record = {
+          search,
+          timesTriggered: 0,
+          bookIds: []
+        };
+        this.recorder.records.push(record);
+      }
+      record.timesTriggered++;
+      if (!record.bookIds.includes(pendingRecord.bookId)) {
+        record.bookIds.push(pendingRecord.bookId);
+      }
+    }
+    this.clearPendingRecords();
+  }
+  /**
+   * Record data for statistical analysis.
+   */
+  record(data) {
+    this.recorder.pendingRecords.push({
+      bookId: this.state.currentSimulationId,
+      properties: Object.fromEntries(
+        Object.entries(data).map(([k, v]) => [k, String(v)])
+      )
+    });
+  }
+  /**
+   * Records a symbol occurrence for statistical analysis.
+   *
+   * Calls `this.record()` with the provided data.
+   */
+  recordSymbolOccurrence(data) {
+    this.record(data);
+  }
+  /**
+   * Gets all confirmed records.
+   */
+  getRecords() {
+    return this.recorder.records;
+  }
+  /**
+   * Moves the current book to the library and resets the current book.
+   */
+  moveBookToLibrary() {
+    this.state.library.set(this.state.book.id.toString(), this.state.book);
+    this.state.book = new Book({ id: 0 });
+  }
+  /**
+   * Increases the freespin count by the specified amount.
+   *
+   * Also sets `state.triggeredFreespins` to true.
+   */
+  awardFreespins(amount) {
+    this.state.currentFreespinAmount += amount;
+    this.state.totalFreespinAmount += amount;
+    this.state.triggeredFreespins = true;
+  }
+  /**
+   * Ensures the requested number of scatters is valid based on the game configuration.\
+   * Returns a valid number of scatters.
+   */
+  verifyScatterCount(numScatters) {
+    const scatterCounts = this.config.scatterToFreespins[this.state.currentSpinType];
+    if (!scatterCounts) {
+      throw new Error(
+        `No scatter counts defined for spin type "${this.state.currentSpinType}". Please check your game configuration.`
+      );
+    }
+    const validCounts = Object.keys(scatterCounts).map((key) => parseInt(key, 10));
+    if (validCounts.length === 0) {
+      throw new Error(
+        `No scatter counts defined for spin type "${this.state.currentSpinType}". Please check your game configuration.`
+      );
+    }
+    if (numScatters < Math.min(...validCounts)) {
+      return Math.min(...validCounts);
+    }
+    if (numScatters > Math.max(...validCounts)) {
+      return Math.max(...validCounts);
+    }
+    return numScatters;
+  }
+};
+
+// src/Board.ts
+var StandaloneBoard = class {
+  reels;
+  paddingTop;
+  paddingBottom;
+  anticipation;
+  ctx;
+  constructor(opts) {
+    this.reels = [];
+    this.paddingTop = [];
+    this.paddingBottom = [];
+    this.anticipation = [];
+    this.ctx = opts.ctx;
+  }
+  /**
+   * Updates the context used by this board instance.
+   */
+  context(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Resets the board to an empty state.\
+   * This is called before drawing a new board.
+   */
+  resetBoard() {
+    this.resetReels();
+  }
+  makeEmptyReels() {
+    return Array.from({ length: this.ctx.getCurrentGameMode().reelsAmount }, () => []);
+  }
+  resetReels() {
+    this.reels = this.makeEmptyReels();
+    this.anticipation = Array.from(
+      { length: this.ctx.getCurrentGameMode().reelsAmount },
+      () => 0
+    );
+    if (this.ctx.config.padSymbols && this.ctx.config.padSymbols > 0) {
+      this.paddingTop = this.makeEmptyReels();
+      this.paddingBottom = this.makeEmptyReels();
+    }
+  }
+  /**
+   * Counts how many symbols matching the criteria are on a specific reel.
+   */
+  countSymbolsOnReel(symbolOrProperties, reelIndex) {
+    let total = 0;
+    for (const symbol of this.reels[reelIndex]) {
+      let matches = true;
+      if (symbolOrProperties instanceof GameSymbol) {
+        if (symbol.id !== symbolOrProperties.id) matches = false;
+      } else {
+        for (const [key, value] of Object.entries(symbolOrProperties)) {
+          if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
+            matches = false;
+            break;
+          }
+        }
+      }
+      if (matches) {
+        total++;
+      }
+    }
+    return total;
+  }
+  /**
+   * Counts how many symbols matching the criteria are on the board.
+   *
+   * Passing a GameSymbol will compare by ID, passing a properties object will compare by properties.
+   *
+   * Returns a tuple where the first element is the total count, and the second element is a record of counts per reel index.
+   */
+  countSymbolsOnBoard(symbolOrProperties) {
+    let total = 0;
+    const onReel = {};
+    for (const [ridx, reel] of this.reels.entries()) {
+      for (const symbol of reel) {
+        let matches = true;
+        if (symbolOrProperties instanceof GameSymbol) {
+          if (symbol.id !== symbolOrProperties.id) matches = false;
+        } else {
+          for (const [key, value] of Object.entries(symbolOrProperties)) {
+            if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
+              matches = false;
+              break;
+            }
+          }
+        }
+        if (matches) {
+          total++;
+          if (onReel[ridx] === void 0) {
+            onReel[ridx] = 1;
+          } else {
+            onReel[ridx]++;
+          }
+        }
+      }
+    }
+    return [total, onReel];
+  }
+  /**
+   * Checks if a symbol appears more than once on any reel in the current reel set.
+   *
+   * Useful to check for "forbidden" generations, e.g. 2 scatters on one reel.
+   */
+  isSymbolOnAnyReelMultipleTimes(symbol) {
+    for (const reel of this.reels) {
+      let count = 0;
+      for (const sym of reel) {
+        if (sym.id === symbol.id) {
+          count++;
+        }
+        if (count > 1) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Draws a board using specified reel stops.
+   */
+  drawBoardWithForcedStops(reels, forcedStops) {
+    this.drawBoardMixed(reels, forcedStops);
+  }
+  /**
+   * Draws a board using random reel stops.
+   */
+  drawBoardWithRandomStops(reels) {
+    this.drawBoardMixed(reels);
+  }
+  drawBoardMixed(reels, forcedStops) {
+    this.resetReels();
+    const finalReelStops = Array.from(
+      { length: this.ctx.getCurrentGameMode().reelsAmount },
+      () => null
+    );
+    if (forcedStops) {
+      for (const [r, stopPos] of Object.entries(forcedStops)) {
+        const reelIdx = Number(r);
+        const symCount = this.ctx.getCurrentGameMode().symbolsPerReel[reelIdx];
+        finalReelStops[reelIdx] = stopPos - Math.round(this.ctx.state.rng.randomFloat(0, symCount - 1));
+      }
+    }
+    for (let i = 0; i < finalReelStops.length; i++) {
+      if (finalReelStops[i] === null) {
+        finalReelStops[i] = Math.floor(
+          this.ctx.state.rng.randomFloat(0, reels[i].length - 1)
+        );
+      }
+    }
+    for (let ridx = 0; ridx < this.ctx.getCurrentGameMode().reelsAmount; ridx++) {
+      const reelPos = finalReelStops[ridx];
+      if (this.ctx.config.padSymbols && this.ctx.config.padSymbols > 0) {
+        for (let p = this.ctx.config.padSymbols - 1; p >= 0; p--) {
+          const topPos = (reelPos - (p + 1)) % reels[ridx].length;
+          this.paddingTop[ridx].push(reels[ridx][topPos]);
+          const bottomPos = (reelPos + this.ctx.getCurrentGameMode().symbolsPerReel[ridx] + p) % reels[ridx].length;
+          this.paddingBottom[ridx].unshift(reels[ridx][bottomPos]);
+        }
+      }
+      for (let row = 0; row < this.ctx.getCurrentGameMode().symbolsPerReel[ridx]; row++) {
+        const symbol = reels[ridx][(reelPos + row) % reels[ridx].length];
+        if (!symbol) {
+          throw new Error(`Failed to get symbol at pos ${reelPos + row} on reel ${ridx}`);
+        }
+        this.reels[ridx][row] = symbol;
+      }
+    }
+  }
+};
+var Board = class extends GameState {
+  board;
+  constructor(opts) {
+    super(opts);
+    this.board = {
+      reels: [],
+      paddingTop: [],
+      paddingBottom: [],
+      anticipation: []
+    };
+  }
+  /**
+   * Resets the board to an empty state.\
+   * This is called before drawing a new board.
+   */
+  resetBoard() {
+    this.resetReels();
+  }
+  makeEmptyReels() {
+    return Array.from({ length: this.getCurrentGameMode().reelsAmount }, () => []);
+  }
+  resetReels() {
+    this.board.reels = this.makeEmptyReels();
+    this.board.anticipation = Array.from(
+      { length: this.getCurrentGameMode().reelsAmount },
+      () => 0
+    );
+    if (this.config.padSymbols && this.config.padSymbols > 0) {
+      this.board.paddingTop = this.makeEmptyReels();
+      this.board.paddingBottom = this.makeEmptyReels();
+    }
+  }
+  /**
+   * Counts how many symbols matching the criteria are on a specific reel.
+   */
+  countSymbolsOnReel(symbolOrProperties, reelIndex) {
+    let total = 0;
+    for (const symbol of this.board.reels[reelIndex]) {
+      let matches = true;
+      if (symbolOrProperties instanceof GameSymbol) {
+        if (symbol.id !== symbolOrProperties.id) matches = false;
+      } else {
+        for (const [key, value] of Object.entries(symbolOrProperties)) {
+          if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
+            matches = false;
+            break;
+          }
+        }
+      }
+      if (matches) {
+        total++;
+      }
+    }
+    return total;
+  }
+  /**
+   * Counts how many symbols matching the criteria are on the board.
+   *
+   * Passing a GameSymbol will compare by ID, passing a properties object will compare by properties.
+   *
+   * Returns a tuple where the first element is the total count, and the second element is a record of counts per reel index.
+   */
+  countSymbolsOnBoard(symbolOrProperties) {
+    let total = 0;
+    const onReel = {};
+    for (const [ridx, reel] of this.board.reels.entries()) {
+      for (const symbol of reel) {
+        let matches = true;
+        if (symbolOrProperties instanceof GameSymbol) {
+          if (symbol.id !== symbolOrProperties.id) matches = false;
+        } else {
+          for (const [key, value] of Object.entries(symbolOrProperties)) {
+            if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
+              matches = false;
+              break;
+            }
+          }
+        }
+        if (matches) {
+          total++;
+          if (onReel[ridx] === void 0) {
+            onReel[ridx] = 1;
+          } else {
+            onReel[ridx]++;
+          }
+        }
+      }
+    }
+    return [total, onReel];
+  }
+  /**
+   * Checks if a symbol appears more than once on any reel in the current reel set.
+   *
+   * Useful to check for "forbidden" generations, e.g. 2 scatters on one reel.
+   */
+  isSymbolOnAnyReelMultipleTimes(symbol) {
+    for (const reel of this.board.reels) {
+      let count = 0;
+      for (const sym of reel) {
+        if (sym.id === symbol.id) {
+          count++;
+        }
+        if (count > 1) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Gets all reel stops (positions) where the specified symbol appears in the current reel set.\
+   * Returns an array of arrays, where each inner array contains the positions for the corresponding reel.
+   */
+  getReelStopsForSymbol(reels, symbol) {
+    const reelStops = [];
+    for (let ridx = 0; ridx < reels.length; ridx++) {
+      const reel = reels[ridx];
+      const positions = [];
+      for (let pos = 0; pos < reel.length; pos++) {
+        if (reel[pos].id === symbol.id) {
+          positions.push(pos);
+        }
+      }
+      reelStops.push(positions);
+    }
+    return reelStops;
+  }
+  /**
+   * Combines multiple arrays of reel stops into a single array of reel stops.\
+   */
+  combineReelStops(...reelStops) {
+    const combined = [];
+    for (let ridx = 0; ridx < this.getCurrentGameMode().reelsAmount; ridx++) {
+      combined[ridx] = [];
+      for (const stops of reelStops) {
+        combined[ridx] = combined[ridx].concat(stops[ridx]);
+      }
+    }
+    return combined;
+  }
+  /**
+   * From a list of reel stops on reels, selects a random stop for a speficied number of random symbols.
+   *
+   * Mostly useful for placing scatter symbols on the board.
+   */
+  getRandomReelStops(reels, reelStops, amount) {
+    const reelsAmount = this.getCurrentGameMode().reelsAmount;
+    const symProbsOnReels = [];
+    const stopPositionsForReels = {};
+    for (let ridx = 0; ridx < reelsAmount; ridx++) {
+      symProbsOnReels.push(reelStops[ridx].length / reels[ridx].length);
+    }
+    while (Object.keys(stopPositionsForReels).length !== amount) {
+      const possibleReels = [];
+      for (let i = 0; i < reelsAmount; i++) {
+        if (symProbsOnReels[i] > 0) {
+          possibleReels.push(i);
+        }
+      }
+      const possibleProbs = symProbsOnReels.filter((p) => p > 0);
+      const weights = Object.fromEntries(
+        possibleReels.map((ridx, idx) => [ridx, possibleProbs[idx]])
+      );
+      const chosenReel = weightedRandom(weights, this.state.rng);
+      const chosenStop = randomItem(reelStops[Number(chosenReel)], this.state.rng);
+      symProbsOnReels[Number(chosenReel)] = 0;
+      stopPositionsForReels[chosenReel] = chosenStop;
+    }
+    return stopPositionsForReels;
+  }
+  /**
+   * Selects a random reelset based on the configured weights for the current game mode.\
+   * Returns the reels as arrays of GameSymbols.
+   */
+  getRandomReelset() {
+    const weights = this.state.currentResultSet.reelWeights;
+    const evalWeights = this.state.currentResultSet.reelWeights.evaluate?.(
+      this
+    );
+    let reelSetId = "";
+    if (evalWeights) {
+      reelSetId = weightedRandom(evalWeights, this.state.rng);
+    } else {
+      reelSetId = weightedRandom(weights[this.state.currentSpinType], this.state.rng);
+    }
+    const reelSet = this.getReelsetById(this.state.currentGameMode, reelSetId);
+    return reelSet.reels;
+  }
+  /**
+   * Draws a board using specified reel stops.
+   */
+  drawBoardWithForcedStops(reels, forcedStops) {
+    this.drawBoardMixed(reels, forcedStops);
+  }
+  /**
+   * Draws a board using random reel stops.
+   */
+  drawBoardWithRandomStops(reels) {
+    this.drawBoardMixed(reels);
+  }
+  drawBoardMixed(reels, forcedStops) {
+    this.resetReels();
+    const finalReelStops = Array.from(
+      { length: this.getCurrentGameMode().reelsAmount },
+      () => null
+    );
+    if (forcedStops) {
+      for (const [r, stopPos] of Object.entries(forcedStops)) {
+        const reelIdx = Number(r);
+        const symCount = this.getCurrentGameMode().symbolsPerReel[reelIdx];
+        finalReelStops[reelIdx] = stopPos - Math.round(this.state.rng.randomFloat(0, symCount - 1));
+        if (finalReelStops[reelIdx] < 0) {
+          finalReelStops[reelIdx] = reels[reelIdx].length + finalReelStops[reelIdx];
+        }
+      }
+    }
+    for (let i = 0; i < finalReelStops.length; i++) {
+      if (finalReelStops[i] === null) {
+        finalReelStops[i] = Math.floor(
+          this.state.rng.randomFloat(0, reels[i].length - 1)
+        );
+      }
+    }
+    for (let ridx = 0; ridx < this.getCurrentGameMode().reelsAmount; ridx++) {
+      const reelPos = finalReelStops[ridx];
+      if (this.config.padSymbols && this.config.padSymbols > 0) {
+        for (let p = this.config.padSymbols - 1; p >= 0; p--) {
+          const topPos = (reelPos - (p + 1)) % reels[ridx].length;
+          this.board.paddingTop[ridx].push(reels[ridx][topPos]);
+          const bottomPos = (reelPos + this.getCurrentGameMode().symbolsPerReel[ridx] + p) % reels[ridx].length;
+          this.board.paddingBottom[ridx].unshift(reels[ridx][bottomPos]);
+        }
+      }
+      for (let row = 0; row < this.getCurrentGameMode().symbolsPerReel[ridx]; row++) {
+        const symbol = reels[ridx][(reelPos + row) % reels[ridx].length];
+        if (!symbol) {
+          throw new Error(`Failed to get symbol at pos ${reelPos + row} on reel ${ridx}`);
+        }
+        this.board.reels[ridx][row] = symbol;
+      }
+    }
+  }
+};
+
+// src/WinType.ts
+var WinType = class {
+  payout;
+  winCombinations;
+  ctx;
+  wildSymbol;
+  constructor(opts) {
+    this.payout = 0;
+    this.winCombinations = [];
+    this.wildSymbol = opts?.wildSymbol;
+  }
+  /**
+   * Sets the simulation context for this WinType instance.
+   * 
+   * This gives the WinType access to the current board.
+   */
+  context(ctx) {
+    this.ctx = ctx;
+    return this;
+  }
+  ensureContext() {
+    if (!this.ctx) {
+      throw new Error("WinType context is not set. Call context(ctx) first.");
+    }
+  }
+  /**
+   * Implementation of win evaluation logic. Sets `this.payout` and `this.winCombinations`.
+   */
+  evaluateWins() {
+    this.ensureContext();
+    return this;
+  }
+  /**
+   * Custom post-processing of wins, e.g. for handling multipliers.
+   */
+  postProcess(func) {
+    this.ensureContext();
+    const result = func(this, this.ctx);
+    this.payout = result.payout;
+    this.winCombinations = result.winCombinations;
+    return this;
+  }
+  /**
+   * Returns the total payout and detailed win combinations.
+   */
+  getWins() {
+    return {
+      payout: this.payout,
+      winCombinations: this.winCombinations
+    };
+  }
+};
+
+// src/winTypes/LinesWinType.ts
+var LinesWinType = class extends WinType {
+  lines;
+  constructor(opts) {
+    super(opts);
+    this.lines = opts.lines;
+    if (Object.keys(this.lines).length === 0) {
+      throw new Error("LinesWinType must have at least one line defined.");
+    }
+  }
+  validateConfig() {
+    const reelsAmount = this.ctx.getCurrentGameMode().reelsAmount;
+    const symsPerReel = this.ctx.getCurrentGameMode().symbolsPerReel;
+    for (const [lineNum, positions] of Object.entries(this.lines)) {
+      if (positions.length !== reelsAmount) {
+        throw new Error(
+          `Line ${lineNum} has ${positions.length} positions, but the current game mode has ${reelsAmount} reels.`
+        );
+      }
+      for (let i = 0; i < positions.length; i++) {
+        if (positions[i] < 0 || positions[i] >= symsPerReel[i]) {
+          throw new Error(
+            `Line ${lineNum} has an invalid position ${positions[i]} on reel ${i}. Valid range is 0 to ${symsPerReel[i] - 1}.`
+          );
+        }
+      }
+    }
+    const firstLine = Math.min(...Object.keys(this.lines).map(Number));
+    if (firstLine !== 1) {
+      throw new Error(
+        `Lines must start from 1. Found line ${firstLine} as the first line.`
+      );
+    }
+  }
+  isWild(symbol) {
+    return !!this.wildSymbol && symbol.compare(this.wildSymbol);
+  }
+  evaluateWins() {
+    this.ensureContext();
+    this.validateConfig();
+    const lineWins = [];
+    let payout = 0;
+    const reels = this.ctx.board.reels;
+    const reelsAmount = this.ctx.getCurrentGameMode().reelsAmount;
+    for (const [lineNumStr, lineDef] of Object.entries(this.lines)) {
+      const lineNum = Number(lineNumStr);
+      let baseSymbol = null;
+      let leadingWilds = 0;
+      const chain = [];
+      const details = [];
+      for (let ridx = 0; ridx < reelsAmount; ridx++) {
+        const rowIdx = lineDef[ridx];
+        const sym = reels[ridx][rowIdx];
+        if (!sym) throw new Error("Encountered an invalid symbol while evaluating wins.");
+        const wild = this.isWild(sym);
+        if (ridx === 0) {
+          chain.push(sym);
+          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: wild });
+          if (wild) leadingWilds++;
+          else baseSymbol = sym;
+          continue;
+        }
+        if (wild) {
+          chain.push(sym);
+          details.push({
+            reelIndex: ridx,
+            posIndex: rowIdx,
+            symbol: sym,
+            isWild: true,
+            substitutedFor: baseSymbol || void 0
+          });
+          continue;
+        }
+        if (!baseSymbol) {
+          baseSymbol = sym;
+          chain.push(sym);
+          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: false });
+          continue;
+        }
+        if (sym.id === baseSymbol.id) {
+          chain.push(sym);
+          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: false });
+          continue;
+        }
+        break;
+      }
+      if (chain.length === 0) continue;
+      const allWild = chain.every((s) => this.isWild(s));
+      const wildRepresentative = this.wildSymbol instanceof GameSymbol ? this.wildSymbol : null;
+      const len = chain.length;
+      let bestPayout = 0;
+      let bestType = null;
+      let payingSymbol = null;
+      if (baseSymbol?.pays && baseSymbol.pays[len]) {
+        bestPayout = baseSymbol.pays[len];
+        bestType = "substituted";
+        payingSymbol = baseSymbol;
+      }
+      if (allWild && wildRepresentative?.pays && wildRepresentative.pays[len]) {
+        const wildPay = wildRepresentative.pays[len];
+        if (wildPay > bestPayout) {
+          bestPayout = wildPay;
+          bestType = "pure-wild";
+          payingSymbol = wildRepresentative;
+        }
+      }
+      if (!bestPayout || !bestType || !payingSymbol) continue;
+      const minLen = payingSymbol.pays ? Math.min(...Object.keys(payingSymbol.pays).map(Number)) : Infinity;
+      if (len < minLen) continue;
+      const wildCount = details.filter((d) => d.isWild).length;
+      const nonWildCount = len - wildCount;
+      lineWins.push({
+        lineNumber: lineNum,
+        kind: len,
+        payout: bestPayout,
+        symbol: payingSymbol,
+        winType: bestType,
+        substitutedBaseSymbol: bestType === "pure-wild" ? null : baseSymbol,
+        symbols: details,
+        stats: { wildCount, nonWildCount, leadingWilds }
+      });
+      payout += bestPayout;
+    }
+    for (const win of lineWins) {
+      this.ctx.recordSymbolOccurrence({
+        kind: win.kind,
+        symbolId: win.symbol.id,
+        spinType: this.ctx.state.currentSpinType
+      });
+    }
+    this.payout = payout;
+    this.winCombinations = lineWins;
+    return this;
+  }
+};
+
+// src/winTypes/ClusterWinType.ts
+var ClusterWinType = class extends WinType {
+};
+
+// src/winTypes/ManywaysWinType.ts
+var ManywaysWinType = class extends WinType {
+};
+
+// src/optimizer/OptimizationConditions.ts
+import assert from "assert";
+var OptimizationConditions = class {
+  rtp;
+  avgWin;
+  hitRate;
+  searchRange;
+  forceSearch;
+  priority;
+  constructor(opts) {
+    let { rtp, avgWin, hitRate, searchConditions, priority } = opts;
+    if (rtp == void 0 || rtp === "x") {
+      assert(avgWin !== void 0 && hitRate !== void 0, "If RTP is not specified, hit-rate (hr) and average win amount (av_win) must be given.");
+      rtp = Math.round(avgWin / Number(hitRate) * 1e5) / 1e5;
+    }
+    let noneCount = 0;
+    for (const val of [rtp, avgWin, hitRate]) {
+      if (val === void 0) noneCount++;
+    }
+    assert(noneCount <= 1, "Invalid combination of optimization conditions.");
+    this.searchRange = [-1, -1];
+    this.forceSearch = {};
+    if (typeof searchConditions === "number") {
+      this.searchRange = [searchConditions, searchConditions];
+    }
+    if (Array.isArray(searchConditions)) {
+      if (searchConditions[0] > searchConditions[1] || searchConditions.length !== 2) {
+        throw new Error("Invalid searchConditions range.");
+      }
+      this.searchRange = searchConditions;
+    }
+    if (typeof searchConditions === "object" && !Array.isArray(searchConditions)) {
+      this.searchRange = [-1, -1];
+      this.forceSearch = searchConditions;
+    }
+    this.rtp = rtp;
+    this.avgWin = avgWin;
+    this.hitRate = hitRate;
+    this.priority = priority;
+  }
+  getRtp() {
+    return this.rtp;
+  }
+  getAvgWin() {
+    return this.avgWin;
+  }
+  getHitRate() {
+    return this.hitRate;
+  }
+  getSearchRange() {
+    return this.searchRange;
+  }
+  getForceSearch() {
+    return this.forceSearch;
+  }
+};
+
+// src/optimizer/OptimizationScaling.ts
+var OptimizationScaling = class {
+  config;
+  constructor(opts) {
+    this.config = opts;
+  }
+  getConfig() {
+    return this.config;
+  }
+};
+
+// src/optimizer/OptimizationParameters.ts
+var OptimizationParameters = class _OptimizationParameters {
+  parameters;
+  constructor(opts) {
+    this.parameters = {
+      ..._OptimizationParameters.DEFAULT_PARAMETERS,
+      ...opts
+    };
+  }
+  static DEFAULT_PARAMETERS = {
+    numShowPigs: 5e3,
+    numPigsPerFence: 1e4,
+    threadsFenceConstruction: 16,
+    threadsShowConstruction: 16,
+    testSpins: [50, 100, 200],
+    testSpinsWeights: [0.3, 0.4, 0.3],
+    simulationTrials: 5e3,
+    graphIndexes: [],
+    run1000Batch: false,
+    minMeanToMedian: 4,
+    maxMeanToMedian: 8,
+    pmbRtp: 1,
+    scoreType: "rtp"
+  };
+  getParameters() {
+    return this.parameters;
+  }
+};
+
+// src/Simulation.ts
+import fs3 from "fs";
+import path3 from "path";
+import assert2 from "assert";
+import { buildSync } from "esbuild";
+import { Worker, isMainThread as isMainThread2, parentPort, workerData } from "worker_threads";
+
+// src/utils/zstd.ts
+import path2 from "path";
+import { spawn } from "child_process";
+async function zstd(...args) {
+  return new Promise((resolve, reject) => {
+    const task = spawn(path2.join(__dirname, "./lib/zstd.exe"), args);
+    task.on("error", (error) => {
+      console.error("Error:", error);
+      reject(error);
+    });
+    task.on("exit", () => {
+      resolve(true);
+    });
+    task.on("close", () => {
+      resolve(true);
+    });
+    task.stdout.on("data", (data) => {
+      console.log(data.toString());
+    });
+    task.stderr.on("data", (data) => {
+      console.log(data.toString());
+    });
+    task.stdout.on("error", (data) => {
+      console.log(data.toString());
+      reject(data.toString());
+    });
+  });
+}
+
+// src/Simulation.ts
+var completedSimulations = 0;
+var TEMP_FILENAME = "__temp_compiled_src_IGNORE.js";
+var Simulation = class _Simulation {
+  gameConfigOpts;
+  gameConfig;
+  simRunsAmount;
+  concurrency;
+  wallet;
+  library;
+  records;
+  debug = false;
+  constructor(opts, gameConfigOpts) {
+    this.gameConfig = new GameConfig(gameConfigOpts);
+    this.gameConfigOpts = gameConfigOpts;
+    this.simRunsAmount = opts.simRunsAmount || {};
+    this.concurrency = (opts.concurrency || 6) >= 2 ? opts.concurrency || 6 : 2;
+    this.wallet = new Wallet();
+    this.library = /* @__PURE__ */ new Map();
+    this.records = [];
+    const gameModeKeys = Object.keys(this.gameConfig.config.gameModes);
+    assert2(
+      Object.values(this.gameConfig.config.gameModes).map((m) => gameModeKeys.includes(m.name)).every((v) => v === true),
+      "Game mode name must match its key in the gameModes object."
+    );
+    if (isMainThread2) {
+      this.preprocessFiles();
+    }
+  }
+  async runSimulation(opts) {
+    const debug = opts.debug || false;
+    this.debug = debug;
+    const gameModesToSimulate = Object.keys(this.simRunsAmount);
+    const configuredGameModes = Object.keys(this.gameConfig.config.gameModes);
+    if (gameModesToSimulate.length === 0) {
+      throw new Error("No game modes configured for simulation.");
+    }
+    this.gameConfig.generateReelsetFiles();
+    if (isMainThread2) {
+      const debugDetails = {};
+      for (const mode of gameModesToSimulate) {
+        completedSimulations = 0;
+        this.wallet = new Wallet();
+        this.library = /* @__PURE__ */ new Map();
+        debugDetails[mode] = {};
+        console.log(`
+Simulating game mode: ${mode}`);
+        console.time(mode);
+        const runs = this.simRunsAmount[mode] || 0;
+        if (runs <= 0) continue;
+        if (!configuredGameModes.includes(mode)) {
+          throw new Error(
+            `Tried to simulate game mode "${mode}", but it's not configured in the game config.`
+          );
+        }
+        const simNumsToCriteria = ResultSet.assignCriteriaToSimulations(this, mode);
+        await this.spawnWorkersForGameMode({ mode, simNumsToCriteria });
+        createDirIfNotExists(
+          path3.join(
+            process.cwd(),
+            this.gameConfig.config.outputDir,
+            "optimization_files"
+          )
+        );
+        createDirIfNotExists(
+          path3.join(process.cwd(), this.gameConfig.config.outputDir, "publish_files")
+        );
+        _Simulation.writeLookupTableCSV({
+          gameMode: mode,
+          library: this.library,
+          gameConfig: this.gameConfig.config
+        });
+        _Simulation.writeLookupTableSegmentedCSV({
+          gameMode: mode,
+          library: this.library,
+          gameConfig: this.gameConfig.config
+        });
+        _Simulation.writeRecords({
+          gameMode: mode,
+          records: this.records,
+          gameConfig: this.gameConfig.config,
+          debug: this.debug
+        });
+        await _Simulation.writeBooksJson({
+          gameMode: mode,
+          library: this.library,
+          gameConfig: this.gameConfig.config
+        });
+        _Simulation.writeIndexJson({
+          gameConfig: this.gameConfig.config
+        });
+        debugDetails[mode].rtp = this.wallet.getCumulativeWins() / (runs * this.gameConfig.config.gameModes[mode].cost);
+        debugDetails[mode].wins = this.wallet.getCumulativeWins();
+        debugDetails[mode].winsPerSpinType = this.wallet.getCumulativeWinsPerSpinType();
+        console.timeEnd(mode);
+      }
+      console.log("\n=== SIMULATION SUMMARY ===");
+      console.table(debugDetails);
+    }
+    let desiredSims = 0;
+    let actualSims = 0;
+    const criteriaToRetries = {};
+    if (!isMainThread2) {
+      const { mode, simStart, simEnd, index } = workerData;
+      const simNumsToCriteria = ResultSet.assignCriteriaToSimulations(this, mode);
+      for (let simId = simStart; simId <= simEnd; simId++) {
+        if (this.debug) desiredSims++;
+        const criteria = simNumsToCriteria[simId] || "N/A";
+        const ctx = new SimulationContext(this.gameConfigOpts);
+        if (!criteriaToRetries[criteria]) {
+          criteriaToRetries[criteria] = 0;
+        }
+        ctx.runSingleSimulation({ simId, mode, criteria, index });
+        if (this.debug) {
+          criteriaToRetries[criteria] += ctx.actualSims - 1;
+          actualSims += ctx.actualSims;
+        }
+      }
+      if (this.debug) {
+        console.log(`Desired ${desiredSims}, Actual ${actualSims}`);
+        console.log(`Retries per criteria:`, criteriaToRetries);
+      }
+      parentPort?.postMessage({
+        type: "done",
+        workerNum: index
+      });
+    }
+  }
+  /**
+   * Runs all simulations for a specific game mode.
+   */
+  async spawnWorkersForGameMode(opts) {
+    const { mode, simNumsToCriteria } = opts;
+    const numSims = Object.keys(simNumsToCriteria).length;
+    const simRangesPerChunk = this.getSimRangesForChunks(numSims, this.concurrency);
+    await Promise.all(
+      simRangesPerChunk.map(([simStart, simEnd], index) => {
+        return this.callWorker({
+          basePath: this.gameConfig.config.outputDir,
+          mode,
+          simStart,
+          simEnd,
+          index,
+          totalSims: numSims
+        });
+      })
+    );
+  }
+  async callWorker(opts) {
+    const { mode, simEnd, simStart, basePath, index, totalSims } = opts;
+    function logArrowProgress(current, total) {
+      const percentage = current / total * 100;
+      const progressBarLength = 50;
+      const filledLength = Math.round(progressBarLength * current / total);
+      const bar = "\u2588".repeat(filledLength) + "-".repeat(progressBarLength - filledLength);
+      process.stdout.write(`\r[${bar}] ${percentage.toFixed(2)}%   (${current}/${total})`);
+      if (current === total) {
+        process.stdout.write("\n");
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const scriptPath = path3.join(process.cwd(), basePath, TEMP_FILENAME);
+      const worker = new Worker(scriptPath, {
+        workerData: {
+          mode,
+          simStart,
+          simEnd,
+          index
+        }
+      });
+      worker.on("message", (msg) => {
+        if (msg.type === "log") {
+        } else if (msg.type === "complete") {
+          completedSimulations++;
+          if (completedSimulations % 250 === 0) {
+            logArrowProgress(completedSimulations, totalSims);
+          }
+          const book = Book.fromSerialized(msg.book);
+          this.library.set(book.id.toString(), book);
+          this.wallet.mergeSerialized(msg.wallet);
+          this.mergeRecords(msg.records);
+        } else if (msg.type === "done") {
+          resolve(true);
+        }
+      });
+      worker.on("error", (error) => {
+        console.error("Error:", error);
+        reject(error);
+      });
+      worker.on("exit", (code) => {
+        if (code !== 0) {
+          reject(new Error(`Worker stopped with exit code ${code}`));
+        }
+      });
+    });
+  }
+  /**
+   * Creates a CSV file in the format "simulationId,weight,payout".
+   *
+   * `weight` defaults to 1.
+   */
+  static writeLookupTableCSV(opts) {
+    const { gameMode, fileNameWithoutExtension, library, gameConfig } = opts;
+    const rows = [];
+    for (const [bookId, book] of library.entries()) {
+      rows.push(`${book.id},1,${Math.round(book.getPayout())}`);
+    }
+    rows.sort((a, b) => Number(a.split(",")[0]) - Number(b.split(",")[0]));
+    const outputFileName = fileNameWithoutExtension ? `${fileNameWithoutExtension}.csv` : `lookUpTable_${gameMode}.csv`;
+    const outputFilePath = path3.join(gameConfig.outputDir, outputFileName);
+    writeFile(outputFilePath, rows.join("\n"));
+    return outputFilePath;
+  }
+  /**
+   * Creates a CSV file in the format "simulationId,criteria,payoutBase,payoutFreespins".
+   */
+  static writeLookupTableSegmentedCSV(opts) {
+    const { gameMode, fileNameWithoutExtension, library, gameConfig } = opts;
+    const rows = [];
+    for (const [bookId, book] of library.entries()) {
+      rows.push(
+        `${book.id},${book.criteria},${book.getBasegameWins()},${book.getFreespinsWins()}`
+      );
+    }
+    rows.sort((a, b) => Number(a.split(",")[0]) - Number(b.split(",")[0]));
+    const outputFileName = fileNameWithoutExtension ? `${fileNameWithoutExtension}.csv` : `lookUpTableSegmented_${gameMode}.csv`;
+    const outputFilePath = path3.join(gameConfig.outputDir, outputFileName);
+    writeFile(outputFilePath, rows.join("\n"));
+    return outputFilePath;
+  }
+  static writeRecords(opts) {
+    const { gameMode, fileNameWithoutExtension, records, gameConfig, debug } = opts;
+    const outputFileName = fileNameWithoutExtension ? `${fileNameWithoutExtension}.json` : `force_record_${gameMode}.json`;
+    const outputFilePath = path3.join(gameConfig.outputDir, outputFileName);
+    writeFile(outputFilePath, JSON.stringify(records, null, 2));
+    if (debug) _Simulation.logSymbolOccurrences(records);
+    return outputFilePath;
+  }
+  static writeIndexJson(opts) {
+    const { gameConfig } = opts;
+    const outputFilePath = path3.join(
+      process.cwd(),
+      gameConfig.outputDir,
+      "publish_files",
+      "index.json"
+    );
+    const modes = Object.entries(gameConfig.gameModes).map(([mode, modeConfig]) => ({
+      name: mode,
+      cost: modeConfig.cost,
+      events: `books_${mode}.jsonl.zst`,
+      weights: `lookUpTable_${mode}_0.csv`
+    }));
+    writeFile(outputFilePath, JSON.stringify({ modes }, null, 2));
+  }
+  static async writeBooksJson(opts) {
+    const { gameMode, fileNameWithoutExtension, library, gameConfig } = opts;
+    const outputFileName = fileNameWithoutExtension ? `${fileNameWithoutExtension}.jsonl` : `books_${gameMode}.jsonl`;
+    const outputFilePath = path3.join(gameConfig.outputDir, outputFileName);
+    const books = Array.from(library.values()).map((b) => b.serialize()).map((b) => ({
+      id: b.id,
+      payoutMultiplier: b.payout,
+      events: b.events
+    })).sort((a, b) => a.id - b.id);
+    const contents = JSONL.stringify(books);
+    writeFile(outputFilePath, contents);
+    const compressedFileName = fileNameWithoutExtension ? `${fileNameWithoutExtension}.jsonl.zst` : `books_${gameMode}.jsonl.zst`;
+    const compressedFilePath = path3.join(
+      process.cwd(),
+      gameConfig.outputDir,
+      "publish_files",
+      compressedFileName
+    );
+    fs3.rmSync(compressedFilePath, { force: true });
+    await zstd("-f", outputFilePath, "-o", compressedFilePath);
+  }
+  static logSymbolOccurrences(records) {
+    const validRecords = records.filter(
+      (r) => r.search.some((s) => s.name === "symbolId") && r.search.some((s) => s.name === "kind")
+    );
+    const structuredRecords = validRecords.map((r) => {
+      const symbolEntry = r.search.find((s) => s.name === "symbolId");
+      const kindEntry = r.search.find((s) => s.name === "kind");
+      const spinTypeEntry = r.search.find((s) => s.name === "spinType");
+      return {
+        symbol: symbolEntry ? symbolEntry.value : "unknown",
+        kind: kindEntry ? kindEntry.value : "unknown",
+        spinType: spinTypeEntry ? spinTypeEntry.value : "unknown",
+        timesTriggered: r.timesTriggered
+      };
+    }).sort((a, b) => {
+      if (a.symbol < b.symbol) return -1;
+      if (a.symbol > b.symbol) return 1;
+      if (a.kind < b.kind) return -1;
+      if (a.kind > b.kind) return 1;
+      if (a.spinType < b.spinType) return -1;
+      if (a.spinType > b.spinType) return 1;
+      return 0;
+    });
+    console.table(structuredRecords);
+  }
+  /**
+   * Compiles user configured game to JS for use in different Node processes
+   */
+  preprocessFiles() {
+    const builtFilePath = path3.join(this.gameConfig.config.outputDir, TEMP_FILENAME);
+    fs3.rmSync(builtFilePath, { force: true });
+    buildSync({
+      entryPoints: [process.cwd()],
+      bundle: true,
+      platform: "node",
+      outfile: path3.join(this.gameConfig.config.outputDir, TEMP_FILENAME),
+      external: ["esbuild", "@mongodb-js/zstd"]
+    });
+  }
+  getSimRangesForChunks(total, chunks) {
+    const base = Math.floor(total / chunks);
+    const remainder = total % chunks;
+    const result = [];
+    let current = 1;
+    for (let i = 0; i < chunks; i++) {
+      const size = base + (i < remainder ? 1 : 0);
+      const start = current;
+      const end = current + size - 1;
+      result.push([start, end]);
+      current = end + 1;
+    }
+    return result;
+  }
+  mergeRecords(otherRecords) {
+    for (const otherRecord of otherRecords) {
+      let record = this.records.find((r) => {
+        if (r.search.length !== otherRecord.search.length) return false;
+        for (let i = 0; i < r.search.length; i++) {
+          if (r.search[i].name !== otherRecord.search[i].name) return false;
+          if (r.search[i].value !== otherRecord.search[i].value) return false;
+        }
+        return true;
+      });
+      if (!record) {
+        record = {
+          search: otherRecord.search,
+          timesTriggered: 0,
+          bookIds: []
+        };
+        this.records.push(record);
+      }
+      record.timesTriggered += otherRecord.timesTriggered;
+      for (const bookId of otherRecord.bookIds) {
+        if (!record.bookIds.includes(bookId)) {
+          record.bookIds.push(bookId);
+        }
+      }
+    }
+  }
+};
+var SimulationContext = class extends Board {
+  constructor(opts) {
+    super(opts);
+  }
+  actualSims = 0;
+  /**
+   * Will run a single simulation until the specified criteria is met.
+   */
+  runSingleSimulation(opts) {
+    const { simId, mode, criteria, index } = opts;
+    this.state.currentGameMode = mode;
+    this.state.currentSimulationId = simId;
+    this.state.isCriteriaMet = false;
+    while (!this.state.isCriteriaMet) {
+      this.actualSims++;
+      this.resetSimulation();
+      const resultSet = this.getGameModeCriteria(this.state.currentGameMode, criteria);
+      this.state.currentResultSet = resultSet;
+      this.state.book.criteria = resultSet.criteria;
+      this.handleGameFlow();
+      if (resultSet.meetsCriteria(this)) {
+        this.state.isCriteriaMet = true;
+        this.config.hooks.onSimulationAccepted?.(this);
+        this.record({
+          criteria: resultSet.criteria
+        });
+      }
+    }
+    this.wallet.confirmWins(this);
+    this.confirmRecords();
+    parentPort?.postMessage({
+      type: "complete",
+      simId,
+      book: this.state.book.serialize(),
+      wallet: this.wallet.serialize(),
+      records: this.getRecords()
+    });
+  }
+  /**
+   * If a simulation does not meet the required criteria, reset the state to run it again.
+   *
+   * This also runs once before each simulation to ensure a clean state.
+   */
+  resetSimulation() {
+    this.resetState();
+    this.resetBoard();
+  }
+  /**
+   * Contains and executes the entire game logic:
+   * - Drawing the board
+   * - Evaluating wins
+   * - Updating wallet
+   * - Handling free spins
+   * - Recording events
+   *
+   * You can customize the game flow by implementing the `onHandleGameFlow` hook in the game configuration.
+   */
+  handleGameFlow() {
+    this.config.hooks.onHandleGameFlow(this);
+  }
+};
+
+// src/analysis/index.ts
+import fs4 from "fs";
+import path4 from "path";
+import assert3 from "assert";
+
+// src/analysis/utils.ts
+function parseLookupTable(content) {
+  const lines = content.trim().split("\n");
+  const lut = [];
+  for (const line of lines) {
+    const [indexStr, weightStr, payoutStr] = line.split(",");
+    const index = parseInt(indexStr.trim());
+    const weight = parseInt(weightStr.trim());
+    const payout = parseFloat(payoutStr.trim());
+    lut.push([index, weight, payout]);
+  }
+  return lut;
+}
+function getTotalLutWeight(lut) {
+  return lut.reduce((sum, [, weight]) => sum + weight, 0);
+}
+function getTotalWeight(payoutWeights) {
+  return Object.values(payoutWeights).reduce((sum, w) => sum + w, 0);
+}
+function getPayoutWeights(lut, opts = {}) {
+  const { normalize = true } = opts;
+  const totalWeight = getTotalLutWeight(lut);
+  let payoutWeights = {};
+  for (const [, weight, p] of lut) {
+    const payout = p / 100;
+    if (payoutWeights[payout] === void 0) {
+      payoutWeights[payout] = 0;
+    }
+    payoutWeights[payout] += weight;
+  }
+  payoutWeights = Object.fromEntries(
+    Object.entries(payoutWeights).sort(([a], [b]) => parseFloat(a) - parseFloat(b))
+  );
+  if (normalize) {
+    for (const payout in payoutWeights) {
+      payoutWeights[payout] /= totalWeight;
+    }
+  }
+  return payoutWeights;
+}
+function getNonZeroHitrate(payoutWeights) {
+  const totalWeight = getTotalWeight(payoutWeights);
+  const nonZeroWeight = totalWeight - (payoutWeights[0] ?? 0) * totalWeight;
+  return nonZeroWeight / totalWeight;
+}
+function getNullHitrate(payoutWeights) {
+  return payoutWeights[0] ?? 0;
+}
+function getMaxwinHitrate(payoutWeights) {
+  const totalWeight = getTotalWeight(payoutWeights);
+  const maxWin = Math.max(...Object.keys(payoutWeights).map(Number));
+  const hitRate = (payoutWeights[maxWin] || 0) / totalWeight;
+  return 1 / hitRate;
+}
+function getUniquePayouts(payoutWeights) {
+  return Object.keys(payoutWeights).length;
+}
+function getMinWin(payoutWeights) {
+  const payouts = Object.keys(payoutWeights).map(Number);
+  return Math.min(...payouts);
+}
+function getMaxWin(payoutWeights) {
+  const payouts = Object.keys(payoutWeights).map(Number);
+  return Math.max(...payouts);
+}
+function getAvgWin(payoutWeights) {
+  let avgWin = 0;
+  for (const [payoutStr, weight] of Object.entries(payoutWeights)) {
+    const payout = parseFloat(payoutStr);
+    avgWin += payout * weight;
+  }
+  return avgWin;
+}
+function getRtp(payoutWeights, cost) {
+  const avgWin = getAvgWin(payoutWeights);
+  return avgWin / cost;
+}
+function getStandardDeviation(payoutWeights) {
+  const variance = getVariance(payoutWeights);
+  return Math.sqrt(variance);
+}
+function getVariance(payoutWeights) {
+  const totalWeight = getTotalWeight(payoutWeights);
+  const avgWin = getAvgWin(payoutWeights);
+  let variance = 0;
+  for (const [payoutStr, weight] of Object.entries(payoutWeights)) {
+    const payout = parseFloat(payoutStr);
+    variance += Math.pow(payout - avgWin, 2) * (weight / totalWeight);
+  }
+  return variance;
+}
+function getLessBetHitrate(payoutWeights, cost) {
+  let lessBetWeight = 0;
+  const totalWeight = getTotalWeight(payoutWeights);
+  for (const [payoutStr, weight] of Object.entries(payoutWeights)) {
+    const payout = parseFloat(payoutStr);
+    if (payout < cost) {
+      lessBetWeight += weight;
+    }
+  }
+  return lessBetWeight / totalWeight;
+}
+
+// src/analysis/index.ts
+var Analysis = class {
+  gameConfig;
+  optimizerConfig;
+  filePaths;
+  constructor(optimizer) {
+    this.gameConfig = optimizer.getGameConfig();
+    this.optimizerConfig = optimizer.getOptimizerGameModes();
+    this.filePaths = {};
+  }
+  async runAnalysis(gameModes) {
+    this.filePaths = this.getPathsForModes(gameModes);
+    this.getNumberStats(gameModes);
+    this.getWinRanges(gameModes);
+    console.log("Analysis complete. Files written to build directory.");
+  }
+  getPathsForModes(gameModes) {
+    const rootPath = process.cwd();
+    const paths = {};
+    for (const modeStr of gameModes) {
+      const lut = path4.join(
+        rootPath,
+        this.gameConfig.outputDir,
+        `lookUpTable_${modeStr}.csv`
+      );
+      const lutSegmented = path4.join(
+        rootPath,
+        this.gameConfig.outputDir,
+        `lookUpTableSegmented_${modeStr}.csv`
+      );
+      const lutOptimized = path4.join(
+        rootPath,
+        this.gameConfig.outputDir,
+        "publish_files",
+        `lookUpTable_${modeStr}_0.csv`
+      );
+      const booksJsonl = path4.join(
+        rootPath,
+        this.gameConfig.outputDir,
+        `books_${modeStr}.jsonl`
+      );
+      const booksJsonlCompressed = path4.join(
+        rootPath,
+        this.gameConfig.outputDir,
+        "publish_files",
+        `books_${modeStr}.jsonl.zst`
+      );
+      paths[modeStr] = {
+        lut,
+        lutSegmented,
+        lutOptimized,
+        booksJsonl,
+        booksJsonlCompressed
+      };
+      for (const p of Object.values(paths[modeStr])) {
+        assert3(
+          fs4.existsSync(p),
+          `File "${p}" does not exist. Run optimization to auto-create it.`
+        );
+      }
+    }
+    return paths;
+  }
+  getNumberStats(gameModes) {
+    const stats = [];
+    for (const modeStr of gameModes) {
+      const mode = this.getGameModeConfig(modeStr);
+      const lutOptimized = parseLookupTable(
+        fs4.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
+      );
+      const totalWeight = getTotalLutWeight(lutOptimized);
+      const payoutWeights = getPayoutWeights(lutOptimized);
+      stats.push({
+        gameMode: mode.name,
+        totalWeight,
+        avgWin: getAvgWin(payoutWeights),
+        rtp: getRtp(payoutWeights, mode.cost),
+        minWin: getMinWin(payoutWeights),
+        maxWin: getMaxWin(payoutWeights),
+        stdDev: getStandardDeviation(payoutWeights),
+        variance: getVariance(payoutWeights),
+        nonZeroHitRate: getNonZeroHitrate(payoutWeights),
+        nullHitRate: getNullHitrate(payoutWeights),
+        maxwinHitRate: getMaxwinHitrate(payoutWeights),
+        lessBetHitRate: getLessBetHitrate(payoutWeights, mode.cost),
+        uniquePayouts: getUniquePayouts(payoutWeights)
+      });
+    }
+    writeJsonFile(
+      path4.join(process.cwd(), this.gameConfig.outputDir, "stats_summary.json"),
+      stats
+    );
+  }
+  getWinRanges(gameModes) {
+    const winRanges = [
+      [0, 0.1],
+      [0, 0.99],
+      [1, 1.99],
+      [2, 2.99],
+      [3, 4.99],
+      [5, 9.99],
+      [10, 19.99],
+      [20, 49.99],
+      [50, 99.99],
+      [100, 199.99],
+      [200, 499.99],
+      [500, 999.99],
+      [1e3, 1999.99],
+      [2e3, 2999.99],
+      [3e3, 4999.99],
+      [5e3, 7499.99],
+      [7500, 9999.99],
+      [1e4, 14999.99],
+      [15e3, 19999.99],
+      [2e4, 24999.99]
+    ];
+    for (const modeStr of gameModes) {
+      const mode = this.getGameModeConfig(modeStr);
+      const lutOptimized = parseLookupTable(
+        fs4.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
+      );
+      const totalWeight = getTotalLutWeight(lutOptimized);
+      const payoutWeights = getPayoutWeights(lutOptimized);
+    }
+  }
+  getGameModeConfig(mode) {
+    const config = this.gameConfig.gameModes[mode];
+    assert3(config, `Game mode "${mode}" not found in game config`);
+    return config;
+  }
+};
+
+// src/utils/math-config.ts
+import path5 from "path";
+function makeMathConfig(optimizer, opts = {}) {
+  const game = optimizer.getGameConfig();
+  const gameModesCfg = optimizer.getOptimizerGameModes();
+  const { writeToFile } = opts;
+  const isDefined = (v) => v !== void 0;
+  const config = {
+    game_id: game.id,
+    bet_modes: Object.entries(game.gameModes).map(([key, mode]) => ({
+      bet_mode: mode.name,
+      cost: mode.cost,
+      rtp: mode.rtp,
+      max_win: game.maxWinX
+    })),
+    fences: Object.entries(gameModesCfg).map(([gameModeName, modeCfg]) => ({
+      bet_mode: gameModeName,
+      fences: Object.entries(modeCfg.conditions).map(([fenceName, fence]) => ({
+        name: fenceName,
+        avg_win: isDefined(fence.getAvgWin()) ? fence.getAvgWin().toString() : void 0,
+        hr: isDefined(fence.getHitRate()) ? fence.getHitRate().toString() : void 0,
+        rtp: isDefined(fence.getRtp()) ? fence.getRtp().toString() : void 0,
+        identity_condition: {
+          search: Object.entries(fence.getForceSearch()).map(([k, v]) => ({
+            name: k,
+            value: v
+          })),
+          win_range_start: fence.getSearchRange()[0],
+          win_range_end: fence.getSearchRange()[1],
+          opposite: false
+        },
+        priority: fence.priority
+      })).sort((a, b) => b.priority - a.priority)
+    })),
+    dresses: Object.entries(gameModesCfg).flatMap(([gameModeName, modeCfg]) => ({
+      bet_mode: gameModeName,
+      dresses: modeCfg.scaling.getConfig().map((s) => ({
+        fence: s.criteria,
+        scale_factor: s.scaleFactor.toString(),
+        identity_condition_win_range: s.winRange,
+        prob: s.probability
+      }))
+    }))
+  };
+  if (writeToFile) {
+    const outPath = path5.join(process.cwd(), game.outputDir, "math_config.json");
+    writeJsonFile(outPath, config);
+  }
+  return config;
+}
+
+// src/utils/setup-file.ts
+import path6 from "path";
+function makeSetupFile(optimizer, gameMode) {
+  const gameConfig = optimizer.getGameConfig();
+  const optimizerGameModes = optimizer.getOptimizerGameModes();
+  const modeConfig = optimizerGameModes[gameMode];
+  if (!modeConfig) {
+    throw new Error(`Game mode "${gameMode}" not found in optimizer configuration.`);
+  }
+  const params = modeConfig.parameters.getParameters();
+  let content = "";
+  content += `game_name;${gameConfig.id}
+`;
+  content += `bet_type;${gameMode}
+`;
+  content += `num_show_pigs;${params.numShowPigs}
+`;
+  content += `num_pigs_per_fence;${params.numPigsPerFence}
+`;
+  content += `threads_for_fence_construction;${params.threadsFenceConstruction}
+`;
+  content += `threads_for_show_construction;${params.threadsShowConstruction}
+`;
+  content += `score_type;${params.scoreType}
+`;
+  content += `test_spins;${JSON.stringify(params.testSpins)}
+`;
+  content += `test_spins_weights;${JSON.stringify(params.testSpinsWeights)}
+`;
+  content += `simulation_trials;${params.simulationTrials}
+`;
+  content += `graph_indexes;0
+`;
+  content += `run_1000_batch;False
+`;
+  content += `simulation_trials;${params.simulationTrials}
+`;
+  content += `user_game_build_path;${path6.join(process.cwd(), gameConfig.outputDir)}
+`;
+  content += `pmb_rtp;${params.pmbRtp}
+`;
+  const outPath = path6.join(__dirname, "./optimizer-rust/src", "setup.txt");
+  writeFile(outPath, content);
+}
+
+// src/optimizer/index.ts
+import { spawn as spawn2 } from "child_process";
+import path7 from "path";
+import assert4 from "assert";
+import { isMainThread as isMainThread3 } from "worker_threads";
+var Optimizer = class {
+  gameConfig;
+  gameModes;
+  constructor(opts) {
+    this.gameConfig = opts.game.getConfig().config;
+    this.gameModes = opts.gameModes;
+    this.verifyConfig();
+  }
+  /**
+   * Runs the optimization process, and runs analysis after.
+   */
+  async runOptimization({ gameModes }) {
+    if (!isMainThread3) return;
+    const mathConfig = makeMathConfig(this, { writeToFile: true });
+    for (const mode of gameModes) {
+      const setupFile = makeSetupFile(this, mode);
+      await this.runSingleOptimization();
+    }
+  }
+  async runSingleOptimization() {
+    return await rustProgram();
+  }
+  verifyConfig() {
+    for (const [k, mode] of Object.entries(this.gameModes)) {
+      const configMode = this.gameConfig.gameModes[k];
+      if (!configMode) {
+        throw new Error(
+          `Game mode "${mode}" defined in optimizer config does not exist in the game config.`
+        );
+      }
+      const conditions = Object.keys(mode.conditions);
+      const scalings = Object.keys(mode.scaling);
+      const parameters = Object.keys(mode.parameters);
+      for (const condition of conditions) {
+        if (!configMode.resultSets.find((r) => r.criteria === condition)) {
+          throw new Error(
+            `Condition "${condition}" defined in optimizer config for game mode "${k}" does not exist as criteria in any ResultSet of the same game mode.`
+          );
+        }
+      }
+      const criteria = configMode.resultSets.map((r) => r.criteria);
+      assert4(
+        conditions.every((c) => criteria.includes(c)),
+        `Not all ResultSet criteria in game mode "${k}" are defined as optimization conditions.`
+      );
+      let gameModeRtp = configMode.rtp;
+      let paramRtp = 0;
+      for (const cond of conditions) {
+        const paramConfig = mode.conditions[cond];
+        paramRtp += Number(paramConfig.getRtp());
+      }
+      gameModeRtp = Math.round(gameModeRtp * 1e3) / 1e3;
+      paramRtp = Math.round(paramRtp * 1e3) / 1e3;
+      assert4(
+        gameModeRtp === paramRtp,
+        `Sum of all RTP conditions (${paramRtp}) does not match the game mode RTP (${gameModeRtp}) in game mode "${k}".`
+      );
+    }
+  }
+  getGameConfig() {
+    return this.gameConfig;
+  }
+  getOptimizerGameModes() {
+    return this.gameModes;
+  }
+};
+async function rustProgram(...args) {
+  return new Promise((resolve, reject) => {
+    const task = spawn2("cargo", ["run", "--release", ...args], {
+      shell: true,
+      cwd: path7.join(__dirname, "./optimizer-rust"),
+      stdio: "pipe"
+    });
+    task.on("error", (error) => {
+      console.error("Error:", error);
+      reject(error);
+    });
+    task.on("exit", () => {
+      resolve(true);
+    });
+    task.on("close", () => {
+      resolve(true);
+    });
+    task.stdout.on("data", (data) => {
+      console.log(data.toString());
+    });
+    task.stderr.on("data", (data) => {
+      console.log(data.toString());
+    });
+    task.stdout.on("error", (data) => {
+      console.log(data.toString());
+      reject(data.toString());
+    });
+  });
+}
+
+// src/SlotGame.ts
+var SlotGame = class {
+  gameConfigOpts;
+  simulation;
+  optimizer;
+  analyzer;
+  constructor(config) {
+    this.gameConfigOpts = config;
+  }
+  /**
+   * Sets up the simulation configuration.\
+   * Must be called before `runTasks()`.
+   */
+  configureSimulation(opts) {
+    this.simulation = new Simulation(opts, this.gameConfigOpts);
+  }
+  /**
+   * Sets up the optimization configuration.\
+   * Must be called before `runTasks()`.
+   */
+  configureOptimization(opts) {
+    this.optimizer = new Optimizer({
+      game: this,
+      gameModes: opts.gameModes
+    });
+  }
+  /**
+   * Runs the simulation based on the configured settings.
+   */
+  async runSimulation(opts = {}) {
+    if (!this.simulation) {
+      throw new Error(
+        "Simulation is not configured. Do so by calling configureSimulation() first."
+      );
+    }
+    await this.simulation.runSimulation(opts);
+  }
+  /**
+   * Runs the optimization based on the configured settings.
+   */
+  async runOptimization(opts) {
+    if (!this.optimizer) {
+      throw new Error(
+        "Optimization is not configured. Do so by calling configureOptimization() first."
+      );
+    }
+    await this.optimizer.runOptimization(opts);
+  }
+  /**
+   * Runs the analysis based on the configured settings.
+   */
+  async runAnalysis(opts) {
+    if (!this.optimizer) {
+      throw new Error(
+        "Optimization must be configured to run analysis. Do so by calling configureOptimization() first."
+      );
+    }
+    this.analyzer = new Analysis(this.optimizer);
+    await this.analyzer.runAnalysis(opts.gameModes);
+  }
+  async runTasks(opts = {}) {
+    if (!opts.doSimulation && !opts.doOptimization && !opts.doAnalysis) {
+      console.log("No tasks to run. Enable either simulation, optimization or analysis.");
+    }
+    if (opts.doSimulation) {
+      await this.runSimulation({ debug: opts.debug });
+    }
+    if (opts.doOptimization) {
+      await this.runOptimization(opts.optimizationOpts || { gameModes: [] });
+    }
+    if (opts.doAnalysis) {
+      await this.runAnalysis(opts.analysisOpts || { gameModes: [] });
+    }
+  }
+  /**
+   * Gets the game configuration.
+   */
+  getConfig() {
+    return new GameConfig(this.gameConfigOpts);
+  }
+};
+
+// index.ts
+function createSlotGame(opts) {
+  return new SlotGame(opts);
+}
+var defineUserState = (data) => data;
+var defineSymbols = (symbols) => symbols;
+var defineGameModes = (gameModes) => gameModes;
+var defineReelSets = (reelSets) => reelSets;
+export {
+  ClusterWinType,
+  GameConfig,
+  GameMode,
+  GameSymbol,
+  LinesWinType,
+  ManywaysWinType,
+  OptimizationConditions,
+  OptimizationParameters,
+  OptimizationScaling,
+  ReelGenerator,
+  ResultSet,
+  StandaloneBoard,
+  WinType,
+  createSlotGame,
+  defineGameModes,
+  defineReelSets,
+  defineSymbols,
+  defineUserState,
+  weightedRandom
+};
+//# sourceMappingURL=index.mjs.map