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

package/README.md

@@ -1,4 +1,4 @@
-# `libs/dopa-open-client-ts`
+# `libs/dopa-open/client-ts`
 
 Status: implemented
 Ownership: Optional official TypeScript SDK for DOPA-OPEN self-custody agents:
@@ -36,8 +36,8 @@ signatures, not whether this package is used. Allowed dependencies:
 ## Parity
 
 Preimages and signatures are pinned byte-identical to the Rust signer by
-`libs/dopa-open-client-rs/vectors/ts-signer-parity.json`, generated by
-`libs/dopa-open-client-rs/tests/ts_parity_vectors.rs` and replayed by
+`libs/dopa-open/client-rs/vectors/ts-signer-parity.json`, generated by
+`libs/dopa-open/client-rs/tests/ts_parity_vectors.rs` and replayed by
 `src/parity.test.ts` here. Regenerate with
 `WRITE_TS_PARITY_VECTORS=1 cargo test -p dopa-open-client-rs --test
 ts_parity_vectors`; a wire change updates both sides together.

package/dist/agentHttp.js

@@ -2,7 +2,7 @@
  * tour or table request without ever holding a bearer credential.
  *
  * Byte-identical to `dopa_open_api::agent_http`, pinned by
- * `libs/dopa-open-api/vectors/agent_http_capability_v1.json`. A bearer token
+ * `libs/dopa-open/api/vectors/agent_http_capability_v1.json`. A bearer token
  * is a secret presented per request; a signature is not, so each capability is
  * bound to the method, the request target, a digest of the exact body bytes,
  * and a single-use nonce inside a bounded window. One minted to enter the
@@ -13,7 +13,7 @@
  * server reconstructs them from the request it actually received, so there is
  * no restated copy to compare and therefore no comparison to forget.
  */
-import { ByteWriter, frameSigningBytes, fromHex, textBytes, toHex } from "./bytes.js";
+import { ByteReader, ByteWriter, frameSigningBytes, fromHex, textBytes, toHex, } from "./bytes.js";
 import { blake2b256 } from "./crypto.js";
 import { signRaw } from "./keypair.js";
 const AGENT_HTTP_CAPABILITY_DOMAIN = textBytes("dopa_open::agent_http_capability::v1");
@@ -94,20 +94,17 @@ export function decodeAgentHttpHeader(value) {
     const bytes = fromHex(value);
     if (bytes.length !== HEADER_BYTES)
         throw new Error(`capability header must be ${HEADER_BYTES} bytes, got ${bytes.length}`);
-    const readU64 = (offset) => {
-        let out = 0n;
-        for (let index = 0; index < 8; index++)
-            out = (out << 8n) | BigInt(bytes[offset + index]);
-        return out;
-    };
-    return {
-        agentId: bytes.slice(0, 32),
-        agentPublicKey: bytes.slice(32, 64),
-        issuedAtMs: readU64(64),
-        expiresAtMs: readU64(72),
-        nonce: bytes.slice(80, 80 + AGENT_HTTP_CAPABILITY_NONCE_BYTES),
-        signature: bytes.slice(80 + AGENT_HTTP_CAPABILITY_NONCE_BYTES),
+    const reader = new ByteReader(bytes);
+    const capability = {
+        agentId: reader.readFixed(32, "agent id"),
+        agentPublicKey: reader.readFixed(32, "agent public key"),
+        issuedAtMs: reader.readU64("issued_at_ms"),
+        expiresAtMs: reader.readU64("expires_at_ms"),
+        nonce: reader.readFixed(AGENT_HTTP_CAPABILITY_NONCE_BYTES, "nonce"),
+        signature: reader.readFixed(SIGNATURE_BYTES, "signature"),
     };
+    reader.finish();
+    return capability;
 }
 /** Mint and sign one capability, and return the header to send with it.
  *

package/dist/bytes.js

@@ -5,7 +5,7 @@
  * These helpers exist so every framing in this package spells a number the
  * same way; a preimage that drifts from the Rust client by one byte produces
  * signatures the authority silently rejects, which is why the parity vectors
- * in `libs/dopa-open-client-rs/vectors/` pin all of it.
+ * in `libs/dopa-open/client-rs/vectors/` pin all of it.
  */
 export function toHex(bytes) {
     let out = "";

package/dist/claim.js

@@ -1,6 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { signRaw } from "./keypair.js";
-import { concatBytes, equalBytes, frameSigningBytes, fromHex, textBytes, toHex0x, } from "./bytes.js";
+import { ByteReader, ByteWriter, equalBytes, frameSigningBytes, fromHex, textBytes, toHex0x, } from "./bytes.js";
 /* The agent's half of a claim: an invitation its own key signs.
  *
  * A wallet claims an agent by signing for it in the arena's UI. That proves
@@ -22,16 +22,6 @@ export const AGENT_CLAIM_INVITE_MAX_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
  *  nonce || signature`, every field fixed-width. */
 export const AGENT_CLAIM_INVITE_TOKEN_BYTES = 32 + 32 + 32 + 8 + 8 + 16 + 64;
 const ZERO_OWNER = new Uint8Array(32);
-function u64be(value) {
-    const out = new Uint8Array(8);
-    new DataView(out.buffer).setBigUint64(0, value, false);
-    return out;
-}
-function fixed(bytes, length, what) {
-    if (bytes.length !== length)
-        throw new Error(`${what} must be ${length} bytes, got ${bytes.length}`);
-    return bytes;
-}
 /** `AgentClaimInvite::canonical_payload` -- the framed fields. */
 export function claimInviteCanonicalPayload(invite) {
     if (invite.expiresAtMs <= invite.issuedAtMs)
@@ -41,7 +31,18 @@ export function claimInviteCanonicalPayload(invite) {
         throw new Error("an invitation may stay open for at most a week");
     if (invite.nonce.every((byte) => byte === 0))
         throw new Error("the invitation's nonce must not be all zero");
-    return concatBytes(AGENT_CLAIM_INVITE_DOMAIN, Uint8Array.of(0, CANONICAL_WIRE_VERSION, INVITE_OPERATION), fixed(invite.agentId, 32, "agent id"), invite.owner ? fixed(invite.owner, 32, "owner") : ZERO_OWNER, fixed(invite.agentPublicKey, 32, "agent public key"), u64be(invite.issuedAtMs), u64be(invite.expiresAtMs), fixed(invite.nonce, AGENT_CLAIM_INVITE_NONCE_BYTES, "nonce"));
+    return new ByteWriter()
+        .pushBytes(AGENT_CLAIM_INVITE_DOMAIN)
+        .pushByte(0)
+        .pushByte(CANONICAL_WIRE_VERSION)
+        .pushByte(INVITE_OPERATION)
+        .pushFixed(invite.agentId, 32, "agent id")
+        .pushFixed(invite.owner ?? ZERO_OWNER, 32, "owner")
+        .pushFixed(invite.agentPublicKey, 32, "agent public key")
+        .pushU64(invite.issuedAtMs)
+        .pushU64(invite.expiresAtMs)
+        .pushFixed(invite.nonce, AGENT_CLAIM_INVITE_NONCE_BYTES, "nonce")
+        .bytes();
 }
 /** The bytes the agent's key signs, raw ed25519. */
 export function claimInviteSigningBytes(invite) {
@@ -66,7 +67,15 @@ export async function mintClaimInvite(agent, agentId, options = {}) {
 function claimInviteBytes(invite) {
     if (invite.signature.length !== 64)
         throw new Error("an invitation is encoded only once it is signed");
-    return concatBytes(fixed(invite.agentId, 32, "agent id"), invite.owner ?? ZERO_OWNER, fixed(invite.agentPublicKey, 32, "agent public key"), u64be(invite.issuedAtMs), u64be(invite.expiresAtMs), fixed(invite.nonce, 16, "nonce"), invite.signature);
+    return new ByteWriter()
+        .pushFixed(invite.agentId, 32, "agent id")
+        .pushFixed(invite.owner ?? ZERO_OWNER, 32, "owner")
+        .pushFixed(invite.agentPublicKey, 32, "agent public key")
+        .pushU64(invite.issuedAtMs)
+        .pushU64(invite.expiresAtMs)
+        .pushFixed(invite.nonce, AGENT_CLAIM_INVITE_NONCE_BYTES, "nonce")
+        .pushBytes(invite.signature)
+        .bytes();
 }
 /** The token the link carries and the claim body posts back: 0x-hex.
  *
@@ -115,20 +124,27 @@ export function decodeClaimInvite(token) {
     const bytes = claimInviteTokenBytes(token.trim());
     if (bytes.length !== AGENT_CLAIM_INVITE_TOKEN_BYTES)
         throw new Error(`an invitation token is ${AGENT_CLAIM_INVITE_TOKEN_BYTES} bytes, got ${bytes.length}`);
-    const view = new DataView(bytes.buffer, bytes.byteOffset);
-    const owner = bytes.slice(32, 64);
+    const reader = new ByteReader(bytes);
+    const agentId = reader.readFixed(32, "agent id");
+    const owner = reader.readFixed(32, "owner");
+    const agentPublicKey = reader.readFixed(32, "agent public key");
+    const issuedAtMs = reader.readU64("issued");
+    const expiresAtMs = reader.readU64("expires");
+    const nonce = reader.readFixed(AGENT_CLAIM_INVITE_NONCE_BYTES, "nonce");
+    const signature = reader.readFixed(64, "signature");
+    reader.finish();
     return {
-        agentId: bytes.slice(0, 32),
+        agentId,
         owner: equalBytes(owner, ZERO_OWNER) ? null : owner,
-        agentPublicKey: bytes.slice(64, 96),
-        issuedAtMs: view.getBigUint64(96, false),
-        expiresAtMs: view.getBigUint64(104, false),
-        nonce: bytes.slice(112, 128),
-        signature: bytes.slice(128),
+        agentPublicKey,
+        issuedAtMs,
+        expiresAtMs,
+        nonce,
+        signature,
     };
 }
 /** Where the owner goes to accept: the agent's claim page with the token. */
 export function claimInviteLink(arenaOrigin, agentIdHex, token) {
     const id = agentIdHex.startsWith("0x") ? agentIdHex : `0x${agentIdHex}`;
-    return `${arenaOrigin.replace(/\/$/, "")}/arena/agents/${id}/claim?invite=${token}`;
+    return `${arenaOrigin.replace(/\/$/, "")}/open/agents/${id}/claim?invite=${token}`;
 }

package/dist/cli.js

@@ -23,14 +23,20 @@ import { claimInviteLink, encodeClaimInvite, encodeClaimInviteCompact, mintClaim
 import { acceptAndAwaitAdmission } from "./offer.js";
 import { playTour, queueUntilSeated } from "./tour.js";
 import { joinRoomWhenComposed, MIN_ROOM_SEATS, openRoom, roomInvitePrompt, } from "./room.js";
-import { disputeHolding, JoinRefused, joinTransaction, leaveTransaction, listTournaments, matchmakingOverLine, planJoin, presentToTournament, readAgentEntry, playsHeldBy, giveBackTransaction, readTournament, sponsorAndExecute, tournamentIdArg, } from "./openTournament.js";
-import { authorityOriginFromSessionBase, buildConsentRequest, digestForPrompt, settlementConsentPath, verifyConsentDisclosure, } from "./settlement.js";
+import { disputeHolding, JoinRefused, joinTransaction, leaveTransaction, listTournaments, matchmakingOverLine, planJoin, presentToTournament, readAgentEntry, readAgentEntrySettled, playsHeldBy, giveBackTransaction, readTournament, sponsorAndExecute, tournamentIdArg, } from "./openTournament.js";
+import { buildConsentRequest, DEFAULT_OPEN_API_BASE_URL, digestForPrompt, settlementConsentPath, verifyConsentDisclosure, } from "./settlement.js";
 import { actionSigningBytes, joinSigningBytes, requireSessionVersion, resumeSigningBytes, SESSION_VERSION, } from "./sessionWire.js";
 import { describeNext, refusalMessageFromText } from "./refusal.js";
 function fail(message) {
     console.error(`dopa-open: ${message}`);
     process.exit(1);
 }
+/** Resolves `--product-url`, falling back to `DOPA_OPEN_PRODUCT_URL` and then
+ * to the deployed default — the same precedence and env name the Rust CLI
+ * uses, so a script that sets one variable configures both binaries. */
+function resolveProductUrl(explicit) {
+    return explicit ?? process.env.DOPA_OPEN_PRODUCT_URL ?? DEFAULT_OPEN_API_BASE_URL;
+}
 const hex = (value, field) => {
     if (typeof value !== "string")
         fail(`${field} must be a hex string`);
@@ -116,9 +122,7 @@ async function commandRegister(args) {
             "dry-run": { type: "boolean", default: false },
         },
     });
-    const productUrl = values["product-url"];
-    if (!productUrl && !values["dry-run"])
-        fail("--product-url is required (or pass --dry-run to print the request)");
+    const productUrl = resolveProductUrl(values["product-url"]);
     const agent = loadKeypair(values.key);
     const versions = (raw, flag) => {
         const list = raw.split(",").map((piece) => Number.parseInt(piece, 10));
@@ -162,7 +166,7 @@ async function commandRegister(args) {
         console.log(JSON.stringify(request, null, 2));
         return;
     }
-    const response = await fetch(`${productUrl.replace(/\/$/, "")}/open/v1/agents`, {
+    const response = await fetch(`${productUrl.replace(/\/$/, "")}/v1/agents`, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify(request),
@@ -225,9 +229,7 @@ async function commandName(args) {
             bio: { type: "string" },
         },
     });
-    const productUrl = values["product-url"];
-    if (!productUrl)
-        fail("--product-url is required");
+    const productUrl = resolveProductUrl(values["product-url"]);
     if (!values["agent-id"])
         fail("--agent-id is required");
     if (!values.name && !values.handle && !values.bio)
@@ -258,7 +260,7 @@ async function commandName(args) {
  * against what they believed, and the refusal for getting it wrong is a bare
  * `stale_generation` that names neither. */
 async function readKeyState(productUrl, agentId) {
-    const response = await fetch(`${productUrl}/open/v1/agents/${encodeURIComponent(agentId)}`);
+    const response = await fetch(`${productUrl}/v1/agents/${encodeURIComponent(agentId)}`);
     if (!response.ok)
         fail(`could not read agent ${agentId} (${response.status})`);
     const wire = (await response.json());
@@ -291,9 +293,7 @@ async function commandKey(args) {
             "dry-run": { type: "boolean", default: false },
         },
     });
-    const productUrl = values["product-url"]?.replace(/\/$/, "");
-    if (!productUrl)
-        fail("--product-url is required");
+    const productUrl = resolveProductUrl(values["product-url"]).replace(/\/$/, "");
     const agentId = values["agent-id"];
     if (!agentId)
         fail("--agent-id is required");
@@ -356,7 +356,7 @@ async function commandKey(args) {
         return;
     }
     const path = retire ? "revocations" : "key-rotations";
-    const response = await fetch(`${productUrl}/open/v1/agents/${encodeURIComponent(agentId)}/${path}`, {
+    const response = await fetch(`${productUrl}/v1/agents/${encodeURIComponent(agentId)}/${path}`, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify(request),
@@ -486,9 +486,7 @@ async function commandPlay(args) {
             "disconnect-after-actions": { type: "string" },
         },
     });
-    const productUrl = values["product-url"];
-    if (!productUrl)
-        fail("--product-url is required");
+    const productUrl = resolveProductUrl(values["product-url"]);
     if (!values["agent-id"])
         fail("--agent-id is required");
     /* A tour seat is played over the Product API, so it needs none of the
@@ -581,7 +579,7 @@ function runRecordPath(keyFile) {
 }
 function writeRunRecord(keyFile, record) {
     const path = runRecordPath(keyFile);
-    const watchUrl = `${record.productUrl.replace(/\/$/, "")}/arena/matches/0x${record.executionId.replace(/^0x/i, "")}`;
+    const watchUrl = `${record.productUrl.replace(/\/$/, "")}/open/matches/0x${record.executionId.replace(/^0x/i, "")}`;
     writeFileSync(path, `${JSON.stringify({ ...record, watchUrl, at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
     return path;
 }
@@ -642,7 +640,7 @@ async function signedGet(productUrl, target, agent, agentIdHex) {
         headers: { [AGENT_HTTP_CAPABILITY_HEADER]: header },
     });
 }
-/** `dopa-open me`: the arena's record of this agent, signed for.
+/** `dopa-open me`: Open's record of this agent, signed for.
  *
  *  Both agents that played on 2026-09-06 wrote this request by hand, against
  *  the skill's own warning that a hand-written signature drifts by a byte. */
@@ -657,13 +655,13 @@ async function signedGet(productUrl, target, agent, agentIdHex) {
 async function resolveAgentId(productUrl, ownerAddressHex, given) {
     if (given)
         return given;
-    const response = await fetch(`${productUrl.replace(/\/$/, "")}/open/v1/agents?owner=${ownerAddressHex}&limit=60`);
+    const response = await fetch(`${productUrl.replace(/\/$/, "")}/v1/agents?owner=${ownerAddressHex}&limit=60`);
     if (!response.ok)
         fail(`--agent-id was not given and the roster could not be read (${response.status})`);
     const body = (await response.json());
     const agents = body.agents ?? [];
     if (agents.length === 0)
-        fail(`no agent on this arena is claimed by ${ownerAddressHex}. The roster lists an agent under the wallet that ` +
+        fail(`no agent on this Open deployment is claimed by ${ownerAddressHex}. The roster lists an agent under the wallet that ` +
             "claimed it, so one that registered itself is not here until it is claimed; pass --agent-id (register printed it)");
     if (agents.length > 1)
         fail(`this key owns ${agents.length} agents; pass --agent-id to say which:\n  ${agents
@@ -680,16 +678,14 @@ async function commandMe(args) {
             "agent-id": { type: "string" },
         },
     });
-    const productUrl = values["product-url"];
-    if (!productUrl)
-        fail("--product-url is required");
+    const productUrl = resolveProductUrl(values["product-url"]);
     const agent = loadKeypair(values.key);
     /* Without `--agent-id`, ask the roster which agent this key owns. */
     const agentId = await resolveAgentId(productUrl, agent.ownerAddressHex, values["agent-id"]);
-    const response = await signedGet(productUrl, "/open/v1/agent/me", agent, agentId);
+    const response = await signedGet(productUrl, "/v1/agent/me", agent, agentId);
     const body = await response.text();
     if (!response.ok)
-        fail(refusalMessageFromText(`agent/me at ${productUrl}/open/v1/agent/me`, response.status, body));
+        fail(refusalMessageFromText(`agent/me at ${productUrl}/v1/agent/me`, response.status, body));
     try {
         console.log(JSON.stringify(JSON.parse(body), null, 2));
     }
@@ -857,14 +853,19 @@ async function commandAct(args) {
  *  this, so it is worth a caller of its own rather than a flag on the play
  *  loop. Prints what the authority recorded. */
 async function consentToTerminal(options) {
-    const offerResponse = await fetch(`${options.productUrl.replace(/\/$/, "")}/open/v1/playground/matches/${options.offerId}`);
+    const offerResponse = await fetch(`${options.productUrl.replace(/\/$/, "")}/v1/playground/matches/${options.offerId}`);
     const offerBody = await offerResponse.text();
     if (!offerResponse.ok)
         fail(`offer read failed (${offerResponse.status}): ${offerBody}`);
     const record = JSON.parse(offerBody);
     if (!record.admission)
         fail("offer is not admitted; there is no execution to settle");
-    const origin = authorityOriginFromSessionBase(record.admission.session_base_url);
+    /* The settlement verbs live on the product origin — `/v1/authority/…` is
+       the product's public route, which forwards to the shard that admitted
+       the execution. The session's own origin serves `/v1/exec/` only, so
+       deriving the consent root from `session_base_url` asks a listener that
+       does not serve this spelling. */
+    const origin = options.productUrl.replace(/\/$/, "");
     const path = settlementConsentPath(record.admission.execution_id);
     const promptResponse = await fetch(`${origin}${path}`);
     const promptText = await promptResponse.text();
@@ -1007,9 +1008,7 @@ async function commandConsent(args) {
             "agent-id": { type: "string" },
         },
     });
-    const productUrl = values["product-url"];
-    if (!productUrl)
-        fail("--product-url is required");
+    const productUrl = resolveProductUrl(values["product-url"]);
     if (!values.offer)
         fail("--offer is required");
     if (!values.seat)
@@ -1045,9 +1044,7 @@ async function commandQueue(args) {
             play: { type: "boolean", default: false },
         },
     });
-    const productUrl = values["product-url"];
-    if (!productUrl)
-        fail("--product-url is required");
+    const productUrl = resolveProductUrl(values["product-url"]);
     if (!values["agent-id"])
         fail("--agent-id is required");
     const tour = values.tour;
@@ -1091,7 +1088,7 @@ async function commandQueue(args) {
        Labelled `agent_page`, never `watch`. It was `watch` for one release, and
        an agent reading that line handed its operator a profile under the word
        WATCH; `watch` is the table, printed below once there is one. */
-    console.log(`agent_page ${client.productUrl.replace(/\/$/, "")}/arena/agents/0x${values["agent-id"].replace(/^0x/i, "")}`);
+    console.log(`agent_page ${client.productUrl.replace(/\/$/, "")}/open/agents/0x${values["agent-id"].replace(/^0x/i, "")}`);
     let lastWaitingLine = "";
     const seated = await queueUntilSeated(client, tour, {
         minAgents,
@@ -1146,7 +1143,7 @@ async function commandQueue(args) {
             executionId: admitted.executionId,
         };
         const recordPath = writeRunRecord(values.key, runRecord);
-        console.log(`watch ${client.productUrl.replace(/\/$/, "")}/arena/matches/0x${admitted.executionId.replace(/^0x/i, "")}`);
+        console.log(`watch ${client.productUrl.replace(/\/$/, "")}/open/matches/0x${admitted.executionId.replace(/^0x/i, "")}`);
         console.log(`run_record ${recordPath}`);
         console.log(`reconnect ${reconnectCommand(values.key, runRecord)}`);
         takeSeatLock(values.key, values["agent-id"]);
@@ -1238,9 +1235,7 @@ async function commandRoom(args) {
             "timeout-ms": { type: "string", default: String(30 * 60_000) },
         },
     });
-    const productUrl = values["product-url"];
-    if (!productUrl)
-        fail("--product-url is required");
+    const productUrl = resolveProductUrl(values["product-url"]);
     if (!values["agent-id"])
         fail("--agent-id is required");
     const client = {
@@ -1279,7 +1274,7 @@ async function commandRoom(args) {
            that word is the match link on every door, and `room join` prints it
            once the room composes, so two different links under one label was a
            thing an agent had to be warned about. */
-        console.log(`room_page ${client.productUrl.replace(/\/$/, "")}/arena/tours/private-room/tables/${room.tableId}`);
+        console.log(`room_page ${client.productUrl.replace(/\/$/, "")}/open/tours/private-room/tables/${room.tableId}`);
         return;
     }
     const tableId = values["table-id"];
@@ -1328,7 +1323,7 @@ async function commandRoom(args) {
         executionId: admitted.executionId,
     };
     const recordPath = writeRunRecord(values.key, runRecord);
-    console.log(`watch ${client.productUrl.replace(/\/$/, "")}/arena/matches/0x${admitted.executionId.replace(/^0x/i, "")}`);
+    console.log(`watch ${client.productUrl.replace(/\/$/, "")}/open/matches/0x${admitted.executionId.replace(/^0x/i, "")}`);
     console.log(`run_record ${recordPath}`);
     console.log(`reconnect ${reconnectCommand(values.key, runRecord)}`);
     takeSeatLock(values.key, values["agent-id"]);
@@ -1395,9 +1390,7 @@ async function commandTournament(args) {
             "until-out": { type: "boolean", default: false },
         },
     });
-    const productUrl = values["product-url"];
-    if (!productUrl)
-        fail("--product-url is required");
+    const productUrl = resolveProductUrl(values["product-url"]);
     const agent = loadKeypair(values.key);
     const tournamentId = await tournamentArg(productUrl, values.tournament);
     const overview = await readTournament(productUrl, tournamentId);
@@ -1408,7 +1401,7 @@ async function commandTournament(args) {
        this agent holds now is on the owner's side of the book. */
     const playTakenBackNext = () => describeNext({
         action: "read",
-        route: `/open/v1/tournaments/${tournamentId}/owners/${owner ?? "{owner}"}`,
+        route: `/v1/tournaments/${tournamentId}/owners/${owner ?? "{owner}"}`,
     });
     const held = async () => owner ? await playsHeldBy(productUrl, tournamentId, owner, chip) : [];
     let plays = await held();
@@ -1471,8 +1464,16 @@ async function commandTournament(args) {
         return;
     }
     if (verb === "leave") {
-        if (entry?.state !== "queued")
-            fail(`this agent is ${entry?.state ?? "not in the book"}; only a queued agent can leave, and a seated one plays its table out`);
+        /* An agent that queued a moment ago is on chain and not yet in the book,
+           which is read a checkpoint behind it. Refusing on the first read told an
+           agent that had just been printed `queued waiting` that it was not in the
+           book at all, and the refusal's own `next` sent it to join again — which
+           would queue an agent that is already queued. So an absent entry is
+           waited out, briefly, before it is believed. */
+        const settled = entry ??
+            (await readAgentEntrySettled(productUrl, tournamentId, chip));
+        if (settled?.state !== "queued")
+            fail(`this agent is ${settled?.state ?? "not in the book"}; only a queued agent can leave, and a seated one plays its table out`);
         const executed = await sponsorAndExecute(client, leaveTransaction(overview, chip));
         console.log(`left ${executed.digest} ${executed.status}`);
         if (executed.status !== "success")
@@ -1634,7 +1635,7 @@ async function commandTournament(args) {
         console.log(`offer ${offerId}`);
         console.log(`seat ${seated.seat}`);
         if (seated.executionId)
-            console.log(`watch ${client.productUrl.replace(/\/$/, "")}/arena/matches/${seated.executionId}`);
+            console.log(`watch ${client.productUrl.replace(/\/$/, "")}/open/matches/${seated.executionId}`);
         if (!values.play)
             return;
         const seat = seated.seat;
@@ -1676,7 +1677,7 @@ async function commandTournament(args) {
 }
 /** `dopa-open claim-invite`: the link a wallet needs to claim this agent.
  *
- *  A claim is two consents. The wallet signs on the arena's page; you, holding
+ *  A claim is two consents. The wallet signs on Open's claim page; you, holding
  *  the agent's key, sign the invitation that lets it. Name the wallet with
  *  `--owner` to make the link good for that wallet alone; leave it out and the
  *  link is good for whoever opens it, for as long as `--hours` says. */
@@ -1692,9 +1693,7 @@ async function commandClaimInvite(args) {
             hours: { type: "string", default: "24" },
         },
     });
-    const productUrl = values["product-url"]?.replace(/\/$/, "");
-    if (!productUrl)
-        fail("--product-url is required");
+    const productUrl = resolveProductUrl(values["product-url"]).replace(/\/$/, "");
     if (!values["agent-id"])
         fail("--agent-id is required");
     const hours = Number(values.hours);
@@ -1712,7 +1711,7 @@ async function commandClaimInvite(args) {
        expects the old form. Both decode to the same 192 bytes. */
     const token = encodeClaimInvite(invite);
     const linkToken = encodeClaimInviteCompact(invite);
-    /* The arena's pages and its API share an origin on a deployment; a local
+    /* Open's pages and its API share an origin on a deployment; a local
        stack serves them apart, which is what --arena-url is for. */
     const arena = (values["arena-url"] ?? productUrl).replace(/\/$/, "");
     console.log(`invite ${token}`);
@@ -1724,7 +1723,7 @@ const USAGE = `usage: dopa-open <command>
 
   keygen    generate a keypair into .dopa-keypair (Sui suiprivkey format)
   address   print the owner address and public key of an existing key file
-  me        print the arena's record of this agent, signed for (agent/me)
+  me        print Open's record of this agent, signed for (agent/me)
   claim-invite
             mint the claim link a wallet needs to claim this agent
   register  self-allocate and register the agent with a product deployment

package/dist/identity.js

@@ -7,11 +7,13 @@
  * and this key can no longer sign for it -- which is the point of a claim.
  *
  * The payload mirrors `AgentIdentityEdit::canonical_payload` in
- * `backend/dopa-open/product/src/domain/custodial/key_rotation.rs`: every
- * field is length-framed, so "ab"/"c" and "a"/"bc" cannot sign the same
- * bytes. The product parses before it verifies -- it trims each field and
- * lower-cases the handle -- so this signs the parsed form, or the signature
- * is over bytes the store never holds. */
+ * `backend/dopa-open/product/src/domain/custodial/key_rotation.rs`: the two
+ * ids are fixed 32 bytes and every named field is length-framed, so "ab"/"c"
+ * and "a"/"bc" cannot sign the same bytes, and neither can a shorter agent id
+ * borrow a byte from the owner behind it. The product parses before it
+ * verifies -- it trims each field and lower-cases the handle -- so this signs
+ * the parsed form, or the signature is over bytes the store never holds. */
+import { ByteWriter, fromHex, textBytes } from "./bytes.js";
 import { signOwnerAuthenticator } from "./keypair.js";
 import { refusalMessageFromText } from "./refusal.js";
 const IDENTITY_DOMAIN = "dopa_open::agent_identity::v1";
@@ -25,40 +27,20 @@ export function parseIdentityFields(fields) {
         bio: fields.bio?.trim() || null,
     };
 }
-function u64be(value) {
-    const out = new Uint8Array(8);
-    new DataView(out.buffer).setBigUint64(0, BigInt(value));
-    return out;
-}
-function fromHex(value) {
-    const hex = value.replace(/^0x/i, "");
-    const out = new Uint8Array(hex.length / 2);
-    for (let index = 0; index < out.length; index++)
-        out[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
-    return out;
-}
 /** The exact bytes the owning address signs to name an agent. */
 export function canonicalIdentityPayload(edit) {
-    const encoder = new TextEncoder();
-    const domain = encoder.encode(IDENTITY_DOMAIN);
+    const domain = textBytes(IDENTITY_DOMAIN);
     const parsed = parseIdentityFields(edit.fields);
-    const parts = [parsed.name ?? "", parsed.handle ?? "", parsed.bio ?? ""].map((field) => encoder.encode(field));
-    const chunks = [
-        u64be(domain.length),
-        domain,
-        fromHex(edit.agentId),
-        fromHex(edit.owner),
-        ...parts.flatMap((field) => [u64be(field.length), field]),
-        u64be(edit.issuedAtMs),
-        u64be(edit.expiresAtMs),
-    ];
-    const out = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
+    const writer = new ByteWriter()
+        .pushU64(domain.length)
+        .pushBytes(domain)
+        .pushFixed(fromHex(edit.agentId), 32, "agent id")
+        .pushFixed(fromHex(edit.owner), 32, "owner");
+    for (const field of [parsed.name ?? "", parsed.handle ?? "", parsed.bio ?? ""]) {
+        const bytes = textBytes(field);
+        writer.pushU64(bytes.length).pushBytes(bytes);
     }
-    return out;
+    return writer.pushU64(edit.issuedAtMs).pushU64(edit.expiresAtMs).bytes();
 }
 /** Name an agent, as the address that owns it. Answers what the arena stored. */
 export async function nameAgent(args) {
@@ -73,8 +55,8 @@ export async function nameAgent(args) {
         issuedAtMs,
         expiresAtMs,
     }));
-    const agentId = `0x${args.agentId.replace(/^0x/i, "")}`;
-    const response = await fetchImpl(`${args.productUrl.replace(/\/$/, "")}/open/v1/agents/${agentId}/identity`, {
+    const agentId = `0x${args.agentId.replace(/^0x/, "")}`;
+    const response = await fetchImpl(`${args.productUrl.replace(/\/$/, "")}/v1/agents/${agentId}/identity`, {
         method: "PUT",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({

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.10",
   "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",