@slot-engine/core 0.1.13 → 0.1.14

package/dist/index.d.mts

@@ -107,6 +107,7 @@ declare class Simulation {
     private wallet;
     private recordsWriteStream;
     private hasWrittenRecord;
+    private readonly streamHighWaterMark;
     private readonly maxPendingSims;
     private readonly maxHighWaterMark;
     private PATHS;

package/dist/index.d.ts

@@ -107,6 +107,7 @@ declare class Simulation {
     private wallet;
     private recordsWriteStream;
     private hasWrittenRecord;
+    private readonly streamHighWaterMark;
     private readonly maxPendingSims;
     private readonly maxHighWaterMark;
     private PATHS;

package/dist/index.js

@@ -252,68 +252,6 @@ var RandomNumberGenerator = class {
   }
 };
 
-// utils.ts
-var import_fs = __toESM(require("fs"));
-var import_readline = __toESM(require("readline"));
-function createDirIfNotExists(dirPath) {
-  if (!import_fs.default.existsSync(dirPath)) {
-    import_fs.default.mkdirSync(dirPath, { recursive: true });
-  }
-}
-function writeJsonFile(filePath, data) {
-  try {
-    import_fs.default.writeFileSync(filePath, JSON.stringify(data, null, 2), {
-      encoding: "utf8"
-    });
-  } catch (error) {
-    throw new Error(`Failed to write JSON file at ${filePath}: ${error}`);
-  }
-}
-function writeFile(filePath, data) {
-  try {
-    import_fs.default.writeFileSync(filePath, data, { encoding: "utf8" });
-  } catch (error) {
-    throw new Error(`Failed to write file at ${filePath}: ${error}`);
-  }
-}
-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 = import_fs.default.createWriteStream(outputPath, { encoding: "utf-8" });
-    writeStream.write("[\n");
-    const rl = import_readline.default.createInterface({
-      input: import_fs.default.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);
-}
-
 // src/result-set/index.ts
 var ResultSet = class {
   criteria;
@@ -380,10 +318,10 @@ var ResultSet = class {
    * Checks if core criteria is met, e.g. target multiplier or max win.
    */
   meetsCriteria(ctx) {
-    const customEval = this.evaluate?.(copy(ctx));
+    const customEval = this.evaluate?.(ctx);
     const freespinsMet = this.forceFreespins ? ctx.state.triggeredFreespins : true;
     const wallet = ctx.services.wallet._getWallet();
-    const multiplierMet = this.multiplier !== void 0 ? wallet.getCurrentWin() === this.multiplier && !this.forceMaxWin : wallet.getCurrentWin() > 0 && (!this.forceMaxWin || true);
+    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 finalResult = customEval !== void 0 ? coreCriteriaMet && customEval === true : coreCriteriaMet;
@@ -1330,6 +1268,68 @@ function createGameContext(opts) {
   return context;
 }
 
+// utils.ts
+var import_fs = __toESM(require("fs"));
+var import_readline = __toESM(require("readline"));
+function createDirIfNotExists(dirPath) {
+  if (!import_fs.default.existsSync(dirPath)) {
+    import_fs.default.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function writeJsonFile(filePath, data) {
+  try {
+    import_fs.default.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+      encoding: "utf8"
+    });
+  } catch (error) {
+    throw new Error(`Failed to write JSON file at ${filePath}: ${error}`);
+  }
+}
+function writeFile(filePath, data) {
+  try {
+    import_fs.default.writeFileSync(filePath, data, { encoding: "utf8" });
+  } catch (error) {
+    throw new Error(`Failed to write file at ${filePath}: ${error}`);
+  }
+}
+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 = import_fs.default.createWriteStream(outputPath, { encoding: "utf-8" });
+    writeStream.write("[\n");
+    const rl = import_readline.default.createInterface({
+      input: import_fs.default.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);
+}
+
 // src/book/index.ts
 var Book = class {
   id;
@@ -1711,6 +1711,7 @@ var Simulation = class {
   wallet;
   recordsWriteStream;
   hasWrittenRecord = false;
+  streamHighWaterMark = 500 * 1024 * 1024;
   maxPendingSims;
   maxHighWaterMark;
   PATHS = {};
@@ -1803,24 +1804,34 @@ Simulating game mode: ${mode}`);
         console.log(
           `Writing final files for game mode "${mode}". This may take a while...`
         );
-        const finalBookStream = import_fs2.default.createWriteStream(booksPath);
-        let isFirstChunk = true;
-        for (let i = 0; i < chunks.length; i++) {
-          const tempBookPath = this.PATHS.tempBooks(mode, i);
-          if (import_fs2.default.existsSync(tempBookPath)) {
-            if (!isFirstChunk) {
-              finalBookStream.write("\n");
-            }
-            const content = import_fs2.default.createReadStream(tempBookPath);
-            for await (const chunk of content) {
-              finalBookStream.write(chunk);
+        try {
+          const finalBookStream = import_fs2.default.createWriteStream(booksPath, {
+            highWaterMark: this.streamHighWaterMark
+          });
+          let isFirstChunk = true;
+          for (let i = 0; i < chunks.length; i++) {
+            const tempBookPath = this.PATHS.tempBooks(mode, i);
+            if (import_fs2.default.existsSync(tempBookPath)) {
+              if (!isFirstChunk) {
+                if (!finalBookStream.write("\n")) {
+                  await new Promise((r) => finalBookStream.once("drain", r));
+                }
+              }
+              const content = import_fs2.default.createReadStream(tempBookPath);
+              for await (const chunk of content) {
+                if (!finalBookStream.write(chunk)) {
+                  await new Promise((r) => finalBookStream.once("drain", r));
+                }
+              }
+              import_fs2.default.rmSync(tempBookPath);
+              isFirstChunk = false;
             }
-            import_fs2.default.rmSync(tempBookPath);
-            isFirstChunk = false;
           }
+          finalBookStream.end();
+          await new Promise((resolve) => finalBookStream.on("finish", resolve));
+        } catch (error) {
+          throw new Error(`Error merging book files: ${error.message}`);
         }
-        finalBookStream.end();
-        await new Promise((resolve) => finalBookStream.on("finish", resolve));
         const lutPath = this.PATHS.lookupTable(mode);
         const lutPathPublish = this.PATHS.lookupTablePublish(mode);
         const lutSegmentedPath = this.PATHS.lookupTableSegmented(mode);
@@ -2135,7 +2146,9 @@ ${error.stack}
     const forceRecordsPath = this.PATHS.forceRecords(mode);
     const aggregatedRecords = /* @__PURE__ */ new Map();
     if (import_fs2.default.existsSync(tempRecordsPath)) {
-      const fileStream = import_fs2.default.createReadStream(tempRecordsPath);
+      const fileStream = import_fs2.default.createReadStream(tempRecordsPath, {
+        highWaterMark: this.streamHighWaterMark
+      });
       const rl = import_readline2.default.createInterface({
         input: fileStream,
         crlfDelay: Infinity
@@ -2258,20 +2271,29 @@ ${error.stack}
     }
   }
   async mergeCsv(chunks, outPath, tempName) {
-    import_fs2.default.rmSync(outPath, { force: true });
-    const out = import_fs2.default.createWriteStream(outPath);
-    let wroteAny = false;
-    for (let i = 0; i < chunks.length; i++) {
-      const p = import_path.default.join(this.PATHS.base, TEMP_FOLDER, tempName(i));
-      if (!import_fs2.default.existsSync(p)) continue;
-      if (wroteAny) out.write("");
-      const rs = import_fs2.default.createReadStream(p);
-      for await (const buf of rs) out.write(buf);
-      import_fs2.default.rmSync(p);
-      wroteAny = true;
+    try {
+      import_fs2.default.rmSync(outPath, { force: true });
+      const out = import_fs2.default.createWriteStream(outPath, {
+        highWaterMark: this.streamHighWaterMark
+      });
+      for (let i = 0; i < chunks.length; i++) {
+        const p = import_path.default.join(this.PATHS.base, TEMP_FOLDER, tempName(i));
+        if (!import_fs2.default.existsSync(p)) continue;
+        const rs = import_fs2.default.createReadStream(p, {
+          highWaterMark: this.streamHighWaterMark
+        });
+        for await (const buf of rs) {
+          if (!out.write(buf)) {
+            await new Promise((resolve) => out.once("drain", resolve));
+          }
+        }
+        import_fs2.default.rmSync(p);
+      }
+      out.end();
+      await new Promise((resolve) => out.on("finish", resolve));
+    } catch (error) {
+      throw new Error(`Error merging CSV files: ${error.message}`);
     }
-    out.end();
-    await new Promise((resolve) => out.on("finish", resolve));
   }
   /**
    * Confirms all pending records and adds them to the main records list.