@dopamint-fun/open-sdk 0.1.0-dev.0 → 0.2.0-dev.0

package/dist/decide.d.ts

@@ -0,0 +1,16 @@
+import type { SeatDecision, SeatPosition } from "./session.js";
+import type { TexasAction } from "./texas.js";
+/** How many seats are still live in this hand besides this one. */
+export declare function opponentsStillIn(position: SeatPosition): number;
+/** The move this position calls for, and a line saying why.
+ *
+ *  Exported on its own so an agent can wrap it -- run it, then override the
+ *  cases it has an opinion about -- rather than fork the file to change one
+ *  branch. */
+export declare function baselineMove(position: SeatPosition): {
+    action: TexasAction;
+    say: string;
+};
+/** The baseline as a `SeatDecision`, which is what `--decide` wants. */
+export declare const baselineDecision: SeatDecision;
+export default baselineDecision;

package/dist/decide.js

@@ -0,0 +1,122 @@
+import { handEquity, requiredEquity } from "./equity.js";
+/* A seat that plays on price, so nobody has to write this again.
+ *
+ * The CLI used to offer two doors and nothing between them: `--strategy`,
+ * which is a filler for a seat nobody is deciding for and plays badly on
+ * purpose, or `--decide <module>`, which is a blank page. So every agent that
+ * wanted to play properly wrote a Monte Carlo evaluator and a pot-odds
+ * comparison from scratch, before it could play one hand. This is that, ready
+ * to point at, and it is meant to be read and copied rather than trusted: an
+ * agent that wants an edge should start from it, not stop at it.
+ *
+ * The whole policy is one comparison. Calling costs `toCall` to win a pot of
+ * `pot + toCall`, so it needs `toCall / (pot + toCall)` of the pot to break
+ * even; the hand's equity against the opponents still in says how often it
+ * gets there. Above the line, call. Below it, fold. Everything else here is a
+ * guardrail on top of that, and the guardrails are the part worth reading.
+ *
+ * ── Why the guardrails exist ──────────────────────────────────────────────
+ * The agent whose session prompted this lost its sitting to a rule of its own
+ * that had no street in it: shove whenever the stack is short. On the river
+ * that is a losing move by construction. There are no cards left to improve,
+ * so a shove can only be called by a hand that already beats it -- the fold
+ * equity a short stack is playing for on earlier streets is not there. It
+ * jammed its last chips into a hand it was behind and was out.
+ *
+ * So push/fold is fenced to preflop, and the river is fenced hardest of all.
+ * These fences are deliberately deterministic and sit above the equity number
+ * rather than inside it: a policy that can talk itself past its own limit
+ * does not have one. */
+/** Equity a hand needs before this seat puts money in with no bet to answer.
+ *  Above the pot-odds line by a margin, because betting invites a raise. */
+const VALUE_BET_EQUITY = 0.62;
+/** On the river, a bet is called by better and folded to by worse, so it
+ *  wants to be near the top of the range rather than merely ahead. */
+const RIVER_BET_EQUITY = 0.78;
+/** How much a call has to beat its price before taking it, so a hand sitting
+ *  exactly on the line does not pay the rake of being wrong half the time. */
+const CALL_MARGIN = 0.02;
+/** Big blinds at which push/fold becomes the preflop plan. The literature
+ *  puts it at 10 to 15; the lower end suits a table that also holds seats
+ *  playing a fixed policy. */
+const SHORT_STACK_BB = 12;
+/** Equity a short stack wants before it commits everything preflop. */
+const SHOVE_EQUITY = 0.55;
+function wagerTo(amount) {
+    return { type: "wagerTo", amount: BigInt(Math.round(amount)) };
+}
+/** How many seats are still live in this hand besides this one. */
+export function opponentsStillIn(position) {
+    const others = position.seats.filter((seat) => seat.seat !== position.seat && !seat.folded);
+    /* A read that did not answer leaves no seats at all. One opponent is the
+       cautious assumption there: it never reports a hand as safer than it is. */
+    return others.length > 0 ? others.length : 1;
+}
+/** The move this position calls for, and a line saying why.
+ *
+ *  Exported on its own so an agent can wrap it -- run it, then override the
+ *  cases it has an opinion about -- rather than fork the file to change one
+ *  branch. */
+export function baselineMove(position) {
+    const { legal, table, hole } = position;
+    const fold = { type: "fold" };
+    const check = { type: "check" };
+    const call = { type: "call" };
+    /* No cards means this seat is out of the hand; no table means the read did
+       not answer. Neither is a position to reason from, so take the free move. */
+    if (!hole || !table)
+        return legal.canCheck
+            ? { action: check, say: "checking." }
+            : { action: fold, say: "no read, out." };
+    const toCall = position.toCall ?? 0;
+    const pot = table.pot;
+    const street = table.street.toLowerCase();
+    const opponents = opponentsStillIn(position);
+    const equity = handEquity(hole, table.board, { opponents }).value;
+    const price = requiredEquity(toCall, pot);
+    const odds = `${Math.round(equity * 100)}% vs ${Math.round(price * 100)}%`;
+    const me = position.seats.find((seat) => seat.seat === position.seat);
+    const stack = me?.stack ?? 0;
+    const bigBlind = table.bigBlind || 1;
+    const shortStack = stack > 0 && stack <= SHORT_STACK_BB * bigBlind;
+    /* Push/fold, and only where it belongs. Preflop a short stack shoves for
+       the fold equity, which is the whole point of the move; past the flop that
+       reason is gone and on the river it is inverted. */
+    if (street === "preflop" &&
+        shortStack &&
+        equity >= SHOVE_EQUITY &&
+        legal.maxWagerTo !== null) {
+        return {
+            action: wagerTo(Number(legal.maxWagerTo)),
+            say: `short stack, all in at ${odds}.`,
+        };
+    }
+    if (toCall <= 0) {
+        /* Nothing to answer. Bet only with a hand that wants a bigger pot, and
+           size it at half the pot: enough to charge a draw, small enough that
+           being wrong is survivable. A medium hand takes the free card instead of
+           bloating a pot it does not want to play for. */
+        const bar = street === "river" ? RIVER_BET_EQUITY : VALUE_BET_EQUITY;
+        if (equity >= bar && legal.minWagerTo !== null && legal.maxWagerTo !== null) {
+            const target = Math.max(Number(legal.minWagerTo), Math.min(Number(legal.maxWagerTo), (table.currentWager || 0) + pot / 2));
+            return { action: wagerTo(target), say: `betting it, ${odds}.` };
+        }
+        return legal.canCheck
+            ? { action: check, say: "check." }
+            : { action: fold, say: "folding." };
+    }
+    /* Facing a bet: the price is the whole decision. */
+    if (equity < price + CALL_MARGIN) {
+        return legal.canCheck
+            ? { action: check, say: "checking behind." }
+            : { action: fold, say: `fold, ${odds}.` };
+    }
+    if (legal.canCall)
+        return { action: call, say: `call, ${odds}.` };
+    return legal.canCheck
+        ? { action: check, say: "check." }
+        : { action: fold, say: "out." };
+}
+/** The baseline as a `SeatDecision`, which is what `--decide` wants. */
+export const baselineDecision = (position) => baselineMove(position);
+export default baselineDecision;

package/dist/equity.d.ts

@@ -0,0 +1,34 @@
+import type { Card } from "./texas.js";
+export { scoreHand } from "./handRank.js";
+/** A card as `Tc`, from either the SDK's `Card` or the wire's own string. */
+export declare function cardCode(card: Card | string): string;
+export interface HandEquity {
+    /** fraction of trials this hand won outright */
+    win: number;
+    /** fraction it split */
+    tie: number;
+    /** win plus a tie's share, which is what a pot-odds comparison wants */
+    value: number;
+    trials: number;
+}
+export interface HandEquityOptions {
+    /** How many opponents are still in the hand. Zero is a walk. */
+    opponents: number;
+    /** Simulation count. Default 5,000. */
+    trials?: number;
+    /** Injectable for tests; anything returning `[0, 1)`. */
+    random?: () => number;
+}
+/** How often this seat's two cards win, against that many unknown hands.
+ *
+ *  Opponents are drawn uniformly from the remaining deck, which assumes they
+ *  would play any two cards. A real range is tighter than that and stronger on
+ *  average, so this reads a little high against opponents who fold their worst
+ *  hands -- knowing that, and that it cannot know their range, is more useful
+ *  to a caller than a number that pretends otherwise. */
+export declare function handEquity(hole: readonly (Card | string)[], board: readonly (Card | string)[], options: HandEquityOptions): HandEquity;
+/** The equity a call needs to break even: what it costs over what it wins.
+ *
+ *  `toCall / (pot + toCall)`. The pot here is what is already out there
+ *  including the bet being answered, so calling 20 into 60 needs 25%. */
+export declare function requiredEquity(toCall: number, pot: number): number;

package/dist/equity.js

@@ -0,0 +1,99 @@
+import { cardIndex, scoreHand } from "./handRank.js";
+/* The ranking core moved to `handRank.ts` once the arena's broadcast overlay
+   needed the same answer this does. Re-exported here because callers who
+   already had it from this module should keep getting it. */
+export { scoreHand } from "./handRank.js";
+/* How often a hand wins, when only this seat's cards are known.
+ *
+ * The arena UI has an equity engine too, and it answers a different question:
+ * it is given every seat's hole cards, because a broadcast overlay can see
+ * them once a hand has closed. A seat cannot. It knows its own two cards, the
+ * board, and how many opponents are still in, so its equity is an average over
+ * every hand they could be holding -- which is a simulation, not an
+ * enumeration, past the flop.
+ *
+ * This exists because every agent that wanted to play well was writing it
+ * again. The one whose session prompted this spent most of four minutes
+ * authoring a Monte Carlo evaluator before it could play a single hand, and
+ * the copy it wrote had a bug that cost it the sitting. That is a tax on
+ * everyone arriving, paid in the same place each time.
+ *
+ * Accuracy: 5,000 trials puts the standard error near half a percentage point,
+ * which is far below the precision any pot-odds decision needs -- the
+ * thresholds that matter are 25%, 33%, 37.5%, and a hand sitting within half a
+ * point of one of those is a hand where either choice is close to break-even.
+ * A caller who wants tighter can ask for more trials; one deciding against a
+ * clock should not. */
+/** A card as `Tc`, from either the SDK's `Card` or the wire's own string. */
+export function cardCode(card) {
+    return typeof card === "string" ? card : card.label;
+}
+/** How often this seat's two cards win, against that many unknown hands.
+ *
+ *  Opponents are drawn uniformly from the remaining deck, which assumes they
+ *  would play any two cards. A real range is tighter than that and stronger on
+ *  average, so this reads a little high against opponents who fold their worst
+ *  hands -- knowing that, and that it cannot know their range, is more useful
+ *  to a caller than a number that pretends otherwise. */
+export function handEquity(hole, board, options) {
+    const trials = options.trials ?? 5_000;
+    const random = options.random ?? Math.random;
+    const mine = hole.map((card) => cardIndex(cardCode(card)));
+    const shown = board.map((card) => cardIndex(cardCode(card)));
+    if (mine.length !== 2)
+        throw new Error("a seat holds two cards");
+    if (options.opponents <= 0)
+        return { win: 1, tie: 0, value: 1, trials: 0 };
+    const dead = new Set([...mine, ...shown]);
+    const deck = [];
+    for (let card = 0; card < 52; card++)
+        if (!dead.has(card))
+            deck.push(card);
+    let wins = 0;
+    let ties = 0;
+    for (let trial = 0; trial < trials; trial++) {
+        /* Partial Fisher-Yates: only as many cards as this trial needs, so the
+           cost is the deal rather than the deck. */
+        const needed = 5 - shown.length + options.opponents * 2;
+        for (let at = 0; at < needed; at++) {
+            const pick = at + Math.floor(random() * (deck.length - at));
+            const held = deck[at];
+            deck[at] = deck[pick];
+            deck[pick] = held;
+        }
+        const runout = deck.slice(0, 5 - shown.length);
+        const fullBoard = [...shown, ...runout];
+        const mineScore = scoreHand([...mine, ...fullBoard]);
+        let best = mineScore;
+        let shared = 1;
+        for (let opponent = 0; opponent < options.opponents; opponent++) {
+            const at = runout.length + opponent * 2;
+            const score = scoreHand([deck[at], deck[at + 1], ...fullBoard]);
+            if (score > best) {
+                best = score;
+                shared = 1;
+            }
+            else if (score === best) {
+                shared += 1;
+            }
+        }
+        if (best > mineScore)
+            continue;
+        if (shared === 1)
+            wins += 1;
+        else
+            ties += 1 / shared;
+    }
+    const win = wins / trials;
+    const tie = ties / trials;
+    return { win, tie, value: win + tie, trials };
+}
+/** The equity a call needs to break even: what it costs over what it wins.
+ *
+ *  `toCall / (pot + toCall)`. The pot here is what is already out there
+ *  including the bet being answered, so calling 20 into 60 needs 25%. */
+export function requiredEquity(toCall, pot) {
+    if (toCall <= 0)
+        return 0;
+    return toCall / (pot + toCall);
+}

package/dist/handRank.d.ts

@@ -0,0 +1,36 @@
+/** Low to high. A card's rank is an index into this. */
+export declare const RANK_ORDER = "23456789TJQKA";
+/** A card's suit is an index into this. Suits do not rank against each other;
+ *  the order only has to be the same on both sides of an index. */
+export declare const SUIT_ORDER = "cdhs";
+/** 0..51, clubs first and deuce first, matching the wire's own byte.
+ *
+ *  Callers holding cards in some other shape convert into this, rather than
+ *  the core learning every caller's card type. */
+export declare function cardIndex(code: string): number;
+/** Weakest to strongest, indexed by a score's category. */
+export declare const HAND_CATEGORIES: readonly ["high card", "one pair", "two pair", "three of a kind", "straight", "flush", "full house", "four of a kind", "straight flush"];
+export type HandCategory = (typeof HAND_CATEGORIES)[number];
+/** What a score is called. */
+export declare function handCategory(score: number): HandCategory;
+/** Rank the best five of these cards. Higher is better, and two hands compare
+ *  exactly when their scores do -- the value itself means nothing else.
+ *
+ *  Takes any number of cards, so the same scale ranks a five-card subset
+ *  against the seven it came from. */
+export declare function scoreHand(cards: readonly number[]): number;
+export interface BestFive<T> {
+    /** the five that play, in the order the caller gave them */
+    cards: T[];
+    score: number;
+    category: HandCategory;
+}
+/** The best five of the cards given, and what they are called.
+ *
+ *  Generic over the caller's own card type: a broadcast overlay wants the card
+ *  objects it can draw back, not indices. `index` maps one of those to its
+ *  0..51 index.
+ *
+ *  Fewer than five cards is not an error -- an incomplete board still has a
+ *  best hand, and naming it is what a hand log in progress wants. */
+export declare function bestFive<T>(cards: readonly T[], index: (card: T) => number): BestFive<T>;

package/dist/handRank.js

@@ -0,0 +1,170 @@
+/* Ranking seven cards, for everything that needs to know which hand is best.
+ *
+ * This was written twice: once here, for a seat working out its own equity
+ * against opponents it cannot see, and once in the arena's broadcast overlay,
+ * which is given every hole card and enumerates the runout exactly. Two
+ * questions, one ranking core -- and two copies of it, which agreed on the day
+ * they were written and had no way of staying that way. The first sign that
+ * they had stopped would be a viewer and an agent reading different odds off
+ * the same board, which reads as a bug in whichever of the two the reader
+ * trusts less.
+ *
+ * So the core lives here, in the library the agents install, and the overlay
+ * imports it. The direction is deliberate: the overlay reports the number, it
+ * does not own it.
+ *
+ * Nothing in here knows about a deck, a street, or a pot. It takes card
+ * indices and answers which hand beats which. */
+/** Low to high. A card's rank is an index into this. */
+export const RANK_ORDER = "23456789TJQKA";
+/** A card's suit is an index into this. Suits do not rank against each other;
+ *  the order only has to be the same on both sides of an index. */
+export const SUIT_ORDER = "cdhs";
+/** 0..51, clubs first and deuce first, matching the wire's own byte.
+ *
+ *  Callers holding cards in some other shape convert into this, rather than
+ *  the core learning every caller's card type. */
+export function cardIndex(code) {
+    const rank = RANK_ORDER.indexOf(code[0].toUpperCase());
+    const suit = SUIT_ORDER.indexOf(code[1].toLowerCase());
+    if (rank < 0 || suit < 0)
+        throw new Error(`not a card: ${code}`);
+    return suit * 13 + rank;
+}
+/** The width of one category's tie-break space: five ranks packed base 13. */
+const CATEGORY = 13 ** 5;
+/** Weakest to strongest, indexed by a score's category. */
+export const HAND_CATEGORIES = [
+    "high card",
+    "one pair",
+    "two pair",
+    "three of a kind",
+    "straight",
+    "flush",
+    "full house",
+    "four of a kind",
+    "straight flush",
+];
+/** What a score is called. */
+export function handCategory(score) {
+    return HAND_CATEGORIES[Math.floor(score / CATEGORY)];
+}
+/** Rank the best five of these cards. Higher is better, and two hands compare
+ *  exactly when their scores do -- the value itself means nothing else.
+ *
+ *  Takes any number of cards, so the same scale ranks a five-card subset
+ *  against the seven it came from. */
+export function scoreHand(cards) {
+    const rankCounts = new Array(13).fill(0);
+    const suitCounts = new Array(4).fill(0);
+    const suitRanks = [[], [], [], []];
+    for (const card of cards) {
+        const rank = card % 13;
+        const suit = Math.floor(card / 13);
+        rankCounts[rank]++;
+        suitCounts[suit]++;
+        suitRanks[suit].push(rank);
+    }
+    const flushSuit = suitCounts.findIndex((count) => count >= 5);
+    const straightTop = (ranks) => {
+        /* The wheel: an ace plays low in A-2-3-4-5 and nowhere else, so it is
+           added as a rank below the deuce rather than handled as a special case
+           at every comparison. */
+        const present = new Set(ranks);
+        if (present.has(12))
+            present.add(-1);
+        let run = 0;
+        let top = -2;
+        for (let rank = 12; rank >= -1; rank--) {
+            if (present.has(rank)) {
+                run += 1;
+                if (run === 5) {
+                    top = rank + 4;
+                    break;
+                }
+            }
+            else {
+                run = 0;
+            }
+        }
+        return top;
+    };
+    if (flushSuit >= 0) {
+        const straightFlush = straightTop(suitRanks[flushSuit]);
+        if (straightFlush >= 0)
+            return 8 * CATEGORY + straightFlush;
+    }
+    const byCount = [...rankCounts.keys()].sort((left, right) => rankCounts[right] - rankCounts[left] || right - left);
+    const counts = byCount.map((rank) => rankCounts[rank]);
+    const pack = (ranks) => ranks.reduce((total, rank) => total * 13 + rank, 0);
+    if (counts[0] === 4)
+        return (7 * CATEGORY +
+            byCount[0] * 13 +
+            byCount.find((rank) => rankCounts[rank] < 4));
+    if (counts[0] === 3 && counts[1] >= 2)
+        return 6 * CATEGORY + byCount[0] * 13 + byCount[1];
+    if (flushSuit >= 0)
+        return (5 * CATEGORY +
+            pack([...suitRanks[flushSuit]].sort((a, b) => b - a).slice(0, 5)));
+    const straight = straightTop([...rankCounts.keys()].filter((rank) => rankCounts[rank] > 0));
+    if (straight >= 0)
+        return 4 * CATEGORY + straight;
+    if (counts[0] === 3)
+        return (3 * CATEGORY +
+            pack([
+                byCount[0],
+                ...byCount.filter((r) => rankCounts[r] < 3).slice(0, 2),
+            ]));
+    if (counts[0] === 2 && counts[1] === 2)
+        return (2 * CATEGORY +
+            pack([
+                byCount[0],
+                byCount[1],
+                byCount.find((r) => rankCounts[r] < 2),
+            ]));
+    if (counts[0] === 2)
+        return (CATEGORY +
+            pack([
+                byCount[0],
+                ...byCount.filter((r) => rankCounts[r] < 2).slice(0, 3),
+            ]));
+    return pack(byCount.slice(0, 5));
+}
+/** The best five of the cards given, and what they are called.
+ *
+ *  Generic over the caller's own card type: a broadcast overlay wants the card
+ *  objects it can draw back, not indices. `index` maps one of those to its
+ *  0..51 index.
+ *
+ *  Fewer than five cards is not an error -- an incomplete board still has a
+ *  best hand, and naming it is what a hand log in progress wants. */
+export function bestFive(cards, index) {
+    if (cards.length <= 5) {
+        const score = scoreHand(cards.map(index));
+        return { cards: [...cards], score, category: handCategory(score) };
+    }
+    /* Every five-card subset, scored on the same scale as the whole hand. At
+       seven cards that is the 21 ways to choose five, which is cheaper than
+       reasoning about which two a category wants dropped -- and it cannot
+       disagree with `scoreHand`, because it is `scoreHand`. */
+    let bestScore = -1;
+    let best = [];
+    const chosen = [];
+    const choose = (from) => {
+        if (chosen.length === 5) {
+            const score = scoreHand(chosen.map(index));
+            if (score > bestScore) {
+                bestScore = score;
+                best = [...chosen];
+            }
+            return;
+        }
+        for (let at = from; at < cards.length; at++) {
+            chosen.push(cards[at]);
+            choose(at + 1);
+            chosen.pop();
+        }
+    };
+    choose(0);
+    return { cards: best, score: bestScore, category: handCategory(bestScore) };
+}

package/dist/identity.js

@@ -13,6 +13,7 @@
  * lower-cases the handle -- so this signs the parsed form, or the signature
  * is over bytes the store never holds. */
 import { signOwnerAuthenticator } from "./keypair.js";
+import { refusalMessageFromText } from "./refusal.js";
 const IDENTITY_DOMAIN = "dopa_open::agent_identity::v1";
 /** How long a naming request is good for, unless the caller says otherwise. */
 const DEFAULT_WINDOW_MS = 5 * 60 * 1000;
@@ -93,7 +94,7 @@ export async function nameAgent(args) {
         const taken = detail.includes("handle_taken");
         throw new Error(taken
             ? `handle "${fields.handle}" belongs to another agent; choose another`
-            : `naming refused (${response.status}): ${detail}`);
+            : refusalMessageFromText("naming", response.status, detail));
     }
     const body = (await response.json());
     return parseIdentityFields(body);

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { DEFAULT_KEY_FILE, generateKeypair, keypairFromSeed, loadKeypair, saveKeypair, signOwnerAuthenticator, signRaw, type AgentKeypair, } from "./keypair.js";
 export { deriveAgentId, registerCanonicalPayload, registerPayloadDigest, type RegisterAgentPayload, } from "./registration.js";
 export { canonicalIdentityPayload, nameAgent, parseIdentityFields, type AgentIdentityFields, type NameAgentArgs, } from "./identity.js";
-export { actionSigningBytes, encodeActionFrame, encodeJoinFrame, encodeResumeFrame, joinSigningBytes, resumeSigningBytes, type ActionProposal, type ArtifactReference, type JoinRequest, type ResumeRequest, type SessionContext, } from "./sessionWire.js";
+export { actionSigningBytes, encodeActionFrame, encodeJoinFrame, encodeResumeFrame, joinSigningBytes, resumeSigningBytes, SESSION_VERSION, UnsupportedSessionVersionError, type ActionProposal, type ArtifactReference, type JoinRequest, type ResumeRequest, type SessionContext, } from "./sessionWire.js";
 export { encodeAckFrame, SESSION_ERROR_NAMES, sessionErrorHint, sessionErrorName, } from "./sessionCodec.js";
 export { type OpenTableView, type PlayReport, type SeatDecision, type SeatDecisionResult, type SeatPosition, SessionClient, SessionRefusal, chooseSeatAction, playSeat, } from "./session.js";
 export { cardFromByte, decodeLegalActions, decodeParticipantView, encodeAction, pickAction, type Card, type Rank, type Suit, type TexasAction, type TexasLegalActions, type TexasSeatView, } from "./texas.js";
@@ -9,5 +9,13 @@ export { authorityOriginFromSessionBase, buildConsentRequest, digestForPrompt, r
 export { PACKAGE_NAME, RELEASE_CHANNELS, channelDistTag, installCommand, installSpec, resolveChannel, versionMatchesChannel, type ReleaseChannel, } from "./channel.js";
 export { fromHex, toHex } from "./bytes.js";
 export { AGENT_HTTP_CAPABILITY_HEADER, AGENT_HTTP_CAPABILITY_NONCE_BYTES, MAX_AGENT_HTTP_CAPABILITY_WINDOW_MS, agentHttpCanonicalPayload, agentHttpSigningBytes, decodeAgentHttpHeader, encodeAgentHttpHeader, mintAgentHttpCapability, type AgentHttpBinding, type AgentHttpCapability, } from "./agentHttp.js";
-export { act, enterTour, foldHeavy, playTour, queueUntilSeated, readPosition, type TableMove, type TourClient, type TourEntry, type TourKind, type TurnView, } from "./tour.js";
-export { AGENT_CLAIM_INVITE_DOMAIN, AGENT_CLAIM_INVITE_MAX_WINDOW_MS, AGENT_CLAIM_INVITE_TOKEN_BYTES, claimInviteCanonicalPayload, claimInviteLink, claimInviteSigningBytes, decodeClaimInvite, encodeClaimInvite, mintClaimInvite, type ClaimInvite, } from "./claim.js";
+export { act, enterTour, foldHeavy, playTour, queueUntilSeated, QUEUE_RESTART_BOUND_MS, TourEntryUnavailable, readPosition, type TableMove, type TourClient, type TourEntry, type TourKind, type TurnView, } from "./tour.js";
+export { joinRoom, MAX_ROOM_SEATS, MIN_ROOM_SEATS, openRoom, roomInvitePrompt, type RoomClient, type RoomJoined, type RoomOpened, } from "./room.js";
+export { AGENT_CLAIM_INVITE_DOMAIN, AGENT_CLAIM_INVITE_MAX_WINDOW_MS, AGENT_CLAIM_INVITE_TOKEN_BYTES, claimInviteCanonicalPayload, claimInviteLink, claimInviteSigningBytes, decodeClaimInvite, encodeClaimInvite, encodeClaimInviteCompact, mintClaimInvite, type ClaimInvite, } from "./claim.js";
+export { baselineDecision, baselineMove, opponentsStillIn, } from "./decide.js";
+export { handEquity, requiredEquity, cardCode, type HandEquity, type HandEquityOptions, } from "./equity.js";
+export { bestFive, cardIndex, handCategory, scoreHand, HAND_CATEGORIES, RANK_ORDER, SUIT_ORDER, type BestFive, type HandCategory, } from "./handRank.js";
+export { DEFAULT_SEAT_STATE_FILE, loadSeatState, saveSeatState, type SeatSessionState, } from "./seatState.js";
+export { newSeatState, openTurn, submitTurn, type SeatTurnOutcome, type SeatTurnPosition, } from "./seatTurn.js";
+export { chipAddressOf, joinTransaction, leaveTransaction, listTournaments, planJoin, presentToTournament, readAgentEntry, readPass, readOwner, playsHeldBy, giveBackTransaction, readTournament, sponsorAndExecute, tournamentIdArg, tournamentPossessionSignature, JoinRefused, TournamentRefusal, TOURNAMENT_POSSESSION_SEAT, type JoinPlan, type SponsoredExecution, type TournamentAgentEntry, type TournamentPass, type TournamentPlay, type TournamentOwnerView, type TournamentOwnerAgent, type TournamentChainObjects, type TournamentClient, type TournamentOverview, type TournamentQueueEntry, } from "./openTournament.js";
+export { ClientRefusal, describeNext, refusalLines, refusalMessage, refusalMessageFromText, type RefusalBody, type RefusalNext, } from "./refusal.js";

package/dist/index.js

@@ -8,7 +8,7 @@
 export { DEFAULT_KEY_FILE, generateKeypair, keypairFromSeed, loadKeypair, saveKeypair, signOwnerAuthenticator, signRaw, } from "./keypair.js";
 export { deriveAgentId, registerCanonicalPayload, registerPayloadDigest, } from "./registration.js";
 export { canonicalIdentityPayload, nameAgent, parseIdentityFields, } from "./identity.js";
-export { actionSigningBytes, encodeActionFrame, encodeJoinFrame, encodeResumeFrame, joinSigningBytes, resumeSigningBytes, } from "./sessionWire.js";
+export { actionSigningBytes, encodeActionFrame, encodeJoinFrame, encodeResumeFrame, joinSigningBytes, resumeSigningBytes, SESSION_VERSION, UnsupportedSessionVersionError, } from "./sessionWire.js";
 export { encodeAckFrame, SESSION_ERROR_NAMES, sessionErrorHint, sessionErrorName, } from "./sessionCodec.js";
 export { SessionClient, SessionRefusal, chooseSeatAction, playSeat, } from "./session.js";
 export { cardFromByte, decodeLegalActions, decodeParticipantView, encodeAction, pickAction, } from "./texas.js";
@@ -16,7 +16,18 @@ export { authorityOriginFromSessionBase, buildConsentRequest, digestForPrompt, r
 export { PACKAGE_NAME, RELEASE_CHANNELS, channelDistTag, installCommand, installSpec, resolveChannel, versionMatchesChannel, } from "./channel.js";
 export { fromHex, toHex } from "./bytes.js";
 export { AGENT_HTTP_CAPABILITY_HEADER, AGENT_HTTP_CAPABILITY_NONCE_BYTES, MAX_AGENT_HTTP_CAPABILITY_WINDOW_MS, agentHttpCanonicalPayload, agentHttpSigningBytes, decodeAgentHttpHeader, encodeAgentHttpHeader, mintAgentHttpCapability, } from "./agentHttp.js";
-export { act, enterTour, foldHeavy, playTour, queueUntilSeated, readPosition, } from "./tour.js";
+export { act, enterTour, foldHeavy, playTour, queueUntilSeated, QUEUE_RESTART_BOUND_MS, TourEntryUnavailable, readPosition, } from "./tour.js";
+/* The private room: an agent opens one, another joins it by the id the opener
+   hands out, and the guest's seat is taken by accepting the offer the join
+   answers -- with its own key, because nothing else holds one. */
+export { joinRoom, MAX_ROOM_SEATS, MIN_ROOM_SEATS, openRoom, roomInvitePrompt, } from "./room.js";
 /* The agent's half of a claim: an invitation its own key signs, carried as a
    token in the claim link its operator hands the owner. */
-export { AGENT_CLAIM_INVITE_DOMAIN, AGENT_CLAIM_INVITE_MAX_WINDOW_MS, AGENT_CLAIM_INVITE_TOKEN_BYTES, claimInviteCanonicalPayload, claimInviteLink, claimInviteSigningBytes, decodeClaimInvite, encodeClaimInvite, mintClaimInvite, } from "./claim.js";
+export { AGENT_CLAIM_INVITE_DOMAIN, AGENT_CLAIM_INVITE_MAX_WINDOW_MS, AGENT_CLAIM_INVITE_TOKEN_BYTES, claimInviteCanonicalPayload, claimInviteLink, claimInviteSigningBytes, decodeClaimInvite, encodeClaimInvite, encodeClaimInviteCompact, mintClaimInvite, } from "./claim.js";
+export { baselineDecision, baselineMove, opponentsStillIn, } from "./decide.js";
+export { handEquity, requiredEquity, cardCode, } from "./equity.js";
+export { bestFive, cardIndex, handCategory, scoreHand, HAND_CATEGORIES, RANK_ORDER, SUIT_ORDER, } from "./handRank.js";
+export { DEFAULT_SEAT_STATE_FILE, loadSeatState, saveSeatState, } from "./seatState.js";
+export { newSeatState, openTurn, submitTurn, } from "./seatTurn.js";
+export { chipAddressOf, joinTransaction, leaveTransaction, listTournaments, planJoin, presentToTournament, readAgentEntry, readPass, readOwner, playsHeldBy, giveBackTransaction, readTournament, sponsorAndExecute, tournamentIdArg, tournamentPossessionSignature, JoinRefused, TournamentRefusal, TOURNAMENT_POSSESSION_SEAT, } from "./openTournament.js";
+export { ClientRefusal, describeNext, refusalLines, refusalMessage, refusalMessageFromText, } from "./refusal.js";

package/dist/keypair.js

@@ -13,7 +13,8 @@
  * portable and agent-owned. One file carrying both semantics is how one ends
  * up pasted into the other's slot.
  */
-import { chmodSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
 import { fromHex } from "./bytes.js";
@@ -38,6 +39,12 @@ export function keypairFromSeed(seed) {
  *  format is Sui's own bech32, so every ecosystem tool that understands a Sui
  *  key understands this file. */
 export function saveKeypair(agent, path = DEFAULT_KEY_FILE) {
+    const parent = dirname(path);
+    if (parent && parent !== ".") {
+        mkdirSync(parent, { recursive: true, mode: 0o700 });
+        // mkdirSync's mode is umask-masked; the documented key nest is 0700.
+        chmodSync(parent, 0o700);
+    }
     writeFileSync(path, `${agent.keypair.getSecretKey()}\n`, { mode: 0o600 });
     // mode on writeFileSync only applies at creation; an existing file keeps
     // its bits, so tighten explicitly rather than trusting the happy path

package/dist/offer.d.ts

@@ -9,6 +9,13 @@ export interface OfferRecord {
     state: string;
     seats: OfferSeat[];
     acceptedSeats: number[];
+    /** The seats the product filled itself, ascending, empty when none.
+     *
+     *  A house seat signs its acceptance exactly as an agent does, so
+     *  `acceptedSeats` cannot tell you which opponents asked to be here. Read
+     *  this before you accept: a hand played against a house seat counts
+     *  toward no standing, present or future. */
+    houseSeats: number[];
     admission?: {
         sessionBaseUrl: string;
         coordinatorPublicKey: string;