poke-crucible 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 johnjohto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,192 @@
+# poke-crucible
+
+Run masses of headless **Gen 3 OU** battles to rank Teams by how often they win.
+Both sides of every Battle are driven by one fixed, competent heuristic **Pilot**,
+so a result measures the **Team**, not the player. Three capabilities, each a
+single seam built on the last:
+
+- **`evaluate`** (Slice 1) — rank Teams by **Strength** against a fixed Gauntlet, or round-robin.
+- **`critique`** (Slice 2) — an LLM **Critic** explains one Team's weaknesses and matchup holes.
+- **`design`** (Slice 3) — the **Designer** evolves stronger Teams, with the LLM proposing mutations and naming the Archetypes it discovers.
+
+Vocabulary lives in [`CONTEXT.md`](CONTEXT.md); the specs are the
+[PRDs under `docs/`](docs); decisions are the [ADRs](docs/adr).
+
+## Install & build
+
+```bash
+npm install
+npm run build      # compiles TypeScript to dist/
+```
+
+Requires Node ≥ 20. The stack is in-process TypeScript on the `@pkmn/*` toolkit
+(`@pkmn/sim`, `@pkmn/sets`, `@pkmn/data`) — no server, no network, no Python
+(ADR 0001).
+
+## CLI
+
+```bash
+# Absolute Strength vs the fixed Gauntlet
+node dist/cli.js eval --mode gauntlet team.txt
+
+# Relative Strength: rank several of your own Teams round-robin
+node dist/cli.js eval --mode round-robin teamA.txt teamB.txt teamC.txt
+
+# Pipe a single Team paste in on stdin
+cat team.txt | node dist/cli.js eval
+```
+
+Options: `--mode <gauntlet|round-robin>` (default `gauntlet`), `--battles <N>`
+(default 100), `--seed <string>`, `--gauntlet-version <v>`, `--out <file>`
+(default `poke-crucible-results.json`). Each team file is standard Showdown
+export/paste text; multiple Teams in one file are separated by
+`=== [gen3ou] Name ===` header lines.
+
+The CLI prints a ranked Strength table (with a 95% confidence interval and a
+per-matchup breakdown) and writes the full structured result to `--out`.
+
+## Programmatic API
+
+The base seam is `evaluate` — the Critic and Designer build on it, not on the CLI:
+
+```ts
+import { evaluate } from 'poke-crucible';
+
+const result = await evaluate({
+  teams: showdownPasteText,              // string or array of pastes/{name,paste}
+  opposition: { mode: 'gauntlet' },      // or { mode: 'round-robin' }
+  battlesPerPairing: 100,
+  seed: 'my-seed',
+});
+// result: ranked Strength rows (per-matchup win-rates tagged with Archetype),
+// the seed, the Gauntlet version, and any illegal-Team validation errors.
+```
+
+Illegal Teams never throw past the seam — they come back as `result.errors`,
+named, so a bad Team can't silently poison a run.
+
+## How it works
+
+- **Pilot** (ADR 0002): one shared Gen 3 heuristic, identical on both sides,
+  built in competence layers — secure a KO → pivot out of a losing matchup →
+  recover → lay Spikes / spin → spread Toxic/burn/paralysis → set up → max
+  damage. Every Strength number is relative to this Pilot.
+- **Determinism**: a master seed threads through `@pkmn/sim`'s PRNG; each
+  pairing's Battles derive sub-seeds deterministically and sides are swapped
+  50/50, so a fixed seed reproduces identical results.
+- **Gauntlet** (ADR 0003): a fixed, **versioned** roster of Archetype-labeled
+  Gen 3 OU Teams. Every result records the version, so `62% Strength` means the
+  same thing next week. Two versions ship: **`g1`** (default; hand-authored) and
+  **`g2`** (real [Smogon ADV OU sample teams](https://www.smogon.com/forums/threads/adv-ou-sample-teams.3687813/),
+  fetched verbatim, `--gauntlet-version g2`). `g1` stays the default baseline;
+  swapping it is a deliberate rebaseline.
+- **Parallelism**: `--concurrency <N>` (or `POKE_CONCURRENCY`) runs Battles across
+  `N` worker threads. All Battles of a run are dispatched together so the pool
+  stays saturated; results are **byte-identical** to serial (each Battle keeps
+  its own seed). Default is 1 (inline). It pays off on big, expensive runs — the
+  Designer, large evaluations — where it gives roughly a 2× speedup on 4 workers;
+  for small/fast runs the thread overhead can make it a wash, hence the default.
+
+### Gauntlet provenance (a deliberate deviation)
+
+The design envisioned sourcing the Gauntlet from Smogon's sample teams + usage
+stats via fetch-and-parse. That is deferred: the `g1` roster is **hand-authored**
+from canonical Smogon Gen 3 OU sets (see
+[`src/gauntlet/teams-g1.ts`](src/gauntlet/teams-g1.ts)). Because the Gauntlet is
+versioned and every result records its version, re-sourcing later is a `g2`
+bump, not a rewrite — nothing silently drifts.
+
+## Critic (LLM analysis — Slice 2)
+
+Turn an evaluation into a readable, grounded critique of one Team:
+
+```bash
+node dist/cli.js critique team.txt
+node dist/cli.js critique --model claude-sonnet-5 --effort low --battles 100 team.txt
+```
+
+The Critic runs the evaluation, then asks Claude (via the **Claude Agent SDK**)
+to explain the Team's weaknesses, the Archetypes that exploit them, the
+mechanism, and concrete legal fixes — writing a structured `Critique` JSON. It
+is told the Pilot under-rates stall (ADR 0004), so it caveats defense-dependent
+verdicts rather than presenting them as ground truth.
+
+**Auth (individual use):** the Critic runs on your **Claude subscription**, not
+a pay-per-token key. Log in with Claude Code (or set `CLAUDE_CODE_OAUTH_TOKEN`),
+and make sure **`ANTHROPIC_API_KEY` is unset** — it shadows the subscription
+OAuth token and reverts to per-token billing. The model is called with all tools
+disabled and low reasoning effort; nothing runs on your filesystem.
+
+Programmatically the seam is `critique(input, model)` / `critiqueTeam(paste,
+model, opts)`; the model is any `CritiqueModel` (use `StubCritiqueModel` in tests,
+`AgentSdkCritiqueModel` live). See [`docs/prd-slice-2-critic.md`](docs/prd-slice-2-critic.md).
+
+## Designer (discovery — Slice 3)
+
+Evolve stronger Teams automatically. A population of legal Teams is scored each
+generation by a **composite fitness** (Gauntlet Strength + peer round-robin + a
+worst-matchup robustness term), bred by mutation and crossover, with the LLM
+proposing variants — driven by the Critic's findings — and naming the Archetypes
+it discovers.
+
+```bash
+# Evolve from a starting Team (omit the file to search from scratch)
+node dist/cli.js design --population 8 --generations 4 team.txt
+
+# Random operators only — no LLM, no subscription call
+node dist/cli.js design --no-llm --population 8 --generations 4
+```
+
+Options: `--population`, `--generations`, `--battles` (per fitness pairing),
+`--model` / `--effort` (Designer LLM), `--no-llm`, `--seed`, `--gauntlet-version`,
+`--out`. Every candidate is validated legal Gen 3 OU; the run is deterministic
+under its seed and reports each Team's lineage, Archetype name, fitness
+components, plus the budget used and total Battles run. To bound compute it
+caches unchanged Teams, screens cheaply before spending full battles on
+contenders, and honours a hard battle cap.
+
+Programmatically the seam is `design(input, model, options)`; the model is any
+`DesignerModel` (`StubDesignerModel` for tests, `AgentSdkDesignerModel` live),
+and an optional `critic` lets the Critic drive the mutation proposals. Auth is
+the same subscription path as the Critic. See
+[`docs/prd-slice-3-designer.md`](docs/prd-slice-3-designer.md).
+
+**Fitness is deliberately not raw win-rate (ADR 0004)** — it rewards well-rounded
+Teams over glass cannons and dampens the Pilot's offense lean (see the limitation
+below for how far that goes).
+
+## Testing (the trust gate)
+
+```bash
+npm run typecheck
+npm test
+```
+
+The suite asserts external behavior only, through the `evaluate()` seam (never
+the Pilot's individual move choices): determinism, sanity ordering (a strong
+Team out-Strengths a weak one), **archetype non-bias** (a solid stall Team stays
+competitive in a head-to-head ladder of the eight archetypes and can beat
+offense — the live check that the Pilot isn't biased against defense), legality,
+and stable win-rates. Every Gauntlet Team is asserted legal Gen 3 OU.
+
+### Known limitation: the Pilot's offense lean
+
+The shared greedy Pilot systematically **under-rates stall** — offense plays
+near-optimally under greedy heuristics while stall needs long-term planning. In
+an archetype-vs-archetype ladder the best stall Team lands mid-lower (≈38%
+Strength, 6th of 8), not mid-pack.
+
+This was probed exhaustively ([ADR 0004](docs/adr/0004-greedy-pilot-underrates-stall-search-deferred.md)):
+three Pilot improvements (anticipatory switching, tempo tweaks, a positional-eval
+Pilot) all failed to lift stall; real-sim look-ahead is infeasible (`@pkmn/sim`
+state can't be resumed after deserialization); and the Designer's composite
+fitness only *partly* corrects the lean — stall's worst matchups are genuinely
+~0% under the Pilot, so a robustness term can't recover them.
+
+The lean is therefore a **known, bounded, documented property of the greedy-Pilot
+design**, not a bug — every Strength number is explicitly relative to this Pilot
+(ADR 0002). Closing it needs a stronger Pilot (a shallow search or ML policy —
+deferred) or a non-Pilot signal of a Team's merit; both are future work. The
+Critic caveats defense-dependent verdicts and the Designer's fitness avoids
+rewarding glass cannons, so the slices degrade gracefully rather than silently
+trusting the lean.

package/dist/battle/pairing.d.ts

@@ -0,0 +1,25 @@
+export interface PairingRecord {
+    /** Battles Team A won outright. */
+    wins: number;
+    ties: number;
+    battles: number;
+    /** Team A's win-rate in [0, 1]; ties count as half. */
+    winRate: number;
+}
+/** One Team-vs-opponent pairing to run, tagged with a caller key. */
+export interface MatchupSpec {
+    key: string;
+    aPacked: string;
+    bPacked: string;
+    /** Stable indices for reproducible per-Battle seeds (same as RunPairingOptions). */
+    teamIndex: number;
+    opponentIndex: number;
+}
+/**
+ * Run many pairings at once. Every Battle across every pairing is flattened into
+ * one job list and dispatched together, so a worker pool stays saturated instead
+ * of idling between pairings (per-pairing dispatch left workers waiting on a
+ * single long stall mirror). Seeds are unchanged, so results are identical to
+ * running the pairings one at a time.
+ */
+export declare function runMatchups(specs: MatchupSpec[], battles: number, master: string, maxTurns?: number): Promise<Map<string, PairingRecord>>;

package/dist/battle/pairing.js

@@ -0,0 +1,59 @@
+/**
+ * Pairing runner — sits on top of {@link runBattle}. Given a batch of Team-vs-
+ * opponent pairings, it runs every Battle (sides swapped 50/50, so any lead or
+ * turn-order edge cancels out) from deterministically derived sub-seeds and
+ * returns a win-rate record per pairing. Battles are flattened into one job list
+ * so a worker pool stays saturated.
+ */
+import { runBattle } from './run-battle.js';
+import { getBattlePool } from './pool.js';
+import { deriveSeed } from '../seed.js';
+/**
+ * Run many pairings at once. Every Battle across every pairing is flattened into
+ * one job list and dispatched together, so a worker pool stays saturated instead
+ * of idling between pairings (per-pairing dispatch left workers waiting on a
+ * single long stall mirror). Seeds are unchanged, so results are identical to
+ * running the pairings one at a time.
+ */
+export async function runMatchups(specs, battles, master, maxTurns) {
+    const tally = new Map();
+    for (const s of specs)
+        tally.set(s.key, { wins: 0, ties: 0 });
+    const record = (key, aIsP1, res) => {
+        const t = tally.get(key);
+        if (res.winner === null)
+            t.ties++;
+        else if (aIsP1 ? res.winner === 'p1' : res.winner === 'p2')
+            t.wins++;
+    };
+    const jobs = [];
+    for (const s of specs) {
+        for (let b = 0; b < battles; b++) {
+            const aIsP1 = b % 2 === 0;
+            jobs.push({
+                key: s.key,
+                aIsP1,
+                p1: aIsP1 ? s.aPacked : s.bPacked,
+                p2: aIsP1 ? s.bPacked : s.aPacked,
+                seed: deriveSeed(master, s.teamIndex, s.opponentIndex, b),
+            });
+        }
+    }
+    const pool = getBattlePool();
+    if (pool) {
+        await Promise.all(jobs.map((j) => pool.run({ p1: j.p1, p2: j.p2, seed: j.seed, maxTurns }).then((res) => record(j.key, j.aIsP1, res))));
+    }
+    else {
+        for (const j of jobs) {
+            const res = await runBattle(j.p1, j.p2, j.seed, { maxTurns });
+            record(j.key, j.aIsP1, res);
+        }
+    }
+    const out = new Map();
+    for (const s of specs) {
+        const { wins, ties } = tally.get(s.key);
+        out.set(s.key, { wins, ties, battles, winRate: battles > 0 ? (wins + 0.5 * ties) / battles : 0 });
+    }
+    return out;
+}
+//# sourceMappingURL=pairing.js.map

package/dist/battle/pairing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairing.js","sourceRoot":"","sources":["../../src/battle/pairing.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,SAAS,EAAqB,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAiB,MAAM,YAAY,CAAC;AAqBvD;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,KAAoB,EACpB,OAAe,EACf,MAAc,EACd,QAAiB;IAEjB,MAAM,KAAK,GAAG,IAAI,GAAG,EAA0C,CAAC;IAChE,KAAK,MAAM,CAAC,IAAI,KAAK;QAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;IAC9D,MAAM,MAAM,GAAG,CAAC,GAAW,EAAE,KAAc,EAAE,GAAiB,EAAQ,EAAE;QACtE,MAAM,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;QAC1B,IAAI,GAAG,CAAC,MAAM,KAAK,IAAI;YAAE,CAAC,CAAC,IAAI,EAAE,CAAC;aAC7B,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,KAAK,IAAI;YAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IACvE,CAAC,CAAC;IASF,MAAM,IAAI,GAAU,EAAE,CAAC;IACvB,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;YACjC,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAC1B,IAAI,CAAC,IAAI,CAAC;gBACR,GAAG,EAAE,CAAC,CAAC,GAAG;gBACV,KAAK;gBACL,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO;gBACjC,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO;gBACjC,IAAI,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,aAAa,EAAE,CAAC,CAAC;aAC1D,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,MAAM,IAAI,GAAG,aAAa,EAAE,CAAC;IAC7B,IAAI,IAAI,EAAE,CAAC;QACT,MAAM,OAAO,CAAC,GAAG,CACf,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACb,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CACpG,CACF,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;YACrB,MAAM,GAAG,GAAG,MAAM,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC9D,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,GAAG,EAAyB,CAAC;IAC7C,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAE,CAAC;QACzC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACpG,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/battle/pool.d.ts

@@ -0,0 +1,25 @@
+import type { BattleResult } from './run-battle.js';
+import type { PRNGSeed } from '../seed.js';
+export interface BattleJob {
+    p1: string;
+    p2: string;
+    seed: PRNGSeed;
+    maxTurns?: number;
+}
+/** One unit of the pool — wraps a real thread, or a fake in tests. */
+export interface PoolWorker {
+    exec(job: BattleJob): Promise<BattleResult>;
+    terminate(): void;
+}
+export declare class BattlePool {
+    private readonly workers;
+    private readonly idle;
+    private readonly queue;
+    constructor(size: number, spawn: () => PoolWorker);
+    /** Run one Battle, queued until a worker is free. */
+    run(job: BattleJob): Promise<BattleResult>;
+    private pump;
+    close(): void;
+}
+/** The shared pool for this process, or null when concurrency ≤ 1 (run inline). */
+export declare function getBattlePool(): BattlePool | null;

package/dist/battle/pool.js

@@ -0,0 +1,97 @@
+/**
+ * A bounded worker-thread pool for running Battles in parallel. The sim is
+ * CPU-bound and single-threaded, so real speedup needs threads, not just async.
+ *
+ * The pool is deterministic-safe: every Battle carries its own derived seed, and
+ * callers aggregate results order-independently, so parallel and serial runs
+ * produce identical numbers.
+ *
+ * Concurrency comes from `POKE_CONCURRENCY` (default 1 = run inline, no pool).
+ * The worker spawn is injectable so the scheduling logic is unit-testable
+ * without real threads.
+ */
+import { Worker } from 'node:worker_threads';
+export class BattlePool {
+    workers;
+    idle;
+    queue = [];
+    constructor(size, spawn) {
+        this.workers = Array.from({ length: Math.max(1, size) }, spawn);
+        this.idle = [...this.workers];
+    }
+    /** Run one Battle, queued until a worker is free. */
+    run(job) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ job, resolve, reject });
+            this.pump();
+        });
+    }
+    pump() {
+        while (this.idle.length > 0 && this.queue.length > 0) {
+            const worker = this.idle.pop();
+            const { job, resolve, reject } = this.queue.shift();
+            worker.exec(job).then((res) => {
+                this.idle.push(worker);
+                resolve(res);
+                this.pump();
+            }, (err) => {
+                this.idle.push(worker);
+                reject(err);
+                this.pump();
+            });
+        }
+    }
+    close() {
+        for (const w of this.workers)
+            w.terminate();
+    }
+}
+/** A PoolWorker backed by a real `worker_threads` thread running `worker.js`. */
+class ThreadWorker {
+    worker;
+    pending = null;
+    constructor() {
+        this.worker = new Worker(new URL('./worker.js', import.meta.url));
+        this.worker.on('message', (msg) => {
+            const p = this.settle();
+            if (!p)
+                return;
+            if (msg.ok && msg.res)
+                p.resolve(msg.res);
+            else
+                p.reject(new Error(msg.error ?? 'battle worker failed'));
+        });
+        this.worker.on('error', (err) => this.settle()?.reject(err));
+        // Idle workers don't keep the process alive; a worker is ref'd only while it
+        // has a job in flight (see exec), so the run stays alive but can still exit.
+        this.worker.unref();
+    }
+    /** Clear the pending state and stop keeping the loop alive. */
+    settle() {
+        const p = this.pending;
+        this.pending = null;
+        if (p)
+            this.worker.unref();
+        return p;
+    }
+    exec(job) {
+        return new Promise((resolve, reject) => {
+            this.pending = { resolve, reject };
+            this.worker.ref(); // hold the loop open until this Battle finishes
+            this.worker.postMessage(job);
+        });
+    }
+    terminate() {
+        void this.worker.terminate();
+    }
+}
+let cached;
+/** The shared pool for this process, or null when concurrency ≤ 1 (run inline). */
+export function getBattlePool() {
+    if (cached !== undefined)
+        return cached;
+    const n = Math.floor(Number(process.env['POKE_CONCURRENCY'] ?? '1'));
+    cached = Number.isFinite(n) && n > 1 ? new BattlePool(n, () => new ThreadWorker()) : null;
+    return cached;
+}
+//# sourceMappingURL=pool.js.map

package/dist/battle/pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.js","sourceRoot":"","sources":["../../src/battle/pool.ts"],"names":[],"mappings":"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"}

package/dist/battle/run-battle.d.ts

@@ -0,0 +1,13 @@
+import { type SideID } from '../pilot/pilot.js';
+import type { PRNGSeed } from '../seed.js';
+export interface BattleResult {
+    /** 'p1', 'p2', or null for a tie. */
+    winner: SideID | null;
+    turns: number;
+}
+export interface RunBattleOptions {
+    /** Safety net against pathological stall mirrors; forces a tiebreak past this. */
+    maxTurns?: number;
+}
+/** Run a single Battle between two packed Teams and report the winner. */
+export declare function runBattle(p1Packed: string, p2Packed: string, seed: PRNGSeed, options?: RunBattleOptions): Promise<BattleResult>;

package/dist/battle/run-battle.js

@@ -0,0 +1,49 @@
+/**
+ * Battle runner — runs one Gen 3 OU Battle in-process through `@pkmn/sim`'s
+ * BattleStream, both sides driven by the {@link PilotPlayer}, from a fixed seed,
+ * and reports the winner. No server, no network.
+ */
+import { BattleStreams } from '@pkmn/sim';
+import { FORMAT } from '../types.js';
+import { PilotPlayer } from '../pilot/pilot.js';
+/** Run a single Battle between two packed Teams and report the winner. */
+export async function runBattle(p1Packed, p2Packed, seed, options = {}) {
+    const maxTurns = options.maxTurns ?? 1000;
+    const stream = new BattleStreams.BattleStream();
+    const streams = BattleStreams.getPlayerStreams(stream);
+    const getBattle = () => stream.battle;
+    const p1 = new PilotPlayer(streams.p1, getBattle, 'p1');
+    const p2 = new PilotPlayer(streams.p2, getBattle, 'p2');
+    void p1.start();
+    void p2.start();
+    let winner = null;
+    let turns = 0;
+    let forced = false;
+    const consume = (async () => {
+        for await (const chunk of streams.omniscient) {
+            for (const line of chunk.split('\n')) {
+                if (line.startsWith('|turn|')) {
+                    turns = parseInt(line.slice('|turn|'.length), 10) || turns;
+                    if (!forced && turns > maxTurns) {
+                        forced = true;
+                        void stream.write('>tiebreak');
+                    }
+                }
+                else if (line.startsWith('|win|')) {
+                    const name = line.slice('|win|'.length).trim();
+                    winner = name === 'A' ? 'p1' : name === 'B' ? 'p2' : null;
+                }
+                else if (line.startsWith('|tie')) {
+                    winner = null;
+                }
+            }
+        }
+    })();
+    const spec = { formatid: FORMAT, seed };
+    void stream.write(`>start ${JSON.stringify(spec)}`);
+    void stream.write(`>player p1 ${JSON.stringify({ name: 'A', team: p1Packed })}`);
+    void stream.write(`>player p2 ${JSON.stringify({ name: 'B', team: p2Packed })}`);
+    await consume;
+    return { winner, turns };
+}
+//# sourceMappingURL=run-battle.js.map

package/dist/battle/run-battle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-battle.js","sourceRoot":"","sources":["../../src/battle/run-battle.ts"],"names":[],"mappings":"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"}

package/dist/battle/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/battle/worker.js

@@ -0,0 +1,21 @@
+/**
+ * Worker-thread entry: runs one Battle per message and posts the winner back.
+ * Battles are CPU-bound and synchronous in the sim, so a pool of these threads
+ * is what turns a many-battle run from serial into parallel. Loaded by the pool
+ * as the compiled `dist/battle/worker.js` (never imported directly).
+ */
+import { parentPort } from 'node:worker_threads';
+import { runBattle } from './run-battle.js';
+if (parentPort) {
+    const port = parentPort;
+    port.on('message', async (job) => {
+        try {
+            const res = await runBattle(job.p1, job.p2, job.seed, { maxTurns: job.maxTurns });
+            port.postMessage({ ok: true, res });
+        }
+        catch (e) {
+            port.postMessage({ ok: false, error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+}
+//# sourceMappingURL=worker.js.map

package/dist/battle/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","sourceRoot":"","sources":["../../src/battle/worker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAU5C,IAAI,UAAU,EAAE,CAAC;IACf,MAAM,IAAI,GAAG,UAAU,CAAC;IACxB,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,GAAQ,EAAE,EAAE;QACpC,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,SAAS,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;YAClF,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;QACtC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACrF,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};