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/README.md CHANGED
@@ -107,6 +107,24 @@ defineSpot({ ..., board: 'Qs Jh 4d',
107
107
 
108
108
  A subgame keeps the rounds from its own onwards.
109
109
 
110
+ ### Betting per player
111
+
112
+ Every betting setting — `betSizes`, `raiseSizes`, `maxRaises`, `allowAllIn`,
113
+ `allInThreshold` — can also be given apart for each player, each side in its usual form:
114
+
115
+ ```ts
116
+ defineSpot({ ...,
117
+ betSizes: { oop: [[0.33]], ip: [[0.5, 1.25]] }, // OOP bets small, IP bets half or overbets
118
+ maxRaises: { oop: 2, ip: 1 }, // only OOP may raise a bet
119
+ allowAllIn: { oop: false, ip: true },
120
+ });
121
+ ```
122
+
123
+ Settings only shape the betting tree, which is built once before solving, so this costs
124
+ nothing per iteration: the same game given plainly or per player solves at the same
125
+ speed, and asymmetric sizes cost exactly what their tree does. With `maxRaises` apart, a
126
+ player may bet or raise only while the round's aggressions are under their own limit.
127
+
110
128
  ### Trimming the tree
111
129
 
112
130
  Tree size multiplies everything else, so three switches cut the lines that cost the most
package/dist/browser.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,189 @@ 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/browser.ts
2109
+ var PLATFORM = "browser";
2110
+ var THREADS_AVAILABLE = false;
2111
+ var DEFAULT_MAX_BYTES = 512 * 1024 * 1024;
2112
+ function defaultWorkerCount() {
2113
+ return 1;
2114
+ }
2115
+ function spawnWorker(_setup, _onError) {
2116
+ throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
2117
+ }
2118
+ function spawnEngineWorker(_setup, _onError) {
2119
+ throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
2120
+ }
2121
+
2122
+ // src/parallel.ts
2123
+ var CONTROL = {
2124
+ generation: 0,
2125
+ done: 1,
2126
+ command: 2,
2127
+ traverser: 3,
2128
+ iterWeight: 4,
2129
+ ready: 5,
2130
+ mode: 6,
2131
+ size: 8
2132
+ };
2133
+ var COMMAND = { work: 0, exit: 1 };
2134
+ var WORKER_START_MS = 3e4;
2135
+ 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.";
2136
+ function planShards(tree, runouts, workers) {
2137
+ if (workers < 2) return null;
2138
+ let round = -1;
2139
+ for (let r = 1; r < runouts.rounds; r++) {
2140
+ if (runouts.counts[r] > 1) {
2141
+ round = r;
2142
+ break;
2143
+ }
2144
+ }
2145
+ if (round < 0) return null;
2146
+ const boards = runouts.counts[round];
2147
+ if (boards < workers * 2) return null;
2148
+ const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
2149
+ const entryNodes = [];
2150
+ for (let node = 0; node < tree.nodeCount; node++) {
2151
+ if (tree.kind[node] !== NodeKind.Chance) continue;
2152
+ if (tree.round[node] + 1 !== round) continue;
2153
+ entryIndexOf[node] = entryNodes.length;
2154
+ entryNodes.push(node);
2155
+ }
2156
+ if (entryNodes.length === 0) return null;
2157
+ const bounds = new Int32Array(workers + 1);
2158
+ for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
2159
+ return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
2160
+ }
2161
+ function startPool(ctx, solver, plan, payload, workers) {
2162
+ const entryCount = plan.entryNodes.length;
2163
+ const spawned = workers - 1;
2164
+ const reachFloats = entryCount * 2 * COMBOS;
2165
+ const partialFloats = spawned * entryCount * COMBOS;
2166
+ const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
2167
+ const exchange = new Float64Array(exchangeBuffer);
2168
+ const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
2169
+ const control = new Int32Array(controlBuffer);
2170
+ const threads = [];
2171
+ let failure = null;
2172
+ for (let w = 0; w < spawned; w++) {
2173
+ const setup = {
2174
+ workerId: w,
2175
+ payload,
2176
+ plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
2177
+ shardStart: plan.bounds[w + 1],
2178
+ shardEnd: plan.bounds[w + 2],
2179
+ regret: ctx.regret.buffer,
2180
+ strategySum: ctx.strategySum.buffer,
2181
+ regretScale: ctx.regretScale?.buffer ?? null,
2182
+ sumScale: ctx.sumScale?.buffer ?? null,
2183
+ control: controlBuffer,
2184
+ exchange: exchangeBuffer,
2185
+ entryCount
2186
+ };
2187
+ const thread = spawnWorker(setup, (error) => {
2188
+ failure ??= error;
2189
+ Atomics.store(control, CONTROL.ready, spawned);
2190
+ Atomics.add(control, CONTROL.done, spawned);
2191
+ Atomics.notify(control, CONTROL.done);
2192
+ Atomics.notify(control, CONTROL.ready);
2193
+ });
2194
+ threads.push(thread);
2195
+ }
2196
+ const deadline = Date.now() + WORKER_START_MS;
2197
+ for (; ; ) {
2198
+ const ready = Atomics.load(control, CONTROL.ready);
2199
+ if (ready >= spawned || failure) break;
2200
+ if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
2201
+ else Atomics.wait(control, CONTROL.ready, ready, 20);
2202
+ }
2203
+ if (failure) {
2204
+ for (const thread of threads) thread.terminate();
2205
+ throw failure;
2206
+ }
2207
+ const total = new Float64Array(COMBOS);
2208
+ const chanceValues = new Float64Array(entryCount * COMBOS);
2209
+ const mainReachMe = new Float64Array(COMBOS);
2210
+ const mainReachOpp = new Float64Array(COMBOS);
2211
+ const dispatch = (mode, traverser, iterWeight) => {
2212
+ Atomics.store(control, CONTROL.done, 0);
2213
+ Atomics.store(control, CONTROL.mode, mode);
2214
+ Atomics.store(control, CONTROL.traverser, traverser);
2215
+ Atomics.store(control, CONTROL.iterWeight, iterWeight);
2216
+ Atomics.store(control, CONTROL.command, COMMAND.work);
2217
+ Atomics.add(control, CONTROL.generation, 1);
2218
+ Atomics.notify(control, CONTROL.generation);
2219
+ const fullStart = ctx.shardStart;
2220
+ const fullEnd = ctx.shardEnd;
2221
+ ctx.shardStart = plan.bounds[0];
2222
+ ctx.shardEnd = plan.bounds[1];
2223
+ ctx.applyUpdates = true;
2224
+ try {
2225
+ for (let entry = 0; entry < entryCount; entry++) {
2226
+ for (let i = 0; i < COMBOS; i++) {
2227
+ mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
2228
+ mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
2229
+ }
2230
+ const value = solver.traverseChance(
2231
+ mode,
2232
+ traverser,
2233
+ iterWeight,
2234
+ plan.entryNodes[entry],
2235
+ mainReachMe,
2236
+ mainReachOpp
2237
+ );
2238
+ chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
2239
+ }
2240
+ } finally {
2241
+ ctx.shardStart = fullStart;
2242
+ ctx.shardEnd = fullEnd;
2243
+ }
2244
+ for (; ; ) {
2245
+ const done = Atomics.load(control, CONTROL.done);
2246
+ if (done >= spawned) break;
2247
+ if (failure) throw failure;
2248
+ Atomics.wait(control, CONTROL.done, done, 50);
2249
+ }
2250
+ if (failure) throw failure;
2251
+ };
2252
+ return {
2253
+ workers,
2254
+ traverse(mode, traverser, iterWeight) {
2255
+ ctx.applyUpdates = false;
2256
+ ctx.chanceOverride = null;
2257
+ ctx.chanceCollect = (node, reachMe, reachOpp) => {
2258
+ const entry = plan.entryIndexOf[node];
2259
+ exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
2260
+ exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
2261
+ };
2262
+ try {
2263
+ solver.traverseRoot(mode, traverser, iterWeight);
2264
+ } finally {
2265
+ ctx.chanceCollect = null;
2266
+ }
2267
+ dispatch(mode, traverser, iterWeight);
2268
+ for (let w = 0; w < spawned; w++) {
2269
+ const base = reachFloats + w * entryCount * COMBOS;
2270
+ for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
2271
+ }
2272
+ ctx.chanceOverride = chanceValues;
2273
+ ctx.applyUpdates = true;
2274
+ try {
2275
+ const value = solver.traverseRoot(mode, traverser, iterWeight);
2276
+ total.set(value.subarray(0, COMBOS));
2277
+ } finally {
2278
+ ctx.chanceOverride = null;
2279
+ }
2280
+ return total;
2281
+ },
2282
+ close() {
2283
+ Atomics.store(control, CONTROL.command, COMMAND.exit);
2284
+ Atomics.add(control, CONTROL.generation, 1);
2285
+ Atomics.notify(control, CONTROL.generation);
2286
+ for (const thread of threads) thread.terminate();
2287
+ }
2288
+ };
2289
+ }
2290
+
2087
2291
  // src/engine.ts
2088
2292
  var wasm2 = globalThis.WebAssembly;
2089
2293
  var modules = { plain: void 0, shared: void 0 };
@@ -2255,10 +2459,12 @@ function createEngine(input, pool) {
2255
2459
  Atomics.notify(control, ENGINE_CONTROL.ready);
2256
2460
  }));
2257
2461
  }
2462
+ const deadline = Date.now() + WORKER_START_MS;
2258
2463
  for (; ; ) {
2259
2464
  const ready = Atomics.load(control, ENGINE_CONTROL.ready);
2260
2465
  if (ready >= threads - 1 || failure) break;
2261
- Atomics.wait(control, ENGINE_CONTROL.ready, ready, 20);
2466
+ if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
2467
+ else Atomics.wait(control, ENGINE_CONTROL.ready, ready, 20);
2262
2468
  }
2263
2469
  if (failure) {
2264
2470
  for (const worker of workers) worker.terminate();
@@ -2464,185 +2670,6 @@ function warmStart(to, from, averages) {
2464
2670
  return { matchedNodes: matched, decisionNodes: tree.decisionNodes.length, averages };
2465
2671
  }
2466
2672
 
2467
- // src/platform/browser.ts
2468
- var PLATFORM = "browser";
2469
- var THREADS_AVAILABLE = false;
2470
- var DEFAULT_MAX_BYTES = 512 * 1024 * 1024;
2471
- function defaultWorkerCount() {
2472
- return 1;
2473
- }
2474
- function spawnWorker(_setup, _onError) {
2475
- throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
2476
- }
2477
- function spawnEngineWorker(_setup, _onError) {
2478
- throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
2479
- }
2480
-
2481
- // src/parallel.ts
2482
- var CONTROL = {
2483
- generation: 0,
2484
- done: 1,
2485
- command: 2,
2486
- traverser: 3,
2487
- iterWeight: 4,
2488
- ready: 5,
2489
- mode: 6,
2490
- size: 8
2491
- };
2492
- var COMMAND = { work: 0, exit: 1 };
2493
- function planShards(tree, runouts, workers) {
2494
- if (workers < 2) return null;
2495
- let round = -1;
2496
- for (let r = 1; r < runouts.rounds; r++) {
2497
- if (runouts.counts[r] > 1) {
2498
- round = r;
2499
- break;
2500
- }
2501
- }
2502
- if (round < 0) return null;
2503
- const boards = runouts.counts[round];
2504
- if (boards < workers * 2) return null;
2505
- const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
2506
- const entryNodes = [];
2507
- for (let node = 0; node < tree.nodeCount; node++) {
2508
- if (tree.kind[node] !== NodeKind.Chance) continue;
2509
- if (tree.round[node] + 1 !== round) continue;
2510
- entryIndexOf[node] = entryNodes.length;
2511
- entryNodes.push(node);
2512
- }
2513
- if (entryNodes.length === 0) return null;
2514
- const bounds = new Int32Array(workers + 1);
2515
- for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
2516
- return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
2517
- }
2518
- function startPool(ctx, solver, plan, payload, workers) {
2519
- const entryCount = plan.entryNodes.length;
2520
- const spawned = workers - 1;
2521
- const reachFloats = entryCount * 2 * COMBOS;
2522
- const partialFloats = spawned * entryCount * COMBOS;
2523
- const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
2524
- const exchange = new Float64Array(exchangeBuffer);
2525
- const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
2526
- const control = new Int32Array(controlBuffer);
2527
- const threads = [];
2528
- let failure = null;
2529
- for (let w = 0; w < spawned; w++) {
2530
- const setup = {
2531
- workerId: w,
2532
- payload,
2533
- plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
2534
- shardStart: plan.bounds[w + 1],
2535
- shardEnd: plan.bounds[w + 2],
2536
- regret: ctx.regret.buffer,
2537
- strategySum: ctx.strategySum.buffer,
2538
- regretScale: ctx.regretScale?.buffer ?? null,
2539
- sumScale: ctx.sumScale?.buffer ?? null,
2540
- control: controlBuffer,
2541
- exchange: exchangeBuffer,
2542
- entryCount
2543
- };
2544
- const thread = spawnWorker(setup, (error) => {
2545
- failure ??= error;
2546
- Atomics.store(control, CONTROL.ready, spawned);
2547
- Atomics.add(control, CONTROL.done, spawned);
2548
- Atomics.notify(control, CONTROL.done);
2549
- Atomics.notify(control, CONTROL.ready);
2550
- });
2551
- threads.push(thread);
2552
- }
2553
- for (; ; ) {
2554
- const ready = Atomics.load(control, CONTROL.ready);
2555
- if (ready >= spawned || failure) break;
2556
- Atomics.wait(control, CONTROL.ready, ready, 20);
2557
- }
2558
- if (failure) {
2559
- for (const thread of threads) thread.terminate();
2560
- throw failure;
2561
- }
2562
- const total = new Float64Array(COMBOS);
2563
- const chanceValues = new Float64Array(entryCount * COMBOS);
2564
- const mainReachMe = new Float64Array(COMBOS);
2565
- const mainReachOpp = new Float64Array(COMBOS);
2566
- const dispatch = (mode, traverser, iterWeight) => {
2567
- Atomics.store(control, CONTROL.done, 0);
2568
- Atomics.store(control, CONTROL.mode, mode);
2569
- Atomics.store(control, CONTROL.traverser, traverser);
2570
- Atomics.store(control, CONTROL.iterWeight, iterWeight);
2571
- Atomics.store(control, CONTROL.command, COMMAND.work);
2572
- Atomics.add(control, CONTROL.generation, 1);
2573
- Atomics.notify(control, CONTROL.generation);
2574
- const fullStart = ctx.shardStart;
2575
- const fullEnd = ctx.shardEnd;
2576
- ctx.shardStart = plan.bounds[0];
2577
- ctx.shardEnd = plan.bounds[1];
2578
- ctx.applyUpdates = true;
2579
- try {
2580
- for (let entry = 0; entry < entryCount; entry++) {
2581
- for (let i = 0; i < COMBOS; i++) {
2582
- mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
2583
- mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
2584
- }
2585
- const value = solver.traverseChance(
2586
- mode,
2587
- traverser,
2588
- iterWeight,
2589
- plan.entryNodes[entry],
2590
- mainReachMe,
2591
- mainReachOpp
2592
- );
2593
- chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
2594
- }
2595
- } finally {
2596
- ctx.shardStart = fullStart;
2597
- ctx.shardEnd = fullEnd;
2598
- }
2599
- for (; ; ) {
2600
- const done = Atomics.load(control, CONTROL.done);
2601
- if (done >= spawned) break;
2602
- if (failure) throw failure;
2603
- Atomics.wait(control, CONTROL.done, done, 50);
2604
- }
2605
- if (failure) throw failure;
2606
- };
2607
- return {
2608
- workers,
2609
- traverse(mode, traverser, iterWeight) {
2610
- ctx.applyUpdates = false;
2611
- ctx.chanceOverride = null;
2612
- ctx.chanceCollect = (node, reachMe, reachOpp) => {
2613
- const entry = plan.entryIndexOf[node];
2614
- exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
2615
- exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
2616
- };
2617
- try {
2618
- solver.traverseRoot(mode, traverser, iterWeight);
2619
- } finally {
2620
- ctx.chanceCollect = null;
2621
- }
2622
- dispatch(mode, traverser, iterWeight);
2623
- for (let w = 0; w < spawned; w++) {
2624
- const base = reachFloats + w * entryCount * COMBOS;
2625
- for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
2626
- }
2627
- ctx.chanceOverride = chanceValues;
2628
- ctx.applyUpdates = true;
2629
- try {
2630
- const value = solver.traverseRoot(mode, traverser, iterWeight);
2631
- total.set(value.subarray(0, COMBOS));
2632
- } finally {
2633
- ctx.chanceOverride = null;
2634
- }
2635
- return total;
2636
- },
2637
- close() {
2638
- Atomics.store(control, CONTROL.command, COMMAND.exit);
2639
- Atomics.add(control, CONTROL.generation, 1);
2640
- Atomics.notify(control, CONTROL.generation);
2641
- for (const thread of threads) thread.terminate();
2642
- }
2643
- };
2644
- }
2645
-
2646
2673
  // src/index.ts
2647
2674
  var DEFAULT_CHIP_SCALE = 100;
2648
2675
  var OPS_PER_SECOND = 2e8;
@@ -2680,12 +2707,16 @@ function defineSpot(config) {
2680
2707
  const rounds = 6 - board.length;
2681
2708
  if (config.pot <= 0) throw new Error("pot must be positive");
2682
2709
  if (config.stack <= 0) throw new Error("stack must be positive");
2683
- const rows = config.betSizes.length === 1 ? Array.from({ length: rounds }, () => config.betSizes[0]) : config.betSizes;
2684
- if (rows.length !== rounds) {
2685
- throw new Error(
2686
- `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`
2687
- );
2688
- }
2710
+ const rowsFor = (sizes, who) => {
2711
+ const expanded = sizes.length === 1 ? Array.from({ length: rounds }, () => sizes[0]) : sizes;
2712
+ if (expanded.length !== rounds) {
2713
+ throw new Error(
2714
+ `${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`
2715
+ );
2716
+ }
2717
+ return expanded;
2718
+ };
2719
+ const rows = isPerPlayer(config.betSizes) ? { oop: rowsFor(config.betSizes.oop, "oop "), ip: rowsFor(config.betSizes.ip, "ip ") } : rowsFor(config.betSizes, "");
2689
2720
  const onBoard = new Set(board);
2690
2721
  const trim = (range, who) => {
2691
2722
  const weights = typeof range === "string" ? parseRange(range) : Float64Array.from(range);
@@ -2743,9 +2774,10 @@ function defineSpot(config) {
2743
2774
  const compressedBytes = buildLayout(tree, runouts, players, 2).bytes + showdownBytes;
2744
2775
  const suggestions = [];
2745
2776
  if (compressedBytes > maxBytes) {
2746
- const widest = Math.max(...rows.map((r) => r.length));
2777
+ const widest = Math.max(...[0, 1].flatMap((p) => forPlayer(rows, p).map((r) => r.length)));
2747
2778
  if (widest > 1) suggestions.push(`use fewer bet sizes (currently up to ${widest} per round)`);
2748
- if (Math.max(...[config.maxRaises ?? 1].flat()) > 1) suggestions.push(`lower maxRaises to 1`);
2779
+ const raises = [0, 1].flatMap((p) => [forPlayer(config.maxRaises ?? 1, p)].flat());
2780
+ if (Math.max(...raises) > 1) suggestions.push(`lower maxRaises to 1`);
2749
2781
  suggestions.push(`narrow the ranges (currently ${players[0].count} and ${players[1].count} combos)`);
2750
2782
  if (runouts.rounds === 3) suggestions.push("solve from the turn instead of the flop");
2751
2783
  }
@@ -3093,8 +3125,9 @@ function makeSolution(spot, ctx, solver, iterations, totalIterations, history, s
3093
3125
  const invested = (tree.pot[node] - spot.potUnits) / 2;
3094
3126
  const { source } = spot;
3095
3127
  const later = (value, listed) => listed && value.length > 1 ? value.slice(round) : value;
3096
- const rows = later(source.betSizes, true);
3097
- const raiseRows = source.raiseSizes && later(source.raiseSizes, raisesPerRound(source.raiseSizes));
3128
+ const laterEach = (value, listed) => value === void 0 ? void 0 : mapPlayers(value, (side) => later(side, listed(side)));
3129
+ const rows = laterEach(source.betSizes, () => true);
3130
+ const raiseRows = laterEach(source.raiseSizes, (side) => side !== void 0 && raisesPerRound(side));
3098
3131
  return {
3099
3132
  board: formatCards(cards),
3100
3133
  pot: tree.pot[node] / spot.chipScale,
@@ -3103,9 +3136,9 @@ function makeSolution(spot, ctx, solver, iterations, totalIterations, history, s
3103
3136
  ip: reachAt(node, board, 1),
3104
3137
  betSizes: betting.betSizes ?? rows,
3105
3138
  raiseSizes: "raiseSizes" in betting ? betting.raiseSizes : raiseRows,
3106
- maxRaises: betting.maxRaises ?? (source.maxRaises === void 0 ? void 0 : later(source.maxRaises, Array.isArray(source.maxRaises))),
3107
- allowAllIn: betting.allowAllIn ?? (source.allowAllIn === void 0 ? void 0 : later(source.allowAllIn, Array.isArray(source.allowAllIn))),
3108
- allInThreshold: "allInThreshold" in betting ? betting.allInThreshold : source.allInThreshold === void 0 ? void 0 : later(source.allInThreshold, Array.isArray(source.allInThreshold)),
3139
+ maxRaises: betting.maxRaises ?? laterEach(source.maxRaises, Array.isArray),
3140
+ allowAllIn: betting.allowAllIn ?? laterEach(source.allowAllIn, Array.isArray),
3141
+ allInThreshold: "allInThreshold" in betting ? betting.allInThreshold : laterEach(source.allInThreshold, Array.isArray),
3109
3142
  noDonk: "noDonk" in betting ? betting.noDonk : source.noDonk === void 0 ? void 0 : later(source.noDonk, Array.isArray(source.noDonk)),
3110
3143
  mergeSizes: "mergeSizes" in betting ? betting.mergeSizes : source.mergeSizes,
3111
3144
  minWeight: source.minWeight,