castle-web-sdk 0.4.46 → 0.4.48

package/dist/commands.d.ts

@@ -1,4 +1,4 @@
-import type { SaveClaimed, SaveClaimInput, SaveInitializeInput, SaveOpened, SaveOperation, SaveReadTarget, SaveReceipt, SaveSnapshot, SaveTransactionInput } from "./save";
+import type { SaveClaimed, SaveConditionalWriteInput, SaveClaimInput, SaveInitializeInput, SaveOpened, SaveOperation, SaveReadTarget, SaveRecentOperationsInput, SaveRecentOperationsPage, SaveReceipt, SaveSnapshot, SaveTransactionInput } from "./save";
 import type { Json } from "./types";
 export declare const CASTLE_SDK_PROTOCOL = 1;
 export type StorageBlob = Record<string, string>;
@@ -84,6 +84,41 @@ export type PortalInfoResult = {
 export interface PortalPrefetchResult {
     status: PortalPrefetchStatus;
 }
+/** One mutual Castle friend visible to a Cauldron deck. */
+export interface SocialFriend {
+    userId: string;
+    username: string;
+    photoUrl?: string;
+}
+export interface SocialPresence extends SocialFriend {
+    sessionId: string;
+    routeId?: string;
+    slot?: string;
+    updatedAt: string;
+}
+export type PartyStatus = "invited" | "joined" | "rejected" | "left" | "party_closed" | "banned";
+export interface PartySummary {
+    partyId: string;
+    name: string;
+    status: PartyStatus;
+    hasUnreadMessages: boolean;
+}
+export interface PartyMember extends SocialFriend {
+    status: PartyStatus;
+    role: "member" | "host" | "owner";
+}
+export interface PartyMessage {
+    id: string;
+    fromUserId: string;
+    fromUsername: string | null;
+    body: Json;
+    text: string | null;
+    createdAt: string;
+}
+export interface PartyMessagesResult {
+    messages: PartyMessage[];
+    cursor: string | null;
+}
 export interface HubGoParams {
     doorId: string;
 }
@@ -151,6 +186,15 @@ export interface HubReportParams {
 export interface HubReportResult {
     status: "ok" | "unavailable";
 }
+/** Why the hub is asking the player to replace an anonymous account. */
+export interface HubSignInParams {
+    reason: string;
+}
+/** The outcome of the host-owned sign-in flow. */
+export interface HubSignInResult {
+    status: "signedIn" | "dismissed" | "unavailable";
+    userId?: string;
+}
 export type HubFriendsResult = {
     status: "ok";
     friends: HubFriend[];
@@ -158,6 +202,34 @@ export type HubFriendsResult = {
     status: "unavailable";
     friends: null;
 };
+export interface HubInviteResult {
+    status: "ok" | "unavailable";
+    url?: string;
+    expiresAt?: string;
+}
+export interface HubInviteArrivalResult {
+    status: "ok" | "unavailable" | "route";
+    doorId?: string;
+    destination?: {
+        hub: {
+            version: 1;
+            townDeckId: string;
+            target: {
+                kind: "player";
+                id: string;
+            };
+        };
+    };
+    friends?: Array<{
+        userId: string;
+        username: string;
+    }>;
+}
+/** Account-wide hub door hearts, in oldest-first order (at most eight). */
+export interface HubHeartsResult {
+    status: "ok" | "unavailable";
+    hearts: string[];
+}
 /** Hub.chat: only the messages after a cursor an earlier answer returned. */
 export interface HubChatParams {
     after?: string;
@@ -508,6 +580,7 @@ export interface CommandParams {
     "avatar.get": Record<string, never>;
     "avatar.set": {
         avatar: number;
+        color?: number;
     };
     "pass.offer": {
         passId: string;
@@ -526,10 +599,50 @@ export interface CommandParams {
     "portal.info": {
         targetDeckId: string;
     };
+    "social.friends": Record<string, never>;
+    "social.presence": Record<string, never>;
+    "party.current": Record<string, never>;
+    "party.create": {
+        userIds: string[];
+    };
+    "party.invite": {
+        partyId: string;
+        userIds: string[];
+    };
+    "party.respond": {
+        partyId: string;
+        accept: boolean;
+    };
+    "party.members": {
+        partyId: string;
+    };
+    "party.leave": {
+        partyId: string;
+    };
+    "party.messages": {
+        partyId: string;
+        cursor?: string;
+    };
+    "party.say": {
+        partyId: string;
+        text: string;
+    };
     "hub.go": HubGoParams;
     "hub.back": Record<string, never>;
     "hub.doors": Record<string, never>;
     "hub.friends": Record<string, never>;
+    "hub.invite": {
+        crew?: boolean;
+    };
+    "hub.inviteArrival": Record<string, never>;
+    "hub.undoInvite": {
+        userId: string;
+    };
+    "hub.hearts": Record<string, never>;
+    "hub.setHearts": {
+        doorIds: string[];
+    };
+    "hub.signIn": HubSignInParams;
     "hub.jump": HubJumpParams;
     "hub.report": HubReportParams;
     "hub.chat": HubChatParams;
@@ -591,6 +704,8 @@ export interface CommandParams {
     "cauldronStorage.transaction": SaveTransactionInput;
     "cauldronStorage.claim": SaveClaimInput;
     "cauldronStorage.initialize": SaveInitializeInput;
+    "cauldronStorage.conditionalWrite": SaveConditionalWriteInput;
+    "cauldronStorage.recentOperations": SaveRecentOperationsInput;
     "cauldronStorage.operation": {
         operationId: string;
     };
@@ -696,10 +811,32 @@ export interface CommandResult {
     "portal.open": PortalOpenResult;
     "portal.prefetch": PortalPrefetchResult;
     "portal.info": PortalInfoResult;
+    "social.friends": SocialFriend[];
+    "social.presence": SocialPresence[];
+    "party.current": PartySummary | null;
+    "party.create": PartySummary;
+    "party.invite": {
+        ok: true;
+    };
+    "party.respond": {
+        ok: true;
+    };
+    "party.members": PartyMember[];
+    "party.leave": {
+        ok: true;
+    };
+    "party.messages": PartyMessagesResult;
+    "party.say": PartyMessage;
     "hub.go": HubGoResult;
     "hub.back": HubBackResult;
     "hub.doors": HubDoorsResult;
     "hub.friends": HubFriendsResult;
+    "hub.invite": HubInviteResult;
+    "hub.inviteArrival": HubInviteArrivalResult;
+    "hub.undoInvite": HubReportResult;
+    "hub.hearts": HubHeartsResult;
+    "hub.setHearts": HubHeartsResult;
+    "hub.signIn": HubSignInResult;
     "hub.jump": HubJumpResult;
     "hub.report": HubReportResult;
     "hub.chat": HubChatResult;
@@ -735,6 +872,8 @@ export interface CommandResult {
     "cauldronStorage.transaction": SaveReceipt;
     "cauldronStorage.claim": SaveClaimed;
     "cauldronStorage.initialize": SaveOpened;
+    "cauldronStorage.conditionalWrite": SaveReceipt;
+    "cauldronStorage.recentOperations": SaveRecentOperationsPage;
     "cauldronStorage.operation": SaveOperation;
     "cauldronStorage.get": {
         entries: StoreEntry[];
@@ -775,6 +914,8 @@ export interface UserPayload {
     color: string | null;
 }
 export interface AvatarResult {
+    /** Absent from a host before avatar colours. */
+    color?: number;
     status: "ok" | "unavailable";
     avatar: number | null;
     /** False while the player wears the default ghost gives every account. */

package/dist/commands.js

@@ -29,6 +29,9 @@ export const COMMAND_TIMEOUTS_MS = {
     "hub.go": 30_000,
     "hub.back": 30_000,
     "hub.jump": 30_000,
+    // Native auth may include a provider handoff, but it must not leave a deck
+    // waiting forever if the host loses the completion callback.
+    "hub.signIn": 120_000,
 };
 // Once a host streams a command, each stream envelope restarts the wait at this
 // length instead. The deck-agent service sends a heartbeat every 15 seconds, and the host

package/dist/display.d.ts

@@ -1,6 +1,9 @@
 export type DeckLayout = "card" | "fill";
+export type DeckOrientation = "landscape" | "portrait" | "any";
 export interface DeckDisplay {
     layout: DeckLayout;
+    /** The orientation the deck prefers the host to use. */
+    orientation?: DeckOrientation;
     /** Narrowest width / height the deck accepts. */
     minAspect: number;
     /** Widest width / height the deck accepts. */

package/dist/display.js

@@ -5,6 +5,7 @@
 //
 //   <meta name="castle-display" content="layout=fill">
 //   <meta name="castle-display" content="layout=fill, min-aspect=9/16, max-aspect=16/9">
+//   <meta name="castle-display" content="layout=fill, orientation=landscape">
 //
 // With no tag the deck is a `card`: the classic 5:7 portrait card, exactly as
 // before. A `fill` deck takes whatever box the host gives it, as long as the
@@ -42,13 +43,18 @@ export function parseDisplayContent(content) {
             continue;
         fields[part.slice(0, eq).trim().toLowerCase()] = part.slice(eq + 1).trim();
     }
-    if (fields.layout?.toLowerCase() !== "fill")
-        return CARD_DISPLAY;
+    const declaredOrientation = fields.orientation?.toLowerCase();
+    const orientation = declaredOrientation === "landscape" || declaredOrientation === "portrait"
+        ? declaredOrientation
+        : "any";
+    if (fields.layout?.toLowerCase() !== "fill") {
+        return orientation === "any" ? CARD_DISPLAY : { ...CARD_DISPLAY, orientation };
+    }
     let minAspect = parseAspect(fields["min-aspect"] ?? "") ?? FILL_MIN_ASPECT;
     let maxAspect = parseAspect(fields["max-aspect"] ?? "") ?? FILL_MAX_ASPECT;
     if (minAspect > maxAspect)
         [minAspect, maxAspect] = [maxAspect, minAspect];
-    return { layout: "fill", minAspect, maxAspect };
+    return { layout: "fill", orientation, minAspect, maxAspect };
 }
 let cached = null;
 /** The display this deck declared in its index.html (a card when it declared none). */

package/dist/hub.d.ts

@@ -1,5 +1,5 @@
-import type { HubBackResult, HubCancelResult, HubChatResult, HubDoorsResult, HubFriendsResult, HubGoResult, HubJumpResult, HubReportResult, HubSayResult } from "./commands";
-export type { HubBackResult, HubCancelResult, HubCancelStatus, HubChatMessage, HubChatResult, HubDoor, HubDoorsResult, HubFriend, HubFriendsResult, HubGoParams, HubGoResult, HubHandoffResult, HubHandoffStatus, HubJumpResult, HubPlacementKind, HubReportResult, HubSayResult, } from "./commands";
+import type { HubBackResult, HubCancelResult, HubChatResult, HubDoorsResult, HubFriendsResult, HubInviteResult, HubInviteArrivalResult, HubHeartsResult, HubGoResult, HubJumpResult, HubReportResult, HubSayResult, HubSignInResult } from "./commands";
+export type { HubBackResult, HubCancelResult, HubCancelStatus, HubChatMessage, HubChatResult, HubDoor, HubDoorsResult, HubFriend, HubFriendsResult, HubInviteResult, HubInviteArrivalResult, HubHeartsResult, HubGoParams, HubGoResult, HubHandoffResult, HubHandoffStatus, HubJumpResult, HubPlacementKind, HubReportResult, HubSayResult, HubSignInParams, HubSignInResult, } from "./commands";
 /**
  * Doors between hub places. Every hub-kit deck is a place; ghost's door table
  * is the allowlist, and the host supplies real authentication and the current
@@ -35,6 +35,22 @@ export interface CastleHubApi {
      * on hosts without hub support.
      */
     friends(): Promise<HubFriendsResult>;
+    /** Create an expiring link from this hub session. Crew links admit up to five invitees. */
+    invite(options?: {
+        crew?: boolean;
+    }): Promise<HubInviteResult>;
+    /** Hub-kit arrival hook: the trusted host retains the invite token. */
+    inviteArrival(): Promise<HubInviteArrivalResult>;
+    /** Undo both follow directions for one pair from this host's invite arrival. */
+    undoInvite(userId: string): Promise<HubReportResult>;
+    /** Read this signed-in account's hub door hearts. */
+    hearts(): Promise<HubHeartsResult>;
+    /** Replace the hearts, oldest first, at most eight distinct door ids. */
+    setHearts(doorIds: string[]): Promise<HubHeartsResult>;
+    /** Ask the host to let an anonymous player sign in to a permanent account. */
+    signIn(options: {
+        reason: string;
+    }): Promise<HubSignInResult>;
     /**
      * Acquire the layer of this place a friend is in. The destination is this
      * same place in another session; join it exactly like a door's

package/dist/hub.js

@@ -5,6 +5,12 @@ export const Hub = {
     back,
     doors,
     friends,
+    invite,
+    inviteArrival,
+    undoInvite,
+    hearts,
+    setHearts,
+    signIn,
     jump,
     report,
     chat,
@@ -32,6 +38,47 @@ async function doors() {
 async function friends() {
     return hostRequest("hub.friends", {});
 }
+async function invite(options = {}) {
+    if (options.crew !== undefined && typeof options.crew !== "boolean")
+        throw new CastleError({ code: "INVALID_ARGUMENT", message: "Hub.invite crew must be a boolean.", operation: "Hub.invite" });
+    return hostRequest("hub.invite", options.crew === true ? { crew: true } : {});
+}
+async function inviteArrival() {
+    return hostRequest("hub.inviteArrival", {});
+}
+async function undoInvite(userId) {
+    if (!/^[1-9]\d{0,9}$/.test(userId))
+        throw new CastleError({ code: "INVALID_ARGUMENT", message: "Hub.undoInvite requires a userId.", operation: "Hub.undoInvite" });
+    return hostRequest("hub.undoInvite", { userId });
+}
+async function hearts() {
+    return hostRequest("hub.hearts", {});
+}
+async function setHearts(doorIds) {
+    if (!Array.isArray(doorIds) || doorIds.length > 8 ||
+        doorIds.some((id) => typeof id !== "string" || !id.length || id.length > 64) ||
+        new Set(doorIds).size !== doorIds.length) {
+        throw new CastleError({ code: "INVALID_ARGUMENT", message: "Hub.setHearts requires at most eight distinct door ids.", operation: "Hub.setHearts" });
+    }
+    return hostRequest("hub.setHearts", { doorIds });
+}
+const SIGN_IN_REASON_MAX_CHARACTERS = 200;
+const SIGN_IN_REASON_MAX_BYTES = 512;
+async function signIn(options) {
+    const reason = options?.reason;
+    if (typeof reason !== "string" ||
+        reason.length === 0 ||
+        reason.length > SIGN_IN_REASON_MAX_CHARACTERS ||
+        reason.includes("\0") ||
+        new TextEncoder().encode(reason).byteLength > SIGN_IN_REASON_MAX_BYTES) {
+        throw new CastleError({
+            code: "INVALID_ARGUMENT",
+            message: `Hub.signIn requires reason of at most ${SIGN_IN_REASON_MAX_CHARACTERS} characters and ${SIGN_IN_REASON_MAX_BYTES} bytes.`,
+            operation: "Hub.signIn",
+        });
+    }
+    return hostRequest("hub.signIn", { reason });
+}
 async function jump(userId) {
     if (typeof userId !== "string" || userId.length === 0) {
         throw new CastleError({

package/dist/multiplayer.d.ts

@@ -4,7 +4,7 @@ import type { Json } from "./types";
 import { type MultiplayerPlayer, type MultiplayerCharacterDisclosure, type MultiplayerCharacterTurnStatus } from "./multiplayerProtocol";
 import { type MultiplayerVoice } from "./multiplayerVoice";
 export type { MultiplayerJoinHint } from "./commands";
-export type MultiplayerJoinOptions = {
+export type MultiplayerJoinOptions = ({
     mode: "named";
     key: string;
 } | {
@@ -14,6 +14,9 @@ export type MultiplayerJoinOptions = {
 } | {
     mode: "hub";
     handoff: HubHandoffResult;
+}) & {
+    /** Experimental opt-in: reconnect if a keepalive ping receives no pong. */
+    pongTimeoutMs?: number;
 };
 export interface MultiplayerDestinationOptions {
     routeId: string;
@@ -184,6 +187,9 @@ export interface MultiplayerConnection {
     readonly state: MultiplayerConnectionState;
     readonly playerId: string;
     readonly sessionId: string;
+    /** Current host publication diagnostics; null when unavailable or not connected. */
+    readonly serverBundleSha256: string | null;
+    readonly serverBundleId: string | null;
     readonly isSolo: boolean;
     /**
      * Why the join fell back to solo; null while multiplayer is live.

package/dist/multiplayer.js

@@ -7,6 +7,13 @@ const HELLO_TIMEOUT_MS = 10_000;
 const RECONNECT_BUDGET_MS = 30_000;
 const RECONNECT_DELAYS_MS = [500, 1_000, 2_000, 4_000, 8_000];
 const INVALID_DEV_RECONNECT_CLOSE_CODE = 4003;
+// The play proxy closes a handshake it refuses with a reason (cauldron-game-server
+// shared/src/constants.ts). The host that owns the session rejecting the credential is
+// final. "Session ended" is ghost's routing verdict, which a host drain or a ghost
+// error can also produce, so it takes two in a row before the session is given up on.
+const PROXY_CREDENTIAL_REJECTED_CLOSE_CODE = 4401;
+const PROXY_SESSION_ENDED_CLOSE_CODE = 4404;
+const SESSION_ENDED_CONFIRMATIONS = 2;
 // The host may spend the full 15-second grant window waiting for author admission,
 // then up to 10 seconds on the fenced control-plane request. Keep the client above
 // that complete lifecycle so it cannot discard a valid durable receipt.
@@ -39,13 +46,17 @@ async function join(options) {
     const request = hub
         ? { command: "hub", nonce: hub.nonce }
         : { command: "multiplayer.getSession", params: joinParams(options) };
+    const pongTimeoutMs = options.pongTimeoutMs ?? 0;
+    if (!Number.isFinite(pongTimeoutMs) || pongTimeoutMs < 0 || pongTimeoutMs > 2_147_483_647) {
+        throw new RangeError("pongTimeoutMs must be between 0 and 2147483647 milliseconds");
+    }
     latestJoinAttempt += 1;
     cancelPendingDestinationJoin();
     activeConnection?.leave();
     const connection = new MultiplayerConnectionImpl(request, () => {
         if (activeConnection === connection)
             activeConnection = null;
-    });
+    }, null, pongTimeoutMs);
     activeConnection = connection;
     await connection.start(hub ?? undefined);
     // The host moves its place (and every place-scoped command with it) when the
@@ -176,9 +187,12 @@ class MultiplayerConnectionImpl {
     request;
     onClosed;
     destinationAudience;
+    pongTimeoutMs;
     currentState = "acquiring";
     currentPlayerId = "";
     currentSessionId = "";
+    currentServerBundleSha256 = null;
+    currentServerBundleId = null;
     solo = false;
     currentSoloReason = null;
     baseUrl = "";
@@ -187,6 +201,8 @@ class MultiplayerConnectionImpl {
     socket = null;
     socketAttempt = 0;
     keepalive = null;
+    pongExtensionUsed = false;
+    pongDeadline = null;
     reAcquisitionUsed = false;
     recovering = false;
     hubSettled = false;
@@ -212,10 +228,11 @@ class MultiplayerConnectionImpl {
         players: () => this.roster?.players ?? [],
         isSolo: () => this.solo,
     });
-    constructor(request, onClosed, destinationAudience = null) {
+    constructor(request, onClosed, destinationAudience = null, pongTimeoutMs = 0) {
         this.request = request;
         this.onClosed = onClosed;
         this.destinationAudience = destinationAudience;
+        this.pongTimeoutMs = pongTimeoutMs;
     }
     get state() {
         return this.currentState;
@@ -226,6 +243,12 @@ class MultiplayerConnectionImpl {
     get sessionId() {
         return this.currentSessionId;
     }
+    get serverBundleSha256() {
+        return this.currentState === "connected" && !this.solo ? this.currentServerBundleSha256 : null;
+    }
+    get serverBundleId() {
+        return this.currentState === "connected" && !this.solo ? this.currentServerBundleId : null;
+    }
     get isSolo() {
         return this.solo;
     }
@@ -546,6 +569,10 @@ class MultiplayerConnectionImpl {
     acceptHello(frame) {
         this.currentPlayerId = frame.playerId;
         this.currentSessionId = frame.sessionId;
+        // Diagnostics never decide whether a hello is accepted. Missing or malformed
+        // metadata clears the previous host's identity on every reconnect.
+        this.currentServerBundleSha256 = typeof frame.serverBundleSha256 === "string" && /^[0-9a-f]{64}$/.test(frame.serverBundleSha256) ? frame.serverBundleSha256 : null;
+        this.currentServerBundleId = typeof frame.serverBundleId === "string" && /^[A-Za-z0-9_-]{10}$/.test(frame.serverBundleId) ? frame.serverBundleId : null;
         this.reconnectToken = frame.reconnectToken;
         this.sharedCharactersSupported = frame.capabilities?.sharedCharactersV1 === true;
         if (this.devReconnectStorageKey)
@@ -580,6 +607,8 @@ class MultiplayerConnectionImpl {
                 this.acceptHello(frame);
                 break;
             case "pong":
+                this.pongExtensionUsed = false;
+                this.clearPongDeadline();
                 break;
         }
     }
@@ -623,6 +652,7 @@ class MultiplayerConnectionImpl {
     async recover() {
         const startedAt = Date.now();
         let attempt = 0;
+        let sessionEndedCloses = 0;
         while (Date.now() - startedAt < RECONNECT_BUDGET_MS) {
             const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
             attempt += 1;
@@ -633,7 +663,15 @@ class MultiplayerConnectionImpl {
                 return;
             }
             catch (error) {
-                if (error instanceof SocketClosedError && error.code === 1008)
+                const code = error instanceof SocketClosedError ? error.code : null;
+                if (code === 1008 || code === PROXY_CREDENTIAL_REJECTED_CLOSE_CODE)
+                    break;
+                // Retrying a session that is gone only spends the budget; ask for a fresh join.
+                // Any other failure in between means the two refusals were not in a row.
+                sessionEndedCloses = code === PROXY_SESSION_ENDED_CLOSE_CODE
+                    ? sessionEndedCloses + 1
+                    : 0;
+                if (sessionEndedCloses >= SESSION_ENDED_CONFIRMATIONS)
                     break;
             }
         }
@@ -660,10 +698,14 @@ class MultiplayerConnectionImpl {
     }
     startKeepalive() {
         this.stopKeepalive();
+        this.pongExtensionUsed = false;
         this.keepalive = setInterval(() => {
             if (this.socket?.readyState === WebSocket.OPEN) {
+                if (this.pongDeadline !== null)
+                    return;
                 try {
                     this.socket.send('{"t":"ping"}');
+                    this.expectPong(this.socket);
                 }
                 catch {
                     closeSocket(this.socket, 1000, "keepalive failed");
@@ -672,11 +714,46 @@ class MultiplayerConnectionImpl {
         }, KEEPALIVE_INTERVAL_MS);
     }
     stopKeepalive() {
+        this.clearPongDeadline();
         if (this.keepalive === null)
             return;
         clearInterval(this.keepalive);
         this.keepalive = null;
     }
+    clearPongDeadline() {
+        if (this.pongDeadline === null)
+            return;
+        clearTimeout(this.pongDeadline);
+        this.pongDeadline = null;
+    }
+    expectPong(socket) {
+        if (!this.pongTimeoutMs)
+            return;
+        const due = Date.now() + this.pongTimeoutMs;
+        this.pongDeadline = setTimeout(() => {
+            this.pongDeadline = null;
+            if (this.socket !== socket || this.currentState !== "connected")
+                return;
+            // A suspended page can run an overdue timer before queued socket events.
+            // Verify liveness with a fresh ping instead of condemning that socket.
+            if (!this.pongExtensionUsed && Date.now() - due > 1_000 && socket.readyState === WebSocket.OPEN) {
+                this.pongExtensionUsed = true;
+                try {
+                    socket.send('{"t":"ping"}');
+                    this.expectPong(socket);
+                    return;
+                }
+                catch { /* Fall through to recovery if the fresh probe cannot send. */ }
+            }
+            // A half-open transport may never emit close. Fence its queued callbacks
+            // and enter recovery directly rather than waiting for that close event.
+            this.socketAttempt += 1;
+            this.socket = null;
+            this.stopKeepalive();
+            closeSocket(socket, 1000, "pong timeout");
+            this.beginRecovery();
+        }, this.pongTimeoutMs);
+    }
     transition(state, metadata) {
         if (this.currentState === "closed" || this.currentState === state)
             return;

package/dist/multiplayerProtocol.d.ts

@@ -14,6 +14,8 @@ export interface SessionPlayer extends PlayerIdentity {
     playerId: string;
 }
 export interface ClientHelloFrame {
+    serverBundleSha256?: string;
+    serverBundleId?: string;
     t: "hello";
     playerId: string;
     reconnectToken: string;

package/dist/party.d.ts

@@ -0,0 +1,23 @@
+import type { PartyMember, PartyMessage, PartyMessagesResult, PartySummary } from './commands';
+export type { PartyMember, PartyMessage, PartyMessagesResult, PartyStatus, PartySummary, } from './commands';
+export interface CastlePartyApi {
+    /** The party this play was launched with, or null when it has none. */
+    current(): Promise<PartySummary | null>;
+    /** Create a party containing these users and the signed-in player. */
+    create(userIds: string[]): Promise<PartySummary>;
+    invite(partyId: string, userIds: string[]): Promise<{
+        ok: true;
+    }>;
+    respond(partyId: string, accept: boolean): Promise<{
+        ok: true;
+    }>;
+    members(partyId: string): Promise<PartyMember[]>;
+    leave(partyId: string): Promise<{
+        ok: true;
+    }>;
+    /** Newest first. Pass `cursor` to load older history. */
+    messages(partyId: string, cursor?: string): Promise<PartyMessagesResult>;
+    /** Send plain text; the host trims it to Castle's 1,000-character limit. */
+    say(partyId: string, text: string): Promise<PartyMessage>;
+}
+export declare const Party: CastlePartyApi;