@zktable/coup-lite 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1236 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  CARD_MEMBERSHIP_CIRCUIT_DIR: () => CARD_MEMBERSHIP_CIRCUIT_DIR,
+  CARD_MEMBERSHIP_TARGET_DIR: () => CARD_MEMBERSHIP_TARGET_DIR,
+  CONTRACTS_DIR: () => CONTRACTS_DIR,
+  CONTRACTS_WASM_DIR: () => CONTRACTS_WASM_DIR,
+  DEFAULT_BB_BIN: () => DEFAULT_BB_BIN,
+  DEFAULT_BYTECODE_PATH: () => DEFAULT_BYTECODE_PATH,
+  DEFAULT_COUP_REFEREE_WASM: () => DEFAULT_COUP_REFEREE_WASM,
+  DEFAULT_NARGO_BIN: () => DEFAULT_NARGO_BIN,
+  DEFAULT_SHUFFLE_VK_PATH: () => DEFAULT_SHUFFLE_VK_PATH,
+  DEFAULT_STELLAR_BIN: () => DEFAULT_STELLAR_BIN,
+  DEFAULT_VERIFIER_WASM: () => DEFAULT_VERIFIER_WASM,
+  DEFAULT_VK_PATH: () => DEFAULT_VK_PATH,
+  GRAPH_TOOLS_BIN: () => GRAPH_TOOLS_BIN,
+  REPO_ROOT: () => REPO_ROOT,
+  VALID_SHUFFLE_CIRCUIT_DIR: () => VALID_SHUFFLE_CIRCUIT_DIR,
+  VALID_SHUFFLE_TARGET_DIR: () => VALID_SHUFFLE_TARGET_DIR,
+  toolEnv: () => toolEnv
+});
+function toolEnv() {
+  const home = import_node_os.default.homedir();
+  const extraDirs = [import_node_path.default.join(home, ".nargo", "bin"), import_node_path.default.join(home, ".bb", "bin")];
+  const currentPath = process.env.PATH ?? "";
+  return {
+    ...process.env,
+    PATH: [...extraDirs, currentPath].filter(Boolean).join(import_node_path.default.delimiter)
+  };
+}
+var import_node_os, import_node_path, import_node_url, import_meta, here, REPO_ROOT, CONTRACTS_WASM_DIR, DEFAULT_VERIFIER_WASM, DEFAULT_COUP_REFEREE_WASM, CONTRACTS_DIR, CARD_MEMBERSHIP_CIRCUIT_DIR, CARD_MEMBERSHIP_TARGET_DIR, DEFAULT_VK_PATH, DEFAULT_BYTECODE_PATH, VALID_SHUFFLE_CIRCUIT_DIR, VALID_SHUFFLE_TARGET_DIR, DEFAULT_SHUFFLE_VK_PATH, GRAPH_TOOLS_BIN, DEFAULT_STELLAR_BIN, DEFAULT_NARGO_BIN, DEFAULT_BB_BIN;
+var init_paths = __esm({
+  "src/paths.ts"() {
+    "use strict";
+    import_node_os = __toESM(require("os"), 1);
+    import_node_path = __toESM(require("path"), 1);
+    import_node_url = require("url");
+    import_meta = {};
+    here = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+    REPO_ROOT = import_node_path.default.resolve(here, "../../..");
+    CONTRACTS_WASM_DIR = import_node_path.default.join(
+      REPO_ROOT,
+      "packages/contracts/target/wasm32v1-none/release"
+    );
+    DEFAULT_VERIFIER_WASM = import_node_path.default.join(CONTRACTS_WASM_DIR, "zktable_verifier.wasm");
+    DEFAULT_COUP_REFEREE_WASM = import_node_path.default.join(CONTRACTS_WASM_DIR, "zktable_coup_referee.wasm");
+    CONTRACTS_DIR = import_node_path.default.join(REPO_ROOT, "packages/contracts");
+    CARD_MEMBERSHIP_CIRCUIT_DIR = import_node_path.default.join(REPO_ROOT, "packages/circuits/card_membership");
+    CARD_MEMBERSHIP_TARGET_DIR = import_node_path.default.join(CARD_MEMBERSHIP_CIRCUIT_DIR, "target");
+    DEFAULT_VK_PATH = import_node_path.default.join(CARD_MEMBERSHIP_TARGET_DIR, "vk");
+    DEFAULT_BYTECODE_PATH = import_node_path.default.join(CARD_MEMBERSHIP_TARGET_DIR, "card_membership.json");
+    VALID_SHUFFLE_CIRCUIT_DIR = import_node_path.default.join(REPO_ROOT, "packages/circuits/valid_shuffle");
+    VALID_SHUFFLE_TARGET_DIR = import_node_path.default.join(VALID_SHUFFLE_CIRCUIT_DIR, "target");
+    DEFAULT_SHUFFLE_VK_PATH = import_node_path.default.join(VALID_SHUFFLE_TARGET_DIR, "vk");
+    GRAPH_TOOLS_BIN = import_node_path.default.join(
+      REPO_ROOT,
+      "packages/contracts/tools/graph-tools/target/release/zktable-graph"
+    );
+    DEFAULT_STELLAR_BIN = "stellar";
+    DEFAULT_NARGO_BIN = "nargo";
+    DEFAULT_BB_BIN = "bb";
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CHARACTERS: () => CHARACTERS,
+  CHARACTER_NAMES: () => CHARACTER_NAMES,
+  CardProver: () => CardProver,
+  CliRefereeClient: () => CliRefereeClient,
+  DEFAULT_COUP_REFEREE_WASM: () => DEFAULT_COUP_REFEREE_WASM,
+  DEFAULT_SHUFFLE_VK_PATH: () => DEFAULT_SHUFFLE_VK_PATH,
+  DEFAULT_VERIFIER_WASM: () => DEFAULT_VERIFIER_WASM,
+  DEFAULT_VK_PATH: () => DEFAULT_VK_PATH,
+  HAND_SIZE: () => HAND_SIZE,
+  MAX_PLAYERS: () => MAX_PLAYERS,
+  MIN_PLAYERS: () => MIN_PLAYERS,
+  N_PLAYERS: () => N_PLAYERS,
+  RefereeCliError: () => RefereeCliError,
+  START_INFLUENCE: () => START_INFLUENCE,
+  buildRoster: () => buildRoster,
+  chooseMove: () => chooseMove,
+  coupLite: () => coupLite,
+  createLocalMatch: () => createLocalMatch,
+  ensureContractWasms: () => ensureContractWasms,
+  pickSeeded: () => pickSeeded,
+  playCoupLite: () => playCoupLite,
+  playLocalMatch: () => playLocalMatch,
+  seededHand: () => seededHand,
+  stepLocalMatch: () => stepLocalMatch,
+  stripHexPrefix: () => stripHexPrefix,
+  toBe32Hex: () => toBe32Hex,
+  toolEnv: () => toolEnv
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/coup-lite.ts
+var import_core = require("@zktable/core");
+var CHARACTERS = [0, 1, 2, 3, 4];
+var CHARACTER_NAMES = ["Duke", "Assassin", "Captain", "Contessa", "Ambassador"];
+var HAND_SIZE = 2;
+var START_INFLUENCE = 2;
+var MIN_PLAYERS = 2;
+var MAX_PLAYERS = 4;
+var N_PLAYERS = 2;
+function readConfig(raw) {
+  return raw.coupLite ?? {};
+}
+function hashSeed(seed) {
+  let h = 2166136261;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function mulberry32(seed) {
+  let a = seed;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function seededHand(seed) {
+  const rnd = mulberry32(hashSeed(seed));
+  const pool = [...CHARACTERS];
+  const i0 = Math.floor(rnd() * pool.length);
+  const c0 = pool.splice(i0, 1)[0];
+  const i1 = Math.floor(rnd() * pool.length);
+  const c1 = pool.splice(i1, 1)[0];
+  return [c0, c1];
+}
+function handsByPlayer(state) {
+  return state.public.handsByPlayer ?? {};
+}
+function influenceByPlayer(state) {
+  return state.public.influenceByPlayer ?? {};
+}
+function deadByPlayer(state) {
+  return state.public.deadByPlayer ?? {};
+}
+function loseInfluence(state, player) {
+  const dead = deadByPlayer(state);
+  const influence = influenceByPlayer(state);
+  const playerDead = dead[player] ?? [false, false];
+  const slot = playerDead[0] ? 1 : 0;
+  const nextDead = slot === 0 ? [true, playerDead[1]] : [playerDead[0], true];
+  return {
+    influenceByPlayer: { ...influence, [player]: Math.max(0, (influence[player] ?? START_INFLUENCE) - 1) },
+    deadByPlayer: { ...dead, [player]: nextDead }
+  };
+}
+function alivePlayers(state) {
+  const influence = influenceByPlayer(state);
+  return state.players.map((p) => p.id).filter((id) => (influence[id] ?? START_INFLUENCE) > 0);
+}
+var coupLite = (0, import_core.defineGame)({
+  name: "coup-lite",
+  players: { min: MIN_PLAYERS, max: MAX_PLAYERS },
+  components: {
+    // Public shared-deck declaration (the character pool). The shuffle marker
+    // is REAL on-chain as of M8.3: a seed-forced `valid_shuffle` proof with
+    // position-assigned hands (see module doc); each hand stays hidden.
+    deck: import_core.zk.deck.of([...CHARACTER_NAMES]),
+    shuffle: import_core.zk.deck.shuffle(),
+    hand: import_core.zk.deck.deal(HAND_SIZE)
+  },
+  state: {
+    public: () => ({
+      // See the module doc: local-mirror-only visibility, not real hiding.
+      handsByPlayer: {},
+      influenceByPlayer: {},
+      deadByPlayer: {},
+      lastClaim: null,
+      claimHistory: [],
+      eliminatedIds: [],
+      winnerId: null
+    }),
+    // Real data (matches Blackout's `state.secret` / Liar's Dice's own
+    // `secret.dice` precedent — see the module doc): this player's actual
+    // hand, either the REAL `card_membership`-provable hand
+    // (`config.coupLite.handsByPlayer`, supplied by the on-chain runner) or a
+    // deterministic seeded fallback for chain-free local play.
+    secret: (ctx) => {
+      const cfg = readConfig(ctx.config);
+      const seed = ctx.config.seed ?? "coup-lite-default-seed";
+      const hand = cfg.handsByPlayer?.[ctx.id] ?? seededHand(`${seed}:${ctx.id}`);
+      return { hand };
+    }
+  },
+  setup: (state, ctx) => {
+    const cfg = readConfig(ctx.config);
+    const seed = ctx.config.seed ?? "coup-lite-default-seed";
+    const hands = {};
+    const influence = {};
+    const dead = {};
+    for (const p of ctx.players) {
+      hands[p.id] = cfg.handsByPlayer?.[p.id] ?? seededHand(`${seed}:${p.id}`);
+      influence[p.id] = START_INFLUENCE;
+      dead[p.id] = [false, false];
+    }
+    return {
+      ...state,
+      public: { ...state.public, handsByPlayer: hands, influenceByPlayer: influence, deadByPlayer: dead }
+    };
+  },
+  turn: {
+    order: "clockwise",
+    // A player at zero influence is out: the engine skips their turn and
+    // returns no legal moves for them (mirrors the referee's advance_turn).
+    eliminated: (state, playerId) => (influenceByPlayer(state)[playerId] ?? START_INFLUENCE) === 0,
+    moves: {
+      claim: {
+        // Public claim to hold `character` — no ZK binding by itself (the
+        // hidden fact is the hand's contents, proven only if challenged).
+        legal: (view) => CHARACTERS.map((character) => ({ type: "claim", character })),
+        apply: (state, move, ctx) => {
+          const entry = { player: ctx.playerId, character: move.character };
+          return {
+            ...state,
+            public: {
+              ...state.public,
+              lastClaim: entry,
+              claimHistory: [...state.public.claimHistory, entry]
+            }
+          };
+        }
+      },
+      challenge: {
+        // Binds this move to "the target proves in ZK that the claimed
+        // character is in their committed hand, or the challenge stands as a
+        // caught bluff" once ZK-secured — inert marker in the local engine
+        // (see the module doc), real on-chain via `prove_hold`/`reveal_card`
+        // in `runner.ts`.
+        zkp: import_core.zk.deck.proveHoldOrBluff(),
+        // See the module doc's turn-structure deviation note: only legal
+        // for the player whose turn falls immediately after a still-standing
+        // claim by someone else.
+        legal: (view) => {
+          const claim = view.public.lastClaim ?? null;
+          if (!claim || claim.player === view.self.id) return [];
+          return [{ type: "challenge" }];
+        },
+        apply: (state, _move, ctx) => {
+          const claim = state.public.lastClaim;
+          const hands = handsByPlayer(state);
+          const targetHand = hands[claim.player] ?? [0, 0];
+          const challenger = ctx.playerId;
+          const claimIsTrue = targetHand.includes(claim.character);
+          const loser = claimIsTrue ? challenger : claim.player;
+          const { influenceByPlayer: nextInfluence, deadByPlayer: nextDead } = loseInfluence(state, loser);
+          const priorEliminated = state.public.eliminatedIds ?? [];
+          const nextState = {
+            ...state,
+            public: {
+              ...state.public,
+              influenceByPlayer: nextInfluence,
+              deadByPlayer: nextDead,
+              lastClaim: null,
+              eliminatedIds: (nextInfluence[loser] ?? 0) === 0 ? [...priorEliminated, loser] : priorEliminated
+            }
+          };
+          const survivors = alivePlayers(nextState);
+          const winnerId = survivors.length === 1 ? survivors[0] : null;
+          return { ...nextState, public: { ...nextState.public, winnerId } };
+        }
+      }
+    }
+  },
+  end: (state) => {
+    const winnerId = state.public.winnerId;
+    return winnerId ? { winner: winnerId } : null;
+  }
+});
+
+// src/strategy.ts
+function hashSeed2(seed) {
+  let h = 2166136261;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function mulberry322(seed) {
+  let a = seed;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function pickSeeded(items, seed) {
+  if (items.length === 0) throw new Error("pickSeeded: items is empty");
+  const rnd = mulberry322(hashSeed2(seed));
+  const index = Math.min(items.length - 1, Math.floor(rnd() * items.length));
+  return items[index];
+}
+function ownHand(view) {
+  return view.self.secret.hand ?? [0, 0];
+}
+function chooseClaim(view, seed) {
+  const hand = ownHand(view);
+  const isBluff = pickSeeded([0, 1, 2, 3, 4], `${seed}:bluff`) === 0;
+  if (isBluff) {
+    const unheld = CHARACTERS.filter((c) => !hand.includes(c));
+    const character = unheld.length > 0 ? pickSeeded(unheld, `${seed}:bluffchar`) : pickSeeded([...CHARACTERS], `${seed}:fallback`);
+    return { type: "claim", character };
+  }
+  return { type: "claim", character: pickSeeded(hand, `${seed}:claimchar`) };
+}
+function chooseMove(view, seed) {
+  const canChallenge = view.legalMoves.some((m) => m.type === "challenge");
+  const claim = view.public.lastClaim ?? null;
+  if (canChallenge && claim) {
+    const hand = ownHand(view);
+    const holdsClaimed = hand.includes(claim.character);
+    const suspicionThreshold = holdsClaimed ? 0.15 : 0.55;
+    const roll = pickSeeded([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], `${seed}:challengeroll`) / 10;
+    if (roll < suspicionThreshold) {
+      return { type: "challenge" };
+    }
+  }
+  return chooseClaim(view, seed);
+}
+
+// src/card-prover.ts
+var import_node_child_process = require("child_process");
+var import_promises = require("fs/promises");
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_util = require("util");
+init_paths();
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+async function exists(p) {
+  try {
+    await (0, import_promises.access)(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var CardProver = class {
+  circuitDir;
+  shuffleCircuitDir;
+  graphToolsBin;
+  nargoBin;
+  bbBin;
+  workDir;
+  env;
+  constructor(opts = {}) {
+    this.circuitDir = opts.circuitDir ?? CARD_MEMBERSHIP_CIRCUIT_DIR;
+    this.shuffleCircuitDir = opts.shuffleCircuitDir ?? VALID_SHUFFLE_CIRCUIT_DIR;
+    this.graphToolsBin = opts.graphToolsBin ?? GRAPH_TOOLS_BIN;
+    this.nargoBin = opts.nargoBin ?? DEFAULT_NARGO_BIN;
+    this.bbBin = opts.bbBin ?? DEFAULT_BB_BIN;
+    this.workDir = opts.workDir ?? import_node_os2.default.tmpdir();
+    this.env = toolEnv();
+  }
+  get targetDir() {
+    return import_node_path2.default.join(this.circuitDir, "target");
+  }
+  get bytecodePath() {
+    return import_node_path2.default.join(this.targetDir, "card_membership.json");
+  }
+  get vkPath() {
+    return import_node_path2.default.join(this.targetDir, "vk");
+  }
+  get shuffleTargetDir() {
+    return import_node_path2.default.join(this.shuffleCircuitDir, "target");
+  }
+  get shuffleBytecodePath() {
+    return import_node_path2.default.join(this.shuffleTargetDir, "valid_shuffle.json");
+  }
+  get shuffleVkPath() {
+    return import_node_path2.default.join(this.shuffleTargetDir, "vk");
+  }
+  /** Compile the circuit once if `target/card_membership.json` is missing. */
+  async ensureCompiled() {
+    if (await exists(this.bytecodePath)) return;
+    await execFileAsync(this.nargoBin, ["compile"], { cwd: this.circuitDir, env: this.env });
+  }
+  /** Generate the verification key once if `target/vk` is missing. */
+  async ensureVk() {
+    await this.ensureCompiled();
+    if (await exists(this.vkPath)) return;
+    await this.writeVk(this.bytecodePath, this.targetDir);
+  }
+  /** Compile `valid_shuffle` once if its bytecode is missing. */
+  async ensureShuffleCompiled() {
+    if (await exists(this.shuffleBytecodePath)) return;
+    await execFileAsync(this.nargoBin, ["compile"], { cwd: this.shuffleCircuitDir, env: this.env });
+  }
+  /** Generate the `valid_shuffle` verification key once if missing. */
+  async ensureShuffleVk() {
+    await this.ensureShuffleCompiled();
+    if (await exists(this.shuffleVkPath)) return;
+    await this.writeVk(this.shuffleBytecodePath, this.shuffleTargetDir);
+  }
+  async writeVk(bytecodePath, outputDir) {
+    await execFileAsync(
+      this.bbBin,
+      [
+        "write_vk",
+        "--scheme",
+        "ultra_honk",
+        "--oracle_hash",
+        "keccak",
+        "--bytecode_path",
+        bytecodePath,
+        "--output_path",
+        outputDir,
+        "--output_format",
+        "bytes_and_fields"
+      ],
+      { env: this.env }
+    );
+    const vkPath = import_node_path2.default.join(outputDir, "vk");
+    const { stat, rename, rmdir } = await import("fs/promises");
+    const s = await stat(vkPath);
+    if (s.isDirectory()) {
+      await rename(import_node_path2.default.join(vkPath, "vk"), `${vkPath}.tmp`);
+      await rmdir(vkPath);
+      await rename(`${vkPath}.tmp`, vkPath);
+    }
+  }
+  /**
+   * Poseidon2(value, salt) via `zktable-graph commit` — used for the seed
+   * commit-reveal nonces (`hash2(nonce, 0)`), byte-identical to the referee.
+   */
+  async commit(value, salt) {
+    const { stdout } = await execFileAsync(
+      this.graphToolsBin,
+      ["commit", "--value", value.toString(), "--salt", salt.toString()],
+      { env: this.env }
+    );
+    return stdout.trim();
+  }
+  /** The joint commit-reveal seed: left-fold of hash2 over the nonces (player-index order). */
+  async seed(nonces) {
+    const { stdout } = await execFileAsync(
+      this.graphToolsBin,
+      ["seed", "--nonces", nonces.join(",")],
+      { env: this.env }
+    );
+    return stdout.trim();
+  }
+  /**
+   * Full `valid_shuffle` pipeline (M8.3): derive the UNIQUE seed-forced
+   * permutation of the canonical 15-card deck via `zktable-graph
+   * shuffle-witness`, then `nargo execute` -> `bb prove`. The returned
+   * `cards`/`salts` are the dealer's private view (handed to each player
+   * off-chain); `leavesHex` + `proof` go on-chain via `submit_shuffle`.
+   */
+  async proveShuffle(seedHex, salts) {
+    if (salts.length !== 15) throw new Error("proveShuffle: exactly 15 salts required");
+    await this.ensureShuffleCompiled();
+    const dir = await (0, import_promises.mkdtemp)(import_node_path2.default.join(this.workDir, "zktable-shuffle-prove-"));
+    try {
+      const proverTomlPath = import_node_path2.default.join(dir, "Prover");
+      const witnessJsonPath = import_node_path2.default.join(dir, "witness.json");
+      const witnessOutPath = import_node_path2.default.join(dir, "witness");
+      await execFileAsync(
+        this.graphToolsBin,
+        [
+          "shuffle-witness",
+          "--seed",
+          seedHex,
+          "--salts",
+          salts.join(","),
+          "--prover",
+          `${proverTomlPath}.toml`,
+          "--json",
+          witnessJsonPath
+        ],
+        { env: this.env }
+      );
+      const witness = JSON.parse(await (0, import_promises.readFile)(witnessJsonPath, "utf8"));
+      await execFileAsync(this.nargoBin, ["execute", "--prover-name", proverTomlPath, witnessOutPath], {
+        cwd: this.shuffleCircuitDir,
+        env: this.env
+      });
+      await execFileAsync(
+        this.bbBin,
+        [
+          "prove",
+          "--scheme",
+          "ultra_honk",
+          "--oracle_hash",
+          "keccak",
+          "--bytecode_path",
+          this.shuffleBytecodePath,
+          "--witness_path",
+          `${witnessOutPath}.gz`,
+          "--output_path",
+          dir,
+          "--output_format",
+          "bytes_and_fields"
+        ],
+        { env: this.env }
+      );
+      const proof = new Uint8Array(await (0, import_promises.readFile)(import_node_path2.default.join(dir, "proof")));
+      const publicInputs = new Uint8Array(await (0, import_promises.readFile)(import_node_path2.default.join(dir, "public_inputs")));
+      return {
+        proof,
+        publicInputs,
+        seedHex: witness.seed,
+        cards: witness.cards.map((c) => Number(c)),
+        salts: witness.salts,
+        leavesHex: witness.leaves
+      };
+    } finally {
+      await (0, import_promises.rm)(dir, { recursive: true, force: true });
+    }
+  }
+  /**
+   * Full pipeline for one "prove-hold" claim: `zktable-graph card-witness` ->
+   * `nargo execute` -> `bb prove`. Runs entirely inside an isolated temp dir;
+   * never touches `card_membership/Prover.toml` or `card_membership/target/`
+   * (besides the shared, idempotent compiled bytecode).
+   */
+  async proveHold(claimed, cards, salts, heldIndex) {
+    await this.ensureCompiled();
+    const dir = await (0, import_promises.mkdtemp)(import_node_path2.default.join(this.workDir, "zktable-card-prove-"));
+    try {
+      const proverTomlPath = import_node_path2.default.join(dir, "Prover");
+      const witnessJsonPath = import_node_path2.default.join(dir, "witness.json");
+      const witnessOutPath = import_node_path2.default.join(dir, "witness");
+      await execFileAsync(
+        this.graphToolsBin,
+        [
+          "card-witness",
+          "--claimed",
+          claimed.toString(),
+          "--cards",
+          cards.join(","),
+          "--salts",
+          salts.join(","),
+          "--held",
+          String(heldIndex),
+          "--prover",
+          `${proverTomlPath}.toml`,
+          "--json",
+          witnessJsonPath
+        ],
+        { env: this.env }
+      );
+      const witness = JSON.parse(await (0, import_promises.readFile)(witnessJsonPath, "utf8"));
+      await execFileAsync(this.nargoBin, ["execute", "--prover-name", proverTomlPath, witnessOutPath], {
+        cwd: this.circuitDir,
+        env: this.env
+      });
+      await execFileAsync(
+        this.bbBin,
+        [
+          "prove",
+          "--scheme",
+          "ultra_honk",
+          "--oracle_hash",
+          "keccak",
+          "--bytecode_path",
+          this.bytecodePath,
+          "--witness_path",
+          `${witnessOutPath}.gz`,
+          "--output_path",
+          dir,
+          "--output_format",
+          "bytes_and_fields"
+        ],
+        { env: this.env }
+      );
+      const proof = new Uint8Array(await (0, import_promises.readFile)(import_node_path2.default.join(dir, "proof")));
+      const publicInputs = new Uint8Array(await (0, import_promises.readFile)(import_node_path2.default.join(dir, "public_inputs")));
+      const [c0, c1] = witness.commitments;
+      if (!c0 || !c1) throw new Error("proveHold: expected exactly 2 commitments");
+      return {
+        proof,
+        publicInputs,
+        claimed,
+        commitmentsHex: [c0, c1]
+      };
+    } finally {
+      await (0, import_promises.rm)(dir, { recursive: true, force: true });
+    }
+  }
+  /** Off-chain check via `bb verify`, useful for sanity-checking a proof before spending a testnet tx. */
+  async verifyLocally(proof, publicInputs) {
+    await this.ensureVk();
+    return this.bbVerify(proof, publicInputs, this.vkPath);
+  }
+  /** Off-chain `bb verify` of a `valid_shuffle` proof against ITS verification key. */
+  async shuffleLocalVerify(proof, publicInputs) {
+    await this.ensureShuffleVk();
+    return this.bbVerify(proof, publicInputs, this.shuffleVkPath);
+  }
+  async bbVerify(proof, publicInputs, vkPath) {
+    const dir = await (0, import_promises.mkdtemp)(import_node_path2.default.join(this.workDir, "zktable-card-verify-"));
+    try {
+      const { writeFile } = await import("fs/promises");
+      const proofPath = import_node_path2.default.join(dir, "proof");
+      const publicInputsPath = import_node_path2.default.join(dir, "public_inputs");
+      await writeFile(proofPath, proof);
+      await writeFile(publicInputsPath, publicInputs);
+      try {
+        await execFileAsync(
+          this.bbBin,
+          [
+            "verify",
+            "--scheme",
+            "ultra_honk",
+            "--oracle_hash",
+            "keccak",
+            "--proof_path",
+            proofPath,
+            "--vk_path",
+            vkPath,
+            "--public_inputs_path",
+            publicInputsPath
+          ],
+          { env: this.env }
+        );
+        return true;
+      } catch {
+        return false;
+      }
+    } finally {
+      await (0, import_promises.rm)(dir, { recursive: true, force: true });
+    }
+  }
+};
+
+// src/referee-client.ts
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+init_paths();
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var REFEREE_ERROR_NAMES = {
+  1: "AlreadyInitialized",
+  2: "UnsupportedConfig",
+  3: "BadPlayerIndex",
+  4: "WrongPhase",
+  5: "AlreadyDealt",
+  6: "BadArrayLength",
+  7: "NotYourTurn",
+  8: "NotAlive",
+  9: "NoActiveClaim",
+  10: "ClaimTargetMismatch",
+  11: "CannotChallengeSelf",
+  12: "ClaimMismatch",
+  13: "VerificationFailed",
+  14: "ProofSizeMismatch",
+  15: "NotAuthorizedToReveal",
+  16: "SlotAlreadyRevealed",
+  17: "BadSlotIndex",
+  18: "CardRevealMismatch",
+  19: "AlreadyCommitted",
+  20: "NonceRevealMismatch",
+  21: "AlreadyNonceRevealed",
+  22: "NotFullyCommitted"
+};
+var RefereeCliError = class extends Error {
+  args;
+  stderr;
+  contractErrorCode;
+  contractErrorName;
+  constructor(args, stderr) {
+    const match = /Error\(Contract, #(\d+)\)/.exec(stderr);
+    const code = match ? Number(match[1]) : null;
+    const name = code !== null ? REFEREE_ERROR_NAMES[code] ?? null : null;
+    const suffix = code !== null ? ` -> Error(Contract, #${code})${name ? ` (${name})` : ""}` : "";
+    super(`stellar ${args.join(" ")} failed${suffix}
+${stderr.trim()}`);
+    this.name = "RefereeCliError";
+    this.args = args;
+    this.stderr = stderr;
+    this.contractErrorCode = code;
+    this.contractErrorName = name;
+  }
+};
+function stripHexPrefix(hex) {
+  return hex.startsWith("0x") ? hex.slice(2) : hex;
+}
+function toBe32Hex(value) {
+  if (value < 0n) throw new Error("toBe32Hex: value must be non-negative");
+  const hex = value.toString(16);
+  if (hex.length > 64) throw new Error("toBe32Hex: value does not fit in 32 bytes");
+  return hex.padStart(64, "0");
+}
+function extractTxHash(stderr) {
+  const m = /explorer\/testnet\/tx\/([0-9a-f]{64})/i.exec(stderr);
+  return m ? m[1] : null;
+}
+var CliRefereeClient = class {
+  network;
+  source;
+  stellarBin;
+  retries;
+  retryDelayMs;
+  sourceForSeat;
+  constructor(opts = {}) {
+    this.network = opts.network ?? "testnet";
+    this.source = opts.source ?? "alice";
+    this.stellarBin = opts.stellarBin ?? DEFAULT_STELLAR_BIN;
+    this.retries = opts.retries ?? 3;
+    this.retryDelayMs = opts.retryDelayMs ?? 3e3;
+    this.sourceForSeat = opts.sourceForSeat ?? {};
+  }
+  /** `stellar contract deploy` for the `card_membership` verifier. Returns the deployed contract id. */
+  async deployVerifier(wasmPath, vkHex) {
+    const stdout = await this.runDeploy(wasmPath, ["--vk_bytes", stripHexPrefix(vkHex)]);
+    return stdout.trim();
+  }
+  /**
+   * `stellar contract deploy` for the coup referee. Returns the deployed
+   * contract id. `playerAddresses[i]` becomes seat i's owner — every seat-i
+   * action must then be signed by that address (require_auth). `verifier`
+   * holds the `card_membership` VK; `shuffleVerifier` the `valid_shuffle`
+   * VK (M8.3).
+   */
+  async deployReferee(wasmPath, opts) {
+    const stdout = await this.runDeploy(wasmPath, [
+      "--verifier",
+      opts.verifier,
+      "--shuffle_verifier",
+      opts.shuffleVerifier,
+      "--players",
+      JSON.stringify(opts.playerAddresses)
+    ]);
+    return stdout.trim();
+  }
+  async commitSeedNonce(refereeId, opts) {
+    const res = await this.invoke(
+      refereeId,
+      ["commit_seed_nonce", "--player", String(opts.player), "--nonce_commitment", stripHexPrefix(opts.commitmentHex)],
+      opts.player
+    );
+    return res.txHash;
+  }
+  async revealSeedNonce(refereeId, opts) {
+    const res = await this.invoke(
+      refereeId,
+      ["reveal_seed_nonce", "--player", String(opts.player), "--nonce", stripHexPrefix(opts.nonceHex)],
+      opts.player
+    );
+    return res.txHash;
+  }
+  /** Submits the 15 shuffle-proven deck leaves + the `valid_shuffle` proof (permissionless — the proof is the trust anchor). */
+  async submitShuffle(refereeId, opts) {
+    const res = await this.invoke(refereeId, [
+      "submit_shuffle",
+      "--leaves",
+      JSON.stringify(opts.leavesHex.map(stripHexPrefix)),
+      "--proof",
+      stripHexPrefix(opts.proofHex)
+    ]);
+    return res.txHash;
+  }
+  async claim(refereeId, opts) {
+    const res = await this.invoke(
+      refereeId,
+      ["claim", "--player", String(opts.player), "--character", String(opts.character)],
+      opts.player
+    );
+    return res.txHash;
+  }
+  async challenge(refereeId, opts) {
+    const res = await this.invoke(
+      refereeId,
+      ["challenge", "--challenger", String(opts.challenger), "--target", String(opts.target)],
+      opts.challenger
+    );
+    return res.txHash;
+  }
+  async proveHold(refereeId, opts) {
+    const res = await this.invoke(
+      refereeId,
+      [
+        "prove_hold",
+        "--target",
+        String(opts.target),
+        "--claimed",
+        String(opts.claimed),
+        "--proof",
+        stripHexPrefix(opts.proofHex)
+      ],
+      opts.target
+    );
+    return res.txHash;
+  }
+  async revealCard(refereeId, opts) {
+    const res = await this.invoke(
+      refereeId,
+      [
+        "reveal_card",
+        "--player",
+        String(opts.player),
+        "--slot",
+        String(opts.slot),
+        "--card",
+        String(opts.card),
+        "--salt",
+        stripHexPrefix(opts.saltHex)
+      ],
+      opts.player
+    );
+    return res.txHash;
+  }
+  async gameState(refereeId) {
+    const stdout = await this.runReadOnly(refereeId, ["game_state"]);
+    return JSON.parse(stdout.trim());
+  }
+  // --- internals -----------------------------------------------------------
+  async runDeploy(wasmPath, ctorArgs) {
+    const args = [
+      "contract",
+      "deploy",
+      "--wasm",
+      wasmPath,
+      "--source",
+      this.source,
+      "--network",
+      this.network,
+      "--",
+      ...ctorArgs
+    ];
+    return (await this.execWithRetry(args)).stdout;
+  }
+  /**
+   * Mutating call (`--send=yes`). When `seat` is given, signs with that
+   * seat's identity (`sourceForSeat[seat]`, falling back to `source`) so
+   * the referee's per-seat `require_auth()` is satisfied.
+   */
+  async invoke(contractId, methodArgs, seat) {
+    const source = seat !== void 0 ? this.sourceForSeat[seat] ?? this.source : this.source;
+    const args = [
+      "contract",
+      "invoke",
+      "--id",
+      contractId,
+      "--source",
+      source,
+      "--network",
+      this.network,
+      "--send=yes",
+      "--",
+      ...methodArgs
+    ];
+    return this.execWithRetry(args);
+  }
+  /** Read-only call (no `--send`). */
+  async runReadOnly(contractId, methodArgs) {
+    const args = [
+      "contract",
+      "invoke",
+      "--id",
+      contractId,
+      "--source",
+      this.source,
+      "--network",
+      this.network,
+      "--",
+      ...methodArgs
+    ];
+    return (await this.execWithRetry(args)).stdout;
+  }
+  async execWithRetry(args) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const { stdout, stderr } = await execFileAsync2(this.stellarBin, args, {
+          env: toolEnv(),
+          maxBuffer: 32 * 1024 * 1024
+        });
+        return { stdout, txHash: extractTxHash(stderr ?? "") };
+      } catch (err) {
+        const stderr = typeof err === "object" && err !== null && "stderr" in err ? String(err.stderr) : String(err);
+        const cliError = new RefereeCliError(args, stderr);
+        lastError = cliError;
+        if (cliError.contractErrorCode !== null || attempt === this.retries) {
+          throw cliError;
+        }
+        await sleep(this.retryDelayMs * (attempt + 1));
+      }
+    }
+    throw lastError;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/runner.ts
+var import_node_crypto = require("crypto");
+var import_promises2 = require("fs/promises");
+var import_core2 = require("@zktable/core");
+init_paths();
+
+// src/identities.ts
+var import_node_child_process3 = require("child_process");
+var import_node_util3 = require("util");
+init_paths();
+var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
+function seatIdentityNames(source, nSeats, multiSeat) {
+  if (!multiSeat) return Array.from({ length: nSeats }, () => source);
+  return Array.from({ length: nSeats }, (_, i) => i === 0 ? source : `${source}-seat${i}`);
+}
+async function ensureIdentities(names, stellarBin = DEFAULT_STELLAR_BIN) {
+  const out = {};
+  for (const name of [...new Set(names)]) {
+    try {
+      await execFileAsync3(stellarBin, ["keys", "address", name], { env: toolEnv() });
+    } catch {
+      await execFileAsync3(stellarBin, ["keys", "generate", name, "--network", "testnet", "--fund"], {
+        env: toolEnv()
+      });
+    }
+    const { stdout } = await execFileAsync3(stellarBin, ["keys", "address", name], { env: toolEnv() });
+    out[name] = stdout.trim();
+  }
+  return out;
+}
+
+// src/runner.ts
+function buildRoster(count = N_PLAYERS) {
+  const roster = [];
+  for (let i = 0; i < count; i++) roster.push({ id: `player${i + 1}` });
+  return roster;
+}
+function createLocalMatch(roster, config, seed) {
+  return (0, import_core2.createMatch)(coupLite, roster, { seed, config: { coupLite: config } });
+}
+function stepLocalMatch(match, seed) {
+  const playerId = match.state.turn.current;
+  const view = match.view(playerId);
+  const moveSeed = `${seed}:move${match.state.public.claimHistory.length}:${playerId}`;
+  const move = chooseMove(view, moveSeed);
+  match.submit(playerId, move);
+  if (move.type === "claim") {
+    return { playerId, move: { type: "claim", character: move.character } };
+  }
+  return { playerId, move: { type: "challenge" } };
+}
+function playLocalMatch(roster, config, seed, opts = {}) {
+  const match = createLocalMatch(roster, config, seed);
+  const steps = [];
+  const maxSteps = opts.maxSteps ?? 200;
+  while (match.state.status === "active" && steps.length < maxSteps) {
+    steps.push(stepLocalMatch(match, seed));
+  }
+  if (match.state.status === "active") {
+    throw new Error(`playLocalMatch: did not reach a natural end within ${maxSteps} steps`);
+  }
+  return { match, steps };
+}
+async function ensureContractWasms(log) {
+  const { access: access2 } = await import("fs/promises");
+  const missing = [];
+  for (const p of [DEFAULT_VERIFIER_WASM, DEFAULT_COUP_REFEREE_WASM]) {
+    try {
+      await access2(p);
+    } catch {
+      missing.push(p);
+    }
+  }
+  if (missing.length === 0) return;
+  log(`building contract wasms (missing: ${missing.join(", ")})\u2026`);
+  const { execFile: execFile4 } = await import("child_process");
+  const { promisify: promisify4 } = await import("util");
+  const execFileAsync4 = promisify4(execFile4);
+  const { CONTRACTS_DIR: CONTRACTS_DIR2, toolEnv: toolEnv2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+  await execFileAsync4(
+    "cargo",
+    [
+      "+stable",
+      "build",
+      "--release",
+      "--target",
+      "wasm32v1-none",
+      "-p",
+      "zktable-verifier",
+      "-p",
+      "zktable-coup-referee"
+    ],
+    { cwd: CONTRACTS_DIR2, env: toolEnv2() }
+  );
+}
+function randomField() {
+  return BigInt("0x" + (0, import_node_crypto.randomBytes)(16).toString("hex")) + 1n;
+}
+function nextDeadSlot(dead) {
+  return dead[0] ? 1 : 0;
+}
+async function playCoupLite(opts = {}) {
+  const log = opts.log ?? ((line) => console.log(line));
+  const seed = opts.seed ?? `coup-lite-testnet-${Date.now()}`;
+  const nPlayers = opts.players ?? N_PLAYERS;
+  if (nPlayers < MIN_PLAYERS || nPlayers > MAX_PLAYERS) {
+    throw new Error(`playCoupLite: players must be in [${MIN_PLAYERS}, ${MAX_PLAYERS}], got ${nPlayers}`);
+  }
+  const roster = buildRoster(nPlayers);
+  await ensureContractWasms(log);
+  const prover = new CardProver({ circuitDir: CARD_MEMBERSHIP_CIRCUIT_DIR });
+  log("ensuring card_membership circuit is compiled + VK is built\u2026");
+  await prover.ensureVk();
+  log("ensuring valid_shuffle circuit is compiled + VK is built\u2026");
+  await prover.ensureShuffleVk();
+  const source = opts.source ?? "alice";
+  const seatNames = seatIdentityNames(source, nPlayers, opts.multiSeat ?? false);
+  log(`ensuring seat identities exist + are funded: ${[...new Set(seatNames)].join(", ")}\u2026`);
+  const addressByName = await ensureIdentities(seatNames);
+  const playerAddresses = seatNames.map((n) => addressByName[n]);
+  const client = new CliRefereeClient({
+    network: opts.network,
+    source,
+    sourceForSeat: Object.fromEntries(seatNames.map((n, i) => [i, n]))
+  });
+  log("reading card_membership verification key\u2026");
+  const vkHex = (await (0, import_promises2.readFile)(opts.vkPath ?? DEFAULT_VK_PATH)).toString("hex");
+  log("reading valid_shuffle verification key\u2026");
+  const shuffleVkHex = (await (0, import_promises2.readFile)(opts.shuffleVkPath ?? DEFAULT_SHUFFLE_VK_PATH)).toString("hex");
+  log("deploying card_membership verifier\u2026");
+  const verifierContractId = await client.deployVerifier(opts.verifierWasmPath ?? DEFAULT_VERIFIER_WASM, vkHex);
+  log(`  verifier: ${verifierContractId}`);
+  log("deploying valid_shuffle verifier\u2026");
+  const shuffleVerifierContractId = await client.deployVerifier(
+    opts.verifierWasmPath ?? DEFAULT_VERIFIER_WASM,
+    shuffleVkHex
+  );
+  log(`  shuffle verifier: ${shuffleVerifierContractId}`);
+  log(`deploying coup-referee (seats=[${seatNames.join(", ")}])\u2026`);
+  const refereeContractId = await client.deployReferee(opts.refereeWasmPath ?? DEFAULT_COUP_REFEREE_WASM, {
+    verifier: verifierContractId,
+    shuffleVerifier: shuffleVerifierContractId,
+    playerAddresses
+  });
+  log(`  referee: ${refereeContractId}`);
+  const nonces = roster.map(() => randomField());
+  for (let i = 0; i < roster.length; i++) {
+    log(`player ${i}: committing seed nonce (hash2(nonce, 0))\u2026`);
+    const commitmentHex = await prover.commit(nonces[i], 0n);
+    await client.commitSeedNonce(refereeContractId, { player: i, commitmentHex });
+  }
+  for (let i = 0; i < roster.length; i++) {
+    log(`player ${i}: revealing seed nonce\u2026`);
+    await client.revealSeedNonce(refereeContractId, { player: i, nonceHex: toBe32Hex(nonces[i]) });
+  }
+  const seedHex = await prover.seed(nonces);
+  const onChainSeed = (await client.gameState(refereeContractId)).seed;
+  if (onChainSeed && onChainSeed.replace(/^0x/, "") !== seedHex.replace(/^0x/, "")) {
+    throw new Error(`playCoupLite: locally-recomputed seed ${seedHex} != on-chain seed ${onChainSeed}`);
+  }
+  log(`joint seed: ${seedHex}`);
+  const deckSalts = Array.from({ length: 15 }, () => randomField());
+  log("proving valid_shuffle (real UltraHonk proof - the seed forces the order)\u2026");
+  const shuffle = await prover.proveShuffle(seedHex, deckSalts);
+  if (!await prover.shuffleLocalVerify(shuffle.proof, shuffle.publicInputs)) {
+    throw new Error("playCoupLite: valid_shuffle proof failed local verification \u2014 aborting before the on-chain tx");
+  }
+  log("submitting submit_shuffle (ZK-verified on-chain; hands = deck positions)\u2026");
+  await client.submitShuffle(refereeContractId, {
+    leavesHex: shuffle.leavesHex,
+    proofHex: Buffer.from(shuffle.proof).toString("hex")
+  });
+  const handsByPlayer2 = {};
+  const saltsByPlayer = {};
+  const deadByPlayer2 = {};
+  for (let i = 0; i < roster.length; i++) {
+    const playerId = roster[i].id;
+    const hand = [shuffle.cards[2 * i], shuffle.cards[2 * i + 1]];
+    handsByPlayer2[playerId] = hand;
+    saltsByPlayer[playerId] = [BigInt(shuffle.salts[2 * i]), BigInt(shuffle.salts[2 * i + 1])];
+    deadByPlayer2[playerId] = [false, false];
+    log(`player ${i}: shuffled hand [${hand.join(", ")}] (${hand.map((c) => CHARACTER_NAMES[c]).join(", ")})`);
+  }
+  const localMatch = createLocalMatch(roster, { handsByPlayer: handsByPlayer2 }, seed);
+  const moves = [];
+  let state = await client.gameState(refereeContractId);
+  let guard = 0;
+  const maxSteps = 40;
+  while (state.phase === "Playing" && guard < maxSteps) {
+    guard += 1;
+    const turnIdx = state.turn;
+    const playerId = roster[turnIdx].id;
+    const view = localMatch.view(playerId);
+    const moveSeed = `${seed}:move${moves.length}:${playerId}`;
+    const move = chooseMove(view, moveSeed);
+    if (move.type === "claim") {
+      const character = move.character;
+      log(`${playerId} (index ${turnIdx}) claims: ${CHARACTER_NAMES[character]} (${character})`);
+      await client.claim(refereeContractId, { player: turnIdx, character });
+      localMatch.submit(playerId, move);
+      moves.push({ kind: "claim", player: playerId, playerIndex: turnIdx, character });
+    } else {
+      const claim = localMatch.state.public.lastClaim;
+      const targetIdx = roster.findIndex((p) => p.id === claim.player);
+      const targetHand = handsByPlayer2[claim.player];
+      const claimWasTrue = targetHand.includes(claim.character);
+      log(
+        `${playerId} (index ${turnIdx}) challenges ${claim.player} (index ${targetIdx})'s claim of ${CHARACTER_NAMES[claim.character]}\u2026`
+      );
+      await client.challenge(refereeContractId, { challenger: turnIdx, target: targetIdx });
+      let loser;
+      if (claimWasTrue) {
+        const heldIndex = targetHand.indexOf(claim.character);
+        log(`  claim is TRUE - ${claim.player} proves it in ZK (real card_membership proof)\u2026`);
+        const proof = await prover.proveHold(
+          BigInt(claim.character),
+          [BigInt(targetHand[0]), BigInt(targetHand[1])],
+          saltsByPlayer[claim.player],
+          heldIndex
+        );
+        await client.proveHold(refereeContractId, {
+          target: targetIdx,
+          claimed: claim.character,
+          proofHex: Buffer.from(proof.proof).toString("hex")
+        });
+        loser = playerId;
+        const loserDead = deadByPlayer2[loser];
+        const slot = nextDeadSlot(loserDead);
+        const loserHand = handsByPlayer2[loser];
+        log(`  challenger ${loser} loses influence - revealing real card ${loserHand[slot]}\u2026`);
+        await client.revealCard(refereeContractId, {
+          player: turnIdx,
+          slot,
+          card: loserHand[slot],
+          saltHex: toBe32Hex(saltsByPlayer[loser][slot])
+        });
+        loserDead[slot] = true;
+      } else {
+        loser = claim.player;
+        const loserDead = deadByPlayer2[loser];
+        const slot = nextDeadSlot(loserDead);
+        log(`  claim is a BLUFF - ${loser} declines and reveals real card ${targetHand[slot]}\u2026`);
+        await client.revealCard(refereeContractId, {
+          player: targetIdx,
+          slot,
+          card: targetHand[slot],
+          saltHex: toBe32Hex(saltsByPlayer[loser][slot])
+        });
+        loserDead[slot] = true;
+      }
+      localMatch.submit(playerId, { type: "challenge" });
+      moves.push({
+        kind: "challenge",
+        challenger: playerId,
+        challengerIndex: turnIdx,
+        target: claim.player,
+        targetIndex: targetIdx,
+        claim,
+        claimWasTrue,
+        loser
+      });
+    }
+    state = await client.gameState(refereeContractId);
+  }
+  const outcome = state.outcome !== null ? roster[state.outcome]?.id ?? null : null;
+  log(`game finished: outcome=${outcome}`);
+  return {
+    verifierContractId,
+    refereeContractId,
+    roster,
+    handsByPlayer: handsByPlayer2,
+    moves,
+    finalState: state,
+    outcome
+  };
+}
+
+// src/index.ts
+init_paths();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHARACTERS,
+  CHARACTER_NAMES,
+  CardProver,
+  CliRefereeClient,
+  DEFAULT_COUP_REFEREE_WASM,
+  DEFAULT_SHUFFLE_VK_PATH,
+  DEFAULT_VERIFIER_WASM,
+  DEFAULT_VK_PATH,
+  HAND_SIZE,
+  MAX_PLAYERS,
+  MIN_PLAYERS,
+  N_PLAYERS,
+  RefereeCliError,
+  START_INFLUENCE,
+  buildRoster,
+  chooseMove,
+  coupLite,
+  createLocalMatch,
+  ensureContractWasms,
+  pickSeeded,
+  playCoupLite,
+  playLocalMatch,
+  seededHand,
+  stepLocalMatch,
+  stripHexPrefix,
+  toBe32Hex,
+  toolEnv
+});