{message}
;\n\n return (\n{message}
\n\n Browsing is free. Downloads and the API are paid.\n
\n\n {structure.source.replace(/^./, (c) => c.toUpperCase())}. {structure.playersLeft} players left\n {structure.playersLeft > 8\n ? `, everyone off this table at ${fmtBb(structure.fieldAvgBb)}`\n : \", all at this table\"}\n .\n
\n\n No hands match these filters.\n
\n ) : (\n shown.map((r) => (\n\n Filter by ranks (AK222) or look up\n a hand (AsAhKdKcQs). Five ranks\n match exactly; fewer mean “at least these.”\n
\n{error}
: null}\n\n {lookup ? (\n\n Hands with {debouncedRanks}\n
\n ) : null}\n {listError ?{listError}
: null}\n\nLoading hands…
\n ) : rows.length === 0 ? (\nNo hands listed for this action.
\n ) : (\n rows.map((r) => (\nNo solved boards in this pack.
;\n }\n return (\n\n
\n {pack}\n {generatedAt ? ` · ${generatedAt}` : \"\"} · flop actions from{\" \"}\n {postflop}/node\n
Loading nodes…
\n ) : (\nStreet closed — pick a runout to continue.
\n ) : loading ? (\n // A board's first open reads its bundle from Blob storage, which can\n // take several seconds: say so, or the drawer reads as broken.\n\n Loading the {board} solve\n \n First open of a board can take a few seconds.\n \n
\n \n ) : null}\n \n );\n}\n", "type": "registry:component", "target": "components/pokerdata/postflop/postflop-browser.tsx" }, { "path": "src/components/pokerdata/postflop/strategy-grid.tsx", "content": "\"use client\";\n\n// The postflop 13×13 strategy grid (a hand list for Omaha) — ported from pokerstudy.ai's\n// web/src/components/solver/strategy-grid.tsx. Per-combo strategies aggregate\n// into hand classes weighted by how often the acting player actually HOLDS\n// each combo at this node; without reach weighting a deep node renders a wall\n// of action for hands the line already removed.\n\nimport { useMemo } from \"react\";\nimport type { SolverActionInfo, SolverHandStrategy } from \"@/lib/pokerdata/postflop/types\";\nimport { RANGE_COLORS } from \"@/lib/pokerstudy/poker\";\n\nconst RANKS = [\"A\", \"K\", \"Q\", \"J\", \"T\", \"9\", \"8\", \"7\", \"6\", \"5\", \"4\", \"3\", \"2\"];\n\n// pokerstudy.ai's default range palette (Mint: blue fold, check and call\n// green, bets red), so an action reads the same in the postflop and preflop\n// explorers.\nexport const ACTION_COLORS: Record\n {rows.length} hands in range, highest EV first.\n
\n\". Every PLO raise in these\n// packs is pot-sized (capped by stack): raise-to = 2·toCall + pot − committed.\n// House (mtt9) tokens are the bundle's own labels: F, C, X, AI and\n// R (\"R220\" = raise to 2.2bb).\n\nconst PLO_RAISE_RE = /^(Open|3B|4B|5B|6B|7B|8B)(?:-(\\d+))?$/;\n\n/** HydraSolver PLO5 raise: `Raise-4.7x` is a raise to 4.7bb. */\nconst PLO5_RAISE_RE = /^Raise-(\\d+(?:\\.\\d+)?)x$/;\n\n/** Raise-to in bb of a PLO5 raise token, or null. */\nexport function plo5RaiseToBb(token: string): number | null {\n const m = PLO5_RAISE_RE.exec(token);\n return m ? parseFloat(m[1]) : null;\n}\n\n/** PLO depth-tag → human label (\"Open\" → \"Pot\", \"3B\" → \"3-Bet\", …). */\nconst PLO_RAISE_LABEL: Record = {\n Open: \"Pot\",\n \"3B\": \"3-Bet\",\n \"4B\": \"4-Bet\",\n \"5B\": \"5-Bet\",\n \"6B\": \"6-Bet\",\n \"7B\": \"7-Bet\",\n \"8B\": \"8-Bet\",\n};\n\nfunction displayAction(token: string): string {\n if (token === \"Fold\" || token === \"F\") return \"Fold\";\n if (token === \"Call\" || token === \"C\") return \"Call\";\n if (token === \"Limp\") return \"Limp\";\n if (token === \"X\") return \"Check\";\n if (token === \"AI\" || token === \"AllIn\") return \"All-in\";\n const plo5 = plo5RaiseToBb(token);\n if (plo5 !== null) return `Raise ${formatBb(plo5)}`;\n const plo = token.match(PLO_RAISE_RE);\n if (plo) return PLO_RAISE_LABEL[plo[1]] ?? token;\n const houseBb = houseRaiseToBb(token);\n if (houseBb !== null) return `Raise ${formatBb(houseBb)}`;\n return token;\n}\n\nfunction sumCommitted(\n seats: Record,\n order: Position[],\n): number {\n let s = 0;\n for (const p of order) s += seats[p].committed;\n return s;\n}\n\nexport function parseHistory(\n history: string,\n stackBb: number,\n order: Position[] = SEAT_ORDER.nl,\n /** Dead big-blind ante (mtt9): posted by the BB, counted in the pot. */\n anteBb = 0,\n /** Ante every seat posts (nlh8-hydra, nlh8-icm, nlhu), counted in the pot. */\n antePerSeatBb = 0,\n /** Dead ante nobody's stack pays (PLO5's 1.2bb), counted in the pot. */\n deadAnteBb = 0,\n /**\n * Raise-to in bb per line (`\"_\"` → bb), from the feed's\n * `sizeBb`. Wins over decoding the token, which can't size NL MTT tokens\n * like `Open`/`3B` or cash's `Min`.\n */\n sizes: Record = {},\n /** Per-seat starting stacks when they differ (ICM stages); else every seat has `stackBb`. */\n seatStacks?: Partial>,\n): ParsedTable {\n const stackOf = (p: Position) => seatStacks?.[p] ?? stackBb;\n const seats: Record = Object.create(null);\n for (const p of order) {\n seats[p] = {\n position: p,\n action: null,\n committed: 0,\n remaining: stackOf(p),\n folded: false,\n isHero: false,\n isDealer: p === \"BTN\",\n blind: p === \"SB\" ? 0.5 : p === \"BB\" ? 1 : 0,\n ante: (p === \"BB\" ? anteBb : 0) + antePerSeatBb,\n };\n }\n seats.SB.committed = 0.5;\n seats.BB.committed = 1;\n\n const tokens = history.split(\"_\");\n let prevIdx = -1;\n let toCall = 1;\n\n for (let i = 0; i + 1 < tokens.length; i += 2) {\n const pos = tokens[i] as Position;\n const action = tokens[i + 1];\n const posIdx = order.indexOf(pos);\n if (posIdx === -1) continue;\n\n if (prevIdx >= 0) {\n let cur = (prevIdx + 1) % order.length;\n while (cur !== posIdx) {\n const s = seats[order[cur]];\n if (!s.folded && s.action === null) {\n s.folded = true;\n s.action = \"Fold\";\n }\n cur = (cur + 1) % order.length;\n }\n }\n\n const line = tokens.slice(0, i + 2).join(\"_\");\n const sized = sizes[line];\n const houseRaise = houseRaiseToBb(action) ?? plo5RaiseToBb(action);\n seats[pos].action = displayAction(action);\n if (action === \"Fold\" || action === \"F\") {\n seats[pos].folded = true;\n } else if (\n sized !== undefined &&\n action !== \"Call\" &&\n action !== \"C\" &&\n action !== \"X\" &&\n action !== \"Limp\"\n ) {\n const raiseTo = Math.min(stackOf(pos), sized);\n seats[pos].committed = raiseTo;\n seats[pos].raiseTo = raiseTo;\n if (!(action === \"AI\" || action === \"AllIn\")) {\n seats[pos].action = `Raise ${formatBbExact(raiseTo)}`;\n }\n toCall = Math.max(toCall, raiseTo);\n } else if (\n action === \"Call\" ||\n action === \"C\" ||\n action === \"X\" ||\n action === \"Limp\"\n ) {\n seats[pos].committed = toCall;\n } else if (action === \"AI\" || action === \"AllIn\") {\n const allIn = stackOf(pos) - seats[pos].ante;\n seats[pos].committed = allIn;\n seats[pos].raiseTo = allIn;\n toCall = Math.max(toCall, allIn);\n } else if (houseRaise !== null) {\n const raiseTo = Math.min(stackOf(pos), houseRaise);\n seats[pos].committed = raiseTo;\n seats[pos].raiseTo = raiseTo;\n toCall = raiseTo;\n } else if (action.endsWith(\"%\")) {\n const potBefore = sumCommitted(seats, order);\n const raiseTo = toCall + (parseFloat(action) / 100) * potBefore;\n seats[pos].committed = raiseTo;\n seats[pos].raiseTo = raiseTo;\n toCall = raiseTo;\n } else if (PLO_RAISE_RE.test(action)) {\n // Pot-limit raise: call, then raise by the pot after the call — i.e.\n // raise-to = 2·toCall + pot − alreadyCommitted, capped by the stack.\n const potBefore = sumCommitted(seats, order);\n const raiseTo = Math.min(\n stackOf(pos),\n 2 * toCall + potBefore - seats[pos].committed,\n );\n seats[pos].committed = raiseTo;\n seats[pos].raiseTo = raiseTo;\n toCall = raiseTo;\n }\n prevIdx = posIdx;\n }\n\n // An odd token count ends on a seat (its decision); an even one ends on an\n // action, which closed the line.\n const closed = tokens.length % 2 === 0;\n const hero = closed ? null : ((tokens[tokens.length - 1] || order[0]) as Position);\n const heroIdx = hero ? order.indexOf(hero) : -1;\n if (hero && seats[hero]) seats[hero].isHero = true;\n\n if (prevIdx >= 0 && heroIdx !== -1) {\n let cur = (prevIdx + 1) % order.length;\n while (cur !== heroIdx) {\n const s = seats[order[cur]];\n if (!s.folded && s.action === null) {\n s.folded = true;\n s.action = \"Fold\";\n }\n cur = (cur + 1) % order.length;\n }\n }\n\n for (const p of order) {\n seats[p].remaining = Math.max(0, stackOf(p) - seats[p].committed - seats[p].ante);\n }\n\n const antes = anteBb + antePerSeatBb * order.length + deadAnteBb;\n return {\n seats,\n pot: sumCommitted(seats, order) + antes,\n hero,\n toCall: Math.max(...order.map((p) => seats[p].committed)),\n antes,\n };\n}\n\n/** The seat that acts after `action` is taken; null if the line terminates. */\nexport function nextActorAfter(\n history: string,\n action: string,\n stackBb: number,\n order: Position[] = SEAT_ORDER.nl,\n): Position | null {\n const { seats } = parseHistory(history, stackBb, order);\n const tokens = history.split(\"_\");\n const actor = tokens[tokens.length - 1] as Position;\n const actorIdx = order.indexOf(actor);\n if (actorIdx === -1) return null;\n\n const liveAfter = new Set();\n for (const p of order) if (!seats[p].folded) liveAfter.add(p);\n if (action === \"Fold\" || action === \"F\") liveAfter.delete(actor);\n\n for (let i = 1; i <= order.length; i++) {\n const cand = order[(actorIdx + i) % order.length];\n if (liveAfter.has(cand)) return cand;\n }\n return null;\n}\n\n// ─── Display helpers ───────────────────────────────────────────────────────\n\nconst KIND_ORDER: Record = {\n fold: 0,\n call: 1,\n raise: 2,\n allin: 3,\n other: 4,\n};\n\nexport function sortActionsForDisplay(actions: NodeAction[]): NodeAction[] {\n return [...actions].sort((a, b) => {\n const ka = KIND_ORDER[a.kind] ?? 99;\n const kb = KIND_ORDER[b.kind] ?? 99;\n if (ka !== kb) return ka - kb;\n // NL raises sort by pot %, PLO5 by raise-to, PLO by depth then size code.\n return (\n (a.sizePct ?? 0) - (b.sizePct ?? 0) ||\n (plo5RaiseToBb(a.action) ?? 0) - (plo5RaiseToBb(b.action) ?? 0) ||\n (a.raiseDepth ?? 0) - (b.raiseDepth ?? 0) ||\n (a.sizeCode ?? 0) - (b.sizeCode ?? 0)\n );\n });\n}\n\nexport function labelForAction(action: NodeAction, stack: number): string {\n if (action.kind === \"fold\") return \"Fold\";\n if (action.kind === \"call\") {\n if (action.action === \"X\") return \"Check\";\n if (action.action === \"Limp\") return \"Limp\";\n return \"Call\";\n }\n if (action.kind === \"allin\" || action.action === \"AI\" || action.action === \"AllIn\") return `All-in ${formatBbExact(action.sizeBb ?? stack)}`;\n // The feed's decoded raise-to beats any token spelling (\"Open\", \"3B\", \"Min\").\n if (action.sizeBb != null) return `Raise ${formatBbExact(action.sizeBb)}`;\n if (action.kind === \"raise\") {\n if (action.action === \"Open\") return \"Open\";\n const houseBb = houseRaiseToBb(action.action) ?? plo5RaiseToBb(action.action);\n if (houseBb !== null) return `Raise ${formatBb(houseBb)}`;\n const plo = action.action.match(PLO_RAISE_RE);\n if (plo) {\n const label =\n (action.raiseDepth ?? 1) === 1\n ? \"Raise pot\"\n : `${PLO_RAISE_LABEL[plo[1]] ?? plo[1]} pot`;\n return plo[2] ? `${label} (${plo[2]})` : label;\n }\n return `Raise ${action.action}`;\n }\n return action.action;\n}\n\nexport function formatBb(v: number): string {\n if (v < 100) return v.toFixed(v % 1 === 0 ? 0 : 1);\n return Math.round(v).toString();\n}\n\n/**\n * Bb cut (never rounded up) to two decimals, trailing zeros dropped: 2.19,\n * 39.875 → 39.87, 40. The epsilon keeps float noise (2.19 → 2.1899…) from\n * cutting a whole cent.\n */\nexport function formatBbExact(v: number): string {\n return String(Math.trunc(v * 100 + (v < 0 ? -1e-6 : 1e-6)) / 100);\n}\n",
"type": "registry:lib",
"target": "lib/pokerdata/explorer/preflop.ts"
},
{
"path": "src/lib/pokerdata/explorer/range-model.ts",
"content": "// 169-class hand-grid model for the range explorer. A range is a map from\n// hand-class (\"AA\", \"AKs\", \"AKo\", …) to a weight in [0, 1] — the same shape the\n// ranges API returns (NodeAction.weights). Trimmed port of pokerstudy.ai's\n// web/src/lib/solver/range-model.ts (the solve-time serialization is dropped;\n// this app only views ranges).\n\nexport type RangeWeights = Record;\n\nconst RANKS = \"AKQJT98765432\";\n\n/**\n * Every 169 hand-class in grid order: suited upper-right, offsuit lower-left,\n * pairs on the diagonal (\"AA\", \"AKs\", …, \"32o\"). Higher rank is written first.\n */\nexport const ALL_HANDS: string[] = (() => {\n const hands: string[] = [];\n for (let r = 0; r < 13; r++) {\n for (let c = 0; c < 13; c++) {\n const hi = RANKS[Math.min(r, c)];\n const lo = RANKS[Math.max(r, c)];\n if (r === c) hands.push(`${RANKS[r]}${RANKS[r]}`);\n else if (r < c) hands.push(`${hi}${lo}s`);\n else hands.push(`${hi}${lo}o`);\n }\n }\n return hands;\n})();\n\n/** Concrete combos a class represents, ignoring card removal (pair 6, suited 4, offsuit 12). */\nexport function comboCountOf(hand: string): number {\n if (hand.length === 2) {\n return hand[0] === hand[1] && RANKS.includes(hand[0]) ? 6 : 0;\n }\n if (hand.length === 3 && RANKS.includes(hand[0]) && RANKS.includes(hand[1])) {\n if (hand[2] === \"s\") return 4;\n if (hand[2] === \"o\") return 12;\n }\n return 0;\n}\n",
"type": "registry:lib",
"target": "lib/pokerdata/explorer/range-model.ts"
},
{
"path": "src/lib/pokerdata/postflop/types.ts",
"content": "// Wire types for postflop solver nodes — mirrors pokerstudy.ai's\n// web/src/lib/solver/types.ts (the dump_nodes shape). Keep in sync.\n\nexport type SolverActionLabel = \"Fold\" | \"Check\" | \"Call\" | \"Bet\" | \"Raise\" | \"AllIn\";\n\nexport interface SolverActionInfo {\n label: SolverActionLabel;\n /** Chips added by taking this action (chips = bb in these solves). */\n add: number;\n}\n\nexport interface SolverHandStrategy {\n /** Combo string, 4 chars for NLHE (\"AsKh\"). */\n combo: string;\n /** Frequency per action, parallel to the node's `actions`. */\n freqs: number[];\n /** Per-combo equilibrium EV in bb (node-EV solves; absent on older data). */\n ev?: number;\n /** Absolute per-action EV in bb, reconstructed by PokerData when available. */\n action_ev?: number[];\n /** Per-action EV given up vs the best action (action-EV solves). */\n ev_loss?: number[];\n /** Distinguishes derived action values from fields published by the solver. */\n ev_source?:\n | \"reconstructed_complete_turn_tree\"\n | \"reconstructed_action_loss_anchor\";\n}\n\nexport interface SolverNode {\n path: string[];\n player: 0 | 1;\n pot: number;\n actions: SolverActionInfo[];\n hands: SolverHandStrategy[];\n}\n\n/** Per-combo reach weights (\"AsKh\" → weight). */\nexport type ComboWeights = Map;\n",
"type": "registry:lib",
"target": "lib/pokerdata/postflop/types.ts"
}
],
"type": "registry:block"
}