castle-web-sdk 0.4.36 → 0.4.38

package/dist/multiplayer.js

@@ -7,12 +7,24 @@ 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 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.
+const CHARACTER_ADMISSION_TIMEOUT_MS = 30_000;
+const WORLD_CHARACTER_OPERATION_ID_MAX_CHARACTERS = 120;
+const WORLD_CHARACTER_ID_MAX_CHARACTERS = 100;
+const WORLD_CHARACTER_INPUT_MAX_CHARACTERS = 2000;
+let nextCharacterStatusRequestId = 1;
 let activeConnection = null;
-export const Multiplayer = { join };
+let latestJoinAttempt = 0;
+let pendingDestinationJoin = null;
+export const Multiplayer = { join, joinDestination };
 async function join(options) {
     const params = joinParams(options);
+    latestJoinAttempt += 1;
+    cancelPendingDestinationJoin();
     activeConnection?.leave();
-    const connection = new MultiplayerConnectionImpl(params, () => {
+    const connection = new MultiplayerConnectionImpl({ command: "multiplayer.getSession", params }, () => {
         if (activeConnection === connection)
             activeConnection = null;
     });
@@ -20,9 +32,80 @@ async function join(options) {
     await connection.start();
     return connection;
 }
+async function joinDestination(options) {
+    const params = destinationParams(options);
+    const attempt = ++latestJoinAttempt;
+    cancelPendingDestinationJoin();
+    if (activeConnection?.matchesDestination(params)) {
+        return {
+            status: "joined",
+            connection: activeConnection,
+            audience: activeConnection.destinationAudience,
+        };
+    }
+    const previousConnection = activeConnection;
+    const controller = new AbortController();
+    const pending = { controller, connection: null };
+    pendingDestinationJoin = pending;
+    let acquired;
+    try {
+        acquired = await hostRequest("multiplayer.joinDestination", params, {
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        if (pendingDestinationJoin === pending)
+            pendingDestinationJoin = null;
+        if (attempt !== latestJoinAttempt || controller.signal.aborted) {
+            return { status: "cancelled" };
+        }
+        const status = destinationStatusFromError(error);
+        if (status)
+            return { status };
+        throw error;
+    }
+    if (attempt !== latestJoinAttempt)
+        return { status: "cancelled" };
+    if (acquired.status !== "ok") {
+        if (pendingDestinationJoin === pending)
+            pendingDestinationJoin = null;
+        return { status: acquired.status };
+    }
+    if (!acquired.url || !acquired.nonce || !acquired.audience) {
+        if (pendingDestinationJoin === pending)
+            pendingDestinationJoin = null;
+        return { status: "unavailable" };
+    }
+    const connection = new MultiplayerConnectionImpl({ command: "multiplayer.joinDestination", params }, () => {
+        if (activeConnection === connection)
+            activeConnection = null;
+    }, acquired.audience);
+    pending.connection = connection;
+    try {
+        await connection.start(acquired);
+    }
+    catch (error) {
+        if (pendingDestinationJoin === pending)
+            pendingDestinationJoin = null;
+        if (attempt !== latestJoinAttempt || controller.signal.aborted) {
+            return { status: "cancelled" };
+        }
+        throw error;
+    }
+    if (pendingDestinationJoin === pending)
+        pendingDestinationJoin = null;
+    if (attempt !== latestJoinAttempt) {
+        connection.leave();
+        return { status: "cancelled" };
+    }
+    previousConnection?.leave();
+    activeConnection = connection;
+    return { status: "joined", connection, audience: acquired.audience };
+}
 class MultiplayerConnectionImpl {
-    params;
+    request;
     onClosed;
+    destinationAudience;
     currentState = "acquiring";
     currentPlayerId = "";
     currentSessionId = "";
@@ -37,6 +120,8 @@ class MultiplayerConnectionImpl {
     reAcquisitionUsed = false;
     recovering = false;
     roster = null;
+    sharedCharactersSupported = false;
+    pendingCharacterRequests = new Map();
     messages = new Set();
     rosters = new Set();
     states = new Set();
@@ -45,9 +130,10 @@ class MultiplayerConnectionImpl {
         players: () => this.roster?.players ?? [],
         isSolo: () => this.solo,
     });
-    constructor(params, onClosed) {
-        this.params = params;
+    constructor(request, onClosed, destinationAudience = null) {
+        this.request = request;
         this.onClosed = onClosed;
+        this.destinationAudience = destinationAudience;
     }
     get state() {
         return this.currentState;
@@ -67,9 +153,9 @@ class MultiplayerConnectionImpl {
     get voice() {
         return this.voiceImpl;
     }
-    async start() {
+    async start(initial) {
         try {
-            await this.acquire();
+            await this.acquire(initial);
         }
         catch (error) {
             const castleError = asCastleError(error);
@@ -97,6 +183,60 @@ class MultiplayerConnectionImpl {
             return;
         this.socket.send(payload);
     }
+    requestCharacterTurn(request) {
+        const normalized = normalizeCharacterTurnRequest(request, this.currentPlayerId);
+        return this.sendCharacterRequest(normalized.requestId, normalized.operationId, "admission", JSON.stringify({ t: "worldCharacterTurn", ...normalized }));
+    }
+    getCharacterTurnStatus(operationId) {
+        const normalizedOperationId = boundedCharacterText(operationId, 128, "operationId", WORLD_CHARACTER_OPERATION_ID_MAX_CHARACTERS);
+        const requestId = `status-${Date.now().toString(36)}-${nextCharacterStatusRequestId++}`;
+        return this.sendCharacterRequest(requestId, normalizedOperationId, "status", JSON.stringify({
+            t: "worldCharacterStatus",
+            requestId,
+            operationId: normalizedOperationId,
+        }));
+    }
+    requestCharacterCommand(request) {
+        const normalized = normalizeWorldCharacterCommandRequest(request);
+        return this.sendCharacterRequest(normalized.requestId, normalized.operationId, "command", JSON.stringify({ t: "worldCharacterCommand", ...normalized }));
+    }
+    readCharacters(request) {
+        const normalized = normalizeWorldCharacterReadRequest(request);
+        return this.sendCharacterRequest(normalized.requestId, "", "read", JSON.stringify({ t: "worldCharacterRead", ...normalized }));
+    }
+    sendCharacterRequest(requestId, operationId, kind, frame) {
+        this.assertOpen();
+        if (!this.sharedCharactersSupported) {
+            return Promise.reject(characterError("CAULDRON_CHARACTER_UNAVAILABLE", "This multiplayer session does not support shared characters."));
+        }
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            return Promise.reject(characterError("MULTIPLAYER_NOT_CONNECTED", "Shared character requests require a connected session."));
+        }
+        if (this.pendingCharacterRequests.has(requestId)) {
+            return Promise.reject(characterError("CAULDRON_CHARACTER_CONFLICT", "A shared character request with this requestId is already pending."));
+        }
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingCharacterRequests.delete(requestId);
+                reject(characterError("CAULDRON_CHARACTER_TIMEOUT", "Shared character admission timed out. Retry with the same operationId."));
+            }, CHARACTER_ADMISSION_TIMEOUT_MS);
+            this.pendingCharacterRequests.set(requestId, {
+                operationId,
+                kind,
+                resolve: (value) => resolve(value),
+                reject,
+                timer,
+            });
+            try {
+                this.socket.send(frame);
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pendingCharacterRequests.delete(requestId);
+                reject(asCastleError(error));
+            }
+        });
+    }
     onMessage(callback) {
         this.messages.add(callback);
         return () => this.messages.delete(callback);
@@ -117,9 +257,16 @@ class MultiplayerConnectionImpl {
             return;
         this.finish({ type: "left" });
     }
-    async acquire() {
+    matchesDestination(params) {
+        return (this.currentState !== "closed" &&
+            this.request.command === "multiplayer.joinDestination" &&
+            this.request.params.routeId === params.routeId &&
+            this.request.params.slot === params.slot &&
+            this.destinationAudience !== null);
+    }
+    async acquire(initial) {
         this.transition("acquiring");
-        const result = await hostRequest("multiplayer.getSession", this.params);
+        const result = initial ?? await requestAcquisition(this.request);
         this.assertOpen();
         if (result.status === "solo") {
             this.connectSolo(result);
@@ -131,8 +278,11 @@ class MultiplayerConnectionImpl {
         this.solo = false;
         this.currentSoloReason = null;
         this.baseUrl = result.url;
-        this.devReconnectStorageKey = result.devReconnectScope
-            ? `castle-dev-mp-reconnect:${result.url}:${result.sessionId}:${result.devReconnectScope}`
+        const devReconnectScope = "devReconnectScope" in result
+            ? result.devReconnectScope
+            : undefined;
+        this.devReconnectStorageKey = devReconnectScope
+            ? `castle-dev-mp-reconnect:${result.url}:${result.sessionId}:${devReconnectScope}`
             : null;
         this.transition("connecting");
         const savedToken = this.devReconnectStorageKey
@@ -255,6 +405,7 @@ class MultiplayerConnectionImpl {
         this.currentPlayerId = frame.playerId;
         this.currentSessionId = frame.sessionId;
         this.reconnectToken = frame.reconnectToken;
+        this.sharedCharactersSupported = frame.capabilities?.sharedCharactersV1 === true;
         if (this.devReconnectStorageKey)
             writeDevReconnectToken(this.devReconnectStorageKey, frame.reconnectToken);
         // Re-acquisition is limited to one per outage, not one per session. A phone
@@ -274,6 +425,9 @@ class MultiplayerConnectionImpl {
                 for (const callback of this.messages)
                     callListener(callback, frame.d);
                 break;
+            case "worldCharacterResult":
+                this.acceptWorldCharacterResult(frame);
+                break;
             case "replaced":
                 this.finish({ type: "replaced" });
                 break;
@@ -312,6 +466,7 @@ class MultiplayerConnectionImpl {
         if (this.recovering || this.currentState === "closed")
             return;
         this.recovering = true;
+        this.rejectPendingCharacterRequests("MULTIPLAYER_CONNECTION_LOST", "The connection was lost before shared character admission completed.");
         this.transition("reconnecting", { type: "connectionLost" });
         void this.recover()
             .catch((error) => {
@@ -398,6 +553,7 @@ class MultiplayerConnectionImpl {
             (metadata.type === "left" || metadata.type === "bye" || metadata.type === "replaced"))
             clearDevReconnectToken(this.devReconnectStorageKey, this.reconnectToken);
         this.stopKeepalive();
+        this.rejectPendingCharacterRequests("MULTIPLAYER_CONNECTION_CLOSED", "The multiplayer connection closed before the shared character request completed.");
         const socket = this.socket;
         this.socket = null;
         this.socketAttempt += 1;
@@ -413,6 +569,68 @@ class MultiplayerConnectionImpl {
             throw multiplayerError("MULTIPLAYER_CONNECTION_CLOSED", "The multiplayer connection is closed.");
         }
     }
+    acceptWorldCharacterResult(frame) {
+        const pending = this.pendingCharacterRequests.get(frame.requestId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingCharacterRequests.delete(frame.requestId);
+        if (!frame.ok) {
+            pending.reject(characterError(frame.error?.code ?? "CAULDRON_CHARACTER_UNAVAILABLE", frame.error?.message ?? "Shared character admission failed."));
+            return;
+        }
+        if (pending.kind === "command" || pending.kind === "read") {
+            if (pending.kind === "command" && frame.operationId !== pending.operationId) {
+                pending.reject(characterError("CAULDRON_CHARACTER_UNAVAILABLE", "The host returned an invalid command receipt."));
+                return;
+            }
+            pending.resolve(frame.value);
+            return;
+        }
+        if (frame.operationId !== pending.operationId || typeof frame.replayed !== "boolean") {
+            pending.reject(characterError("CAULDRON_CHARACTER_UNAVAILABLE", "The host returned an invalid shared character receipt."));
+            return;
+        }
+        if (pending.kind === "admission") {
+            if (frame.status !== "queued" && frame.status !== "completed" && frame.status !== "interrupted") {
+                pending.reject(characterError("CAULDRON_CHARACTER_UNAVAILABLE", "The host returned an invalid admission status."));
+                return;
+            }
+            pending.resolve({ operationId: frame.operationId, status: frame.status, replayed: frame.replayed });
+            return;
+        }
+        if (!frame.status ||
+            !["queued", "running", "completed", "interrupted"].includes(frame.status) ||
+            !frame.jobStatus ||
+            !["queued", "running", "completed", "interrupted"].includes(frame.jobStatus) ||
+            !frame.turnStatus ||
+            !["admitted", "reply_committed", "completed", "interrupted"].includes(frame.turnStatus) ||
+            (frame.response !== undefined && typeof frame.response !== "string") ||
+            (frame.progress !== undefined &&
+                (!isRecord(frame.progress) || typeof frame.progress.response !== "string")) ||
+            (frame.response !== undefined && frame.progress !== undefined)) {
+            pending.reject(characterError("CAULDRON_CHARACTER_UNAVAILABLE", "The host returned an invalid character status."));
+            return;
+        }
+        pending.resolve({
+            operationId: frame.operationId,
+            status: frame.status,
+            jobStatus: frame.jobStatus,
+            turnStatus: frame.turnStatus,
+            ...(frame.response === undefined ? {} : { response: frame.response }),
+            ...(frame.progress === undefined
+                ? {}
+                : { progress: { response: frame.progress.response } }),
+            replayed: frame.replayed,
+        });
+    }
+    rejectPendingCharacterRequests(code, message) {
+        for (const pending of this.pendingCharacterRequests.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(characterError(code, message));
+        }
+        this.pendingCharacterRequests.clear();
+    }
 }
 class SocketClosedError extends Error {
     code;
@@ -436,9 +654,187 @@ function joinParams(options) {
     }
     throw invalidJoinOptions();
 }
+function destinationParams(options) {
+    if (!options ||
+        typeof options !== "object" ||
+        typeof options.routeId !== "string" ||
+        !/^[A-Za-z0-9_-]{1,64}$/.test(options.routeId) ||
+        typeof options.slot !== "string" ||
+        options.slot.length === 0 ||
+        options.slot.includes("\0") ||
+        !isValidUnicode(options.slot) ||
+        new TextEncoder().encode(options.slot).byteLength > 128) {
+        throw multiplayerError("INVALID_ARGUMENT", "Multiplayer.joinDestination requires a valid routeId and a non-empty slot of at most 128 bytes.", "Multiplayer.joinDestination");
+    }
+    return { routeId: options.routeId, slot: options.slot };
+}
+function cancelPendingDestinationJoin() {
+    const pending = pendingDestinationJoin;
+    pendingDestinationJoin = null;
+    pending?.controller.abort();
+    pending?.connection?.leave();
+}
+async function requestAcquisition(request) {
+    if (request.command === "multiplayer.getSession") {
+        return hostRequest(request.command, request.params);
+    }
+    return hostRequest(request.command, request.params);
+}
+function destinationStatusFromError(error) {
+    if (!(error instanceof CastleError))
+        return null;
+    switch (error.code) {
+        case "CAULDRON_DESTINATION_NOT_FOUND":
+            return "not_found";
+        case "CAULDRON_DESTINATION_FORBIDDEN":
+            return "forbidden";
+        case "CAULDRON_DESTINATION_PARTY_REQUIRED":
+            return "party_required";
+        case "CAULDRON_DESTINATION_FULL":
+            return "full";
+        case "CAULDRON_DESTINATION_UNAVAILABLE":
+        case "CAULDRON_DESTINATION_CONFIG_CHANGED":
+            return "unavailable";
+        case "CANCELLED":
+            return "cancelled";
+        default:
+            return null;
+    }
+}
+function isValidUnicode(value) {
+    try {
+        encodeURIComponent(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function invalidJoinOptions() {
     return multiplayerError("INVALID_ARGUMENT", "Multiplayer.join requires named, party, or public options.");
 }
+function normalizeCharacterTurnRequest(request, speakerPlayerId) {
+    if (!request || typeof request !== "object") {
+        throw characterError("INVALID_ARGUMENT", "requestCharacterTurn requires a request object.");
+    }
+    const requestId = boundedCharacterText(request.requestId, 128, "requestId");
+    const operationId = boundedCharacterText(request.operationId, 128, "operationId", WORLD_CHARACTER_OPERATION_ID_MAX_CHARACTERS);
+    const characterId = boundedCharacterText(request.characterId, 128, "characterId", WORLD_CHARACTER_ID_MAX_CHARACTERS);
+    const input = boundedCharacterText(request.input, 8000, "input", WORLD_CHARACTER_INPUT_MAX_CHARACTERS);
+    const disclosure = request.audience?.disclosure ?? "participants";
+    if (disclosure !== "participants" && disclosure !== "world") {
+        throw characterError("INVALID_ARGUMENT", "audience.disclosure must be participants or world.");
+    }
+    const playerIds = boundedCharacterIds(request.audience?.playerIds ?? [], 7, "audience.playerIds");
+    const characterIds = boundedCharacterIds(request.audience?.characterIds ?? [], 3, "audience.characterIds", WORLD_CHARACTER_ID_MAX_CHARACTERS);
+    if (playerIds.includes(speakerPlayerId) || characterIds.includes(characterId)) {
+        throw characterError("INVALID_ARGUMENT", "The speaker and target character are implicit audience members.");
+    }
+    return {
+        requestId,
+        operationId,
+        characterId,
+        input,
+        audience: { disclosure, playerIds, characterIds },
+    };
+}
+function normalizeWorldCharacterCommandRequest(request) {
+    if (!request || typeof request !== "object" || !request.command || typeof request.command !== "object") {
+        throw characterError("INVALID_ARGUMENT", "requestCharacterCommand requires a command request.");
+    }
+    const requestId = boundedCharacterText(request.requestId, 128, "requestId");
+    const operationId = boundedCharacterText(request.operationId, 128, "operationId", WORLD_CHARACTER_OPERATION_ID_MAX_CHARACTERS);
+    const command = request.command;
+    if (command.type === "perform_action") {
+        return {
+            requestId,
+            operationId,
+            command: {
+                type: "perform_action",
+                characterId: boundedCharacterText(command.characterId, 128, "command.characterId", WORLD_CHARACTER_ID_MAX_CHARACTERS),
+                actionId: boundedCharacterText(command.actionId, 128, "command.actionId", WORLD_CHARACTER_ID_MAX_CHARACTERS),
+                ...(command.parameters === undefined ? {} : { parameters: normalizeJson(command.parameters, "command.parameters") }),
+                ...(command.consentQuote === undefined ? {} : {
+                    consentQuote: boundedCharacterText(command.consentQuote, 2 * 1024, "command.consentQuote"),
+                }),
+            },
+        };
+    }
+    if (command.type === "record_event") {
+        return {
+            requestId,
+            operationId,
+            command: {
+                type: "record_event",
+                eventTypeId: boundedCharacterText(command.eventTypeId, 128, "command.eventTypeId", WORLD_CHARACTER_ID_MAX_CHARACTERS),
+                ...(command.data === undefined ? {} : { data: normalizeJson(command.data, "command.data") }),
+            },
+        };
+    }
+    throw characterError("INVALID_ARGUMENT", "Unknown shared character command type.");
+}
+function normalizeWorldCharacterReadRequest(request) {
+    if (!request || typeof request !== "object" || !request.query || typeof request.query !== "object") {
+        throw characterError("INVALID_ARGUMENT", "readCharacters requires a query request.");
+    }
+    const requestId = boundedCharacterText(request.requestId, 128, "requestId");
+    const query = request.query;
+    if (query.type === "inspect")
+        return { requestId, query: { type: "inspect" } };
+    if (query.type === "status") {
+        return { requestId, query: { type: "status", operationId: boundedCharacterText(query.operationId, 128, "character query operationId", WORLD_CHARACTER_OPERATION_ID_MAX_CHARACTERS) } };
+    }
+    if (query.type === "history") {
+        if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 50)) {
+            throw characterError("INVALID_ARGUMENT", "Character query limit must be an integer from 1 through 50.");
+        }
+        return {
+            requestId,
+            query: {
+                type: "history",
+                ...(query.characterId === undefined ? {} : { characterId: boundedCharacterText(query.characterId, 128, "character query characterId", WORLD_CHARACTER_ID_MAX_CHARACTERS) }),
+                ...(query.limit === undefined ? {} : { limit: query.limit }),
+                ...(query.cursor === undefined ? {} : { cursor: boundedCharacterText(query.cursor, 128, "character query cursor", 128) }),
+            },
+        };
+    }
+    throw characterError("INVALID_ARGUMENT", "Unknown shared character query type.");
+}
+function normalizeJson(value, field) {
+    try {
+        const text = JSON.stringify(value);
+        if (text === undefined)
+            throw new Error("not JSON");
+        return JSON.parse(text);
+    }
+    catch {
+        throw characterError("INVALID_ARGUMENT", `${field} must be JSON-serializable.`);
+    }
+}
+function boundedCharacterIds(value, maxItems, field, maxCharacters = 128) {
+    if (!Array.isArray(value) || value.length > maxItems) {
+        throw characterError("INVALID_ARGUMENT", `${field} may contain at most ${maxItems} ids.`);
+    }
+    const ids = value.map((item) => boundedCharacterText(item, 128, field, maxCharacters));
+    if (new Set(ids).size !== ids.length) {
+        throw characterError("INVALID_ARGUMENT", `${field} may not contain duplicate ids.`);
+    }
+    return ids;
+}
+function boundedCharacterText(value, maxBytes, field, maxCharacters = maxBytes) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > maxCharacters ||
+        value.includes("\0") ||
+        !isValidUnicode(value) ||
+        new TextEncoder().encode(value).byteLength > maxBytes) {
+        throw characterError("INVALID_ARGUMENT", `${field} must be non-empty valid text of at most ${maxCharacters} characters and ${maxBytes} bytes.`);
+    }
+    return value;
+}
+function characterError(code, message) {
+    return new CastleError({ code, message, operation: "Multiplayer.sharedCharacters" });
+}
 function serializeClientMessage(data) {
     let text;
     try {
@@ -521,6 +917,8 @@ function parsePlatformFrame(value) {
             return Object.prototype.hasOwnProperty.call(frame, "d")
                 ? frame
                 : null;
+        case "worldCharacterResult":
+            return isWorldCharacterResultFrame(frame) ? frame : null;
         case "replaced":
         case "pong":
             return frame;
@@ -536,7 +934,19 @@ function isHelloFrame(frame) {
     return (typeof frame.playerId === "string" &&
         typeof frame.reconnectToken === "string" &&
         typeof frame.sessionId === "string" &&
-        isMode(frame.mode));
+        isMode(frame.mode) &&
+        (frame.capabilities === undefined ||
+            (isRecord(frame.capabilities) &&
+                (frame.capabilities.sharedCharactersV1 === undefined ||
+                    typeof frame.capabilities.sharedCharactersV1 === "boolean"))));
+}
+function isWorldCharacterResultFrame(frame) {
+    return (typeof frame.requestId === "string" &&
+        typeof frame.ok === "boolean" &&
+        (frame.ok === true ||
+            (isRecord(frame.error) &&
+                typeof frame.error.code === "string" &&
+                typeof frame.error.message === "string")));
 }
 function isRosterFrame(frame) {
     return Array.isArray(frame.players) && frame.players.every(isPlayer);

package/dist/multiplayerProtocol.d.ts

@@ -19,6 +19,9 @@ export interface ClientHelloFrame {
     reconnectToken: string;
     sessionId: string;
     mode: SessionType;
+    capabilities?: {
+        sharedCharactersV1?: boolean;
+    };
 }
 export interface ClientRosterFrame {
     t: "roster";
@@ -38,7 +41,28 @@ export interface ClientByeFrame {
 export interface ClientPongFrame {
     t: "pong";
 }
-export type PlatformToClientFrame = ClientHelloFrame | ClientRosterFrame | ClientMessageFrame | ClientReplacedFrame | ClientByeFrame | ClientPongFrame;
+export type MultiplayerCharacterDisclosure = "participants" | "world";
+export type MultiplayerCharacterTurnStatus = "queued" | "running" | "completed" | "interrupted";
+export interface ClientWorldCharacterResultFrame {
+    t: "worldCharacterResult";
+    requestId: string;
+    ok: boolean;
+    operationId?: string;
+    status?: MultiplayerCharacterTurnStatus;
+    jobStatus?: MultiplayerCharacterTurnStatus;
+    turnStatus?: "admitted" | "reply_committed" | "completed" | "interrupted";
+    response?: string;
+    progress?: {
+        response: string;
+    };
+    replayed?: boolean;
+    value?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export type PlatformToClientFrame = ClientHelloFrame | ClientRosterFrame | ClientMessageFrame | ClientReplacedFrame | ClientByeFrame | ClientWorldCharacterResultFrame | ClientPongFrame;
 export interface ClientToPlatformMessageFrame {
     t: "m";
     d: unknown;
@@ -46,7 +70,35 @@ export interface ClientToPlatformMessageFrame {
 export interface ClientPingFrame {
     t: "ping";
 }
-export type ClientToPlatformFrame = ClientToPlatformMessageFrame | ClientPingFrame;
+export interface ClientWorldCharacterTurnFrame {
+    t: "worldCharacterTurn";
+    requestId: string;
+    operationId: string;
+    characterId: string;
+    input: string;
+    audience: {
+        disclosure: MultiplayerCharacterDisclosure;
+        playerIds: string[];
+        characterIds: string[];
+    };
+}
+export interface ClientWorldCharacterStatusFrame {
+    t: "worldCharacterStatus";
+    requestId: string;
+    operationId: string;
+}
+export interface ClientWorldCharacterCommandFrame {
+    t: "worldCharacterCommand";
+    requestId: string;
+    operationId: string;
+    command: unknown;
+}
+export interface ClientWorldCharacterReadFrame {
+    t: "worldCharacterRead";
+    requestId: string;
+    query: unknown;
+}
+export type ClientToPlatformFrame = ClientToPlatformMessageFrame | ClientWorldCharacterTurnFrame | ClientWorldCharacterStatusFrame | ClientWorldCharacterCommandFrame | ClientWorldCharacterReadFrame | ClientPingFrame;
 export type MultiplayerMode = SessionType;
 export type MultiplayerPlayer = SessionPlayer;
 export type MultiplayerHelloFrame = ClientHelloFrame;