@slot-engine/core 0.1.14 → 0.2.1

package/dist/index.mjs

@@ -1,11 +1,63 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/constants.ts
 var SPIN_TYPE = {
   BASE_GAME: "basegame",
   FREE_SPINS: "freespins"
 };
+var CLI_ARGS = {
+  RUN: "slot-engine-run"
+};
 
 // src/game-config/index.ts
 import assert from "assert";
+
+// src/utils/file-paths.ts
+import path from "path";
+function createPermanentFilePaths(basePath) {
+  return {
+    base: basePath,
+    books: (mode) => path.join(basePath, `books_${mode}.jsonl`),
+    booksIndexMeta: (mode) => path.join(basePath, `books_${mode}.index.meta.json`),
+    booksIndex: (mode, worker) => path.join(basePath, "books_chunks", `books_${mode}_${worker}.index.txt`),
+    booksChunk: (mode, worker, chunk) => path.join(
+      basePath,
+      "books_chunks",
+      `books_${mode}_chunk_${worker}-${chunk}.jsonl.zst`
+    ),
+    booksCompressed: (mode) => path.join(basePath, "publish_files", `books_${mode}.jsonl.zst`),
+    booksUncompressed: (mode) => path.join(basePath, `books_${mode}.jsonl`),
+    lookupTable: (mode) => path.join(basePath, `lookUpTable_${mode}.csv`),
+    lookupTableIndex: (mode) => path.join(basePath, `lookUpTable_${mode}.index`),
+    lookupTableSegmented: (mode) => path.join(basePath, `lookUpTableSegmented_${mode}.csv`),
+    lookupTableSegmentedIndex: (mode) => path.join(basePath, `lookUpTableSegmented_${mode}.index`),
+    lookupTablePublish: (mode) => path.join(basePath, "publish_files", `lookUpTable_${mode}_0.csv`),
+    forceRecords: (mode) => path.join(basePath, `force_record_${mode}.json`),
+    forceKeys: (mode) => path.join(basePath, `force_keys_${mode}.json`),
+    indexJson: path.join(basePath, "publish_files", "index.json"),
+    optimizationFiles: path.join(basePath, "optimization_files"),
+    publishFiles: path.join(basePath, "publish_files"),
+    simulationSummary: path.join(basePath, "simulation_summary.json"),
+    statsPayouts: path.join(basePath, "stats_payouts.json"),
+    statsSummary: path.join(basePath, "stats_summary.json")
+  };
+}
+function createTemporaryFilePaths(basePath, tempFolder) {
+  return {
+    tempBooks: (mode, i) => path.join(basePath, tempFolder, `temp_books_${mode}_${i}.jsonl`),
+    tempLookupTable: (mode, i) => path.join(basePath, tempFolder, `temp_lookup_${mode}_${i}.csv`),
+    tempLookupTableSegmented: (mode, i) => path.join(basePath, tempFolder, `temp_lookup_segmented_${mode}_${i}.csv`),
+    tempRecords: (mode) => path.join(basePath, tempFolder, `temp_records_${mode}.jsonl`)
+  };
+}
+
+// src/game-config/index.ts
+import path2 from "path";
 function createGameConfig(opts) {
   const symbols = /* @__PURE__ */ new Map();
   for (const [key, value] of Object.entries(opts.symbols)) {
@@ -15,70 +67,42 @@ function createGameConfig(opts) {
   const getAnticipationTrigger = (spinType) => {
     return Math.min(...Object.keys(opts.scatterToFreespins[spinType] || {}).map(Number)) - 1;
   };
+  const rootDir = opts.rootDir || process.cwd();
+  const outputDir = "__build__";
+  const basePath = path2.join(rootDir, outputDir);
   return {
-    padSymbols: opts.padSymbols || 1,
-    userState: opts.userState || {},
-    ...opts,
-    symbols,
-    anticipationTriggers: {
-      [SPIN_TYPE.BASE_GAME]: getAnticipationTrigger(SPIN_TYPE.BASE_GAME),
-      [SPIN_TYPE.FREE_SPINS]: getAnticipationTrigger(SPIN_TYPE.FREE_SPINS)
+    config: {
+      padSymbols: opts.padSymbols || 1,
+      userState: opts.userState || {},
+      ...opts,
+      symbols,
+      anticipationTriggers: {
+        [SPIN_TYPE.BASE_GAME]: getAnticipationTrigger(SPIN_TYPE.BASE_GAME),
+        [SPIN_TYPE.FREE_SPINS]: getAnticipationTrigger(SPIN_TYPE.FREE_SPINS)
+      }
     },
-    outputDir: "__build__",
-    rootDir: opts.rootDir || process.cwd()
+    metadata: {
+      outputDir,
+      rootDir,
+      isCustomRoot: !!opts.rootDir,
+      paths: createPermanentFilePaths(basePath)
+    }
   };
 }
 
 // src/simulation/index.ts
-import fs2 from "fs";
-import path from "path";
-import assert7 from "assert";
+import fs3 from "fs";
+import path3 from "path";
+import assert5 from "assert";
 import zlib from "zlib";
-import readline2 from "readline";
+import readline from "readline";
 import { buildSync } from "esbuild";
-import { Worker, isMainThread, parentPort, workerData } from "worker_threads";
+import { Worker, isMainThread as isMainThread2, parentPort as parentPort2, workerData } from "worker_threads";
 
 // src/result-set/index.ts
 import assert2 from "assert";
 
-// src/service/index.ts
-var AbstractService = class {
-  /**
-   * Function that returns the current game context.
-   */
-  ctx;
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-};
-
-// src/service/rng.ts
-var RngService = class extends AbstractService {
-  rng = new RandomNumberGenerator();
-  constructor(ctx) {
-    super(ctx);
-  }
-  /**
-   * Random weighted selection from a set of items.
-   */
-  weightedRandom = this.rng.weightedRandom.bind(this.rng);
-  /**
-   * Selects a random item from an array.
-   */
-  randomItem = this.rng.randomItem.bind(this.rng);
-  /**
-   * Shuffles an array.
-   */
-  shuffle = this.rng.shuffle.bind(this.rng);
-  /**
-   * Generates a random float between two values.
-   */
-  randomFloat = this.rng.randomFloat.bind(this.rng);
-  /**
-   * Sets the seed for the RNG.
-   */
-  setSeedIfDifferent = this.rng.setSeedIfDifferent.bind(this.rng);
-};
+// src/rng/index.ts
 var RandomNumberGenerator = class {
   mIdum;
   mIy;
@@ -270,10 +294,10 @@ var ResultSet = class {
     const freespinsMet = this.forceFreespins ? ctx.state.triggeredFreespins : true;
     const wallet = ctx.services.wallet._getWallet();
     const multiplierMet = this.forceMaxWin ? true : this.multiplier !== void 0 ? wallet.getCurrentWin() === this.multiplier : wallet.getCurrentWin() > 0;
-    const maxWinMet = this.forceMaxWin ? wallet.getCurrentWin() >= ctx.config.maxWinX : true;
-    const coreCriteriaMet = freespinsMet && multiplierMet && maxWinMet;
+    const respectsMaxWin = this.forceMaxWin ? wallet.getCurrentWin() >= ctx.config.maxWinX : wallet.getCurrentWin() < ctx.config.maxWinX;
+    const coreCriteriaMet = freespinsMet && multiplierMet && respectsMaxWin;
     const finalResult = customEval !== void 0 ? coreCriteriaMet && customEval === true : coreCriteriaMet;
-    if (this.forceMaxWin && maxWinMet) {
+    if (this.forceMaxWin && respectsMaxWin) {
       ctx.services.data.record({
         maxwin: true
       });
@@ -308,13 +332,34 @@ function createGameState(opts) {
 // src/recorder/index.ts
 var Recorder = class {
   records;
+  recordsMap;
   pendingRecords;
   constructor() {
     this.records = [];
+    this.recordsMap = /* @__PURE__ */ new Map();
+    this.pendingRecords = [];
+  }
+  /**
+   * Intended for internal use only.
+   */
+  _reset() {
+    this.records = [];
+    this.recordsMap.clear();
     this.pendingRecords = [];
   }
 };
 
+// src/service/index.ts
+var AbstractService = class {
+  /**
+   * Function that returns the current game context.
+   */
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+};
+
 // src/board/index.ts
 import assert3 from "assert";
 
@@ -903,19 +948,13 @@ var BoardService = class extends AbstractService {
 };
 
 // src/service/data.ts
-import assert4 from "assert";
+import { isMainThread, parentPort } from "worker_threads";
 var DataService = class extends AbstractService {
   recorder;
   book;
   constructor(ctx) {
     super(ctx);
   }
-  ensureRecorder() {
-    assert4(this.recorder, "Recorder not set in DataService. Call setRecorder() first.");
-  }
-  ensureBook() {
-    assert4(this.book, "Book not set in DataService. Call setBook() first.");
-  }
   /**
    * Intended for internal use only.
    */
@@ -944,14 +983,12 @@ var DataService = class extends AbstractService {
    * Intended for internal use only.
    */
   _getRecords() {
-    this.ensureRecorder();
     return this.recorder.records;
   }
   /**
    * Record data for statistical analysis.
    */
   record(data) {
-    this.ensureRecorder();
     this.recorder.pendingRecords.push({
       bookId: this.ctx().state.currentSimulationId,
       properties: Object.fromEntries(
@@ -971,14 +1008,19 @@ var DataService = class extends AbstractService {
    * Adds an event to the book.
    */
   addBookEvent(event) {
-    this.ensureBook();
     this.book.addEvent(event);
   }
+  /**
+   * Write a log message to the terminal UI.
+   */
+  log(message) {
+    if (isMainThread) return;
+    parentPort?.postMessage({ type: "user-log", message });
+  }
   /**
    * Intended for internal use only.
    */
   _clearPendingRecords() {
-    this.ensureRecorder();
     this.recorder.pendingRecords = [];
   }
 };
@@ -1119,21 +1161,44 @@ var GameService = class extends AbstractService {
   }
 };
 
+// src/service/rng.ts
+var RngService = class extends AbstractService {
+  rng = new RandomNumberGenerator();
+  constructor(ctx) {
+    super(ctx);
+  }
+  /**
+   * Random weighted selection from a set of items.
+   */
+  weightedRandom = this.rng.weightedRandom.bind(this.rng);
+  /**
+   * Selects a random item from an array.
+   */
+  randomItem = this.rng.randomItem.bind(this.rng);
+  /**
+   * Shuffles an array.
+   */
+  shuffle = this.rng.shuffle.bind(this.rng);
+  /**
+   * Generates a random float between two values.
+   */
+  randomFloat = this.rng.randomFloat.bind(this.rng);
+  /**
+   * Sets the seed for the RNG.
+   */
+  setSeedIfDifferent = this.rng.setSeedIfDifferent.bind(this.rng);
+};
+
 // src/service/wallet.ts
-import assert5 from "assert";
 var WalletService = class extends AbstractService {
   wallet;
   constructor(ctx) {
     super(ctx);
   }
-  ensureWallet() {
-    assert5(this.wallet, "Wallet not set in WalletService. Call setWallet() first.");
-  }
   /**
    * Intended for internal use only.
    */
   _getWallet() {
-    this.ensureWallet();
     return this.wallet;
   }
   /**
@@ -1149,7 +1214,6 @@ var WalletService = class extends AbstractService {
    * If your game has tumbling mechanics, you should call this method again after every new tumble and win calculation.
    */
   addSpinWin(amount) {
-    this.ensureWallet();
     this.wallet.addSpinWin(amount);
   }
   /**
@@ -1158,7 +1222,6 @@ var WalletService = class extends AbstractService {
    * This also calls `addSpinWin()` internally, to add the tumble win to the overall spin win.
    */
   addTumbleWin(amount) {
-    this.ensureWallet();
     this.wallet.addTumbleWin(amount);
   }
   /**
@@ -1168,28 +1231,24 @@ var WalletService = class extends AbstractService {
    * and after a (free) spin is played out to finalize the win.
    */
   confirmSpinWin() {
-    this.ensureWallet();
     this.wallet.confirmSpinWin(this.ctx().state.currentSpinType);
   }
   /**
    * Gets the total win amount of the current simulation.
    */
   getCurrentWin() {
-    this.ensureWallet();
     return this.wallet.getCurrentWin();
   }
   /**
    * Gets the current spin win amount of the ongoing spin.
    */
   getCurrentSpinWin() {
-    this.ensureWallet();
     return this.wallet.getCurrentSpinWin();
   }
   /**
    * Gets the current tumble win amount of the ongoing spin.
    */
   getCurrentTumbleWin() {
-    this.ensureWallet();
     return this.wallet.getCurrentTumbleWin();
   }
 };
@@ -1218,7 +1277,6 @@ function createGameContext(opts) {
 
 // utils.ts
 import fs from "fs";
-import readline from "readline";
 function createDirIfNotExists(dirPath) {
   if (!fs.existsSync(dirPath)) {
     fs.mkdirSync(dirPath, { recursive: true });
@@ -1243,37 +1301,6 @@ function writeFile(filePath, data) {
 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));
-  }
-  static async convertToJson(inputPath, outputPath) {
-    const writeStream = fs.createWriteStream(outputPath, { encoding: "utf-8" });
-    writeStream.write("[\n");
-    const rl = readline.createInterface({
-      input: fs.createReadStream(inputPath),
-      crlfDelay: Infinity
-    });
-    let isFirst = true;
-    for await (const line of rl) {
-      if (line.trim() === "") continue;
-      if (!isFirst) {
-        writeStream.write(",\n");
-      }
-      writeStream.write(line);
-      isFirst = false;
-    }
-    writeStream.write("\n]");
-    writeStream.end();
-    return new Promise((resolve, reject) => {
-      writeStream.on("finish", () => resolve());
-      writeStream.on("error", reject);
-    });
-  }
-};
 function round(value, decimals) {
   return Number(Math.round(Number(value + "e" + decimals)) + "e-" + decimals);
 }
@@ -1293,16 +1320,26 @@ var Book = class {
   /**
    * Intended for internal use only.
    */
-  setCriteria(criteria) {
+  _reset(id, criteria) {
+    this.id = id;
+    this.criteria = criteria;
+    this.events = [];
+    this.payout = 0;
+    this.basegameWins = 0;
+    this.freespinsWins = 0;
+  }
+  /**
+   * Intended for internal use only.
+   */
+  _setCriteria(criteria) {
     this.criteria = criteria;
   }
   /**
    * Adds an event to the book.
    */
   addEvent(event) {
-    const index = this.events.length + 1;
     this.events.push({
-      index,
+      index: this.events.length + 1,
       type: event.type,
       data: copy(event.data)
     });
@@ -1310,7 +1347,7 @@ var Book = class {
   /**
    * Intended for internal use only.
    */
-  serialize() {
+  _serialize() {
     return {
       id: this.id,
       criteria: this.criteria,
@@ -1375,6 +1412,23 @@ var Wallet = class {
   currentTumbleWin = 0;
   constructor() {
   }
+  /**
+   * Intended for internal use only.
+   */
+  _reset() {
+    this.cumulativeWins = 0;
+    this.cumulativeWinsPerSpinType = {
+      [SPIN_TYPE.BASE_GAME]: 0,
+      [SPIN_TYPE.FREE_SPINS]: 0
+    };
+    this.currentWin = 0;
+    this.currentWinPerSpinType = {
+      [SPIN_TYPE.BASE_GAME]: 0,
+      [SPIN_TYPE.FREE_SPINS]: 0
+    };
+    this.currentSpinWin = 0;
+    this.currentTumbleWin = 0;
+  }
   /**
    * Updates the win for the current spin.
    *
@@ -1547,7 +1601,9 @@ var Wallet = class {
 import { pipeline } from "stream/promises";
 
 // src/simulation/utils.ts
-import assert6 from "assert";
+import fs2 from "fs";
+import assert4 from "assert";
+import chalk from "chalk";
 function hashStringToInt(input) {
   let h = 2166136261;
   for (let i = 0; i < input.length; i++) {
@@ -1560,7 +1616,7 @@ function splitCountsAcrossChunks(totalCounts, chunkSizes) {
   const total = chunkSizes.reduce((a, b) => a + b, 0);
   const allCriteria = Object.keys(totalCounts);
   const totalCountsSum = allCriteria.reduce((s, c) => s + (totalCounts[c] ?? 0), 0);
-  assert6(
+  assert4(
     totalCountsSum === total,
     `Counts (${totalCountsSum}) must match chunk total (${total}).`
   );
@@ -1593,9 +1649,9 @@ function splitCountsAcrossChunks(totalCounts, chunkSizes) {
   for (let target = 0; target < chunkSizes.length; target++) {
     while (deficits[target] > 0) {
       const src = deficits.findIndex((d) => d < 0);
-      assert6(src !== -1, "No surplus chunk found, but deficits remain.");
+      assert4(src !== -1, "No surplus chunk found, but deficits remain.");
       const crit = allCriteria.find((c) => (perChunk[src][c] ?? 0) > 0);
-      assert6(crit, `No movable criteria found from surplus chunk ${src}.`);
+      assert4(crit, `No movable criteria found from surplus chunk ${src}.`);
       perChunk[src][crit] -= 1;
       perChunk[target][crit] = (perChunk[target][crit] ?? 0) + 1;
       totals[src] -= 1;
@@ -1606,14 +1662,14 @@ function splitCountsAcrossChunks(totalCounts, chunkSizes) {
   }
   totals = chunkTotals();
   for (let i = 0; i < chunkSizes.length; i++) {
-    assert6(
+    assert4(
       totals[i] === chunkSizes[i],
       `Chunk ${i} size mismatch. Expected ${chunkSizes[i]}, got ${totals[i]}`
     );
   }
   for (const c of allCriteria) {
     const sum = perChunk.reduce((s, m) => s + (m[c] ?? 0), 0);
-    assert6(sum === (totalCounts[c] ?? 0), `Chunk split mismatch for criteria "${c}"`);
+    assert4(sum === (totalCounts[c] ?? 0), `Chunk split mismatch for criteria "${c}"`);
   }
   return perChunk;
 }
@@ -1644,8 +1700,306 @@ function createCriteriaSampler(counts, seed) {
     return keys.find((k) => (remaining[k] ?? 0) > 0) ?? "N/A";
   };
 }
+async function makeLutIndexFromPublishLut(lutPublishPath, lutIndexPath) {
+  console.log(chalk.gray(`Regenerating LUT index file...`));
+  if (!fs2.existsSync(lutPublishPath)) {
+    console.warn(
+      chalk.yellow(
+        `LUT publish file does not exist when regenerating index file: ${lutPublishPath}`
+      )
+    );
+    return;
+  }
+  try {
+    const lutPublishStream = fs2.createReadStream(lutPublishPath, {
+      highWaterMark: 500 * 1024 * 1024
+    });
+    const rl = __require("readline").createInterface({
+      input: lutPublishStream,
+      crlfDelay: Infinity
+    });
+    const lutIndexStream = fs2.createWriteStream(lutIndexPath, {
+      highWaterMark: 500 * 1024 * 1024
+    });
+    let offset = 0n;
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      const indexBuffer = Buffer.alloc(8);
+      indexBuffer.writeBigUInt64LE(offset);
+      if (!lutIndexStream.write(indexBuffer)) {
+        await new Promise((resolve) => lutIndexStream.once("drain", resolve));
+      }
+      offset += BigInt(Buffer.byteLength(line + "\n", "utf8"));
+    }
+    lutIndexStream.end();
+    await new Promise((resolve) => lutIndexStream.on("finish", resolve));
+  } catch (error) {
+    throw new Error(`Error generating LUT index from publish LUT: ${error}`);
+  }
+}
 
 // src/simulation/index.ts
+import { io } from "socket.io-client";
+import chalk2 from "chalk";
+
+// src/tui/index.ts
+var TerminalUi = class {
+  progress = 0;
+  timeRemaining = 0;
+  gameMode;
+  currentSims = 0;
+  totalSims = 0;
+  logs = [];
+  logScrollOffset = 0;
+  isScrolled = false;
+  maxLogs = 500;
+  totalLogs = 0;
+  minWidth = 50;
+  minHeight = 12;
+  isRendering = false;
+  renderInterval = null;
+  resizeHandler;
+  sigintHandler;
+  keyHandler;
+  constructor(opts) {
+    this.gameMode = opts.gameMode;
+    this.resizeHandler = () => {
+      this.clearScreen();
+      this.render();
+    };
+    this.sigintHandler = () => {
+      this.stop();
+      process.exit(0);
+    };
+    this.keyHandler = (data) => {
+      const key = data.toString();
+      if (key === "j" || key === "\x1B[A") {
+        this.scrollUp();
+      } else if (key === "k" || key === "\x1B[B") {
+        this.scrollDown();
+      } else if (key === "l") {
+        this.scrollToBottom();
+      } else if (key === "q" || key === "") {
+        this.stop();
+        process.exit(0);
+      }
+    };
+    process.stdout.on("resize", this.resizeHandler);
+    process.on("SIGINT", this.sigintHandler);
+  }
+  get terminalWidth() {
+    return process.stdout.columns || 80;
+  }
+  get terminalHeight() {
+    return process.stdout.rows || 24;
+  }
+  get isTooSmall() {
+    return this.terminalWidth < this.minWidth || this.terminalHeight < this.minHeight;
+  }
+  start() {
+    this.enterAltScreen();
+    this.hideCursor();
+    this.clearScreen();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on("data", this.keyHandler);
+    }
+    this.render();
+    this.renderInterval = setInterval(() => this.render(), 100);
+  }
+  stop() {
+    if (this.renderInterval) {
+      clearInterval(this.renderInterval);
+      this.renderInterval = null;
+    }
+    if (process.stdin.isTTY) {
+      process.stdin.off("data", this.keyHandler);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    this.showCursor();
+    this.clearScreen();
+    this.exitAltScreen();
+    process.stdout.off("resize", this.resizeHandler);
+    process.off("SIGINT", this.sigintHandler);
+  }
+  setProgress(progress, timeRemaining, completedSims) {
+    this.progress = Math.max(0, Math.min(100, progress));
+    this.timeRemaining = Math.max(0, timeRemaining);
+    this.currentSims = completedSims;
+  }
+  setDetails(opts) {
+    this.gameMode = opts.gameMode;
+    this.totalSims = opts.totalSims;
+  }
+  log(message) {
+    this.logs.push({ i: this.totalLogs, m: message });
+    this.totalLogs++;
+    if (this.logs.length > this.maxLogs) {
+      const excess = this.logs.length - this.maxLogs;
+      this.logs.splice(0, excess);
+      this.logScrollOffset = Math.min(
+        this.logScrollOffset,
+        Math.max(0, this.logs.length - this.getLogAreaHeight())
+      );
+    }
+    if (!this.isScrolled) this.scrollToBottom();
+  }
+  scrollUp(lines = 1) {
+    this.logScrollOffset = Math.max(0, this.logScrollOffset - lines);
+    this.isScrolled = true;
+  }
+  scrollDown(lines = 1) {
+    const maxOffset = Math.max(0, this.logs.length - this.getLogAreaHeight());
+    this.logScrollOffset = Math.min(maxOffset, this.logScrollOffset + lines);
+    if (this.logScrollOffset >= maxOffset) {
+      this.isScrolled = false;
+    }
+  }
+  scrollToBottom() {
+    const maxOffset = Math.max(0, this.logs.length - this.getLogAreaHeight());
+    this.logScrollOffset = maxOffset;
+    this.isScrolled = false;
+  }
+  clearLogs() {
+    this.logs = [];
+    this.logScrollOffset = 0;
+  }
+  getLogAreaHeight() {
+    return Math.max(1, this.terminalHeight - 8);
+  }
+  enterAltScreen() {
+    process.stdout.write("\x1B[?1049h");
+  }
+  exitAltScreen() {
+    process.stdout.write("\x1B[?1049l");
+  }
+  hideCursor() {
+    process.stdout.write("\x1B[?25l");
+  }
+  showCursor() {
+    process.stdout.write("\x1B[?25h");
+  }
+  clearScreen() {
+    process.stdout.write("\x1B[2J\x1B[H");
+  }
+  moveTo(row, col) {
+    process.stdout.write(`\x1B[${row};${col}H`);
+  }
+  render() {
+    if (this.isRendering) return;
+    this.isRendering = true;
+    try {
+      this.moveTo(1, 1);
+      if (this.isTooSmall) {
+        this.clearScreen();
+        let msg = "Terminal too small.";
+        let row = Math.floor(this.terminalHeight / 2);
+        let col = Math.max(1, Math.floor((this.terminalWidth - msg.length) / 2));
+        this.moveTo(row, col);
+        process.stdout.write(msg);
+        msg = "Try resizing or restarting the terminal.";
+        row += 1;
+        col = Math.max(1, Math.floor((this.terminalWidth - msg.length) / 2));
+        this.moveTo(row, col);
+        process.stdout.write(msg);
+        return;
+      }
+      const lines = [];
+      const width = this.terminalWidth;
+      lines.push(this.boxLine("top", width));
+      const canScrollUp = this.logScrollOffset > 0;
+      const topHint = canScrollUp ? "\u2191 scroll up (j)" : "";
+      lines.push(this.contentLine(this.centerText(topHint, width - 2), width));
+      const logAreaHeight = this.getLogAreaHeight();
+      const visibleLogs = this.getVisibleLogs(logAreaHeight);
+      for (const log of visibleLogs) {
+        lines.push(
+          this.contentLine(` (${log.i}) ` + this.truncate(log.m, width - 4), width)
+        );
+      }
+      for (let i = visibleLogs.length; i < logAreaHeight; i++) {
+        lines.push(this.contentLine("", width));
+      }
+      const canScrollDown = this.logScrollOffset < Math.max(0, this.logs.length - logAreaHeight);
+      const bottomHint = canScrollDown ? "\u2193 scroll down (k) \u2193 jump to newest (l)" : "";
+      lines.push(this.contentLine(this.centerText(bottomHint, width - 2), width));
+      lines.push(this.boxLine("middle", width));
+      const modeText = `Mode: ${this.gameMode}`;
+      const simsText = `${this.currentSims}/${this.totalSims}`;
+      const infoLine = this.createInfoLine(modeText, simsText, width);
+      lines.push(infoLine);
+      lines.push(this.boxLine("middle", width));
+      lines.push(this.createProgressLine(width));
+      lines.push(this.boxLine("bottom", width));
+      this.moveTo(1, 1);
+      process.stdout.write(lines.join("\n"));
+    } finally {
+      this.isRendering = false;
+    }
+  }
+  getVisibleLogs(height) {
+    const start = this.logScrollOffset;
+    const end = start + height;
+    return this.logs.slice(start, end);
+  }
+  boxLine(type, width) {
+    const chars = {
+      top: { left: "\u250C", right: "\u2510", fill: "\u2500" },
+      middle: { left: "\u251C", right: "\u2524", fill: "\u2500" },
+      bottom: { left: "\u2514", right: "\u2518", fill: "\u2500" }
+    };
+    const c = chars[type];
+    return c.left + c.fill.repeat(width - 2) + c.right;
+  }
+  contentLine(content, width) {
+    const innerWidth = width - 2;
+    const paddedContent = content.padEnd(innerWidth).slice(0, innerWidth);
+    return "\u2502" + paddedContent + "\u2502";
+  }
+  createInfoLine(left, right, width) {
+    const innerWidth = width - 2;
+    const separator = " \u2502 ";
+    const availableForText = innerWidth - separator.length;
+    const leftWidth = Math.floor(availableForText / 2);
+    const rightWidth = availableForText - leftWidth;
+    const leftTruncated = this.truncate(left, leftWidth);
+    const rightTruncated = this.truncate(right, rightWidth);
+    const leftPadded = this.centerText(leftTruncated, leftWidth);
+    const rightPadded = this.centerText(rightTruncated, rightWidth);
+    return "\u2502" + leftPadded + separator + rightPadded + "\u2502";
+  }
+  createProgressLine(width) {
+    const innerWidth = width - 2;
+    const timeStr = this.formatTime(this.timeRemaining);
+    const percentStr = `${this.progress.toFixed(2)}%`;
+    const rightInfo = `${timeStr}  ${percentStr}`;
+    const barWidth = Math.max(10, innerWidth - rightInfo.length - 3);
+    const filledWidth = Math.round(this.progress / 100 * barWidth);
+    const emptyWidth = barWidth - filledWidth;
+    const bar = "\u2588".repeat(filledWidth) + "-".repeat(emptyWidth);
+    const content = ` ${bar} ${rightInfo}`;
+    return this.contentLine(content, width);
+  }
+  formatTime(seconds) {
+    return new Date(seconds * 1e3).toISOString().substr(11, 8);
+  }
+  centerText(text, width) {
+    if (text.length >= width) return text.slice(0, width);
+    const padding = width - text.length;
+    const leftPad = Math.floor(padding / 2);
+    const rightPad = padding - leftPad;
+    return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+  }
+  truncate(text, maxLength) {
+    if (text.length <= maxLength) return text;
+    return text.slice(0, maxLength - 3) + "...";
+  }
+};
+
+// src/simulation/index.ts
+import { Readable } from "stream";
 var completedSimulations = 0;
 var TEMP_FILENAME = "__temp_compiled_src_IGNORE.js";
 var TEMP_FOLDER = "temp_files";
@@ -1654,70 +2008,114 @@ var Simulation = class {
   gameConfig;
   simRunsAmount;
   concurrency;
+  makeUncompressedBooks;
   debug = false;
   actualSims = 0;
-  wallet;
+  wallet = new Wallet();
+  summary = {};
   recordsWriteStream;
   hasWrittenRecord = false;
   streamHighWaterMark = 500 * 1024 * 1024;
   maxPendingSims;
   maxHighWaterMark;
+  panelPort = 7770;
+  panelActive = false;
+  panelWsUrl;
+  socket;
+  tui;
+  tempBookIndexPaths = [];
+  bookIndexMetas = [];
   PATHS = {};
   // Worker related
   credits = 0;
   creditWaiters = [];
   creditListenerInit = false;
+  bookBuffers = /* @__PURE__ */ new Map();
+  bookBufferSizes = /* @__PURE__ */ new Map();
+  bookChunkIndexes = /* @__PURE__ */ new Map();
   constructor(opts, gameConfigOpts) {
-    this.gameConfig = createGameConfig(gameConfigOpts);
+    const { config, metadata } = createGameConfig(gameConfigOpts);
+    this.gameConfig = { ...config, ...metadata };
     this.gameConfigOpts = gameConfigOpts;
+    this.makeUncompressedBooks = opts.makeUncompressedBooks || false;
     this.simRunsAmount = opts.simRunsAmount || {};
     this.concurrency = (opts.concurrency || 6) >= 2 ? opts.concurrency || 6 : 2;
-    this.wallet = new Wallet();
-    this.maxPendingSims = Math.max(10, opts.maxPendingSims ?? 250);
-    this.maxHighWaterMark = (opts.maxDiskBuffer ?? 50) * 1024 * 1024;
+    this.maxPendingSims = opts.maxPendingSims ?? 25;
+    this.maxHighWaterMark = (opts.maxDiskBuffer ?? 150) * 1024 * 1024;
     const gameModeKeys = Object.keys(this.gameConfig.gameModes);
-    assert7(
+    assert5(
       Object.values(this.gameConfig.gameModes).map((m) => gameModeKeys.includes(m.name)).every((v) => v === true),
       "Game mode name must match its key in the gameModes object."
     );
-    this.PATHS.base = path.join(this.gameConfig.rootDir, this.gameConfig.outputDir);
+    const basePath = path3.join(this.gameConfig.rootDir, this.gameConfig.outputDir);
     this.PATHS = {
-      ...this.PATHS,
-      books: (mode) => path.join(this.PATHS.base, `books_${mode}.jsonl`),
-      booksCompressed: (mode) => path.join(this.PATHS.base, "publish_files", `books_${mode}.jsonl.zst`),
-      tempBooks: (mode, i) => path.join(this.PATHS.base, TEMP_FOLDER, `temp_books_${mode}_${i}.jsonl`),
-      lookupTable: (mode) => path.join(this.PATHS.base, `lookUpTable_${mode}.csv`),
-      tempLookupTable: (mode, i) => path.join(this.PATHS.base, TEMP_FOLDER, `temp_lookup_${mode}_${i}.csv`),
-      lookupTableSegmented: (mode) => path.join(this.PATHS.base, `lookUpTableSegmented_${mode}.csv`),
-      tempLookupTableSegmented: (mode, i) => path.join(this.PATHS.base, TEMP_FOLDER, `temp_lookup_segmented_${mode}_${i}.csv`),
-      lookupTablePublish: (mode) => path.join(this.PATHS.base, "publish_files", `lookUpTable_${mode}_0.csv`),
-      tempRecords: (mode) => path.join(this.PATHS.base, TEMP_FOLDER, `temp_records_${mode}.jsonl`),
-      forceRecords: (mode) => path.join(this.PATHS.base, `force_record_${mode}.json`),
-      indexJson: path.join(this.PATHS.base, "publish_files", "index.json"),
-      optimizationFiles: path.join(this.PATHS.base, "optimization_files"),
-      publishFiles: path.join(this.PATHS.base, "publish_files")
+      ...createPermanentFilePaths(basePath),
+      ...createTemporaryFilePaths(basePath, TEMP_FOLDER)
     };
+    this.tui = new TerminalUi({
+      gameMode: "N/A"
+    });
   }
   async runSimulation(opts) {
     const debug = opts.debug || false;
     this.debug = debug;
+    let statusMessage = "";
     const gameModesToSimulate = Object.keys(this.simRunsAmount);
     const configuredGameModes = Object.keys(this.gameConfig.gameModes);
     if (gameModesToSimulate.length === 0) {
       throw new Error("No game modes configured for simulation.");
     }
     this.generateReelsetFiles();
-    if (isMainThread) {
+    if (isMainThread2) {
       this.preprocessFiles();
-      const debugDetails = {};
+      this.panelPort = opts.panelPort || 7770;
+      this.panelWsUrl = `http://localhost:${this.panelPort}`;
+      await new Promise((resolve) => {
+        try {
+          this.socket = io(this.panelWsUrl, {
+            path: "/ws",
+            transports: ["websocket", "polling"],
+            withCredentials: true,
+            autoConnect: false,
+            reconnection: false
+          });
+          this.socket.connect();
+          this.socket.once("connect", () => {
+            this.panelActive = true;
+            resolve();
+          });
+          this.socket.once("connect_error", () => {
+            this.socket?.close();
+            this.socket = void 0;
+            resolve();
+          });
+        } catch (error) {
+          this.socket = void 0;
+          resolve();
+        }
+      });
+      this.tui?.start();
+      fs3.rmSync(path3.join(this.PATHS.base, "books_chunks"), {
+        recursive: true,
+        force: true
+      });
       for (const mode of gameModesToSimulate) {
         completedSimulations = 0;
         this.wallet = new Wallet();
+        this.tui?.setDetails({
+          gameMode: mode,
+          totalSims: this.simRunsAmount[mode] || 0
+        });
         this.hasWrittenRecord = false;
-        debugDetails[mode] = {};
-        console.log(`
-Simulating game mode: ${mode}`);
-        console.time(mode);
+        this.bookIndexMetas = [];
+        this.tempBookIndexPaths = [];
+        this.bookChunkIndexes = /* @__PURE__ */ new Map();
+        this.bookBuffers = /* @__PURE__ */ new Map();
+        this.bookBufferSizes = /* @__PURE__ */ new Map();
+        const startTime = Date.now();
+        statusMessage = `Simulating mode "${mode}" with ${this.simRunsAmount[mode]} runs.`;
+        this.tui?.log(statusMessage);
+        this.sendSimulationStatus(statusMessage);
         const runs = this.simRunsAmount[mode] || 0;
         if (runs <= 0) continue;
         if (!configuredGameModes.includes(mode)) {
@@ -1725,16 +2123,19 @@ Simulating game mode: ${mode}`);
             `Tried to simulate game mode "${mode}", but it's not configured in the game config.`
           );
         }
-        const booksPath = this.PATHS.books(mode);
+        this.summary[mode] = {
+          total: { numSims: runs, bsWins: 0, fsWins: 0, rtp: 0 },
+          criteria: {}
+        };
         const tempRecordsPath = this.PATHS.tempRecords(mode);
         createDirIfNotExists(this.PATHS.base);
-        createDirIfNotExists(path.join(this.PATHS.base, TEMP_FOLDER));
-        this.recordsWriteStream = fs2.createWriteStream(tempRecordsPath, {
+        createDirIfNotExists(path3.join(this.PATHS.base, TEMP_FOLDER));
+        this.recordsWriteStream = fs3.createWriteStream(tempRecordsPath, {
           highWaterMark: this.maxHighWaterMark
         }).setMaxListeners(30);
         const criteriaCounts = ResultSet.getNumberOfSimsForCriteria(this, mode);
         const totalSims = Object.values(criteriaCounts).reduce((a, b) => a + b, 0);
-        assert7(
+        assert5(
           totalSims === runs,
           `Criteria mismatch for mode "${mode}". Expected ${runs}, got ${totalSims}`
         );
@@ -1749,46 +2150,52 @@ Simulating game mode: ${mode}`);
         });
         createDirIfNotExists(this.PATHS.optimizationFiles);
         createDirIfNotExists(this.PATHS.publishFiles);
-        console.log(
-          `Writing final files for game mode "${mode}". This may take a while...`
+        statusMessage = `Writing final files for game mode "${mode}". This may take a while...`;
+        this.tui?.log(statusMessage);
+        this.sendSimulationStatus(statusMessage);
+        writeFile(
+          this.PATHS.booksIndexMeta(mode),
+          JSON.stringify(
+            this.bookIndexMetas.sort((a, b) => a.worker - b.worker),
+            null,
+            2
+          )
         );
+        const booksPath = this.PATHS.booksCompressed(mode);
         try {
-          const finalBookStream = fs2.createWriteStream(booksPath, {
+          const finalBookStream = fs3.createWriteStream(booksPath, {
             highWaterMark: this.streamHighWaterMark
           });
-          let isFirstChunk = true;
-          for (let i = 0; i < chunks.length; i++) {
-            const tempBookPath = this.PATHS.tempBooks(mode, i);
-            if (fs2.existsSync(tempBookPath)) {
-              if (!isFirstChunk) {
-                if (!finalBookStream.write("\n")) {
-                  await new Promise((r) => finalBookStream.once("drain", r));
-                }
+          for (const { worker, chunks: chunks2 } of this.bookIndexMetas) {
+            for (let chunk = 0; chunk < chunks2; chunk++) {
+              const bookChunkPath = this.PATHS.booksChunk(mode, worker, chunk);
+              if (!fs3.existsSync(bookChunkPath)) continue;
+              const chunkData = fs3.readFileSync(bookChunkPath);
+              if (!finalBookStream.write(chunkData)) {
+                await new Promise((r) => finalBookStream.once("drain", () => r()));
               }
-              const content = fs2.createReadStream(tempBookPath);
-              for await (const chunk of content) {
-                if (!finalBookStream.write(chunk)) {
-                  await new Promise((r) => finalBookStream.once("drain", r));
-                }
-              }
-              fs2.rmSync(tempBookPath);
-              isFirstChunk = false;
             }
           }
           finalBookStream.end();
-          await new Promise((resolve) => finalBookStream.on("finish", resolve));
+          await new Promise((r) => finalBookStream.on("finish", () => r()));
         } catch (error) {
           throw new Error(`Error merging book files: ${error.message}`);
         }
         const lutPath = this.PATHS.lookupTable(mode);
         const lutPathPublish = this.PATHS.lookupTablePublish(mode);
         const lutSegmentedPath = this.PATHS.lookupTableSegmented(mode);
-        await this.mergeCsv(chunks, lutPath, (i) => `temp_lookup_${mode}_${i}.csv`);
-        fs2.copyFileSync(lutPath, lutPathPublish);
+        await this.mergeCsv(
+          chunks,
+          lutPath,
+          (i) => `temp_lookup_${mode}_${i}.csv`,
+          this.PATHS.lookupTableIndex(mode)
+        );
+        fs3.copyFileSync(lutPath, lutPathPublish);
         await this.mergeCsv(
           chunks,
           lutSegmentedPath,
-          (i) => `temp_lookup_segmented_${mode}_${i}.csv`
+          (i) => `temp_lookup_segmented_${mode}_${i}.csv`,
+          this.PATHS.lookupTableSegmentedIndex(mode)
         );
         if (this.recordsWriteStream) {
           await new Promise((resolve) => {
@@ -1799,29 +2206,52 @@ Simulating game mode: ${mode}`);
           this.recordsWriteStream = void 0;
         }
         await this.writeRecords(mode);
-        await this.writeBooksJson(mode);
         this.writeIndexJson();
-        console.log(`Mode ${mode} done!`);
-        debugDetails[mode].rtp = round(
-          this.wallet.getCumulativeWins() / (runs * this.gameConfig.gameModes[mode].cost),
-          3
-        );
-        debugDetails[mode].wins = round(this.wallet.getCumulativeWins(), 3);
-        debugDetails[mode].winsPerSpinType = Object.fromEntries(
-          Object.entries(this.wallet.getCumulativeWinsPerSpinType()).map(([k, v]) => [
-            k,
-            round(v, 3)
-          ])
-        );
-        console.timeEnd(mode);
+        if (this.makeUncompressedBooks) {
+          statusMessage = `Creating decompressed book file for mode "${mode}". This may take a while...`;
+          this.tui?.log(statusMessage);
+          this.sendSimulationStatus(statusMessage);
+          const uncompressedBooksPath = this.PATHS.booksUncompressed(mode);
+          const outputStream = fs3.createWriteStream(uncompressedBooksPath, {
+            highWaterMark: this.streamHighWaterMark
+          });
+          try {
+            for (const { worker, chunks: chunks2 } of this.bookIndexMetas) {
+              for (let chunk = 0; chunk < chunks2; chunk++) {
+                const bookChunkPath = this.PATHS.booksChunk(mode, worker, chunk);
+                if (!fs3.existsSync(bookChunkPath)) continue;
+                const inputStream = fs3.createReadStream(bookChunkPath);
+                const compress = zlib.createZstdDecompress();
+                for await (const decompChunk of inputStream.pipe(compress)) {
+                  if (!outputStream.write(decompChunk)) {
+                    await new Promise((r) => outputStream.once("drain", () => r()));
+                  }
+                }
+              }
+            }
+            outputStream.end();
+            await new Promise((r) => outputStream.on("finish", () => r()));
+          } catch (error) {
+            statusMessage = chalk2.yellow(
+              `Error creating uncompressed book file: ${error.message}`
+            );
+            this.tui?.log(statusMessage);
+            this.sendSimulationStatus(statusMessage);
+          }
+        }
+        const endTime = Date.now();
+        const prettyTime = new Date(endTime - startTime).toISOString().slice(11, -1);
+        statusMessage = `Mode ${mode} done! Time taken: ${prettyTime}`;
+        this.tui?.log(statusMessage);
+        this.sendSimulationStatus(statusMessage);
       }
-      console.log("\n=== SIMULATION SUMMARY ===");
-      console.table(debugDetails);
+      this.tui?.stop();
+      await this.printSimulationSummary();
     }
     let desiredSims = 0;
     let actualSims = 0;
     const criteriaToRetries = {};
-    if (!isMainThread) {
+    if (!isMainThread2) {
       const { mode, simStart, simEnd, index, criteriaCounts } = workerData;
       const seed = hashStringToInt(mode) + index >>> 0;
       const nextCriteria = createCriteriaSampler(criteriaCounts, seed);
@@ -1836,16 +2266,16 @@ Simulating game mode: ${mode}`);
           actualSims += this.actualSims;
         }
       }
-      if (this.debug) {
-        console.log(`Desired ${desiredSims}, Actual ${actualSims}`);
-        console.log(`Retries per criteria:`, criteriaToRetries);
-      }
-      parentPort?.postMessage({
+      parentPort2?.postMessage({
         type: "done",
         workerNum: index
       });
-      parentPort?.removeAllListeners();
-      parentPort?.close();
+      parentPort2?.removeAllListeners();
+      parentPort2?.close();
+    }
+    if (this.socket && this.panelActive) {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      this.socket?.close();
     }
   }
   /**
@@ -1853,39 +2283,36 @@ Simulating game mode: ${mode}`);
    */
   async spawnWorkersForGameMode(opts) {
     const { mode, chunks, chunkCriteriaCounts, totalSims } = opts;
-    await Promise.all(
-      chunks.map(([simStart, simEnd], index) => {
-        return this.callWorker({
-          basePath: this.PATHS.base,
-          mode,
-          simStart,
-          simEnd,
-          index,
-          totalSims,
-          criteriaCounts: chunkCriteriaCounts[index]
-        });
-      })
-    );
+    try {
+      await Promise.all(
+        chunks.map(([simStart, simEnd], index) => {
+          return this.callWorker({
+            basePath: this.PATHS.base,
+            mode,
+            simStart,
+            simEnd,
+            index,
+            totalSims,
+            criteriaCounts: chunkCriteriaCounts[index]
+          });
+        })
+      );
+    } catch (error) {
+      this.tui?.stop();
+      throw error;
+    }
   }
   async callWorker(opts) {
     const { mode, simEnd, simStart, basePath, index, totalSims, criteriaCounts } = 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");
-      }
-    }
     const write = async (stream, chunk) => {
       if (!stream.write(chunk)) {
         await new Promise((resolve) => stream.once("drain", resolve));
       }
     };
     return new Promise((resolve, reject) => {
-      const scriptPath = path.join(basePath, TEMP_FILENAME);
+      const scriptPath = path3.join(basePath, TEMP_FILENAME);
+      createDirIfNotExists(path3.join(this.PATHS.base, "books_chunks"));
+      const startTime = Date.now();
       const worker = new Worker(scriptPath, {
         workerData: {
           mode,
@@ -1896,50 +2323,137 @@ Simulating game mode: ${mode}`);
         }
       });
       worker.postMessage({ type: "credit", amount: this.maxPendingSims });
-      const tempBookPath = this.PATHS.tempBooks(mode, index);
-      const bookStream = fs2.createWriteStream(tempBookPath, {
+      const flushBookChunk = async () => {
+        if (this.bookBuffers.get(index)?.length === 0) return;
+        if (!this.bookChunkIndexes.has(index)) {
+          this.bookChunkIndexes.set(index, 0);
+        }
+        const chunkIndex = this.bookChunkIndexes.get(index);
+        const bookChunkPath = this.PATHS.booksChunk(mode, index, chunkIndex);
+        const data = this.bookBuffers.get(index).join("\n") + "\n";
+        await pipeline(
+          Readable.from([Buffer.from(data, "utf8")]),
+          zlib.createZstdCompress(),
+          fs3.createWriteStream(bookChunkPath)
+        );
+        this.bookBuffers.set(index, []);
+        this.bookBufferSizes.set(index, 0);
+        this.bookChunkIndexes.set(index, chunkIndex + 1);
+      };
+      const booksIndexPath = this.PATHS.booksIndex(mode, index);
+      const booksIndexStream = fs3.createWriteStream(booksIndexPath, {
         highWaterMark: this.maxHighWaterMark
       });
       const tempLookupPath = this.PATHS.tempLookupTable(mode, index);
-      const lookupStream = fs2.createWriteStream(tempLookupPath, {
+      const lookupStream = fs3.createWriteStream(tempLookupPath, {
         highWaterMark: this.maxHighWaterMark
       });
       const tempLookupSegPath = this.PATHS.tempLookupTableSegmented(mode, index);
-      const lookupSegmentedStream = fs2.createWriteStream(tempLookupSegPath, {
+      const lookupSegmentedStream = fs3.createWriteStream(tempLookupSegPath, {
         highWaterMark: this.maxHighWaterMark
       });
       let writeChain = Promise.resolve();
       worker.on("message", (msg) => {
-        if (msg.type === "log") {
+        if (msg.type === "log" || msg.type === "user-log") {
+          this.tui?.log(msg.message);
           return;
         }
+        if (msg.type === "log-exit") {
+          this.tui?.log(msg.message);
+          this.tui?.stop();
+          console.log(msg.message);
+          process.exit(1);
+        }
         if (msg.type === "complete") {
-          writeChain = writeChain.then(async () => {
-            completedSimulations++;
-            if (completedSimulations % 250 === 0) {
-              logArrowProgress(completedSimulations, totalSims);
+          completedSimulations++;
+          if (completedSimulations % 250 === 0 || completedSimulations === totalSims) {
+            const percentage = completedSimulations / totalSims * 100;
+            this.tui?.setProgress(
+              percentage,
+              this.getTimeRemaining(startTime, totalSims),
+              completedSimulations
+            );
+          }
+          if (this.socket && this.panelActive) {
+            if (completedSimulations % 1e3 === 0 || completedSimulations === totalSims) {
+              this.socket.emit("simulationProgress", {
+                mode,
+                percentage: completedSimulations / totalSims * 100,
+                current: completedSimulations,
+                total: totalSims,
+                timeRemaining: this.getTimeRemaining(startTime, totalSims)
+              });
+              this.socket.emit(
+                "simulationShouldStop",
+                this.gameConfig.id,
+                (shouldStop) => {
+                  if (shouldStop) {
+                    worker.terminate();
+                  }
+                }
+              );
             }
+          }
+          writeChain = writeChain.then(async () => {
             const book = msg.book;
             const bookData = {
               id: book.id,
               payoutMultiplier: book.payout,
               events: book.events
             };
-            const prefix = book.id === simStart ? "" : "\n";
-            await write(bookStream, prefix + JSONL.stringify([bookData]));
-            await write(lookupStream, `${book.id},1,${Math.round(book.payout)}
-`);
-            await write(
-              lookupSegmentedStream,
-              `${book.id},${book.criteria},${book.basegameWins},${book.freespinsWins}
+            if (!this.summary[mode]?.criteria[book.criteria]) {
+              this.summary[mode].criteria[book.criteria] = {
+                numSims: 0,
+                bsWins: 0,
+                fsWins: 0,
+                rtp: 0
+              };
+            }
+            const bsWins = round(book.basegameWins, 4);
+            const fsWins = round(book.freespinsWins, 4);
+            this.summary[mode].criteria[book.criteria].numSims += 1;
+            this.summary[mode].total.bsWins += bsWins;
+            this.summary[mode].total.fsWins += fsWins;
+            this.summary[mode].criteria[book.criteria].bsWins += bsWins;
+            this.summary[mode].criteria[book.criteria].fsWins += fsWins;
+            const bookLine = JSON.stringify(bookData);
+            const lineSize = Buffer.byteLength(bookLine + "\n", "utf8");
+            if (this.bookBuffers.has(index)) {
+              this.bookBuffers.get(index).push(bookLine);
+              this.bookBufferSizes.set(
+                index,
+                this.bookBufferSizes.get(index) + lineSize
+              );
+            } else {
+              this.bookBuffers.set(index, [bookLine]);
+              this.bookBufferSizes.set(index, lineSize);
+            }
+            if (!this.tempBookIndexPaths.includes(booksIndexPath)) {
+              this.tempBookIndexPaths.push(booksIndexPath);
+            }
+            await Promise.all([
+              write(
+                booksIndexStream,
+                `${book.id},${index},${this.bookChunkIndexes.get(index) || 0}
 `
-            );
+              ),
+              write(lookupStream, `${book.id},1,${Math.round(book.payout)}
+`),
+              write(
+                lookupSegmentedStream,
+                `${book.id},${book.criteria},${book.basegameWins},${book.freespinsWins}
+`
+              )
+            ]);
+            if (this.bookBufferSizes.get(index) >= 10 * 1024 * 1024) {
+              await flushBookChunk();
+            }
             if (this.recordsWriteStream) {
               for (const record of msg.records) {
                 const recordPrefix = this.hasWrittenRecord ? "\n" : "";
                 await write(
                   this.recordsWriteStream,
-                  recordPrefix + JSONL.stringify([record])
+                  recordPrefix + JSON.stringify(record)
                 );
                 this.hasWrittenRecord = true;
               }
@@ -1951,31 +2465,35 @@ Simulating game mode: ${mode}`);
         }
         if (msg.type === "done") {
           writeChain.then(async () => {
-            bookStream.end();
+            await flushBookChunk();
             lookupStream.end();
             lookupSegmentedStream.end();
+            booksIndexStream.end();
             await Promise.all([
-              new Promise((r) => bookStream.on("finish", () => r())),
               new Promise((r) => lookupStream.on("finish", () => r())),
-              new Promise((r) => lookupSegmentedStream.on("finish", () => r()))
+              new Promise((r) => lookupSegmentedStream.on("finish", () => r())),
+              new Promise((r) => booksIndexStream.on("finish", () => r()))
             ]);
+            const bookIndexMeta = {
+              worker: index,
+              chunks: this.bookChunkIndexes.get(index) + 2,
+              simStart,
+              simEnd
+            };
+            this.bookIndexMetas.push(bookIndexMeta);
             resolve(true);
           }).catch(reject);
           return;
         }
       });
       worker.on("error", (error) => {
-        process.stdout.write(`
-${error.message}
-`);
-        process.stdout.write(`
-${error.stack}
-`);
-        reject(error);
+        this.tui?.log(error.message);
+        resolve(error);
       });
       worker.on("exit", (code) => {
         if (code !== 0) {
-          reject(new Error(`Worker stopped with exit code ${code}`));
+          this.tui?.log(chalk2.yellow(`Worker stopped with exit code ${code}`));
+          resolve(false);
         }
       });
     });
@@ -1985,12 +2503,21 @@ ${error.stack}
    */
   runSingleSimulation(opts) {
     const { simId, mode, criteria } = opts;
+    let retries = 0;
     const ctx = createGameContext({
       config: this.gameConfig
     });
     ctx.state.currentGameMode = mode;
     ctx.state.currentSimulationId = simId;
     ctx.state.isCriteriaMet = false;
+    ctx.services.data._setBook(
+      new Book({
+        id: simId,
+        criteria
+      })
+    );
+    ctx.services.wallet._setWallet(new Wallet());
+    ctx.services.data._setRecorder(new Recorder());
     const resultSet = ctx.services.game.getResultSetByCriteria(
       ctx.state.currentGameMode,
       criteria
@@ -2003,6 +2530,21 @@ ${error.stack}
       if (resultSet.meetsCriteria(ctx)) {
         ctx.state.isCriteriaMet = true;
       }
+      retries++;
+      if (!ctx.state.isCriteriaMet && retries % 1e4 === 0) {
+        parentPort2?.postMessage({
+          type: "log",
+          message: chalk2.yellow(
+            `Excessive retries @ #${simId} @ criteria "${criteria}": ${retries} retries`
+          )
+        });
+      }
+      if (!ctx.state.isCriteriaMet && retries % 5e4 === 0) {
+        parentPort2?.postMessage({
+          type: "log-exit",
+          message: chalk2.red("Possible infinite loop detected, exiting simulation.")
+        });
+      }
     }
     ctx.services.wallet._getWallet().writePayoutToBook(ctx);
     ctx.services.wallet._getWallet().confirmWins(ctx);
@@ -2014,10 +2556,10 @@ ${error.stack}
     });
     ctx.config.hooks.onSimulationAccepted?.(ctx);
     this.confirmRecords(ctx);
-    parentPort?.postMessage({
+    parentPort2?.postMessage({
       type: "complete",
       simId,
-      book: ctx.services.data._getBook().serialize(),
+      book: ctx.services.data._getBook()._serialize(),
       wallet: ctx.services.wallet._getWallet().serialize(),
       records: ctx.services.data._getRecords()
     });
@@ -2025,7 +2567,7 @@ ${error.stack}
   initCreditListener() {
     if (this.creditListenerInit) return;
     this.creditListenerInit = true;
-    parentPort?.on("message", (msg) => {
+    parentPort2?.on("message", (msg) => {
       if (msg?.type !== "credit") return;
       const amount = Number(msg?.amount ?? 0);
       if (!Number.isFinite(amount) || amount <= 0) return;
@@ -2055,17 +2597,10 @@ ${error.stack}
   resetSimulation(ctx) {
     this.resetState(ctx);
     ctx.services.board.resetBoard();
-    ctx.services.data._setRecorder(new Recorder());
-    ctx.services.wallet._setWallet(new Wallet());
-    ctx.services.data._setBook(
-      new Book({
-        id: ctx.state.currentSimulationId,
-        criteria: ctx.state.currentResultSet.criteria
-      })
-    );
-    Object.values(ctx.config.gameModes).forEach((mode) => {
-      mode._resetTempValues();
-    });
+    ctx.services.data._getRecorder()._reset();
+    ctx.services.wallet._getWallet()._reset();
+    ctx.services.data._getBook()._reset(ctx.state.currentSimulationId, ctx.state.currentResultSet.criteria);
+    ctx.services.game.getCurrentGameMode()._resetTempValues();
   }
   resetState(ctx) {
     ctx.services.rng.setSeedIfDifferent(ctx.state.currentSimulationId);
@@ -2092,18 +2627,25 @@ ${error.stack}
   async writeRecords(mode) {
     const tempRecordsPath = this.PATHS.tempRecords(mode);
     const forceRecordsPath = this.PATHS.forceRecords(mode);
+    const allSearchKeysAndValues = /* @__PURE__ */ new Map();
     const aggregatedRecords = /* @__PURE__ */ new Map();
-    if (fs2.existsSync(tempRecordsPath)) {
-      const fileStream = fs2.createReadStream(tempRecordsPath, {
+    if (fs3.existsSync(tempRecordsPath)) {
+      const fileStream = fs3.createReadStream(tempRecordsPath, {
         highWaterMark: this.streamHighWaterMark
       });
-      const rl = readline2.createInterface({
+      const rl = readline.createInterface({
         input: fileStream,
         crlfDelay: Infinity
       });
       for await (const line of rl) {
         if (line.trim() === "") continue;
         const record = JSON.parse(line);
+        for (const entry of record.search) {
+          if (!allSearchKeysAndValues.has(entry.name)) {
+            allSearchKeysAndValues.set(entry.name, /* @__PURE__ */ new Set());
+          }
+          allSearchKeysAndValues.get(entry.name).add(String(entry.value));
+        }
         const key = JSON.stringify(record.search);
         let existing = aggregatedRecords.get(key);
         if (!existing) {
@@ -2120,8 +2662,9 @@ ${error.stack}
         }
       }
     }
-    fs2.rmSync(forceRecordsPath, { force: true });
-    const writeStream = fs2.createWriteStream(forceRecordsPath, { encoding: "utf-8" });
+    fs3.rmSync(forceRecordsPath, { force: true });
+    fs3.rmSync(this.PATHS.forceKeys(mode), { force: true });
+    const writeStream = fs3.createWriteStream(forceRecordsPath, { encoding: "utf-8" });
     writeStream.write("[\n");
     let isFirst = true;
     for (const record of aggregatedRecords.values()) {
@@ -2136,13 +2679,17 @@ ${error.stack}
     await new Promise((resolve) => {
       writeStream.on("finish", () => resolve());
     });
-    fs2.rmSync(tempRecordsPath, { force: true });
+    const forceJson = Object.fromEntries(
+      Array.from(allSearchKeysAndValues.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([key, values]) => [key, Array.from(values)])
+    );
+    writeFile(this.PATHS.forceKeys(mode), JSON.stringify(forceJson, null, 2));
+    fs3.rmSync(tempRecordsPath, { force: true });
   }
   writeIndexJson() {
     const outputFilePath = this.PATHS.indexJson;
     const modes = Object.keys(this.simRunsAmount).map((id) => {
       const mode = this.gameConfig.gameModes[id];
-      assert7(mode, `Game mode "${id}" not found in game config.`);
+      assert5(mode, `Game mode "${id}" not found in game config.`);
       return {
         name: mode.name,
         cost: mode.cost,
@@ -2152,38 +2699,26 @@ ${error.stack}
     });
     writeFile(outputFilePath, JSON.stringify({ modes }, null, 2));
   }
-  async writeBooksJson(gameMode) {
-    const outputFilePath = this.PATHS.books(gameMode);
-    const compressedFilePath = this.PATHS.booksCompressed(gameMode);
-    fs2.rmSync(compressedFilePath, { force: true });
-    if (fs2.existsSync(outputFilePath)) {
-      await pipeline(
-        fs2.createReadStream(outputFilePath),
-        zlib.createZstdCompress(),
-        fs2.createWriteStream(compressedFilePath)
-      );
-    }
-  }
   /**
    * Compiles user configured game to JS for use in different Node processes
    */
   preprocessFiles() {
-    const builtFilePath = path.join(
+    const builtFilePath = path3.join(
       this.gameConfig.rootDir,
       this.gameConfig.outputDir,
       TEMP_FILENAME
     );
-    fs2.rmSync(builtFilePath, { force: true });
+    fs3.rmSync(builtFilePath, { force: true });
     buildSync({
       entryPoints: [this.gameConfig.rootDir],
       bundle: true,
       platform: "node",
-      outfile: path.join(
+      outfile: path3.join(
         this.gameConfig.rootDir,
         this.gameConfig.outputDir,
         TEMP_FILENAME
       ),
-      external: ["esbuild"]
+      external: ["esbuild", "yargs"]
     });
   }
   getSimRangesForChunks(total, chunks) {
@@ -2218,27 +2753,62 @@ ${error.stack}
       }
     }
   }
-  async mergeCsv(chunks, outPath, tempName) {
+  getTimeRemaining(startTime, totalSims) {
+    const elapsedTime = Date.now() - startTime;
+    const simsLeft = totalSims - completedSimulations;
+    const timePerSim = elapsedTime / completedSimulations;
+    const timeRemaining = Math.round(simsLeft * timePerSim / 1e3);
+    return timeRemaining;
+  }
+  async mergeCsv(chunks, outPath, tempName, lutIndexPath) {
     try {
-      fs2.rmSync(outPath, { force: true });
-      const out = fs2.createWriteStream(outPath, {
+      fs3.rmSync(outPath, { force: true });
+      const lutStream = fs3.createWriteStream(outPath, {
         highWaterMark: this.streamHighWaterMark
       });
+      const lutIndexStream = lutIndexPath ? fs3.createWriteStream(lutIndexPath, {
+        highWaterMark: this.streamHighWaterMark
+      }) : void 0;
+      let offset = 0n;
       for (let i = 0; i < chunks.length; i++) {
-        const p = path.join(this.PATHS.base, TEMP_FOLDER, tempName(i));
-        if (!fs2.existsSync(p)) continue;
-        const rs = fs2.createReadStream(p, {
-          highWaterMark: this.streamHighWaterMark
-        });
-        for await (const buf of rs) {
-          if (!out.write(buf)) {
-            await new Promise((resolve) => out.once("drain", resolve));
+        const tempLutChunk = path3.join(this.PATHS.base, TEMP_FOLDER, tempName(i));
+        if (!fs3.existsSync(tempLutChunk)) continue;
+        if (lutIndexStream) {
+          const rl = readline.createInterface({
+            input: fs3.createReadStream(tempLutChunk),
+            crlfDelay: Infinity
+          });
+          for await (const line of rl) {
+            if (!line.trim()) continue;
+            const indexBuffer = Buffer.alloc(8);
+            indexBuffer.writeBigUInt64LE(offset);
+            if (!lutIndexStream.write(indexBuffer)) {
+              await new Promise((resolve) => lutIndexStream.once("drain", resolve));
+            }
+            const lineWithNewline = line + "\n";
+            if (!lutStream.write(lineWithNewline)) {
+              await new Promise((resolve) => lutStream.once("drain", resolve));
+            }
+            offset += BigInt(Buffer.byteLength(lineWithNewline, "utf8"));
+          }
+        } else {
+          const tempChunkStream = fs3.createReadStream(tempLutChunk, {
+            highWaterMark: this.streamHighWaterMark
+          });
+          for await (const buf of tempChunkStream) {
+            if (!lutStream.write(buf)) {
+              await new Promise((resolve) => lutStream.once("drain", resolve));
+            }
           }
         }
-        fs2.rmSync(p);
+        fs3.rmSync(tempLutChunk);
       }
-      out.end();
-      await new Promise((resolve) => out.on("finish", resolve));
+      lutStream.end();
+      lutIndexStream?.end();
+      await Promise.all([
+        new Promise((resolve) => lutStream.on("finish", resolve)),
+        lutIndexStream ? new Promise((resolve) => lutIndexStream.on("finish", resolve)) : Promise.resolve()
+      ]);
     } catch (error) {
       throw new Error(`Error merging CSV files: ${error.message}`);
     }
@@ -2249,21 +2819,16 @@ ${error.stack}
   confirmRecords(ctx) {
     const recorder = ctx.services.data._getRecorder();
     for (const pendingRecord of recorder.pendingRecords) {
-      const search = Object.entries(pendingRecord.properties).map(([name, value]) => ({ name, value })).sort((a, b) => a.name.localeCompare(b.name));
-      let record = 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;
-      });
+      const key = Object.keys(pendingRecord.properties).sort().map((k) => `${k}:${pendingRecord.properties[k]}`).join("|");
+      let record = recorder.recordsMap.get(key);
       if (!record) {
+        const search = Object.entries(pendingRecord.properties).map(([name, value]) => ({ name, value })).sort((a, b) => a.name.localeCompare(b.name));
         record = {
           search,
           timesTriggered: 0,
           bookIds: []
         };
+        recorder.recordsMap.set(key, record);
         recorder.records.push(record);
       }
       record.timesTriggered++;
@@ -2273,18 +2838,76 @@ ${error.stack}
     }
     recorder.pendingRecords = [];
   }
+  async printSimulationSummary() {
+    Object.entries(this.summary).forEach(([mode, modeSummary]) => {
+      const modeCost = this.gameConfig.gameModes[mode].cost;
+      Object.entries(modeSummary.criteria).forEach(([criteria, criteriaSummary]) => {
+        const totalWins2 = criteriaSummary.bsWins + criteriaSummary.fsWins;
+        const rtp2 = totalWins2 / (criteriaSummary.numSims * modeCost);
+        this.summary[mode].criteria[criteria].rtp = round(rtp2, 4);
+        this.summary[mode].criteria[criteria].bsWins = round(criteriaSummary.bsWins, 4);
+        this.summary[mode].criteria[criteria].fsWins = round(criteriaSummary.fsWins, 4);
+      });
+      const totalWins = modeSummary.total.bsWins + modeSummary.total.fsWins;
+      const rtp = totalWins / (modeSummary.total.numSims * modeCost);
+      this.summary[mode].total.rtp = round(rtp, 4);
+      this.summary[mode].total.bsWins = round(modeSummary.total.bsWins, 4);
+      this.summary[mode].total.fsWins = round(modeSummary.total.fsWins, 4);
+    });
+    const maxLineLength = 50;
+    let output = chalk2.green.bold("\nSimulation Summary\n");
+    for (const [mode, modeSummary] of Object.entries(this.summary)) {
+      output += "-".repeat(maxLineLength) + "\n\n";
+      output += chalk2.bold.bgWhite(`Mode: ${mode}
+`);
+      output += `Simulations: ${modeSummary.total.numSims}
+`;
+      output += `Basegame Wins: ${modeSummary.total.bsWins}
+`;
+      output += `Freespins Wins: ${modeSummary.total.fsWins}
+`;
+      output += `RTP (unoptimized): ${modeSummary.total.rtp}
+`;
+      output += chalk2.bold("\n    Result Set Summary:\n");
+      for (const [criteria, criteriaSummary] of Object.entries(modeSummary.criteria)) {
+        output += chalk2.gray("    " + "-".repeat(maxLineLength - 4)) + "\n";
+        output += chalk2.bold(`    Criteria: ${criteria}
+`);
+        output += `    Simulations: ${criteriaSummary.numSims}
+`;
+        output += `    Basegame Wins: ${criteriaSummary.bsWins}
+`;
+        output += `    Freespins Wins: ${criteriaSummary.fsWins}
+`;
+        output += `    RTP (unoptimized): ${criteriaSummary.rtp}
+`;
+      }
+    }
+    console.log(output);
+    writeFile(this.PATHS.simulationSummary, JSON.stringify(this.summary, null, 2));
+    if (this.socket && this.panelActive) {
+      this.socket.emit("simulationSummary", {
+        summary: this.summary
+      });
+    }
+  }
+  sendSimulationStatus(message) {
+    if (this.socket && this.panelActive) {
+      this.socket.emit("simulationStatus", message);
+    }
+  }
 };
 
 // src/analysis/index.ts
-import fs3 from "fs";
-import path2 from "path";
-import assert8 from "assert";
+import fs4 from "fs";
+import assert6 from "assert";
 
 // src/analysis/utils.ts
 function parseLookupTable(content) {
   const lines = content.trim().split("\n");
   const lut = [];
   for (const line of lines) {
+    if (!line.trim()) continue;
     const [indexStr, weightStr, payoutStr] = line.split(",");
     const index = parseInt(indexStr.trim());
     const weight = parseInt(weightStr.trim());
@@ -2297,11 +2920,12 @@ function parseLookupTableSegmented(content) {
   const lines = content.trim().split("\n");
   const lut = [];
   for (const line of lines) {
-    const [indexStr, criteria, weightStr, payoutStr] = line.split(",");
+    if (!line.trim()) continue;
+    const [indexStr, criteria, bsWinsStr, fsWinsStr] = line.split(",");
     const index = parseInt(indexStr.trim());
-    const weight = parseInt(weightStr.trim());
-    const payout = parseFloat(payoutStr.trim());
-    lut.push([index, criteria, weight, payout]);
+    const bsWins = parseFloat(bsWinsStr.trim());
+    const fsWins = parseFloat(fsWinsStr.trim());
+    lut.push([index, criteria, bsWins, fsWins]);
   }
   return lut;
 }
@@ -2335,19 +2959,19 @@ function getPayoutWeights(lut, opts = {}) {
 function getNonZeroHitrate(payoutWeights) {
   const totalWeight = getTotalWeight(payoutWeights);
   if (Math.min(...Object.keys(payoutWeights).map(Number)) == 0) {
-    return totalWeight / (totalWeight - (payoutWeights[0] ?? 0) / totalWeight);
+    return round(totalWeight / (totalWeight - (payoutWeights[0] ?? 0) / totalWeight), 4);
   } else {
     return 1;
   }
 }
 function getNullHitrate(payoutWeights) {
-  return payoutWeights[0] ?? 0;
+  return round(payoutWeights[0] ?? 0, 4);
 }
 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;
+  return round(1 / hitRate, 4);
 }
 function getUniquePayouts(payoutWeights) {
   return Object.keys(payoutWeights).length;
@@ -2366,15 +2990,15 @@ function getAvgWin(payoutWeights) {
     const payout = parseFloat(payoutStr);
     avgWin += payout * weight;
   }
-  return avgWin;
+  return round(avgWin, 4);
 }
 function getRtp(payoutWeights, cost) {
   const avgWin = getAvgWin(payoutWeights);
-  return avgWin / cost;
+  return round(avgWin / cost, 4);
 }
 function getStandardDeviation(payoutWeights) {
   const variance = getVariance(payoutWeights);
-  return Math.sqrt(variance);
+  return round(Math.sqrt(variance), 4);
 }
 function getVariance(payoutWeights) {
   const totalWeight = getTotalWeight(payoutWeights);
@@ -2384,7 +3008,7 @@ function getVariance(payoutWeights) {
     const payout = parseFloat(payoutStr);
     variance += Math.pow(payout - avgWin, 2) * (weight / totalWeight);
   }
-  return variance;
+  return round(variance, 4);
 }
 function getLessBetHitrate(payoutWeights, cost) {
   let lessBetWeight = 0;
@@ -2395,80 +3019,29 @@ function getLessBetHitrate(payoutWeights, cost) {
       lessBetWeight += weight;
     }
   }
-  return lessBetWeight / totalWeight;
+  return round(lessBetWeight / totalWeight, 4);
 }
 
 // src/analysis/index.ts
-import { isMainThread as isMainThread2 } from "worker_threads";
+import { isMainThread as isMainThread3 } from "worker_threads";
 var Analysis = class {
-  gameConfig;
-  optimizerConfig;
-  filePaths;
-  constructor(optimizer) {
-    this.gameConfig = optimizer.getGameConfig();
-    this.optimizerConfig = optimizer.getOptimizerGameModes();
-    this.filePaths = {};
+  game;
+  constructor(game) {
+    this.game = game;
   }
   async runAnalysis(gameModes) {
-    if (!isMainThread2) return;
-    this.filePaths = this.getPathsForModes(gameModes);
+    if (!isMainThread3) return;
     this.getNumberStats(gameModes);
     this.getWinRanges(gameModes);
     console.log("Analysis complete. Files written to build directory.");
   }
-  getPathsForModes(gameModes) {
-    const rootPath = this.gameConfig.rootDir;
-    const paths = {};
-    for (const modeStr of gameModes) {
-      const lut = path2.join(
-        rootPath,
-        this.gameConfig.outputDir,
-        `lookUpTable_${modeStr}.csv`
-      );
-      const lutSegmented = path2.join(
-        rootPath,
-        this.gameConfig.outputDir,
-        `lookUpTableSegmented_${modeStr}.csv`
-      );
-      const lutOptimized = path2.join(
-        rootPath,
-        this.gameConfig.outputDir,
-        "publish_files",
-        `lookUpTable_${modeStr}_0.csv`
-      );
-      const booksJsonl = path2.join(
-        rootPath,
-        this.gameConfig.outputDir,
-        `books_${modeStr}.jsonl`
-      );
-      const booksJsonlCompressed = path2.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])) {
-        assert8(
-          fs3.existsSync(p),
-          `File "${p}" does not exist. Run optimization to auto-create it.`
-        );
-      }
-    }
-    return paths;
-  }
   getNumberStats(gameModes) {
+    const meta = this.game.getMetadata();
     const stats = [];
     for (const modeStr of gameModes) {
       const mode = this.getGameModeConfig(modeStr);
       const lutOptimized = parseLookupTable(
-        fs3.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
+        fs4.readFileSync(meta.paths.lookupTablePublish(modeStr), "utf-8")
       );
       const totalWeight = getTotalLutWeight(lutOptimized);
       const payoutWeights = getPayoutWeights(lutOptimized);
@@ -2488,10 +3061,7 @@ var Analysis = class {
         uniquePayouts: getUniquePayouts(payoutWeights)
       });
     }
-    writeJsonFile(
-      path2.join(this.gameConfig.rootDir, this.gameConfig.outputDir, "stats_summary.json"),
-      stats
-    );
+    writeJsonFile(meta.paths.statsSummary, stats);
   }
   getWinRanges(gameModes) {
     const winRanges = [
@@ -2514,14 +3084,31 @@ var Analysis = class {
       [7500, 9999.99],
       [1e4, 14999.99],
       [15e3, 19999.99],
-      [2e4, 24999.99]
+      [2e4, 24999.99],
+      [25e3, 49999.99],
+      [5e4, 74999.99],
+      [75e3, 99999.99],
+      [1e5, Infinity]
     ];
-    const payoutRanges = {};
+    const payoutRanges = [];
+    const meta = this.game.getMetadata();
     for (const modeStr of gameModes) {
-      payoutRanges[modeStr] = { overall: {}, criteria: {} };
       const lutSegmented = parseLookupTableSegmented(
-        fs3.readFileSync(this.filePaths[modeStr].lutSegmented, "utf-8")
+        fs4.readFileSync(meta.paths.lookupTableSegmented(modeStr), "utf-8")
       );
+      const range = {
+        gameMode: modeStr,
+        allPayouts: {
+          overall: {},
+          criteria: {}
+        },
+        uniquePayouts: {
+          overall: {},
+          criteria: {}
+        }
+      };
+      const uniquePayoutsOverall = /* @__PURE__ */ new Map();
+      const uniquePayoutsCriteria = /* @__PURE__ */ new Map();
       lutSegmented.forEach(([, criteria, bp, fsp]) => {
         const basePayout = bp;
         const freeSpinPayout = fsp;
@@ -2529,32 +3116,54 @@ var Analysis = class {
         for (const [min, max] of winRanges) {
           if (payout >= min && payout <= max) {
             const rangeKey = `${min}-${max}`;
-            if (!payoutRanges[modeStr].overall[rangeKey]) {
-              payoutRanges[modeStr].overall[rangeKey] = 0;
+            if (!range.allPayouts.overall[rangeKey]) {
+              range.allPayouts.overall[rangeKey] = 0;
             }
-            payoutRanges[modeStr].overall[rangeKey] += 1;
-            if (!payoutRanges[modeStr].criteria[criteria]) {
-              payoutRanges[modeStr].criteria[criteria] = {};
+            range.allPayouts.overall[rangeKey] += 1;
+            if (!range.allPayouts.criteria[criteria]) {
+              range.allPayouts.criteria[criteria] = {};
             }
-            if (!payoutRanges[modeStr].criteria[criteria][rangeKey]) {
-              payoutRanges[modeStr].criteria[criteria][rangeKey] = 0;
+            if (!range.allPayouts.criteria[criteria][rangeKey]) {
+              range.allPayouts.criteria[criteria][rangeKey] = 0;
             }
-            payoutRanges[modeStr].criteria[criteria][rangeKey] += 1;
+            range.allPayouts.criteria[criteria][rangeKey] += 1;
+            if (!uniquePayoutsOverall.has(rangeKey)) {
+              uniquePayoutsOverall.set(rangeKey, /* @__PURE__ */ new Set());
+            }
+            uniquePayoutsOverall.get(rangeKey).add(payout);
+            if (!uniquePayoutsCriteria.has(criteria)) {
+              uniquePayoutsCriteria.set(criteria, /* @__PURE__ */ new Map());
+            }
+            if (!uniquePayoutsCriteria.get(criteria).has(rangeKey)) {
+              uniquePayoutsCriteria.get(criteria).set(rangeKey, /* @__PURE__ */ new Set());
+            }
+            uniquePayoutsCriteria.get(criteria).get(rangeKey).add(payout);
             break;
           }
         }
       });
-      const orderedOverall = {};
-      Object.keys(payoutRanges[modeStr].overall).sort((a, b) => {
+      uniquePayoutsOverall.forEach((payoutSet, rangeKey) => {
+        range.uniquePayouts.overall[rangeKey] = payoutSet.size;
+      });
+      uniquePayoutsCriteria.forEach((rangeMap, criteria) => {
+        if (!range.uniquePayouts.criteria[criteria]) {
+          range.uniquePayouts.criteria[criteria] = {};
+        }
+        rangeMap.forEach((payoutSet, rangeKey) => {
+          range.uniquePayouts.criteria[criteria][rangeKey] = payoutSet.size;
+        });
+      });
+      const orderedAllOverall = {};
+      Object.keys(range.allPayouts.overall).sort((a, b) => {
         const [aMin] = a.split("-").map(Number);
         const [bMin] = b.split("-").map(Number);
         return aMin - bMin;
       }).forEach((key) => {
-        orderedOverall[key] = payoutRanges[modeStr].overall[key];
+        orderedAllOverall[key] = range.allPayouts.overall[key];
       });
-      const orderedCriteria = {};
-      Object.keys(payoutRanges[modeStr].criteria).forEach((crit) => {
-        const critMap = payoutRanges[modeStr].criteria[crit];
+      const orderedAllCriteria = {};
+      Object.keys(range.allPayouts.criteria).forEach((crit) => {
+        const critMap = range.allPayouts.criteria[crit];
         const orderedCritMap = {};
         Object.keys(critMap).sort((a, b) => {
           const [aMin] = a.split("-").map(Number);
@@ -2563,35 +3172,61 @@ var Analysis = class {
         }).forEach((key) => {
           orderedCritMap[key] = critMap[key];
         });
-        orderedCriteria[crit] = orderedCritMap;
+        orderedAllCriteria[crit] = orderedCritMap;
+      });
+      const orderedUniqueOverall = {};
+      Object.keys(range.uniquePayouts.overall).sort((a, b) => {
+        const [aMin] = a.split("-").map(Number);
+        const [bMin] = b.split("-").map(Number);
+        return aMin - bMin;
+      }).forEach((key) => {
+        orderedUniqueOverall[key] = range.uniquePayouts.overall[key];
+      });
+      const orderedUniqueCriteria = {};
+      Object.keys(range.uniquePayouts.criteria).forEach((crit) => {
+        const critMap = range.uniquePayouts.criteria[crit];
+        const orderedCritMap = {};
+        Object.keys(critMap).sort((a, b) => {
+          const [aMin] = a.split("-").map(Number);
+          const [bMin] = b.split("-").map(Number);
+          return aMin - bMin;
+        }).forEach((key) => {
+          orderedCritMap[key] = critMap[key];
+        });
+        orderedUniqueCriteria[crit] = orderedCritMap;
+      });
+      payoutRanges.push({
+        gameMode: modeStr,
+        allPayouts: {
+          overall: orderedAllOverall,
+          criteria: orderedAllCriteria
+        },
+        uniquePayouts: {
+          overall: orderedUniqueOverall,
+          criteria: orderedUniqueCriteria
+        }
       });
-      payoutRanges[modeStr] = {
-        overall: orderedOverall,
-        criteria: {}
-      };
     }
-    writeJsonFile(
-      path2.join(this.gameConfig.rootDir, this.gameConfig.outputDir, "stats_payouts.json"),
-      payoutRanges
-    );
+    writeJsonFile(meta.paths.statsPayouts, payoutRanges);
   }
   getGameModeConfig(mode) {
-    const config = this.gameConfig.gameModes[mode];
-    assert8(config, `Game mode "${mode}" not found in game config`);
+    const config = this.game.getConfig().gameModes[mode];
+    assert6(config, `Game mode "${mode}" not found in game config`);
     return config;
   }
 };
 
 // src/optimizer/index.ts
-import path5 from "path";
-import assert10 from "assert";
+import path6 from "path";
+import assert8 from "assert";
 import { spawn } from "child_process";
-import { isMainThread as isMainThread3 } from "worker_threads";
+import { isMainThread as isMainThread4 } from "worker_threads";
 
 // src/utils/math-config.ts
-import path3 from "path";
+import path4 from "path";
 function makeMathConfig(optimizer, opts = {}) {
   const game = optimizer.getGameConfig();
+  const meta = optimizer.getGameMeta();
   const gameModesCfg = optimizer.getOptimizerGameModes();
   const { writeToFile } = opts;
   const isDefined = (v) => v !== void 0;
@@ -2633,16 +3268,17 @@ function makeMathConfig(optimizer, opts = {}) {
     }))
   };
   if (writeToFile) {
-    const outPath = path3.join(game.rootDir, game.outputDir, "math_config.json");
+    const outPath = path4.join(meta.rootDir, meta.outputDir, "math_config.json");
     writeJsonFile(outPath, config);
   }
   return config;
 }
 
 // src/utils/setup-file.ts
-import path4 from "path";
+import path5 from "path";
 function makeSetupFile(optimizer, gameMode) {
   const gameConfig = optimizer.getGameConfig();
+  const gameMeta = optimizer.getGameMeta();
   const optimizerGameModes = optimizer.getOptimizerGameModes();
   const modeConfig = optimizerGameModes[gameMode];
   if (!modeConfig) {
@@ -2676,16 +3312,16 @@ function makeSetupFile(optimizer, gameMode) {
 `;
   content += `simulation_trials;${params.simulationTrials}
 `;
-  content += `user_game_build_path;${path4.join(gameConfig.rootDir, gameConfig.outputDir)}
+  content += `user_game_build_path;${path5.join(gameMeta.rootDir, gameMeta.outputDir)}
 `;
   content += `pmb_rtp;${params.pmbRtp}
 `;
-  const outPath = path4.join(__dirname, "./optimizer-rust/src", "setup.txt");
+  const outPath = path5.join(__dirname, "./optimizer-rust/src", "setup.txt");
   writeFile(outPath, content);
 }
 
 // src/optimizer/OptimizationConditions.ts
-import assert9 from "assert";
+import assert7 from "assert";
 var OptimizationConditions = class {
   rtp;
   avgWin;
@@ -2696,14 +3332,14 @@ var OptimizationConditions = class {
   constructor(opts) {
     let { rtp, avgWin, hitRate, searchConditions, priority } = opts;
     if (rtp == void 0 || rtp === "x") {
-      assert9(avgWin !== void 0 && hitRate !== void 0, "If RTP is not specified, hit-rate (hr) and average win amount (av_win) must be given.");
+      assert7(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++;
     }
-    assert9(noneCount <= 1, "Invalid combination of optimization conditions.");
+    assert7(noneCount <= 1, "Invalid combination of optimization conditions.");
     this.searchRange = [-1, -1];
     this.forceSearch = {};
     if (typeof searchConditions === "number") {
@@ -2784,9 +3420,11 @@ var OptimizationParameters = class _OptimizationParameters {
 // src/optimizer/index.ts
 var Optimizer = class {
   gameConfig;
+  gameMeta;
   gameModes;
   constructor(opts) {
     this.gameConfig = opts.game.getConfig();
+    this.gameMeta = opts.game.getMetadata();
     this.gameModes = opts.gameModes;
     this.verifyConfig();
   }
@@ -2794,11 +3432,15 @@ var Optimizer = class {
    * Runs the optimization process, and runs analysis after.
    */
   async runOptimization({ gameModes }) {
-    if (!isMainThread3) return;
+    if (!isMainThread4) return;
     const mathConfig = makeMathConfig(this, { writeToFile: true });
     for (const mode of gameModes) {
       const setupFile = makeSetupFile(this, mode);
       await this.runSingleOptimization();
+      await makeLutIndexFromPublishLut(
+        this.gameMeta.paths.lookupTablePublish(mode),
+        this.gameMeta.paths.lookupTableIndex(mode)
+      );
     }
     console.log("Optimization complete. Files written to build directory.");
   }
@@ -2831,7 +3473,7 @@ var Optimizer = class {
       }
       gameModeRtp = Math.round(gameModeRtp * 1e3) / 1e3;
       paramRtp = Math.round(paramRtp * 1e3) / 1e3;
-      assert10(
+      assert8(
         gameModeRtp === paramRtp,
         `Sum of all RTP conditions (${paramRtp}) does not match the game mode RTP (${gameModeRtp}) in game mode "${k}".`
       );
@@ -2840,6 +3482,9 @@ var Optimizer = class {
   getGameConfig() {
     return this.gameConfig;
   }
+  getGameMeta() {
+    return this.gameMeta;
+  }
   getOptimizerGameModes() {
     return this.gameModes;
   }
@@ -2848,7 +3493,7 @@ async function rustProgram(...args) {
   console.log("Starting Rust optimizer. This may take a while...");
   return new Promise((resolve, reject) => {
     const task = spawn("cargo", ["run", "-q", "--release", ...args], {
-      cwd: path5.join(__dirname, "./optimizer-rust"),
+      cwd: path6.join(__dirname, "./optimizer-rust"),
       stdio: "pipe"
     });
     task.on("error", (error) => {
@@ -2875,8 +3520,8 @@ async function rustProgram(...args) {
 }
 
 // src/slot-game/index.ts
-import { isMainThread as isMainThread4 } from "worker_threads";
-var SlotGame = class {
+import { isMainThread as isMainThread5, workerData as workerData2 } from "worker_threads";
+var SlotGame = class _SlotGame {
   configOpts;
   simulation;
   optimizer;
@@ -2926,38 +3571,56 @@ var SlotGame = class {
   /**
    * 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);
+  runAnalysis(opts) {
+    this.analyzer = new Analysis(this);
+    this.analyzer.runAnalysis(opts.gameModes);
   }
   /**
    * Runs the configured tasks: simulation, optimization, and/or analysis.
    */
   async runTasks(opts = {}) {
+    if (isMainThread5 && !opts._internal_ignore_args) {
+      const [{ default: yargs }, { hideBin }] = await Promise.all([
+        import("yargs"),
+        import("yargs/helpers")
+      ]);
+      const argvParser = yargs(hideBin(process.argv)).options({
+        [CLI_ARGS.RUN]: { type: "boolean", default: false }
+      });
+      const argv = await argvParser.parse();
+      if (!argv[CLI_ARGS.RUN]) return;
+    }
+    if (!isMainThread5 && workerData2 && typeof workerData2 === "object" && "simStart" in workerData2) {
+      opts.doSimulation = true;
+    }
     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(opts.simulationOpts || {});
     }
+    if (opts.doAnalysis) {
+      this.runAnalysis(opts.analysisOpts || { gameModes: [] });
+    }
     if (opts.doOptimization) {
       await this.runOptimization(opts.optimizationOpts || { gameModes: [] });
+      if (opts.doAnalysis) {
+        this.runAnalysis(opts.analysisOpts || { gameModes: [] });
+      }
     }
-    if (opts.doAnalysis) {
-      await this.runAnalysis(opts.analysisOpts || { gameModes: [] });
-    }
-    if (isMainThread4) console.log("Finishing up...");
+    if (isMainThread5) console.log("Done!");
   }
   /**
    * Gets the game configuration.
    */
   getConfig() {
-    return createGameConfig(this.configOpts);
+    return createGameConfig(this.configOpts).config;
+  }
+  getMetadata() {
+    return createGameConfig(this.configOpts).metadata;
+  }
+  clone() {
+    return new _SlotGame(this.configOpts);
   }
 };
 
@@ -2970,7 +3633,7 @@ var defineSymbols = (symbols) => symbols;
 var defineGameModes = (gameModes) => gameModes;
 
 // src/game-mode/index.ts
-import assert11 from "assert";
+import assert9 from "assert";
 var GameMode = class {
   name;
   _reelsAmount;
@@ -2993,12 +3656,12 @@ var GameMode = class {
     this.reelSets = opts.reelSets;
     this.resultSets = opts.resultSets;
     this.isBonusBuy = opts.isBonusBuy;
-    assert11(this.rtp >= 0.9 && this.rtp <= 0.99, "RTP must be between 0.9 and 0.99");
-    assert11(
+    assert9(this.rtp >= 0.9 && this.rtp <= 0.99, "RTP must be between 0.9 and 0.99");
+    assert9(
       this.symbolsPerReel.length === this.reelsAmount,
       "symbolsPerReel length must match reelsAmount."
     );
-    assert11(this.reelSets.length > 0, "GameMode must have at least one ReelSet defined.");
+    assert9(this.reelSets.length > 0, "GameMode must have at least one ReelSet defined.");
   }
   /**
    * Intended for internal use only.
@@ -3011,7 +3674,7 @@ var GameMode = class {
    * Intended for internal use only.
    */
   _setSymbolsPerReel(symbolsPerReel) {
-    assert11(
+    assert9(
       symbolsPerReel.length === this._reelsAmount,
       "symbolsPerReel length must match reelsAmount."
     );
@@ -3077,7 +3740,7 @@ var WinType = class {
 };
 
 // src/win-types/LinesWinType.ts
-import assert12 from "assert";
+import assert10 from "assert";
 var LinesWinType = class extends WinType {
   lines;
   constructor(opts) {
@@ -3131,8 +3794,8 @@ var LinesWinType = class extends WinType {
         if (!baseSymbol) {
           baseSymbol = thisSymbol;
         }
-        assert12(baseSymbol, `No symbol found at line ${lineNum}, reel ${ridx}`);
-        assert12(thisSymbol, `No symbol found at line ${lineNum}, reel ${ridx}`);
+        assert10(baseSymbol, `No symbol found at line ${lineNum}, reel ${ridx}`);
+        assert10(thisSymbol, `No symbol found at line ${lineNum}, reel ${ridx}`);
         if (potentialWinLine.length == 0) {
           if (this.isWild(thisSymbol)) {
             potentialWildLine.push({ reel: ridx, row: sidx, symbol: thisSymbol });
@@ -3447,13 +4110,13 @@ var ManywaysWinType = class extends WinType {
 };
 
 // src/reel-set/GeneratedReelSet.ts
-import fs5 from "fs";
-import path7 from "path";
-import { isMainThread as isMainThread5 } from "worker_threads";
+import fs6 from "fs";
+import path8 from "path";
+import { isMainThread as isMainThread6 } from "worker_threads";
 
 // src/reel-set/index.ts
-import fs4 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path7 from "path";
 var ReelSet = class {
   id;
   associatedGameModeName;
@@ -3473,11 +4136,11 @@ var ReelSet = class {
    * Reads a reelset CSV file and returns the reels as arrays of GameSymbols.
    */
   parseReelsetCSV(reelSetPath, config) {
-    if (!fs4.existsSync(reelSetPath)) {
+    if (!fs5.existsSync(reelSetPath)) {
       throw new Error(`Reelset CSV file not found at path: ${reelSetPath}`);
     }
     const allowedExtensions = [".csv"];
-    const ext = path6.extname(reelSetPath).toLowerCase();
+    const ext = path7.extname(reelSetPath).toLowerCase();
     if (!allowedExtensions.includes(ext)) {
       throw new Error(
         `Invalid file extension for reelset CSV: ${ext}. Allowed extensions are: ${allowedExtensions.join(
@@ -3485,7 +4148,7 @@ var ReelSet = class {
         )}`
       );
     }
-    const csvData = fs4.readFileSync(reelSetPath, "utf8");
+    const csvData = fs5.readFileSync(reelSetPath, "utf8");
     const rows = csvData.split("\n").filter((line) => line.trim() !== "");
     const reels = Array.from(
       { length: config.gameModes[this.associatedGameModeName].reelsAmount },
@@ -3493,6 +4156,7 @@ var ReelSet = class {
     );
     rows.forEach((row) => {
       const symsInRow = row.split(",").map((symbolId) => {
+        if (!symbolId.trim()) return null;
         const symbol = config.symbols.get(symbolId.trim());
         if (!symbol) {
           throw new Error(`Symbol with id "${symbolId}" not found in game config.`);
@@ -3505,18 +4169,9 @@ var ReelSet = class {
             `Row in reelset CSV has more symbols than expected reels amount (${reels.length})`
           );
         }
-        reels[ridx].push(symbol);
+        if (symbol) reels[ridx].push(symbol);
       });
     });
-    const reelLengths = reels.map((r) => r.length);
-    const uniqueLengths = new Set(reelLengths);
-    if (uniqueLengths.size > 1) {
-      throw new Error(
-        `Inconsistent reel lengths in reelset CSV at ${reelSetPath}: ${[
-          ...uniqueLengths
-        ].join(", ")}`
-      );
-    }
     return reels;
   }
 };
@@ -3646,12 +4301,12 @@ var GeneratedReelSet = class extends ReelSet {
         `Error generating reels for game mode "${this.associatedGameModeName}". It's not defined in the game config.`
       );
     }
-    const outputDir = config.rootDir.endsWith(config.outputDir) ? config.rootDir : path7.join(config.rootDir, config.outputDir);
-    const filePath = path7.join(
+    const outputDir = config.rootDir.endsWith(config.outputDir) ? config.rootDir : path8.join(config.rootDir, config.outputDir);
+    const filePath = path8.join(
       outputDir,
       `reels_${this.associatedGameModeName}-${this.id}.csv`
     );
-    const exists = fs5.existsSync(filePath);
+    const exists = fs6.existsSync(filePath);
     if (exists && !this.overrideExisting) {
       this.reels = this.parseReelsetCSV(filePath, config);
       return this;
@@ -3788,9 +4443,9 @@ var GeneratedReelSet = class extends ReelSet {
       }
     }
     const csvString = csvRows.map((row) => row.join(",")).join("\n");
-    if (isMainThread5) {
+    if (isMainThread6) {
       createDirIfNotExists(outputDir);
-      fs5.writeFileSync(filePath, csvString);
+      fs6.writeFileSync(filePath, csvString);
       console.log(
         `Generated reelset ${this.id} for game mode ${this.associatedGameModeName}`
       );
@@ -3801,7 +4456,7 @@ var GeneratedReelSet = class extends ReelSet {
 };
 
 // src/reel-set/StaticReelSet.ts
-import assert13 from "assert";
+import assert11 from "assert";
 var StaticReelSet = class extends ReelSet {
   reels;
   csvPath;
@@ -3811,7 +4466,7 @@ var StaticReelSet = class extends ReelSet {
     this.reels = [];
     this._strReels = opts.reels || [];
     this.csvPath = opts.csvPath || "";
-    assert13(
+    assert11(
       opts.reels || opts.csvPath,
       `Either 'reels' or 'csvPath' must be provided for StaticReelSet ${this.id}`
     );
@@ -4064,6 +4719,7 @@ export {
   OptimizationConditions,
   OptimizationParameters,
   OptimizationScaling,
+  RandomNumberGenerator,
   ResultSet,
   SPIN_TYPE,
   StandaloneBoard,
@@ -4071,6 +4727,8 @@ export {
   createSlotGame,
   defineGameModes,
   defineSymbols,
-  defineUserState
+  defineUserState,
+  parseLookupTable,
+  parseLookupTableSegmented
 };
 //# sourceMappingURL=index.mjs.map