@dopamint-fun/open-sdk 0.2.0-dev.1 → 0.2.0-dev.11

package/dist/index.d.ts

@@ -3,9 +3,9 @@ export { deriveAgentId, registerCanonicalPayload, registerPayloadDigest, type Re
 export { canonicalIdentityPayload, nameAgent, parseIdentityFields, type AgentIdentityFields, type NameAgentArgs, } from "./identity.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, MAX_PREDICTION_PACING_MS, admitAuthorityEvent, applyPredictionGateStatus, decodeAuthorityMessage, freshSessionBoundary, predictionGateMessage, predictionGatePreparationOf, predictionGateTargetReceipt, sessionErrorHint, sessionErrorName, PredictionGateConflictError, SessionBoundaryError, type AcceptedSessionBoundary, type AuthorityMessage, type PredictionGateMessage, type PredictionGateOpening, type PredictionGatePreparation, type PredictionGateRelease, type PredictionGateStatus, type PredictionWindowRef, type ReceiptRef, type ResumeCursor, type StateRef, type ViewSnapshot, } from "./sessionCodec.js";
-export { type OpenTableView, type PlayReport, type SeatDecision, type SeatDecisionResult, type SeatPosition, SessionClient, SessionRefusal, chooseSeatAction, playSeat, } from "./session.js";
+export { type OpenTableView, type PlayReport, type SeatDecision, type SeatDecisionResult, type SeatPosition, SessionClient, SessionRefusal, chooseSeatAction, playSeat, waitForReadyOwner, } from "./session.js";
 export { cardFromByte, decodeLegalActions, decodeParticipantView, encodeAction, pickAction, type Card, type Rank, type Suit, type TexasAction, type TexasLegalActions, type TexasSeatView, } from "./texas.js";
-export { authorityOriginFromSessionBase, buildConsentRequest, digestForPrompt, recomputeSettlementDigest, settlementConsentPath, verifyConsentDisclosure, } from "./settlement.js";
+export { buildConsentRequest, DEFAULT_OPEN_API_BASE_URL, digestForPrompt, recomputeSettlementDigest, settlementConsentPath, verifyConsentDisclosure, } from "./settlement.js";
 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";
@@ -17,5 +17,5 @@ export { handEquity, requiredEquity, cardCode, type HandEquity, type HandEquityO
 export { 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 SeatStateCheckpoint, 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";
+export { chipAddressOf, joinTransaction, leaveTransaction, listTournaments, planJoin, presentToTournament, readAgentEntry, readAgentEntrySettled, BOOK_CATCHES_UP_MS, 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, ownershipFencePoll, ownershipFenced, refusalLines, refusalMessage, refusalMessageFromText, type RefusalBody, type RefusalNext, } from "./refusal.js";

package/dist/index.js

@@ -3,16 +3,16 @@
  * Generate and hold an ed25519 keypair (Sui format, `.dopa-keypair`), produce
  * the canonical signatures, and drive the Participant Session against
  * `session_base_url`. Byte parity with the Rust client is pinned by
- * `libs/dopa-open-client-rs/vectors/ts-signer-parity.json`.
+ * `libs/dopa-open/client-rs/vectors/ts-signer-parity.json`.
  */
 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, SESSION_VERSION, UnsupportedSessionVersionError, } from "./sessionWire.js";
 export { encodeAckFrame, SESSION_ERROR_NAMES, MAX_PREDICTION_PACING_MS, admitAuthorityEvent, applyPredictionGateStatus, decodeAuthorityMessage, freshSessionBoundary, predictionGateMessage, predictionGatePreparationOf, predictionGateTargetReceipt, sessionErrorHint, sessionErrorName, PredictionGateConflictError, SessionBoundaryError, } from "./sessionCodec.js";
-export { SessionClient, SessionRefusal, chooseSeatAction, playSeat, } from "./session.js";
+export { SessionClient, SessionRefusal, chooseSeatAction, playSeat, waitForReadyOwner, } from "./session.js";
 export { cardFromByte, decodeLegalActions, decodeParticipantView, encodeAction, pickAction, } from "./texas.js";
-export { authorityOriginFromSessionBase, buildConsentRequest, digestForPrompt, recomputeSettlementDigest, settlementConsentPath, verifyConsentDisclosure, } from "./settlement.js";
+export { buildConsentRequest, DEFAULT_OPEN_API_BASE_URL, digestForPrompt, recomputeSettlementDigest, settlementConsentPath, verifyConsentDisclosure, } from "./settlement.js";
 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";
@@ -29,5 +29,5 @@ export { handEquity, requiredEquity, cardCode, } from "./equity.js";
 export { 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";
+export { chipAddressOf, joinTransaction, leaveTransaction, listTournaments, planJoin, presentToTournament, readAgentEntry, readAgentEntrySettled, BOOK_CATCHES_UP_MS, readPass, readOwner, playsHeldBy, giveBackTransaction, readTournament, sponsorAndExecute, tournamentIdArg, tournamentPossessionSignature, JoinRefused, TournamentRefusal, TOURNAMENT_POSSESSION_SEAT, } from "./openTournament.js";
+export { ClientRefusal, describeNext, ownershipFencePoll, ownershipFenced, refusalLines, refusalMessage, refusalMessageFromText, } from "./refusal.js";

package/dist/offer.js

@@ -52,7 +52,7 @@ function record(raw) {
     };
 }
 export async function readOffer(productUrl, offerId) {
-    const { status, json } = await readJson(`${productUrl.replace(/\/$/, "")}/open/v1/playground/matches/${offerId}`);
+    const { status, json } = await readJson(`${productUrl.replace(/\/$/, "")}/v1/playground/matches/${offerId}`);
     if (status !== 200)
         throw new Error(refusalMessage("offer read", status, json));
     return record(json);
@@ -81,7 +81,7 @@ export async function acceptOffer(productUrl, offerId, seat, agent) {
         signature: Array.from(signed.signature),
         seat_possession_signature: Array.from(signed.seatPossessionSignature),
     });
-    const { status, json } = await readJson(`${productUrl.replace(/\/$/, "")}/open/v1/playground/matches/${offerId}/acceptances`, { method: "POST", headers: { "content-type": "application/json" }, body });
+    const { status, json } = await readJson(`${productUrl.replace(/\/$/, "")}/v1/playground/matches/${offerId}/acceptances`, { method: "POST", headers: { "content-type": "application/json" }, body });
     if (status === 200 || status === 201)
         return;
     if (status === 409)
@@ -89,7 +89,7 @@ export async function acceptOffer(productUrl, offerId, seat, agent) {
     throw new Error(refusalMessage("acceptance", status, json));
 }
 async function admit(productUrl, offerId, agentId, agent) {
-    const target = `/open/v1/playground/matches/${offerId}/admit`;
+    const target = `/v1/playground/matches/${offerId}/admit`;
     const { header } = await mintAgentHttpCapability(agent, agentId, {
         method: "POST",
         requestTarget: target,

package/dist/openTournament.d.ts

@@ -143,6 +143,28 @@ export declare function readTournamentMatches(productUrl: string, tournamentId:
 export declare function disputeHolding(productUrl: string, tournamentId: string, chipAddress: string, fetchImpl?: typeof fetch): Promise<number | undefined>;
 /** The agent's entry in the chip book, or `null` before its first redeem. */
 export declare function readAgentEntry(productUrl: string, tournamentId: string, chipAddress: string, fetchImpl?: typeof fetch): Promise<TournamentAgentEntry | null>;
+/** How long a book read waits for a join that has just landed.
+ *
+ *  The book is the chain's, read a checkpoint behind it: an agent whose
+ *  `queue_join` succeeded a moment ago is on chain and not yet in the book.
+ *  Measured at about a second on a local stack; this is generous enough to
+ *  cover a slower one and short enough that an agent that really is absent is
+ *  told so rather than left waiting. */
+export declare const BOOK_CATCHES_UP_MS = 8000;
+/** The agent's entry, waited for while the book catches up with the chain.
+ *
+ *  For a caller that has just been told its join landed. A plain
+ *  `readAgentEntry` answering `null` in that window is not "this agent never
+ *  queued" — it is "the book has not seen the queue join yet", and the two are
+ *  worth telling apart before refusing somebody. Absent for the whole bound is
+ *  the first answer, and this returns `null` for it. */
+export declare function readAgentEntrySettled(productUrl: string, tournamentId: string, chipAddress: string, options?: {
+    boundMs?: number;
+    pollMs?: number;
+    fetchImpl?: typeof fetch;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}): Promise<TournamentAgentEntry | null>;
 /** An owner's pass, or `null` when the owner has claimed none. */
 export declare function readPass(productUrl: string, tournamentId: string, owner: string, fetchImpl?: typeof fetch): Promise<TournamentPass | null>;
 /** An owner's side: its pass and every agent it has claimed, each with the

package/dist/openTournament.js

@@ -26,7 +26,7 @@ function base(productUrl) {
     return productUrl.replace(/\/$/, "");
 }
 function tournamentPath(tournamentId, rest = "") {
-    return `/open/v1/tournaments/${tournamentId}${rest}`;
+    return `/v1/tournaments/${tournamentId}${rest}`;
 }
 async function readJson(fetchImpl, url) {
     const response = await fetchImpl(url);
@@ -57,7 +57,7 @@ export async function readTournament(productUrl, tournamentId, fetchImpl = fetch
 }
 /** The open-entry tournaments the product runs. */
 export async function listTournaments(productUrl, fetchImpl = fetch) {
-    const { status, json } = await readJson(fetchImpl, `${base(productUrl)}/open/v1/tournaments`);
+    const { status, json } = await readJson(fetchImpl, `${base(productUrl)}/v1/tournaments`);
     if (status === 404)
         return [];
     if (status !== 200)
@@ -100,6 +100,37 @@ export async function readAgentEntry(productUrl, tournamentId, chipAddress, fetc
         throw new TournamentRefusal(status, json, "chip book read");
     return json;
 }
+/** How long a book read waits for a join that has just landed.
+ *
+ *  The book is the chain's, read a checkpoint behind it: an agent whose
+ *  `queue_join` succeeded a moment ago is on chain and not yet in the book.
+ *  Measured at about a second on a local stack; this is generous enough to
+ *  cover a slower one and short enough that an agent that really is absent is
+ *  told so rather than left waiting. */
+export const BOOK_CATCHES_UP_MS = 8_000;
+/** The agent's entry, waited for while the book catches up with the chain.
+ *
+ *  For a caller that has just been told its join landed. A plain
+ *  `readAgentEntry` answering `null` in that window is not "this agent never
+ *  queued" — it is "the book has not seen the queue join yet", and the two are
+ *  worth telling apart before refusing somebody. Absent for the whole bound is
+ *  the first answer, and this returns `null` for it. */
+export async function readAgentEntrySettled(productUrl, tournamentId, chipAddress, options = {}) {
+    const boundMs = options.boundMs ?? BOOK_CATCHES_UP_MS;
+    const pollMs = options.pollMs ?? 1_000;
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ??
+        ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const deadline = now() + boundMs;
+    for (;;) {
+        const entry = await readAgentEntry(productUrl, tournamentId, chipAddress, options.fetchImpl ?? fetch);
+        if (entry)
+            return entry;
+        if (now() >= deadline)
+            return null;
+        await sleep(pollMs);
+    }
+}
 /** An owner's pass, or `null` when the owner has claimed none. */
 export async function readPass(productUrl, tournamentId, owner, fetchImpl = fetch) {
     const { status, json } = await readJson(fetchImpl, `${base(productUrl)}${tournamentPath(tournamentId, `/passes/${owner}`)}`);
@@ -178,7 +209,7 @@ plays, owner) {
     if (entry && entry.state !== "idle")
         throw new JoinRefused(`this agent is already ${entry.state}${entry.state === "seated" ? " at a table" : ""}; an agent plays one table at a time`, {
             action: "wait",
-            poll: `/open/v1/tournaments/${overview.tournamentId}/agents/${entry.chipAddress}`,
+            poll: `/v1/tournaments/${overview.tournamentId}/agents/${entry.chipAddress}`,
         });
     const booked = entry?.balance ?? 0;
     const wallet = entry?.walletBalance ?? booked;

package/dist/refusal.d.ts

@@ -29,6 +29,11 @@ export interface RefusalBody {
     docs?: string;
 }
 /** `next …`, as one line an agent can act on. */
+/** True when a refusal body says the writer is fenced and the caller should
+ *  poll committed ownership rather than resend to the same origin. */
+export declare function ownershipFenced(body: unknown): boolean;
+/** The product route a fenced seat polls, when the refusal named one. */
+export declare function ownershipFencePoll(body: unknown): string | undefined;
 export declare function describeNext(next: RefusalNext): string;
 /** The lines a refusal prints: its code, what it said, the move, the entry. */
 export declare function refusalLines(body: unknown): string[];

package/dist/refusal.js

@@ -6,6 +6,27 @@
  * reading a refused command's output reads its move off the same lines rather
  * than off a table in a skill document. */
 /** `next …`, as one line an agent can act on. */
+/** True when a refusal body says the writer is fenced and the caller should
+ *  poll committed ownership rather than resend to the same origin. */
+export function ownershipFenced(body) {
+    if (typeof body !== "object" || body === null)
+        return false;
+    const refusal = body;
+    if (refusal.code !== "ownership_fenced")
+        return false;
+    return (isNext(refusal.next) &&
+        refusal.next.action === "wait" &&
+        typeof refusal.next.poll === "string");
+}
+/** The product route a fenced seat polls, when the refusal named one. */
+export function ownershipFencePoll(body) {
+    if (!ownershipFenced(body))
+        return undefined;
+    const next = body.next;
+    if (next && next.action === "wait")
+        return next.poll;
+    return undefined;
+}
 export function describeNext(next) {
     switch (next.action) {
         case "retry":

package/dist/room.js

@@ -57,7 +57,7 @@ export async function openRoom(client, seatCount) {
         seatCount < MIN_ROOM_SEATS ||
         seatCount > MAX_ROOM_SEATS)
         throw new Error(`a private room seats ${MIN_ROOM_SEATS} to ${MAX_ROOM_SEATS}, not ${seatCount}`);
-    const { status, json } = await signedFetch(client, "POST", "/open/v1/tables/private-rooms", { seatCount });
+    const { status, json } = await signedFetch(client, "POST", "/v1/tables/private-rooms", { seatCount });
     if (status !== 201) {
         if (json?.code === "agent_not_claimed")
             throw notClaimed();
@@ -95,7 +95,7 @@ export class RoomJoinRefusal extends Error {
 }
 /** Join a room by the id its opener handed out. */
 export async function joinRoom(client, tableId) {
-    const target = `/open/v1/tables/private-rooms/${tableId}/join`;
+    const target = `/v1/tables/private-rooms/${tableId}/join`;
     const { status, json } = await signedFetch(client, "POST", target);
     if (status !== 201) {
         if (json?.code === "agent_not_claimed")

package/dist/seatState.d.ts

@@ -100,6 +100,7 @@ interface SerialisedRelease {
     arrivalMs: string;
     lockedAtMs: string;
     budgetMs: string;
+    terminalDigest: string | null;
 }
 type SerialisedGate = {
     phase: "prepared";

package/dist/seatState.js

@@ -175,6 +175,9 @@ export function encodeGate(gate) {
                     arrivalMs: gate.release.arrivalMs.toString(),
                     lockedAtMs: gate.release.lockedAtMs.toString(),
                     budgetMs: gate.release.budgetMs.toString(),
+                    terminalDigest: gate.release.terminalDigest
+                        ? toHex0x(gate.release.terminalDigest)
+                        : null,
                 },
             };
     }
@@ -208,6 +211,9 @@ export function decodeGate(stored) {
                     arrivalMs: BigInt(stored.release.arrivalMs),
                     lockedAtMs: BigInt(stored.release.lockedAtMs),
                     budgetMs: BigInt(stored.release.budgetMs),
+                    terminalDigest: stored.release.terminalDigest
+                        ? fromHex(stored.release.terminalDigest)
+                        : null,
                 }),
             };
         default:

package/dist/seatTurn.js

@@ -478,7 +478,7 @@ async function sayAtTable(fetchImpl, session, agent, agentId, say) {
     if (!trimmed)
         return false;
     const { mintAgentHttpCapability, AGENT_HTTP_CAPABILITY_HEADER } = await import("./agentHttp.js");
-    const target = `/open/v1/executions/${session.executionHex}/talk`;
+    const target = `/v1/executions/${session.executionHex}/talk`;
     const body = new TextEncoder().encode(JSON.stringify({ say: trimmed }));
     try {
         const { header } = await mintAgentHttpCapability(agent, agentId, {

package/dist/session.d.ts

@@ -327,6 +327,18 @@ export interface RestartRetry {
  *  answer, 408, 429 or a 5xx -- until `bound` has passed. Any other answer is
  *  returned as it came, so a refusal stays the caller's to read. */
 export declare function fetchWhileRestarting(fetchImpl: typeof fetch, url: string, retry?: RestartRetry): Promise<Response>;
+/** Poll product until the committed owner is ready, then return its origin. */
+export declare function waitForReadyOwner(args: {
+    productUrl: string;
+    executionId: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+    pauseMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<{
+    sessionOrigin: string;
+    version: number;
+}>;
 export declare function openSeatSession(args: SeatSessionArgs): Promise<SeatSession>;
 export declare function playSeat(args: PlayArgs): Promise<PlayReport>;
 /** What the play loop does about a refusal, by the refusal's tag.

package/dist/session.js

@@ -7,6 +7,7 @@ import { MAX_TRANSPORT_FRAME_BYTES, PredictionGateConflictError, SessionBoundary
 import { actionSigningBytes, encodeActionFrame, encodeJoinFrame, encodeResumeFrame, joinSigningBytes, requireSessionVersion, resumeSigningBytes, SESSION_VERSION, UnsupportedSessionVersionError, } from "./sessionWire.js";
 import { decodeLegalActions, decodeParticipantView, encodeAction, pickAction, } from "./texas.js";
 import { authorizeSeatChallenge } from "./seatAuth.js";
+import { ownershipFenced } from "./refusal.js";
 const ACTION_IDENTITY_DOMAIN = textBytes("dopa_open::client::action_identity_v1");
 /** The lines a play door reports for one seat's sitting.
  *
@@ -528,13 +529,50 @@ export async function fetchWhileRestarting(fetchImpl, url, retry = {
         await sleep(retry.pauseMs);
     }
 }
+/** Poll product until the committed owner is ready, then return its origin. */
+export async function waitForReadyOwner(args) {
+    const fetchImpl = args.fetchImpl ?? fetch;
+    const sleep = args.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const product = args.productUrl.replace(/\/$/, "");
+    const until = Date.now() + (args.timeoutMs ?? 30_000);
+    const pause = args.pauseMs ?? 200;
+    const id = args.executionId.replace(/^0x/i, "");
+    for (;;) {
+        const response = await fetchImpl(`${product}/v1/authority/executions/${id}/route`);
+        if (response.ok) {
+            const body = (await response.json());
+            if (body.ready && body.sessionOrigin)
+                return { sessionOrigin: body.sessionOrigin, version: body.version ?? 0 };
+        }
+        else {
+            await response.body?.cancel();
+        }
+        if (Date.now() + pause > until)
+            throw new Error("committed owner did not become ready");
+        await sleep(pause);
+    }
+}
+function httpFailure(error) {
+    if (!(error instanceof Error))
+        return null;
+    const match = /^[a-z-]+ failed \((\d+)\): (.*)$/is.exec(error.message);
+    if (!match)
+        return null;
+    const status = Number(match[1]);
+    try {
+        return { status, body: JSON.parse(match[2] ?? "") };
+    }
+    catch {
+        return { status, body: match[2] ?? "" };
+    }
+}
 export async function openSeatSession(args) {
     const fetchImpl = args.fetchImpl ?? fetch;
     const product = args.productUrl.replace(/\/$/, "");
     /* Read again while the product is coming back: a seat reopens its session
        after every dropped stream, and the product answering 502 for the seconds
        it restarts ended the seat as surely as a refusal would have. */
-    const offer = await fetchWhileRestarting(fetchImpl, `${product}/open/v1/playground/matches/${args.offerId}`, args.restartRetry);
+    const offer = await fetchWhileRestarting(fetchImpl, `${product}/v1/playground/matches/${args.offerId}`, args.restartRetry);
     if (!offer.ok)
         throw new Error(`offer read failed (${offer.status}): ${await offer.text()}`);
     const record = (await offer.json());
@@ -581,7 +619,7 @@ export async function openSeatSession(args) {
 }
 export async function playSeat(args) {
     const fetchImpl = args.fetchImpl ?? fetch;
-    const { client, product, executionHex, coordinatorKey, timeAuthorityKey, executionId, } = await openSeatSession(args);
+    let { client, product, executionHex, coordinatorKey, timeAuthorityKey, executionId, } = await openSeatSession(args);
     const record = {
         admission: {
             execution_id: executionId,
@@ -923,6 +961,22 @@ export async function playSeat(args) {
                client joined this seat with this key; fighting it back would evict
                a reconnect that may be the operator's own, so this one steps aside
                and says so. Everything else is transient, and resume is right. */
+            const failed = httpFailure(error);
+            if (failed?.status === 409 && ownershipFenced(failed.body)) {
+                const ready = await waitForReadyOwner({
+                    productUrl: product,
+                    executionId: executionHex,
+                    fetchImpl,
+                    timeoutMs: 30_000,
+                    pauseMs: 200,
+                });
+                client = new SessionClient(ready.sessionOrigin, args.agent, args.seat, args.agentId, client.executionId, client.executionManifestDigest, client.clientNonce, fetchImpl);
+                client.token = originToken;
+                await client.resume(lastContext, lastCursor);
+                originToken = client.token ?? originToken;
+                reconnects += 1;
+                continue;
+            }
             const answer = afterRefusal(error);
             if (answer === "step-aside")
                 return {
@@ -1004,7 +1058,7 @@ export function normaliseCardCode(code) {
 export async function readDisclosedEntitlement(fetchImpl, product, executionId, seat, capability, options = {}) {
     const attempts = options.attempts ?? 15;
     const pauseMs = options.pauseMs ?? 1_000;
-    const target = `/open/v1/spectator/executions/${executionId}`;
+    const target = `/v1/spectator/executions/${executionId}`;
     for (let attempt = 0; attempt < attempts; attempt += 1) {
         try {
             const header = capability ? await capability("GET", target) : null;
@@ -1032,7 +1086,7 @@ export async function readDisclosedEntitlement(fetchImpl, product, executionId,
  *  gone -- which is precisely the moment this question is being asked. */
 export async function readSittingStatus(fetchImpl, product, executionHex) {
     try {
-        const response = await fetchImpl(`${product}/open/v1/history/matches/${executionHex}`);
+        const response = await fetchImpl(`${product}/v1/history/matches/${executionHex}`);
         if (!response.ok)
             return { state: "unknown" };
         const wire = (await response.json());
@@ -1073,7 +1127,7 @@ export function agentReadCapability(agent, agentId) {
 export async function readPublicTable(fetchImpl, product, executionHex, names = new Map(), capability) {
     /* Bound to the target the server reconstructs from the request, which is the
        origin-form path and not the absolute URL the fetch is given. */
-    const target = `/open/v1/spectator/executions/${executionHex}`;
+    const target = `/v1/spectator/executions/${executionHex}`;
     try {
         const header = capability ? await capability("GET", target) : null;
         const response = await fetchImpl(`${product}${target}`, header === null
@@ -1134,14 +1188,14 @@ export async function readPublicTable(fetchImpl, product, executionHex, names =
         return null;
     }
 }
-/** What an agent is called, from `GET /open/v1/agents/{id}/custody`, read
+/** What an agent is called, from `GET /v1/agents/{id}/custody`, read
  *  once and remembered in `names`. Null where the read did not answer. */
 async function readAgentNaming(fetchImpl, product, agentId, names) {
     const known = names.get(agentId);
     if (known !== undefined)
         return known;
     try {
-        const response = await fetchImpl(`${product}/open/v1/agents/${agentId}/custody`);
+        const response = await fetchImpl(`${product}/v1/agents/${agentId}/custody`);
         if (!response.ok) {
             names.set(agentId, null);
             return null;
@@ -1164,7 +1218,7 @@ async function readAgentNaming(fetchImpl, product, agentId, names) {
  *  table: an empty list where the read did not answer. */
 export async function readTableTalk(fetchImpl, product, executionHex, handIndex) {
     try {
-        const response = await fetchImpl(`${product}/open/v1/executions/${executionHex}/talk`);
+        const response = await fetchImpl(`${product}/v1/executions/${executionHex}/talk`);
         if (!response.ok)
             return [];
         const wire = (await response.json());
@@ -1200,7 +1254,7 @@ function potChips(pot) {
 /** File one line at the table, signed as this seat's agent. True when the
  *  product accepted it. */
 async function sayAtTable(fetchImpl, product, executionHex, args, say) {
-    const target = `/open/v1/executions/${executionHex}/talk`;
+    const target = `/v1/executions/${executionHex}/talk`;
     const body = textBytes(JSON.stringify({ say }));
     try {
         const { header } = await mintAgentHttpCapability(args.agent, args.agentId, {

package/dist/sessionCodec.d.ts

@@ -13,6 +13,7 @@ export declare const SEAT_AUTHORIZATION_RESPONSE_TAG = 16;
 export declare const PREDICTION_GATE_RELEASED_TAG = 17;
 export declare const PREDICTION_GATE_PREPARED_TAG = 18;
 export declare const PREDICTION_GATE_OPENED_TAG = 19;
+export declare const PREDICTION_GATE_RELEASED_V4_TAG = 20;
 export declare const MAX_TRANSPORT_FRAME_BYTES: number;
 export interface WireEnvelope {
     message: string;
@@ -104,6 +105,9 @@ export interface PredictionGateRelease {
     lockCappedMs: bigint;
     budgetMs: bigint;
     participantDeadlineMs: bigint;
+    /** Digest of the protected LLM terminal decision, when bound. A release
+     *  with none is the version-three notice; a bound one is version four. */
+    terminalDigest: Uint8Array | null;
 }
 /** The gate facts a participant retains for one revision. */
 export type PredictionGateStatus = {

package/dist/sessionCodec.js

@@ -23,6 +23,12 @@ export const SEAT_AUTHORIZATION_RESPONSE_TAG = 0x10;
 export const PREDICTION_GATE_RELEASED_TAG = 0x11;
 export const PREDICTION_GATE_PREPARED_TAG = 0x12;
 export const PREDICTION_GATE_OPENED_TAG = 0x13;
+/* The released notice carries a version per terminal-digest binding: a
+   release with no protected-terminal digest is the byte-identical
+   version-three notice, and one bound to a digest is this notice with the
+   raw 32-byte digest after the overlay. `arena_session::wire` picks the
+   same tag from the same fact. */
+export const PREDICTION_GATE_RELEASED_V4_TAG = 0x14;
 export const MAX_TRANSPORT_FRAME_BYTES = 1 << 20;
 export function encodeAckFrame(context, cursor) {
     const sequence = typeof cursor === "object" ? cursor.sequence : cursor;
@@ -276,7 +282,11 @@ export function bindPredictionGateOpening(fields) {
         throw new Error("prediction gate closes at or before it opened");
     return fields;
 }
-function readPredictionGateRelease(reader) {
+/* `bound` is the notice version, not a field the sender may vary: the
+   version-three notice ends at the overlay and names no digest, and the
+   version-four notice ends with the raw digest and no option byte. Reading
+   an option here would read the cursor that follows. */
+function readPredictionGateRelease(reader, bound) {
     const window = readPredictionWindow(reader);
     const actingSeat = reader.readU16("prediction gate acting seat");
     const state = readState(reader, "prediction gate state nonce", "prediction gate state commitment");
@@ -288,6 +298,9 @@ function readPredictionGateRelease(reader) {
     const arrivalMs = reader.readU64("prediction gate arrival milliseconds");
     const lockedAtMs = reader.readU64("prediction gate locked-at milliseconds");
     const budgetMs = reader.readU64("participant deadline budget milliseconds");
+    const terminalDigest = bound
+        ? reader.readFixed(32, "prediction gate terminal digest")
+        : null;
     return bindPredictionGateRelease({
         window,
         actingSeat,
@@ -298,6 +311,7 @@ function readPredictionGateRelease(reader) {
         arrivalMs,
         lockedAtMs,
         budgetMs,
+        terminalDigest,
     });
 }
 /** The structural refusals of `PredictionGateRelease::new`, with the bounded
@@ -566,8 +580,9 @@ export function decodeAuthorityMessage(bytes) {
             };
             break;
         }
-        case PREDICTION_GATE_RELEASED_TAG: {
-            const release = readPredictionGateRelease(reader);
+        case PREDICTION_GATE_RELEASED_TAG:
+        case PREDICTION_GATE_RELEASED_V4_TAG: {
+            const release = readPredictionGateRelease(reader, tag === PREDICTION_GATE_RELEASED_V4_TAG);
             const cursor = readCursor(reader);
             message = {
                 type: "predictionGateReleased",

package/dist/sessionWire.js

@@ -3,7 +3,7 @@
  *
  * Join, action, and resume signing bodies live here; acknowledgements are
  * unsigned and encoded next to the authority decoder. The layouts are pinned
- * by `libs/dopa-open-client-rs/vectors/ts-signer-parity.json`.
+ * by `libs/dopa-open/client-rs/vectors/ts-signer-parity.json`.
  */
 import { ByteWriter, frameSigningBytes, textBytes } from "./bytes.js";
 const JOIN_DOMAIN = textBytes("arena_session::join");

package/dist/settlement.d.ts

@@ -1,3 +1,8 @@
+/** The Product API's deployed default origin. `dopa-open`'s `--product-url`
+ * (and `DOPA_OPEN_PRODUCT_URL`) default here, matching the Rust client and
+ * CLI's `DEFAULT_OPEN_API_BASE_URL`, so a caller only has to override it for
+ * a local stack or a non-default plane. */
+export declare const DEFAULT_OPEN_API_BASE_URL = "https://open.dopamint.fun";
 export interface SeatEntitlement {
     seat: number;
     amount: bigint;
@@ -52,5 +57,4 @@ export declare function buildConsentRequest(args: ConsentDisclosure & {
     signature: Uint8Array;
 }): ConsentRequest;
 export declare function settlementConsentPath(executionIdHex: string): string;
-export declare function authorityOriginFromSessionBase(sessionBaseUrl: string): string;
 export declare function digestForPrompt(prompt: ConsentPrompt): Uint8Array;

package/dist/settlement.js

@@ -2,6 +2,11 @@ import { ByteReader, ByteWriter, equalBytes, fromHex, textBytes, toHex0x, } from
 import { digestFramed } from "./crypto.js";
 const ANCHOR_DOMAIN_ID_V1 = textBytes("arena_tunnel::anchor_domain_id_v1");
 const SETTLEMENT_PURPOSE = textBytes("arena_tunnel::settlement");
+/** The Product API's deployed default origin. `dopa-open`'s `--product-url`
+ * (and `DOPA_OPEN_PRODUCT_URL`) default here, matching the Rust client and
+ * CLI's `DEFAULT_OPEN_API_BASE_URL`, so a caller only has to override it for
+ * a local stack or a non-default plane. */
+export const DEFAULT_OPEN_API_BASE_URL = "https://open.dopamint.fun";
 export function encodeTerminalState(state) {
     const writer = new ByteWriter()
         .pushU16(1)
@@ -103,13 +108,7 @@ export function buildConsentRequest(args) {
 }
 export function settlementConsentPath(executionIdHex) {
     const hex = executionIdHex.replace(/^0x/, "");
-    return `/open/v1/authority/executions/${hex}/settlements`;
-}
-export function authorityOriginFromSessionBase(sessionBaseUrl) {
-    const idx = sessionBaseUrl.indexOf("/v1/exec/");
-    if (idx <= 0)
-        throw new Error(`admission session_base_url is not an execution session URL: ${sessionBaseUrl}`);
-    return sessionBaseUrl.slice(0, idx);
+    return `/v1/authority/executions/${hex}/settlements`;
 }
 export function digestForPrompt(prompt) {
     const terminal = decodeTerminalState(fromHex(prompt.encoded_terminal_state));

package/dist/tour.js

@@ -63,8 +63,8 @@ function unavailable(error) {
 }
 export async function enterTour(client, tour, floor = {}) {
     const target = tour === "playground"
-        ? "/open/v1/tours/playground/entries"
-        : "/open/v1/tours/tournament/entries";
+        ? "/v1/tours/playground/entries"
+        : "/v1/tours/tournament/entries";
     if (floor.minAgents !== undefined && tour !== "playground")
         throw new Error("a floor of real agents only applies to the playground");
     /* No body at all when nothing is stated: the join every client sent before
@@ -124,13 +124,13 @@ export async function queueUntilSeated(client, tour, options = {}) {
     }
 }
 export async function readPosition(client, tableId) {
-    const { status, json } = await signedFetch(client, "GET", `/open/v1/tables/${tableId}/decision`);
+    const { status, json } = await signedFetch(client, "GET", `/v1/tables/${tableId}/decision`);
     if (status !== 200)
         throw new Error(refusalMessage("decision read", status, json));
     return json;
 }
 export async function act(client, tableId, move) {
-    const { status, json } = await signedFetch(client, "POST", `/open/v1/tables/${tableId}/actions`, move);
+    const { status, json } = await signedFetch(client, "POST", `/v1/tables/${tableId}/actions`, move);
     if (status !== 200)
         throw new Error(refusalMessage("action", status, json));
     return json;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dopamint-fun/open-sdk",
-  "version": "0.2.0-dev.1",
+  "version": "0.2.0-dev.11",
   "description": "DOPA-OPEN client SDK: generate and hold your own agent key, sign registrations, and play a Participant Session",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/CommandOSSLabs/dopamint-arena.git",
-    "directory": "libs/dopa-open-client-ts"
+    "directory": "libs/dopa-open/client-ts"
   },
   "type": "module",
   "main": "dist/index.js",