poker-flopsolve 0.3.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -79,6 +79,15 @@ function formatCombo(combo) {
79
79
  }
80
80
 
81
81
  // src/tree.ts
82
+ function isPerPlayer(value) {
83
+ return typeof value === "object" && value !== null && !Array.isArray(value) && "oop" in value && "ip" in value;
84
+ }
85
+ function forPlayer(value, player) {
86
+ return isPerPlayer(value) ? player === 0 ? value.oop : value.ip : value;
87
+ }
88
+ function mapPlayers(value, f) {
89
+ return isPerPlayer(value) ? { oop: f(value.oop), ip: f(value.ip) } : f(value);
90
+ }
82
91
  function raisesPerRound(sizes) {
83
92
  return sizes.length > 0 && Array.isArray(sizes[0]);
84
93
  }
@@ -139,14 +148,25 @@ function buildTree(config, runouts) {
139
148
  const edgeChild = [];
140
149
  const { potUnits, stackUnits, chipScale, minRaiseUnits } = config;
141
150
  const rounds = runouts.rounds;
142
- const maxRaises = perRound(config.maxRaises, Array.isArray(config.maxRaises), rounds, "maxRaises");
143
- const allowAllIn = perRound(config.allowAllIn, Array.isArray(config.allowAllIn), rounds, "allowAllIn");
151
+ const players = [0, 1];
152
+ const maxRaises = players.map((p) => {
153
+ const value = forPlayer(config.maxRaises, p);
154
+ return perRound(value, Array.isArray(value), rounds, "maxRaises");
155
+ });
156
+ const allowAllIn = players.map((p) => {
157
+ const value = forPlayer(config.allowAllIn, p);
158
+ return perRound(value, Array.isArray(value), rounds, "allowAllIn");
159
+ });
144
160
  const merge = config.mergeSizes ?? 0;
145
- const raiseSizes = config.raiseSizes ? perRound(config.raiseSizes, raisesPerRound(config.raiseSizes), rounds, "raiseSizes").map(
146
- (row) => mergeBetSizes(row, merge)
147
- ) : null;
148
- const betSizes = config.betSizes.map((row) => mergeBetSizes(row, merge));
149
- const threshold = perRound(config.allInThreshold ?? 0, Array.isArray(config.allInThreshold), rounds, "allInThreshold");
161
+ const raiseSizes = players.map((p) => {
162
+ const value = forPlayer(config.raiseSizes, p);
163
+ return value ? perRound(value, raisesPerRound(value), rounds, "raiseSizes").map((row) => mergeBetSizes(row, merge)) : null;
164
+ });
165
+ const betSizes = players.map((p) => forPlayer(config.betSizes, p).map((row) => mergeBetSizes(row, merge)));
166
+ const threshold = players.map((p) => {
167
+ const value = forPlayer(config.allInThreshold, p) ?? 0;
168
+ return perRound(value, Array.isArray(value), rounds, "allInThreshold");
169
+ });
150
170
  const noDonk = perRound(config.noDonk ?? false, Array.isArray(config.noDonk), rounds, "noDonk");
151
171
  const half = Math.round(potUnits / 2);
152
172
  const addNode = (nodeKind, nodePlayer, nodeRound, nodePot, nodePayoff) => {
@@ -225,13 +245,14 @@ function buildTree(config, runouts) {
225
245
  });
226
246
  const cap = Math.min(stackUnits, theirs + (stackUnits - theirs));
227
247
  const donk = noDonk[state.round] && me === 0 && owed === 0 && state.aggressions === 0 && state.previousAggressor === 1;
228
- if (state.aggressions < maxRaises[state.round] && myRemaining > owed && !donk) {
248
+ if (state.aggressions < maxRaises[me][state.round] && myRemaining > owed && !donk) {
229
249
  const seen = /* @__PURE__ */ new Set();
230
- const sizes = owed > 0 && raiseSizes ? [...raiseSizes[state.round]] : [...betSizes[state.round] ?? []].filter((size) => !(typeof size === "object" && "times" in size));
231
- if (allowAllIn[state.round]) sizes.push("allin");
250
+ const myRaises = raiseSizes[me];
251
+ const sizes = owed > 0 && myRaises ? [...myRaises[state.round]] : [...betSizes[me][state.round] ?? []].filter((size) => !(typeof size === "object" && "times" in size));
252
+ if (allowAllIn[me][state.round]) sizes.push("allin");
232
253
  for (const size of sizes) {
233
254
  let target = resolveTarget(size, state, cap);
234
- if (target !== null && threshold[state.round] > 0 && target - mine >= threshold[state.round] * myRemaining) {
255
+ if (target !== null && threshold[me][state.round] > 0 && target - mine >= threshold[me][state.round] * myRemaining) {
235
256
  target = cap;
236
257
  }
237
258
  if (target === null || seen.has(target)) continue;
@@ -2084,6 +2105,212 @@ var ENGINE_WASM = "AGFzbQEAAAABTglgAX8AYAZ/f39/f38Bf2AFf39/f38AYAd/f39/f3x/AGADf
2084
2105
  // src/wasm/engine-shared.ts
2085
2106
  var ENGINE_SHARED_WASM = "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";
2086
2107
 
2108
+ // src/platform/node.ts
2109
+ import { availableParallelism } from "os";
2110
+ import { fileURLToPath } from "url";
2111
+ import { Worker } from "worker_threads";
2112
+ var PLATFORM = "node";
2113
+ var THREADS_AVAILABLE = true;
2114
+ var DEFAULT_MAX_BYTES = 6 * 1024 * 1024 * 1024;
2115
+ function workerFlags() {
2116
+ return process.execArgv.filter((flag) => !flag.startsWith("--input-type"));
2117
+ }
2118
+ function defaultWorkerCount() {
2119
+ const cores = availableParallelism();
2120
+ return cores < 2 ? 1 : Math.max(2, cores - 1);
2121
+ }
2122
+ function spawnWorker(setup, onError) {
2123
+ const url = new URL(import.meta.url.endsWith(".ts") ? "../worker.ts" : "./worker.js", import.meta.url);
2124
+ const thread = new Worker(fileURLToPath(url), { workerData: setup, execArgv: workerFlags() });
2125
+ thread.on("error", onError);
2126
+ thread.unref();
2127
+ return {
2128
+ terminate() {
2129
+ void thread.terminate();
2130
+ }
2131
+ };
2132
+ }
2133
+ function spawnEngineWorker(setup, onError) {
2134
+ const url = new URL(import.meta.url.endsWith(".ts") ? "../engine-worker.ts" : "./engine-worker.js", import.meta.url);
2135
+ const thread = new Worker(fileURLToPath(url), { workerData: setup, execArgv: workerFlags() });
2136
+ thread.on("error", onError);
2137
+ thread.unref();
2138
+ return {
2139
+ terminate() {
2140
+ void thread.terminate();
2141
+ }
2142
+ };
2143
+ }
2144
+
2145
+ // src/parallel.ts
2146
+ var CONTROL = {
2147
+ generation: 0,
2148
+ done: 1,
2149
+ command: 2,
2150
+ traverser: 3,
2151
+ iterWeight: 4,
2152
+ ready: 5,
2153
+ mode: 6,
2154
+ size: 8
2155
+ };
2156
+ var COMMAND = { work: 0, exit: 1 };
2157
+ var WORKER_START_MS = 3e4;
2158
+ var WORKER_START_ERROR = "Worker threads did not start within 30 s. Run with workers: 1, or check that worker threads can load this package.";
2159
+ function planShards(tree, runouts, workers) {
2160
+ if (workers < 2) return null;
2161
+ let round = -1;
2162
+ for (let r = 1; r < runouts.rounds; r++) {
2163
+ if (runouts.counts[r] > 1) {
2164
+ round = r;
2165
+ break;
2166
+ }
2167
+ }
2168
+ if (round < 0) return null;
2169
+ const boards = runouts.counts[round];
2170
+ if (boards < workers * 2) return null;
2171
+ const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
2172
+ const entryNodes = [];
2173
+ for (let node = 0; node < tree.nodeCount; node++) {
2174
+ if (tree.kind[node] !== NodeKind.Chance) continue;
2175
+ if (tree.round[node] + 1 !== round) continue;
2176
+ entryIndexOf[node] = entryNodes.length;
2177
+ entryNodes.push(node);
2178
+ }
2179
+ if (entryNodes.length === 0) return null;
2180
+ const bounds = new Int32Array(workers + 1);
2181
+ for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
2182
+ return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
2183
+ }
2184
+ function startPool(ctx, solver, plan, payload, workers) {
2185
+ const entryCount = plan.entryNodes.length;
2186
+ const spawned = workers - 1;
2187
+ const reachFloats = entryCount * 2 * COMBOS;
2188
+ const partialFloats = spawned * entryCount * COMBOS;
2189
+ const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
2190
+ const exchange = new Float64Array(exchangeBuffer);
2191
+ const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
2192
+ const control = new Int32Array(controlBuffer);
2193
+ const threads = [];
2194
+ let failure = null;
2195
+ for (let w = 0; w < spawned; w++) {
2196
+ const setup = {
2197
+ workerId: w,
2198
+ payload,
2199
+ plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
2200
+ shardStart: plan.bounds[w + 1],
2201
+ shardEnd: plan.bounds[w + 2],
2202
+ regret: ctx.regret.buffer,
2203
+ strategySum: ctx.strategySum.buffer,
2204
+ regretScale: ctx.regretScale?.buffer ?? null,
2205
+ sumScale: ctx.sumScale?.buffer ?? null,
2206
+ control: controlBuffer,
2207
+ exchange: exchangeBuffer,
2208
+ entryCount
2209
+ };
2210
+ const thread = spawnWorker(setup, (error) => {
2211
+ failure ??= error;
2212
+ Atomics.store(control, CONTROL.ready, spawned);
2213
+ Atomics.add(control, CONTROL.done, spawned);
2214
+ Atomics.notify(control, CONTROL.done);
2215
+ Atomics.notify(control, CONTROL.ready);
2216
+ });
2217
+ threads.push(thread);
2218
+ }
2219
+ const deadline = Date.now() + WORKER_START_MS;
2220
+ for (; ; ) {
2221
+ const ready = Atomics.load(control, CONTROL.ready);
2222
+ if (ready >= spawned || failure) break;
2223
+ if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
2224
+ else Atomics.wait(control, CONTROL.ready, ready, 20);
2225
+ }
2226
+ if (failure) {
2227
+ for (const thread of threads) thread.terminate();
2228
+ throw failure;
2229
+ }
2230
+ const total = new Float64Array(COMBOS);
2231
+ const chanceValues = new Float64Array(entryCount * COMBOS);
2232
+ const mainReachMe = new Float64Array(COMBOS);
2233
+ const mainReachOpp = new Float64Array(COMBOS);
2234
+ const dispatch = (mode, traverser, iterWeight) => {
2235
+ Atomics.store(control, CONTROL.done, 0);
2236
+ Atomics.store(control, CONTROL.mode, mode);
2237
+ Atomics.store(control, CONTROL.traverser, traverser);
2238
+ Atomics.store(control, CONTROL.iterWeight, iterWeight);
2239
+ Atomics.store(control, CONTROL.command, COMMAND.work);
2240
+ Atomics.add(control, CONTROL.generation, 1);
2241
+ Atomics.notify(control, CONTROL.generation);
2242
+ const fullStart = ctx.shardStart;
2243
+ const fullEnd = ctx.shardEnd;
2244
+ ctx.shardStart = plan.bounds[0];
2245
+ ctx.shardEnd = plan.bounds[1];
2246
+ ctx.applyUpdates = true;
2247
+ try {
2248
+ for (let entry = 0; entry < entryCount; entry++) {
2249
+ for (let i = 0; i < COMBOS; i++) {
2250
+ mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
2251
+ mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
2252
+ }
2253
+ const value = solver.traverseChance(
2254
+ mode,
2255
+ traverser,
2256
+ iterWeight,
2257
+ plan.entryNodes[entry],
2258
+ mainReachMe,
2259
+ mainReachOpp
2260
+ );
2261
+ chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
2262
+ }
2263
+ } finally {
2264
+ ctx.shardStart = fullStart;
2265
+ ctx.shardEnd = fullEnd;
2266
+ }
2267
+ for (; ; ) {
2268
+ const done = Atomics.load(control, CONTROL.done);
2269
+ if (done >= spawned) break;
2270
+ if (failure) throw failure;
2271
+ Atomics.wait(control, CONTROL.done, done, 50);
2272
+ }
2273
+ if (failure) throw failure;
2274
+ };
2275
+ return {
2276
+ workers,
2277
+ traverse(mode, traverser, iterWeight) {
2278
+ ctx.applyUpdates = false;
2279
+ ctx.chanceOverride = null;
2280
+ ctx.chanceCollect = (node, reachMe, reachOpp) => {
2281
+ const entry = plan.entryIndexOf[node];
2282
+ exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
2283
+ exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
2284
+ };
2285
+ try {
2286
+ solver.traverseRoot(mode, traverser, iterWeight);
2287
+ } finally {
2288
+ ctx.chanceCollect = null;
2289
+ }
2290
+ dispatch(mode, traverser, iterWeight);
2291
+ for (let w = 0; w < spawned; w++) {
2292
+ const base = reachFloats + w * entryCount * COMBOS;
2293
+ for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
2294
+ }
2295
+ ctx.chanceOverride = chanceValues;
2296
+ ctx.applyUpdates = true;
2297
+ try {
2298
+ const value = solver.traverseRoot(mode, traverser, iterWeight);
2299
+ total.set(value.subarray(0, COMBOS));
2300
+ } finally {
2301
+ ctx.chanceOverride = null;
2302
+ }
2303
+ return total;
2304
+ },
2305
+ close() {
2306
+ Atomics.store(control, CONTROL.command, COMMAND.exit);
2307
+ Atomics.add(control, CONTROL.generation, 1);
2308
+ Atomics.notify(control, CONTROL.generation);
2309
+ for (const thread of threads) thread.terminate();
2310
+ }
2311
+ };
2312
+ }
2313
+
2087
2314
  // src/engine.ts
2088
2315
  var wasm2 = globalThis.WebAssembly;
2089
2316
  var modules = { plain: void 0, shared: void 0 };
@@ -2255,10 +2482,12 @@ function createEngine(input, pool) {
2255
2482
  Atomics.notify(control, ENGINE_CONTROL.ready);
2256
2483
  }));
2257
2484
  }
2485
+ const deadline = Date.now() + WORKER_START_MS;
2258
2486
  for (; ; ) {
2259
2487
  const ready = Atomics.load(control, ENGINE_CONTROL.ready);
2260
2488
  if (ready >= threads - 1 || failure) break;
2261
- Atomics.wait(control, ENGINE_CONTROL.ready, ready, 20);
2489
+ if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
2490
+ else Atomics.wait(control, ENGINE_CONTROL.ready, ready, 20);
2262
2491
  }
2263
2492
  if (failure) {
2264
2493
  for (const worker of workers) worker.terminate();
@@ -2464,205 +2693,6 @@ function warmStart(to, from, averages) {
2464
2693
  return { matchedNodes: matched, decisionNodes: tree.decisionNodes.length, averages };
2465
2694
  }
2466
2695
 
2467
- // src/platform/node.ts
2468
- import { availableParallelism } from "os";
2469
- import { fileURLToPath } from "url";
2470
- import { Worker } from "worker_threads";
2471
- var PLATFORM = "node";
2472
- var THREADS_AVAILABLE = true;
2473
- var DEFAULT_MAX_BYTES = 6 * 1024 * 1024 * 1024;
2474
- function defaultWorkerCount() {
2475
- const cores = availableParallelism();
2476
- return cores < 2 ? 1 : Math.max(2, cores - 1);
2477
- }
2478
- function spawnWorker(setup, onError) {
2479
- const url = new URL(import.meta.url.endsWith(".ts") ? "../worker.ts" : "./worker.js", import.meta.url);
2480
- const thread = new Worker(fileURLToPath(url), { workerData: setup });
2481
- thread.on("error", onError);
2482
- thread.unref();
2483
- return {
2484
- terminate() {
2485
- void thread.terminate();
2486
- }
2487
- };
2488
- }
2489
- function spawnEngineWorker(setup, onError) {
2490
- const url = new URL(import.meta.url.endsWith(".ts") ? "../engine-worker.ts" : "./engine-worker.js", import.meta.url);
2491
- const thread = new Worker(fileURLToPath(url), { workerData: setup });
2492
- thread.on("error", onError);
2493
- thread.unref();
2494
- return {
2495
- terminate() {
2496
- void thread.terminate();
2497
- }
2498
- };
2499
- }
2500
-
2501
- // src/parallel.ts
2502
- var CONTROL = {
2503
- generation: 0,
2504
- done: 1,
2505
- command: 2,
2506
- traverser: 3,
2507
- iterWeight: 4,
2508
- ready: 5,
2509
- mode: 6,
2510
- size: 8
2511
- };
2512
- var COMMAND = { work: 0, exit: 1 };
2513
- function planShards(tree, runouts, workers) {
2514
- if (workers < 2) return null;
2515
- let round = -1;
2516
- for (let r = 1; r < runouts.rounds; r++) {
2517
- if (runouts.counts[r] > 1) {
2518
- round = r;
2519
- break;
2520
- }
2521
- }
2522
- if (round < 0) return null;
2523
- const boards = runouts.counts[round];
2524
- if (boards < workers * 2) return null;
2525
- const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
2526
- const entryNodes = [];
2527
- for (let node = 0; node < tree.nodeCount; node++) {
2528
- if (tree.kind[node] !== NodeKind.Chance) continue;
2529
- if (tree.round[node] + 1 !== round) continue;
2530
- entryIndexOf[node] = entryNodes.length;
2531
- entryNodes.push(node);
2532
- }
2533
- if (entryNodes.length === 0) return null;
2534
- const bounds = new Int32Array(workers + 1);
2535
- for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
2536
- return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
2537
- }
2538
- function startPool(ctx, solver, plan, payload, workers) {
2539
- const entryCount = plan.entryNodes.length;
2540
- const spawned = workers - 1;
2541
- const reachFloats = entryCount * 2 * COMBOS;
2542
- const partialFloats = spawned * entryCount * COMBOS;
2543
- const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
2544
- const exchange = new Float64Array(exchangeBuffer);
2545
- const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
2546
- const control = new Int32Array(controlBuffer);
2547
- const threads = [];
2548
- let failure = null;
2549
- for (let w = 0; w < spawned; w++) {
2550
- const setup = {
2551
- workerId: w,
2552
- payload,
2553
- plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
2554
- shardStart: plan.bounds[w + 1],
2555
- shardEnd: plan.bounds[w + 2],
2556
- regret: ctx.regret.buffer,
2557
- strategySum: ctx.strategySum.buffer,
2558
- regretScale: ctx.regretScale?.buffer ?? null,
2559
- sumScale: ctx.sumScale?.buffer ?? null,
2560
- control: controlBuffer,
2561
- exchange: exchangeBuffer,
2562
- entryCount
2563
- };
2564
- const thread = spawnWorker(setup, (error) => {
2565
- failure ??= error;
2566
- Atomics.store(control, CONTROL.ready, spawned);
2567
- Atomics.add(control, CONTROL.done, spawned);
2568
- Atomics.notify(control, CONTROL.done);
2569
- Atomics.notify(control, CONTROL.ready);
2570
- });
2571
- threads.push(thread);
2572
- }
2573
- for (; ; ) {
2574
- const ready = Atomics.load(control, CONTROL.ready);
2575
- if (ready >= spawned || failure) break;
2576
- Atomics.wait(control, CONTROL.ready, ready, 20);
2577
- }
2578
- if (failure) {
2579
- for (const thread of threads) thread.terminate();
2580
- throw failure;
2581
- }
2582
- const total = new Float64Array(COMBOS);
2583
- const chanceValues = new Float64Array(entryCount * COMBOS);
2584
- const mainReachMe = new Float64Array(COMBOS);
2585
- const mainReachOpp = new Float64Array(COMBOS);
2586
- const dispatch = (mode, traverser, iterWeight) => {
2587
- Atomics.store(control, CONTROL.done, 0);
2588
- Atomics.store(control, CONTROL.mode, mode);
2589
- Atomics.store(control, CONTROL.traverser, traverser);
2590
- Atomics.store(control, CONTROL.iterWeight, iterWeight);
2591
- Atomics.store(control, CONTROL.command, COMMAND.work);
2592
- Atomics.add(control, CONTROL.generation, 1);
2593
- Atomics.notify(control, CONTROL.generation);
2594
- const fullStart = ctx.shardStart;
2595
- const fullEnd = ctx.shardEnd;
2596
- ctx.shardStart = plan.bounds[0];
2597
- ctx.shardEnd = plan.bounds[1];
2598
- ctx.applyUpdates = true;
2599
- try {
2600
- for (let entry = 0; entry < entryCount; entry++) {
2601
- for (let i = 0; i < COMBOS; i++) {
2602
- mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
2603
- mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
2604
- }
2605
- const value = solver.traverseChance(
2606
- mode,
2607
- traverser,
2608
- iterWeight,
2609
- plan.entryNodes[entry],
2610
- mainReachMe,
2611
- mainReachOpp
2612
- );
2613
- chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
2614
- }
2615
- } finally {
2616
- ctx.shardStart = fullStart;
2617
- ctx.shardEnd = fullEnd;
2618
- }
2619
- for (; ; ) {
2620
- const done = Atomics.load(control, CONTROL.done);
2621
- if (done >= spawned) break;
2622
- if (failure) throw failure;
2623
- Atomics.wait(control, CONTROL.done, done, 50);
2624
- }
2625
- if (failure) throw failure;
2626
- };
2627
- return {
2628
- workers,
2629
- traverse(mode, traverser, iterWeight) {
2630
- ctx.applyUpdates = false;
2631
- ctx.chanceOverride = null;
2632
- ctx.chanceCollect = (node, reachMe, reachOpp) => {
2633
- const entry = plan.entryIndexOf[node];
2634
- exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
2635
- exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
2636
- };
2637
- try {
2638
- solver.traverseRoot(mode, traverser, iterWeight);
2639
- } finally {
2640
- ctx.chanceCollect = null;
2641
- }
2642
- dispatch(mode, traverser, iterWeight);
2643
- for (let w = 0; w < spawned; w++) {
2644
- const base = reachFloats + w * entryCount * COMBOS;
2645
- for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
2646
- }
2647
- ctx.chanceOverride = chanceValues;
2648
- ctx.applyUpdates = true;
2649
- try {
2650
- const value = solver.traverseRoot(mode, traverser, iterWeight);
2651
- total.set(value.subarray(0, COMBOS));
2652
- } finally {
2653
- ctx.chanceOverride = null;
2654
- }
2655
- return total;
2656
- },
2657
- close() {
2658
- Atomics.store(control, CONTROL.command, COMMAND.exit);
2659
- Atomics.add(control, CONTROL.generation, 1);
2660
- Atomics.notify(control, CONTROL.generation);
2661
- for (const thread of threads) thread.terminate();
2662
- }
2663
- };
2664
- }
2665
-
2666
2696
  // src/index.ts
2667
2697
  var DEFAULT_CHIP_SCALE = 100;
2668
2698
  var OPS_PER_SECOND = 2e8;
@@ -2700,12 +2730,16 @@ function defineSpot(config) {
2700
2730
  const rounds = 6 - board.length;
2701
2731
  if (config.pot <= 0) throw new Error("pot must be positive");
2702
2732
  if (config.stack <= 0) throw new Error("stack must be positive");
2703
- const rows = config.betSizes.length === 1 ? Array.from({ length: rounds }, () => config.betSizes[0]) : config.betSizes;
2704
- if (rows.length !== rounds) {
2705
- throw new Error(
2706
- `betSizes has ${config.betSizes.length} rows but this board has ${rounds} betting rounds; give one row per round, or a single row for all of them`
2707
- );
2708
- }
2733
+ const rowsFor = (sizes, who) => {
2734
+ const expanded = sizes.length === 1 ? Array.from({ length: rounds }, () => sizes[0]) : sizes;
2735
+ if (expanded.length !== rounds) {
2736
+ throw new Error(
2737
+ `${who}betSizes has ${sizes.length} rows but this board has ${rounds} betting rounds; give one row per round, or a single row for all of them`
2738
+ );
2739
+ }
2740
+ return expanded;
2741
+ };
2742
+ const rows = isPerPlayer(config.betSizes) ? { oop: rowsFor(config.betSizes.oop, "oop "), ip: rowsFor(config.betSizes.ip, "ip ") } : rowsFor(config.betSizes, "");
2709
2743
  const onBoard = new Set(board);
2710
2744
  const trim = (range, who) => {
2711
2745
  const weights = typeof range === "string" ? parseRange(range) : Float64Array.from(range);
@@ -2763,9 +2797,10 @@ function defineSpot(config) {
2763
2797
  const compressedBytes = buildLayout(tree, runouts, players, 2).bytes + showdownBytes;
2764
2798
  const suggestions = [];
2765
2799
  if (compressedBytes > maxBytes) {
2766
- const widest = Math.max(...rows.map((r) => r.length));
2800
+ const widest = Math.max(...[0, 1].flatMap((p) => forPlayer(rows, p).map((r) => r.length)));
2767
2801
  if (widest > 1) suggestions.push(`use fewer bet sizes (currently up to ${widest} per round)`);
2768
- if (Math.max(...[config.maxRaises ?? 1].flat()) > 1) suggestions.push(`lower maxRaises to 1`);
2802
+ const raises = [0, 1].flatMap((p) => [forPlayer(config.maxRaises ?? 1, p)].flat());
2803
+ if (Math.max(...raises) > 1) suggestions.push(`lower maxRaises to 1`);
2769
2804
  suggestions.push(`narrow the ranges (currently ${players[0].count} and ${players[1].count} combos)`);
2770
2805
  if (runouts.rounds === 3) suggestions.push("solve from the turn instead of the flop");
2771
2806
  }
@@ -3113,8 +3148,9 @@ function makeSolution(spot, ctx, solver, iterations, totalIterations, history, s
3113
3148
  const invested = (tree.pot[node] - spot.potUnits) / 2;
3114
3149
  const { source } = spot;
3115
3150
  const later = (value, listed) => listed && value.length > 1 ? value.slice(round) : value;
3116
- const rows = later(source.betSizes, true);
3117
- const raiseRows = source.raiseSizes && later(source.raiseSizes, raisesPerRound(source.raiseSizes));
3151
+ const laterEach = (value, listed) => value === void 0 ? void 0 : mapPlayers(value, (side) => later(side, listed(side)));
3152
+ const rows = laterEach(source.betSizes, () => true);
3153
+ const raiseRows = laterEach(source.raiseSizes, (side) => side !== void 0 && raisesPerRound(side));
3118
3154
  return {
3119
3155
  board: formatCards(cards),
3120
3156
  pot: tree.pot[node] / spot.chipScale,
@@ -3123,9 +3159,9 @@ function makeSolution(spot, ctx, solver, iterations, totalIterations, history, s
3123
3159
  ip: reachAt(node, board, 1),
3124
3160
  betSizes: betting.betSizes ?? rows,
3125
3161
  raiseSizes: "raiseSizes" in betting ? betting.raiseSizes : raiseRows,
3126
- maxRaises: betting.maxRaises ?? (source.maxRaises === void 0 ? void 0 : later(source.maxRaises, Array.isArray(source.maxRaises))),
3127
- allowAllIn: betting.allowAllIn ?? (source.allowAllIn === void 0 ? void 0 : later(source.allowAllIn, Array.isArray(source.allowAllIn))),
3128
- allInThreshold: "allInThreshold" in betting ? betting.allInThreshold : source.allInThreshold === void 0 ? void 0 : later(source.allInThreshold, Array.isArray(source.allInThreshold)),
3162
+ maxRaises: betting.maxRaises ?? laterEach(source.maxRaises, Array.isArray),
3163
+ allowAllIn: betting.allowAllIn ?? laterEach(source.allowAllIn, Array.isArray),
3164
+ allInThreshold: "allInThreshold" in betting ? betting.allInThreshold : laterEach(source.allInThreshold, Array.isArray),
3129
3165
  noDonk: "noDonk" in betting ? betting.noDonk : source.noDonk === void 0 ? void 0 : later(source.noDonk, Array.isArray(source.noDonk)),
3130
3166
  mergeSizes: "mergeSizes" in betting ? betting.mergeSizes : source.mergeSizes,
3131
3167
  minWeight: source.minWeight,