castle-web-sdk 0.4.34 → 0.4.36

package/dist/decks.js

@@ -0,0 +1,31 @@
+// Decks — the player's own published decks and the decks they saved, for
+// picking where a portal leads. Each entry has the same shape as Portal.info:
+// deckId, title, creator and a cover as a data: url.
+//
+// Both lists leave out decks a portal cannot reach: a private deck, or one
+// whose creator turned portals off.
+//
+// Decks is limited to Castle admins for now; other players get a
+// PERMISSION_DENIED error.
+import { CastleError } from "./errors";
+import { hostRequest } from "./transport";
+function mine(options = {}) {
+    return hostRequest("decks.mine", { limit: listLimit(options.limit, "Decks.mine") });
+}
+function saved(options = {}) {
+    return hostRequest("decks.saved", { limit: listLimit(options.limit, "Decks.saved") });
+}
+function listLimit(value, operation) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (Number.isSafeInteger(value) && value >= 1 && value <= 50) {
+        return value;
+    }
+    throw new CastleError({
+        code: "INVALID_ARGUMENT",
+        message: `${operation} limit must be an integer from 1 through 50.`,
+        operation,
+    });
+}
+export const Decks = Object.freeze({ mine, saved });

package/dist/multiplayer.d.ts

@@ -1,6 +1,7 @@
 import type { MultiplayerSoloReason } from "./commands";
 import { CastleError } from "./errors";
 import { type MultiplayerPlayer } from "./multiplayerProtocol";
+import { type MultiplayerVoice } from "./multiplayerVoice";
 export type MultiplayerJoinOptions = {
     mode: "named";
     key: string;
@@ -43,6 +44,8 @@ export interface MultiplayerConnection {
     onMessage(callback: (data: unknown) => void): () => void;
     onRoster(callback: (roster: MultiplayerRoster) => void): () => void;
     onStateChange(callback: (state: MultiplayerConnectionState, metadata?: MultiplayerStateMetadata) => void): () => void;
+    /** Voice chat for this session, run by the host. See MultiplayerVoice. */
+    readonly voice: MultiplayerVoice;
     leave(): void;
 }
 export interface CastleMultiplayerApi {

package/dist/multiplayer.js

@@ -1,6 +1,7 @@
 import { CastleError } from "./errors";
 import { BINARY_MESSAGE_TAG, isBinaryPayload, MAX_CLIENT_FRAME_BYTES, toUint8Array, } from "./multiplayerProtocol";
 import { hostRequest } from "./transport";
+import { MultiplayerVoiceImpl } from "./multiplayerVoice";
 const KEEPALIVE_INTERVAL_MS = 25_000;
 const HELLO_TIMEOUT_MS = 10_000;
 const RECONNECT_BUDGET_MS = 30_000;
@@ -39,6 +40,11 @@ class MultiplayerConnectionImpl {
     messages = new Set();
     rosters = new Set();
     states = new Set();
+    voiceImpl = new MultiplayerVoiceImpl({
+        sessionId: () => this.currentSessionId,
+        players: () => this.roster?.players ?? [],
+        isSolo: () => this.solo,
+    });
     constructor(params, onClosed) {
         this.params = params;
         this.onClosed = onClosed;
@@ -58,6 +64,9 @@ class MultiplayerConnectionImpl {
     get soloReason() {
         return this.currentSoloReason;
     }
+    get voice() {
+        return this.voiceImpl;
+    }
     async start() {
         try {
             await this.acquire();
@@ -171,6 +180,7 @@ class MultiplayerConnectionImpl {
         };
         this.setRoster({ players: [you], you });
         this.transition("connected");
+        void this.voiceImpl.attach();
     }
     openSocket(credential, value) {
         const attempt = ++this.socketAttempt;
@@ -253,6 +263,7 @@ class MultiplayerConnectionImpl {
         this.reAcquisitionUsed = false;
         this.transition("connected");
         this.startKeepalive();
+        void this.voiceImpl.attach();
     }
     handleFrame(frame) {
         switch (frame.t) {
@@ -293,6 +304,7 @@ class MultiplayerConnectionImpl {
     }
     setRoster(roster) {
         this.roster = roster;
+        this.voiceImpl.rosterChanged();
         for (const callback of this.rosters)
             callListener(callback, roster);
     }
@@ -391,6 +403,7 @@ class MultiplayerConnectionImpl {
         this.socketAttempt += 1;
         closeSocket(socket, 1000, "session closed");
         this.currentState = "closed";
+        this.voiceImpl.dispose();
         for (const callback of this.states)
             callStateListener(callback, "closed", metadata);
         this.onClosed();

package/dist/multiplayerVoice.d.ts

@@ -0,0 +1,67 @@
+import type { VoiceEvent, VoiceJoinStatus, VoiceMixEntry, VoiceState } from "./commands";
+import type { MultiplayerPlayer } from "./multiplayerProtocol";
+export declare const VOICE_MIX_INTERVAL_MS = 100;
+export type { VoiceJoinStatus, VoiceMixEntry, VoiceState };
+export interface MultiplayerVoice {
+    /** "unavailable" when this host, deck, session or player can't have voice. */
+    readonly state: VoiceState;
+    /**
+     * Asks the player to join voice. The host shows its own prompt; nothing happens
+     * without the player's say-so. Resolves once they have chosen.
+     */
+    requestJoin(): Promise<VoiceJoinStatus>;
+    /** Leaves voice, or withdraws a pending request. The game connection is unaffected. */
+    leave(): void;
+    /**
+     * Suggested volume (0-1) and stereo position (-1 left to 1 right) per player,
+     * keyed by playerId. Players and fields not named keep their last value (initially
+     * full volume, centered). Sent at most ten times a second; the latest values win.
+     */
+    setMix(mix: Record<string, VoiceMixEntry>): void;
+    onState(callback: (state: VoiceState) => void): () => void;
+    /** The playerIds speaking right now; called whenever that set changes. */
+    onSpeaking(callback: (playerIds: string[]) => void): () => void;
+}
+export interface VoiceSessionAccess {
+    sessionId(): string;
+    players(): MultiplayerPlayer[];
+    isSolo(): boolean;
+}
+export declare class MultiplayerVoiceImpl implements MultiplayerVoice {
+    private readonly access;
+    private currentState;
+    private voiceSessionId;
+    private attaching;
+    private hostStateVersion;
+    private pendingJoin;
+    private joinRequest;
+    private speakingUserIds;
+    private speaking;
+    private pendingMix;
+    private sentMix;
+    private mixTimer;
+    private lastMixSentAt;
+    private disposed;
+    private readonly states;
+    private readonly speakers;
+    constructor(access: VoiceSessionAccess);
+    get state(): VoiceState;
+    attach(): Promise<void>;
+    requestJoin(): Promise<VoiceJoinStatus>;
+    private askToJoin;
+    leave(): void;
+    setMix(mix: Record<string, VoiceMixEntry>): void;
+    onState(callback: (state: VoiceState) => void): () => void;
+    onSpeaking(callback: (playerIds: string[]) => void): () => void;
+    receive(event: VoiceEvent): void;
+    rosterChanged(): void;
+    dispose(): void;
+    private isCurrent;
+    private withdraw;
+    private endSession;
+    private sendLeave;
+    private setState;
+    private emitSpeaking;
+    private scheduleMix;
+    private flushMix;
+}

package/dist/multiplayerVoice.js

@@ -0,0 +1,309 @@
+import { hostRequest, setVoiceEventHandler } from "./transport";
+// Voice chat in a multiplayer session. The host (castle.xyz or the Castle app) owns
+// the microphone, the call and playback, and shows its own prompt and live-mic badge; a
+// deck never touches audio. What a deck gets: whether voice is on, a way to ask the
+// player to join, who is speaking, and a suggested volume and stereo position per
+// player (proximity chat). Push-to-talk and muting are the player's, in the host's UI.
+// A deck driving proximity every frame sends far more than the host needs.
+export const VOICE_MIX_INTERVAL_MS = 100;
+const DEFAULT_MIX = { gain: 1, pan: 0 };
+let activeVoice = null;
+function dispatchVoiceEvent(event) {
+    activeVoice?.receive(event);
+}
+// One multiplayer connection is live at a time, so one voice receives host events.
+function setActiveVoice(voice, current) {
+    if (current && activeVoice !== current)
+        return;
+    activeVoice = voice;
+}
+export class MultiplayerVoiceImpl {
+    access;
+    currentState = "unavailable";
+    // The session this voice state belongs to; "" before the first attach or in solo.
+    voiceSessionId = "";
+    attaching = null;
+    // Bumped on every host state event, so a join reply never overrides a newer one.
+    hostStateVersion = 0;
+    pendingJoin = null;
+    joinRequest = null;
+    speakingUserIds = [];
+    speaking = [];
+    pendingMix = {};
+    sentMix = {};
+    mixTimer = null;
+    lastMixSentAt = 0;
+    disposed = false;
+    states = new Set();
+    speakers = new Set();
+    constructor(access) {
+        this.access = access;
+    }
+    get state() {
+        return this.currentState;
+    }
+    // Called by the connection whenever it (re)gains a session. A reconnect keeps the
+    // session; a re-acquisition may land in a different one, or in solo, and voice for
+    // the old session ends with it. Asks the host where voice stands; a host without
+    // voice (an older app, local dev) answers with an error or "unavailable".
+    attach() {
+        if (this.disposed)
+            return Promise.resolve();
+        setActiveVoice(this);
+        setVoiceEventHandler(dispatchVoiceEvent);
+        const sessionId = this.access.isSolo() ? "" : this.access.sessionId();
+        if (this.voiceSessionId !== sessionId) {
+            this.endSession();
+            // The old session's state means nothing for the new one until the host answers.
+            this.setState("unavailable");
+        }
+        this.voiceSessionId = sessionId;
+        if (!sessionId) {
+            this.setState("unavailable");
+            this.attaching = null;
+            return Promise.resolve();
+        }
+        const attaching = hostRequest("voice.getState", { sessionId }).then((result) => {
+            if (this.isCurrent(sessionId))
+                this.setState(result.state);
+        }, () => {
+            if (this.isCurrent(sessionId))
+                this.setState("unavailable");
+        });
+        this.attaching = attaching;
+        return attaching;
+    }
+    // A second call while the player is still choosing shares the first one's answer.
+    requestJoin() {
+        if (!this.joinRequest) {
+            const request = this.askToJoin().finally(() => {
+                if (this.joinRequest === request)
+                    this.joinRequest = null;
+            });
+            this.joinRequest = request;
+        }
+        return this.joinRequest;
+    }
+    async askToJoin() {
+        // Registered before any waiting, so leave() or a session change can withdraw a
+        // request that hasn't reached the host yet.
+        const pending = new AbortController();
+        this.pendingJoin = pending;
+        // `join()` resolves at hello, before the host has said whether voice is on. A
+        // reconnect can attach again meanwhile; wait for the latest answer.
+        let awaited = null;
+        while (this.attaching && this.attaching !== awaited) {
+            awaited = this.attaching;
+            await awaited;
+        }
+        if (pending.signal.aborted ||
+            this.disposed ||
+            !this.voiceSessionId ||
+            this.currentState === "unavailable" ||
+            this.currentState === "live") {
+            if (this.pendingJoin === pending)
+                this.pendingJoin = null;
+            if (pending.signal.aborted || this.currentState !== "live")
+                return "unavailable";
+            return "joined";
+        }
+        const sessionId = this.voiceSessionId;
+        const version = this.hostStateVersion;
+        this.setState("joining");
+        let status;
+        try {
+            ({ status } = await hostRequest("voice.requestJoin", { sessionId }, { signal: pending.signal }));
+        }
+        catch {
+            status = "unavailable";
+        }
+        finally {
+            if (this.pendingJoin === pending)
+                this.pendingJoin = null;
+        }
+        if (pending.signal.aborted || !this.isCurrent(sessionId)) {
+            // Withdrawn, or the game connection ended, while the player was choosing. The
+            // abort already cancelled the request at the host, whose executor undoes a
+            // "yes" that lands anyway.
+            return "unavailable";
+        }
+        if (version === this.hostStateVersion) {
+            this.setState(status === "joined" ? "live" : status === "unavailable" ? "unavailable" : "off");
+        }
+        return status;
+    }
+    leave() {
+        if (this.disposed)
+            return;
+        const inVoice = this.currentState === "live" || this.currentState === "joining";
+        if (!inVoice && this.pendingJoin === null)
+            return;
+        this.withdraw();
+        if (inVoice) {
+            this.setState("off");
+            this.sendLeave(this.voiceSessionId);
+        }
+    }
+    setMix(mix) {
+        if (this.disposed || !mix || typeof mix !== "object")
+            return;
+        const players = this.access.players();
+        for (const [playerId, entry] of Object.entries(mix)) {
+            const player = players.find((candidate) => candidate.playerId === playerId);
+            if (!player || !entry || typeof entry !== "object")
+                continue;
+            const next = { ...this.pendingMix[player.userId] };
+            if (typeof entry.gain === "number" && Number.isFinite(entry.gain)) {
+                next.gain = clamp(entry.gain, 0, 1);
+            }
+            if (typeof entry.pan === "number" && Number.isFinite(entry.pan)) {
+                next.pan = clamp(entry.pan, -1, 1);
+            }
+            this.pendingMix[player.userId] = next;
+        }
+        this.scheduleMix();
+    }
+    onState(callback) {
+        this.states.add(callback);
+        callListener(callback, this.currentState);
+        return () => this.states.delete(callback);
+    }
+    onSpeaking(callback) {
+        this.speakers.add(callback);
+        callListener(callback, this.speaking.slice());
+        return () => this.speakers.delete(callback);
+    }
+    receive(event) {
+        if (this.disposed || !this.voiceSessionId || event.sessionId !== this.voiceSessionId) {
+            return;
+        }
+        if (event.type === "state") {
+            this.hostStateVersion += 1;
+            this.setState(event.state);
+            return;
+        }
+        this.speakingUserIds = event.userIds.slice();
+        this.emitSpeaking();
+    }
+    // The roster changed: speakers are re-mapped, and mixes for players who left dropped.
+    rosterChanged() {
+        if (this.disposed)
+            return;
+        const userIds = new Set(this.access.players().map((player) => player.userId));
+        for (const userId of Object.keys(this.pendingMix)) {
+            if (!userIds.has(userId))
+                delete this.pendingMix[userId];
+        }
+        for (const userId of Object.keys(this.sentMix)) {
+            if (!userIds.has(userId))
+                delete this.sentMix[userId];
+        }
+        this.emitSpeaking();
+    }
+    // The game connection ended: voice for its session goes with it.
+    dispose() {
+        if (this.disposed)
+            return;
+        this.endSession();
+        this.setState("unavailable");
+        this.disposed = true;
+        if (this.mixTimer !== null)
+            clearTimeout(this.mixTimer);
+        this.mixTimer = null;
+        setActiveVoice(null, this);
+    }
+    isCurrent(sessionId) {
+        return !this.disposed && sessionId !== "" && sessionId === this.voiceSessionId;
+    }
+    // Cancels a pending request, so a retry starts a fresh prompt.
+    withdraw() {
+        this.pendingJoin?.abort();
+        this.pendingJoin = null;
+        this.joinRequest = null;
+    }
+    // Leaves the current voice session, if the player is in it or being asked.
+    endSession() {
+        const inVoice = this.currentState === "live" || this.currentState === "joining" || this.pendingJoin !== null;
+        this.withdraw();
+        if (inVoice && this.voiceSessionId)
+            this.sendLeave(this.voiceSessionId);
+        this.speakingUserIds = [];
+        this.pendingMix = {};
+        this.sentMix = {};
+        this.emitSpeaking();
+    }
+    sendLeave(sessionId) {
+        void hostRequest("voice.leave", { sessionId }).catch(() => { });
+    }
+    setState(state) {
+        if (this.currentState === state)
+            return;
+        this.currentState = state;
+        if (state !== "live")
+            this.speakingUserIds = [];
+        this.emitSpeaking();
+        for (const callback of this.states)
+            callListener(callback, state);
+        if (state === "live") {
+            // A rejoined call starts from scratch at the host: send the deck's mix again.
+            for (const userId of Object.keys(this.sentMix)) {
+                this.pendingMix[userId] ??= {};
+            }
+            this.scheduleMix();
+        }
+    }
+    emitSpeaking() {
+        const userIds = new Set(this.speakingUserIds);
+        const playerIds = this.access
+            .players()
+            .filter((player) => userIds.has(player.userId))
+            .map((player) => player.playerId)
+            .sort();
+        if (playerIds.join("\n") === this.speaking.join("\n"))
+            return;
+        this.speaking = playerIds;
+        for (const callback of this.speakers)
+            callListener(callback, playerIds.slice());
+    }
+    scheduleMix() {
+        if (this.mixTimer !== null || Object.keys(this.pendingMix).length === 0)
+            return;
+        const wait = Math.max(0, this.lastMixSentAt + VOICE_MIX_INTERVAL_MS - Date.now());
+        this.mixTimer = setTimeout(() => {
+            this.mixTimer = null;
+            this.flushMix();
+        }, wait);
+    }
+    // Held until the player is in voice, then sent: the latest mix is what matters. Each
+    // entry goes out whole, so a field the deck didn't name keeps its last value.
+    flushMix() {
+        if (this.disposed || !this.voiceSessionId || this.currentState !== "live")
+            return;
+        const userIds = new Set(this.access.players().map((player) => player.userId));
+        const mix = {};
+        for (const [userId, entry] of Object.entries(this.pendingMix)) {
+            if (!userIds.has(userId))
+                continue;
+            const previous = this.sentMix[userId] ?? DEFAULT_MIX;
+            const full = { gain: entry.gain ?? previous.gain, pan: entry.pan ?? previous.pan };
+            this.sentMix[userId] = full;
+            mix[userId] = full;
+        }
+        this.pendingMix = {};
+        if (Object.keys(mix).length === 0)
+            return;
+        this.lastMixSentAt = Date.now();
+        void hostRequest("voice.setMix", { sessionId: this.voiceSessionId, mix }).catch(() => { });
+    }
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function callListener(callback, value) {
+    try {
+        callback(value);
+    }
+    catch {
+        // One deck listener must not break voice or other listeners.
+    }
+}

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import { type CommandName, type CommandParams, type CommandResponseEnvelope } from "./commands";
+import { type CommandName, type CommandParams, type CommandResponseEnvelope, type CommandStreamEnvelope } from "./commands";
 import { type TunedParam } from "./paramsRegistry";
 export declare const CARD_RATIO: number;
 interface LocalResponse {
@@ -43,7 +43,9 @@ export declare function renameFile(from: string, to: string): Promise<void>;
 export declare function deleteFile(path: string): Promise<void>;
 export declare function openFile(path: string): void;
 export declare function initCard(): HTMLDivElement;
-export declare function sendLocalCommand<C extends CommandName>(command: C, params: CommandParams[C]): Promise<CommandResponseEnvelope>;
+export declare function sendLocalCommand<C extends CommandName>(requestId: string, command: C, params: CommandParams[C], listener: (message: CommandResponseEnvelope | CommandStreamEnvelope) => void): Promise<void>;
+export declare function cancelLocalCommand(requestId: string): void;
+export declare function releaseLocalCommand(requestId: string): void;
 /**
  * Notified `true` on every fresh dev-server socket and `false` when one is lost.
  * What lets a queued write know the moment retrying is worth it again.

package/dist/runtime.js

@@ -13,10 +13,9 @@ const pendingRequests = new Map();
 // Local-dev command channel: the `castle-web serve` dev server is the host, so
 // SDK commands ride the same websocket runtime.ts already uses for
 // logs/screenshots/restart. Correlated by requestId, separate from the
-// screenshot/write_file request map above.
-const COMMAND_TIMEOUT_MS = 15000;
+// screenshot/write_file request map above. transport.ts owns the timeouts.
 const SOCKET_WAIT_TIMEOUT_MS = 10000;
-const pendingCommands = new Map();
+const localCommandListeners = new Map();
 const origLog = console.log;
 const origWarn = console.warn;
 const origError = console.error;
@@ -324,38 +323,42 @@ function sendLocalRequest(msg) {
         ws.send(JSON.stringify(request));
     });
 }
-// Send an SDK command to the dev server and resolve with the raw response
-// envelope (ok/data/error). transport.ts interprets it — error reconstruction
-// stays uniform across all three channels there. Waits for the socket to open
-// so a command issued during startup isn't dropped.
-export function sendLocalCommand(command, params) {
-    const requestId = `cmd_${nextRequestId++}`;
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            pendingCommands.delete(requestId);
-            reject(new Error(`Timed out waiting for command ${command}.`));
-        }, COMMAND_TIMEOUT_MS);
-        pendingCommands.set(requestId, (env) => {
-            clearTimeout(timeout);
-            pendingCommands.delete(requestId);
-            resolve(env);
-        });
-        waitForSocket()
-            .then((socket) => {
-            socket.send(JSON.stringify({
-                type: "castle_command",
-                castleSdk: CASTLE_SDK_PROTOCOL,
-                requestId,
-                command,
-                params,
-            }));
-        })
-            .catch((error) => {
-            clearTimeout(timeout);
-            pendingCommands.delete(requestId);
-            reject(error instanceof Error ? error : new Error(String(error)));
-        });
-    });
+// Send an SDK command to the dev server. Its stream envelopes and its response
+// go to `listener` as they arrive, and the listener is dropped after the
+// response. transport.ts interprets them, so error reconstruction stays uniform
+// across all three channels there. Waits for the socket to open so a command
+// issued during startup isn't dropped; rejects if it never opens.
+export async function sendLocalCommand(requestId, command, params, listener) {
+    localCommandListeners.set(requestId, listener);
+    try {
+        const socket = await waitForSocket();
+        // Cancelled or timed out while the socket was opening.
+        if (!localCommandListeners.has(requestId)) {
+            return;
+        }
+        socket.send(JSON.stringify({
+            type: "castle_command",
+            castleSdk: CASTLE_SDK_PROTOCOL,
+            requestId,
+            command,
+            params,
+        }));
+    }
+    catch (error) {
+        localCommandListeners.delete(requestId);
+        throw error;
+    }
+}
+// Ask the dev server to stop a streaming command, and stop listening for it.
+export function cancelLocalCommand(requestId) {
+    localCommandListeners.delete(requestId);
+    if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: "castle_command_cancel", castleSdk: CASTLE_SDK_PROTOCOL, requestId }));
+    }
+}
+// Stop listening for a command the deck has given up on.
+export function releaseLocalCommand(requestId) {
+    localCommandListeners.delete(requestId);
 }
 function waitForSocket() {
     if (ws && ws.readyState === WebSocket.OPEN)
@@ -374,10 +377,15 @@ function waitForSocket() {
         }, 100);
     });
 }
-function resolveLocalCommand(msg) {
-    const pending = pendingCommands.get(msg.requestId);
-    if (pending)
-        pending(msg);
+function deliverLocalCommand(msg) {
+    const listener = localCommandListeners.get(msg.requestId);
+    if (!listener) {
+        return;
+    }
+    if (!("stream" in msg)) {
+        localCommandListeners.delete(msg.requestId);
+    }
+    listener(msg);
 }
 function resolveLocalRequest(msg) {
     if (!msg.requestId)
@@ -919,7 +927,10 @@ function handleLocalMessage(msg) {
         resolveLocalRequest(msg);
     }
     else if (msg.type === "castle_command_response") {
-        resolveLocalCommand(msg);
+        deliverLocalCommand(msg);
+    }
+    else if (msg.type === "castle_command_stream") {
+        deliverLocalCommand(msg);
     }
 }
 // Files-changed listeners, registered by consumers (the kit engine, editors).

package/dist/server/storage.d.ts

@@ -106,6 +106,48 @@ export interface EvaluateCharacterInformationInput {
     operationId: string;
     maxDeliveries?: number;
 }
+export type CharacterStoryOpportunity = {
+    type: "approach" | "room_entry" | "world_action";
+    id: string;
+};
+export interface EvaluateCharacterBeatsInput {
+    operationId: string;
+    opportunityId: string;
+    opportunity: CharacterStoryOpportunity;
+    presentCharacterIds: string[];
+}
+export interface CharacterBeatSelection {
+    deliveryId: string;
+    beatId: string;
+    characterId: string;
+    openingText: string;
+}
+export interface CharacterBeatEvaluationResult {
+    operationId: string;
+    opportunityId: string;
+    opportunityCount: number;
+    gameTime: number | null;
+    selection: CharacterBeatSelection | null;
+}
+export type CharacterBeatEvaluationOperation = Omit<CharacterOperation, "result"> & {
+    result: CharacterBeatEvaluationResult | null;
+};
+export interface CompleteScheduledCharacterBeatInput {
+    operationId: string;
+    deliveryId: string;
+    outcomeId: string;
+}
+export interface CharacterScheduledBeatCompletionResult {
+    completionId: string;
+    deliveryId: string;
+    beatId: string;
+    characterId: string;
+    outcomeId: string;
+    completedAt: string;
+}
+export type CharacterScheduledBeatCompletionOperation = Omit<CharacterOperation, "result"> & {
+    result: CharacterScheduledBeatCompletionResult | null;
+};
 export interface CharacterInformationEvaluationResult {
     generation: number;
     evaluatedAt: string;
@@ -153,6 +195,8 @@ export interface ServerPlaythroughCharacters {
     deliverKnowledge(input: DeliverCharacterKnowledgeInput): Promise<CharacterOperation>;
     completeBeat(input: CompleteCharacterBeatInput): Promise<CharacterOperation>;
     evaluateInformation(input: EvaluateCharacterInformationInput): Promise<CharacterInformationEvaluationOperation>;
+    evaluateBeats(input: EvaluateCharacterBeatsInput): Promise<CharacterBeatEvaluationOperation>;
+    completeScheduledBeat(input: CompleteScheduledCharacterBeatInput): Promise<CharacterScheduledBeatCompletionOperation>;
     status(operationId: string): Promise<CharacterOperation>;
     history(options?: ServerCharacterHistoryOptions): Promise<CharacterHistory>;
 }