@my-swu/simulator-client 0.1.0

package/dist/local/server/index.js

@@ -0,0 +1,140 @@
+/**
+ * In-worker server: binds the RPC protocol to the engine (HTTP router, virtual
+ * sockets, record persistence). The worker entry wires this to the real wasm
+ * engine; tests drive it with a scripted fake over an in-process port.
+ */
+import { engineFailureResponse, routeHttpRequest } from './http-router.js';
+import { openMatchSocket } from './sockets.js';
+/**
+ * Attaches the local engine server to a message port. Returns a disposer.
+ */
+export function createLocalEngineServer(options) {
+    const { engine, port } = options;
+    const registry = {
+        matches: new Map(),
+        lobbies: new Map(),
+        eventLobbies: new Map(),
+        matchChannels: new Map(),
+    };
+    const channels = new Map();
+    let installed = false;
+    const respond = (response, transfer) => {
+        port.postMessage(response, transfer);
+    };
+    const onMessage = (event) => {
+        const request = event.data;
+        switch (request.kind) {
+            case 'init': {
+                try {
+                    if (!installed) {
+                        engine.install(new Uint8Array(request.catalogBytes));
+                        installed = true;
+                    }
+                    respond({ kind: 'ok', id: request.id, body: engine.engineVersion() });
+                }
+                catch (error) {
+                    respond({ kind: 'error', id: request.id, message: String(error) });
+                }
+                break;
+            }
+            case 'http': {
+                try {
+                    const routed = routeHttpRequest(engine, registry, request.method, request.path, request.body, Date.now());
+                    respond({ kind: 'ok', id: request.id, status: routed.status, body: routed.body });
+                }
+                catch (error) {
+                    // Engine throws surface as a 4xx `ApiErrorResponse` — a rejected
+                    // fetch would strip the status/code the app's error handling reads.
+                    const failure = engineFailureResponse(error);
+                    respond({ kind: 'ok', id: request.id, status: failure.status, body: failure.body });
+                }
+                break;
+            }
+            case 'syncCatalog': {
+                if (!installed) {
+                    respond({ kind: 'error', id: request.id, message: 'card catalog is not installed' });
+                    break;
+                }
+                try {
+                    engine.applyCatalogSync(request.catalogSyncJson);
+                    respond({ kind: 'ok', id: request.id });
+                }
+                catch (error) {
+                    respond({ kind: 'error', id: request.id, message: String(error) });
+                }
+                break;
+            }
+            case 'wsOpen': {
+                const channel = openMatchSocket(registry, request.url, request.protocols, {
+                    opened: () => respond({ kind: 'wsOpened', channelId: request.channelId }),
+                    message: data => respond({ kind: 'wsMessage', channelId: request.channelId, data }),
+                    closed: (code, reason) => respond({ kind: 'wsClosed', channelId: request.channelId, code, reason }),
+                    failed: message => respond({ kind: 'wsFailed', channelId: request.channelId, message }),
+                });
+                if (channel) {
+                    channels.set(request.channelId, channel);
+                }
+                break;
+            }
+            case 'wsSend': {
+                channels.get(request.channelId)?.send(request.data);
+                break;
+            }
+            case 'wsClose': {
+                channels.get(request.channelId)?.close();
+                channels.delete(request.channelId);
+                break;
+            }
+            case 'saveRecord': {
+                // Exactly one live match per worker in the offline flows; save the
+                // most recently created one.
+                const match = [...registry.matches.values()].at(-1);
+                if (!match) {
+                    respond({ kind: 'error', id: request.id, message: 'no live local match to save' });
+                    break;
+                }
+                try {
+                    const bytes = match.toRecordBytes();
+                    const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+                    respond({
+                        kind: 'saved',
+                        id: request.id,
+                        matchId: match.matchId,
+                        seatToken: match.seatToken,
+                        bytes: buffer,
+                    }, [buffer]);
+                }
+                catch (error) {
+                    respond({ kind: 'error', id: request.id, message: String(error) });
+                }
+                break;
+            }
+            case 'restoreRecord': {
+                try {
+                    const match = engine.restoreRecord(new Uint8Array(request.bytes));
+                    // One live match per worker: drop stale hosts so `saveRecord` and
+                    // reconnects always resolve to the restored one.
+                    registry.matches.clear();
+                    registry.matches.set(match.matchId, match);
+                    respond({
+                        kind: 'ok',
+                        id: request.id,
+                        body: JSON.stringify({ matchId: match.matchId, seatToken: match.seatToken }),
+                    });
+                }
+                catch (error) {
+                    respond({ kind: 'error', id: request.id, message: String(error) });
+                }
+                break;
+            }
+        }
+    };
+    port.addEventListener('message', onMessage);
+    return () => {
+        port.removeEventListener('message', onMessage);
+        for (const channel of channels.values()) {
+            channel.close();
+        }
+        channels.clear();
+    };
+}

package/dist/local/server/sockets.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Virtual match sockets: validates the subprotocol token, replays the
+ * server-identical handshake (`welcome` → `snapshot` → `historySnapshot` →
+ * `aiStatus`), routes `ClientMessage` envelopes into the engine, and pumps the
+ * AI between messages. Delay batches are honored with real timers so AI attack
+ * pacing reaches the client exactly like the online path.
+ */
+import type { LocalMatchRegistry } from './http-router.js';
+/** Emits worker→main socket frames for one channel. */
+export interface SocketChannelSink {
+    opened: () => void;
+    message: (data: string) => void;
+    closed: (code?: number, reason?: string) => void;
+    failed: (message: string) => void;
+}
+/** One live virtual socket. */
+export interface SocketChannel {
+    send: (data: string) => void;
+    close: () => void;
+}
+/**
+ * Opens one virtual match socket. Returns `undefined` (after signaling
+ * `failed`) when the URL or token does not resolve to a hosted match.
+ */
+export declare function openMatchSocket(registry: LocalMatchRegistry, url: string, protocols: string[], sink: SocketChannelSink): SocketChannel | undefined;

package/dist/local/server/sockets.js

@@ -0,0 +1,141 @@
+/**
+ * Virtual match sockets: validates the subprotocol token, replays the
+ * server-identical handshake (`welcome` → `snapshot` → `historySnapshot` →
+ * `aiStatus`), routes `ClientMessage` envelopes into the engine, and pumps the
+ * AI between messages. Delay batches are honored with real timers so AI attack
+ * pacing reaches the client exactly like the online path.
+ */
+import { MATCH_SEAT_TOKEN_PROTOCOL, MATCH_SPECTATOR_TOKEN_PROTOCOL, PLAYER_TOKEN_PROTOCOL, } from '../../connection/url.js';
+import { createAiScheduler } from './ai-scheduler.js';
+/**
+ * Opens one virtual match socket. Returns `undefined` (after signaling
+ * `failed`) when the URL or token does not resolve to a hosted match.
+ */
+export function openMatchSocket(registry, url, protocols, sink) {
+    const pathSegments = new URL(url).pathname.split('/').filter(Boolean);
+    if (pathSegments[pathSegments.length - 2] === 'lobbies') {
+        return openLobbySocket(registry, pathSegments[pathSegments.length - 1], protocols, sink);
+    }
+    const matchId = decodeURIComponent(pathSegments.pop() ?? '');
+    const match = registry.matches.get(matchId);
+    if (!match) {
+        sink.failed(`unknown local match ${matchId}`);
+        return undefined;
+    }
+    if (protocols.includes(MATCH_SPECTATOR_TOKEN_PROTOCOL)) {
+        sink.failed('offline matches do not support spectators');
+        return undefined;
+    }
+    const protocolIndex = protocols.indexOf(MATCH_SEAT_TOKEN_PROTOCOL);
+    const seatToken = protocolIndex >= 0 ? protocols[protocolIndex + 1] : undefined;
+    if (!seatToken || seatToken !== match.seatToken) {
+        sink.failed('invalid seat token');
+        return undefined;
+    }
+    let open = true;
+    const scheduler = createAiScheduler({
+        match,
+        deliver: (batch) => {
+            if (!open) {
+                return;
+            }
+            for (const message of batch.messages) {
+                sink.message(JSON.stringify(message));
+            }
+        },
+        failed: (error) => {
+            if (!open) {
+                return;
+            }
+            open = false;
+            // `detachChannel` is declared below but only runs after socket setup.
+            detachChannel();
+            sink.failed(`local engine failed: ${String(error)}`);
+        },
+    });
+    sink.opened();
+    for (const message of match.connect()) {
+        sink.message(JSON.stringify(message));
+    }
+    // The AI may already own the first move (e.g. restored mid-AI-turn).
+    scheduler.pump();
+    // Lets HTTP twins of socket envelopes (the ai/pause route) broadcast their
+    // batches to this open socket and re-pump the AI, like the server does.
+    const channelHandle = {
+        deliver: (batches) => scheduler.enqueueHuman(() => batches),
+    };
+    registry.matchChannels.set(matchId, channelHandle);
+    const detachChannel = () => {
+        if (registry.matchChannels.get(matchId) === channelHandle) {
+            registry.matchChannels.delete(matchId);
+        }
+    };
+    return {
+        send: (data) => {
+            if (!open) {
+                return;
+            }
+            // Serialize behind any in-flight paced AI delivery so a human message's
+            // reply cannot interleave into the middle of a staggered batch.
+            scheduler.enqueueHuman(() => {
+                const batches = match.handleMessage(seatToken, data, Date.now());
+                return batches;
+            });
+        },
+        close: () => {
+            open = false;
+            detachChannel();
+            scheduler.stop();
+            sink.closed(1000, 'closed by client');
+        },
+    };
+}
+/**
+ * Minimal lobby socket for the hidden offline bootstrap: handshake
+ * (`welcome` + `snapshot`) plus ping/pong. The offline flow reads all lobby
+ * state through the HTTP responses, so no pushes are emitted.
+ */
+function openLobbySocket(registry, encodedLobbyId, protocols, sink) {
+    const lobbyId = decodeURIComponent(encodedLobbyId);
+    const lobby = registry.lobbies.get(lobbyId);
+    if (!lobby) {
+        sink.failed(`unknown local lobby ${lobbyId}`);
+        return undefined;
+    }
+    const protocolIndex = protocols.indexOf(PLAYER_TOKEN_PROTOCOL);
+    const playerToken = protocolIndex >= 0 ? protocols[protocolIndex + 1] : undefined;
+    try {
+        lobby.authorize(playerToken ?? '');
+    }
+    catch {
+        sink.failed('invalid lobby player token');
+        return undefined;
+    }
+    let open = true;
+    const access = JSON.parse(lobby.accessJson());
+    sink.opened();
+    sink.message(JSON.stringify({
+        type: 'welcome',
+        payload: { lobbyId, playerId: access.playerId },
+    }));
+    sink.message(JSON.stringify({ type: 'snapshot', payload: access.snapshot }));
+    return {
+        send: (data) => {
+            if (!open) {
+                return;
+            }
+            const message = JSON.parse(data);
+            if (message.type === 'ping') {
+                sink.message(JSON.stringify({ type: 'pong', payload: { nonce: message.payload?.nonce ?? null } }));
+            }
+            else if (message.type === 'syncRequest') {
+                const current = JSON.parse(lobby.accessJson());
+                sink.message(JSON.stringify({ type: 'snapshot', payload: current.snapshot }));
+            }
+        },
+        close: () => {
+            open = false;
+            sink.closed(1000, 'closed by client');
+        },
+    };
+}

package/dist/local/wasm-engine.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Adapts the `swu-wasm` bindings to the {@link LocalSimulatorEngine} contract.
+ *
+ * The wasm module is passed in (already `init()`-ed by the worker entry) so
+ * this file stays importable in tests without wasm glue.
+ */
+import type { LocalSimulatorEngine } from './engine.js';
+/** The subset of `swu_wasm.js` exports this adapter consumes. */
+export interface SwuWasmModule {
+    install_card_catalog: (bytes: Uint8Array) => void;
+    apply_catalog_sync: (catalogSyncJson: string) => void;
+    cards_get: (idsJson: string) => string;
+    limited_events_preflight: (requestJson: string) => string;
+    offline_difficulties: () => string;
+    engine_version: () => string;
+    LocalMatch: {
+        create: (requestJson: string, nowMs: number) => WasmCreatedLocalMatch;
+        restoreRecord: (bytes: Uint8Array) => WasmLocalMatch;
+    };
+    LocalLobby: {
+        create: (requestJson: string) => WasmCreatedLocalLobby;
+    };
+}
+interface WasmCreatedLocalLobby {
+    takeLobby: () => WasmLocalLobby;
+    accessJson: () => string;
+}
+interface WasmLocalLobby {
+    lobbyId: () => string;
+    authorize: (playerToken: string) => void;
+    addAiPlayer: (difficulty: string) => string;
+    setHostReady: (ready: boolean) => string;
+    start: (nowMs: number) => string;
+    eventSnapshot: (seatToken: string | null | undefined, nowMs: number) => string;
+    eventApplyCommand: (seatToken: string, commandJson: string, nowMs: number) => string;
+    submitLimitedDeck: (requestJson: string) => string;
+    prepareLimitedAiDecks: () => string;
+    limitedMatchRequest: () => string;
+    storeStartedMatch: (accessJson: string) => string;
+    accessJson: () => string;
+}
+interface WasmCreatedLocalMatch {
+    takeMatch: () => WasmLocalMatch;
+    accessJson: () => string;
+}
+interface WasmLocalMatch {
+    connect: () => string;
+    handleMessage: (seatToken: string, messageJson: string, nowMs: number) => string;
+    aiHasWork: () => boolean;
+    tickAi: (nowMs: number) => string;
+    save: () => string;
+    toRecordBytes: () => Uint8Array;
+    snapshot: () => string;
+    matchId: () => string;
+    seatToken: () => string | undefined;
+}
+/**
+ * Wraps an initialized wasm module into the engine contract.
+ */
+export declare function createWasmEngine(wasm: SwuWasmModule): LocalSimulatorEngine;
+export {};

package/dist/local/wasm-engine.js

@@ -0,0 +1,63 @@
+/**
+ * Adapts the `swu-wasm` bindings to the {@link LocalSimulatorEngine} contract.
+ *
+ * The wasm module is passed in (already `init()`-ed by the worker entry) so
+ * this file stays importable in tests without wasm glue.
+ */
+function wrapMatch(inner) {
+    const seatToken = inner.seatToken();
+    if (!seatToken) {
+        throw new Error('local match has no viewer seat token');
+    }
+    return {
+        matchId: inner.matchId(),
+        seatToken,
+        connect: () => JSON.parse(inner.connect()),
+        handleMessage: (token, messageJson, nowMs) => JSON.parse(inner.handleMessage(token, messageJson, nowMs)),
+        aiHasWork: () => inner.aiHasWork(),
+        tickAi: nowMs => JSON.parse(inner.tickAi(nowMs)),
+        save: () => inner.save(),
+        toRecordBytes: () => inner.toRecordBytes(),
+        snapshot: () => inner.snapshot(),
+    };
+}
+/**
+ * Wraps an initialized wasm module into the engine contract.
+ */
+export function createWasmEngine(wasm) {
+    return {
+        install: (catalogBytes) => {
+            wasm.install_card_catalog(catalogBytes);
+        },
+        applyCatalogSync: catalogSyncJson => wasm.apply_catalog_sync(catalogSyncJson),
+        createMatch: (requestJson, nowMs) => {
+            const created = wasm.LocalMatch.create(requestJson, nowMs);
+            const match = wrapMatch(created.takeMatch());
+            return { match, accessJson: created.accessJson() };
+        },
+        restoreRecord: bytes => wrapMatch(wasm.LocalMatch.restoreRecord(bytes)),
+        cardsGet: ids => wasm.cards_get(JSON.stringify(ids)),
+        preflightLimitedEvent: requestJson => wasm.limited_events_preflight(requestJson),
+        createLobby: (requestJson) => {
+            const created = wasm.LocalLobby.create(requestJson);
+            const inner = created.takeLobby();
+            const lobby = {
+                lobbyId: inner.lobbyId(),
+                authorize: token => inner.authorize(token),
+                addAiPlayer: difficulty => inner.addAiPlayer(difficulty),
+                setHostReady: ready => inner.setHostReady(ready),
+                start: nowMs => inner.start(nowMs),
+                eventSnapshot: (seatToken, nowMs) => inner.eventSnapshot(seatToken ?? undefined, nowMs),
+                eventApplyCommand: (seatToken, commandJson, nowMs) => inner.eventApplyCommand(seatToken, commandJson, nowMs),
+                submitLimitedDeck: requestJson => inner.submitLimitedDeck(requestJson),
+                prepareLimitedAiDecks: () => inner.prepareLimitedAiDecks(),
+                limitedMatchRequest: () => inner.limitedMatchRequest(),
+                storeStartedMatch: accessJson => inner.storeStartedMatch(accessJson),
+                accessJson: () => inner.accessJson(),
+            };
+            return { lobby, accessJson: created.accessJson() };
+        },
+        offlineDifficulties: () => JSON.parse(wasm.offline_difficulties()),
+        engineVersion: () => wasm.engine_version(),
+    };
+}

package/dist/local/worker-boot.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Boot sequence shared by engine worker entries.
+ *
+ * The worker gets both wasm-bindgen glue and raw wasm bytes from the simulator
+ * server through the main thread's offline asset cache. This prevents npm
+ * package releases from carrying an engine binary and keeps glue paired with
+ * the exact server binary it initializes.
+ */
+import type { WorkerLike } from './protocol.js';
+export interface LocalEngineWorkerBootOptions {
+    /** The worker global scope. */
+    port: WorkerLike;
+}
+/**
+ * Attaches the buffering listener and boots the engine on the `init` frame.
+ */
+export declare function bootLocalEngineWorker(options: LocalEngineWorkerBootOptions): void;

package/dist/local/worker-boot.js

@@ -0,0 +1,76 @@
+/**
+ * Boot sequence shared by engine worker entries.
+ *
+ * The worker gets both wasm-bindgen glue and raw wasm bytes from the simulator
+ * server through the main thread's offline asset cache. This prevents npm
+ * package releases from carrying an engine binary and keeps glue paired with
+ * the exact server binary it initializes.
+ */
+import { createLocalEngineServer } from './server/index.js';
+import { createWasmEngine } from './wasm-engine.js';
+/**
+ * Attaches the buffering listener and boots the engine on the `init` frame.
+ */
+export function bootLocalEngineWorker(options) {
+    const { port } = options;
+    const scope = globalThis;
+    const buffered = [];
+    let booting = false;
+    const bufferListener = (event) => {
+        buffered.push(event);
+        const data = event.data;
+        if (!booting && data?.kind === 'init' && data.wasmBytes && data.glueSource) {
+            booting = true;
+            loadWasmModule(data.glueSource)
+                .then(async ({ initWasm, wasmModule }) => {
+                await initWasm({ module_or_path: data.wasmBytes });
+                return wasmModule;
+            })
+                .then((wasmModule) => {
+                scope.removeEventListener('message', bufferListener);
+                createLocalEngineServer({ engine: createWasmEngine(wasmModule), port });
+                for (const bufferedEvent of buffered.splice(0)) {
+                    scope.dispatchEvent(new MessageEvent('message', { data: bufferedEvent.data }));
+                }
+            })
+                .catch((error) => {
+                // eslint-disable-next-line no-console
+                console.error('[swu-local-worker] wasm init failed', error);
+                const message = `wasm init failed: ${String(error)}`;
+                port.postMessage({ kind: 'error', id: -1, message });
+                // Dead-letter mode: without this, later frames (e.g. a retried
+                // `init`) would buffer forever with no response. The worker cannot
+                // recover a failed wasm compile — callers must spawn a new one.
+                scope.removeEventListener('message', bufferListener);
+                const reject = (data) => {
+                    const id = data?.id;
+                    if (typeof id === 'number') {
+                        port.postMessage({ kind: 'error', id, message });
+                    }
+                };
+                for (const bufferedEvent of buffered.splice(0)) {
+                    reject(bufferedEvent.data);
+                }
+                scope.addEventListener('message', event => reject(event.data));
+            });
+        }
+    };
+    scope.addEventListener('message', bufferListener);
+}
+/** Imports server-provided wasm-bindgen glue without relying on app bundling. */
+async function loadWasmModule(glueSource) {
+    const url = URL.createObjectURL(new Blob([glueSource], { type: 'text/javascript' }));
+    try {
+        const module = await import(/* @vite-ignore */ url);
+        if (typeof module.default !== 'function') {
+            throw new Error('wasm glue has no initializer');
+        }
+        return {
+            initWasm: module.default,
+            wasmModule: module,
+        };
+    }
+    finally {
+        URL.revokeObjectURL(url);
+    }
+}

package/dist/local/worker.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Engine worker entry: boots the wasm engine from the transport's `init`
+ * frame (which carries server-served wasm, glue, and card asset bytes) and serves the local RPC
+ * protocol on the worker port. See `worker-boot.ts` for the sequence.
+ */
+export {};

package/dist/local/worker.js

@@ -0,0 +1,9 @@
+/**
+ * Engine worker entry: boots the wasm engine from the transport's `init`
+ * frame (which carries server-served wasm, glue, and card asset bytes) and serves the local RPC
+ * protocol on the worker port. See `worker-boot.ts` for the sequence.
+ */
+import { bootLocalEngineWorker } from './worker-boot.js';
+bootLocalEngineWorker({
+    port: globalThis,
+});

package/dist/match-session/access.d.ts

@@ -0,0 +1,6 @@
+import type { MatchAccess, MatchReference, MatchSpectatorAccess } from '../resources/matches.js';
+import type { MatchSessionAccess } from './types.js';
+/** Checks whether access includes response-only session seed fields. */
+export declare function hasAccessSnapshot(access: MatchSessionAccess): access is MatchAccess | MatchSpectatorAccess;
+/** Normalizes a string match id into a match reference. */
+export declare function matchReferenceFrom(match: string | MatchReference): MatchReference;

package/dist/match-session/access.js

@@ -0,0 +1,8 @@
+/** Checks whether access includes response-only session seed fields. */
+export function hasAccessSnapshot(access) {
+    return 'snapshot' in access;
+}
+/** Normalizes a string match id into a match reference. */
+export function matchReferenceFrom(match) {
+    return typeof match === 'string' ? { matchId: match } : match;
+}

package/dist/match-session/controller.d.ts

@@ -0,0 +1,63 @@
+import { MatchConnection } from '../connection.js';
+import type { CardInteractionCueRequest } from '../generated/types/client-message.js';
+import type { FormatEventCommand } from '../generated/types/format-event-request.js';
+import type { AiStatusPayload, CreateMatchRequest, ErrorPayload, GameCommand, GameEvent, GameState, JoinMatchRequest, SpectateMatchRequest, WelcomePayload } from '../generated/index.js';
+import type { MatchHistoryFeedEntry } from '../generated/types/server-message.js';
+import type { ConnectionState } from '../session.js';
+import type { MatchAccess, MatchConnectionAccessInput, MatchReference, MatchSpectatorAccess, MatchesResource } from '../resources/matches.js';
+import type { MatchSeat, MatchSession, MatchSessionAccess, MatchSessionConnectOptions, MatchSessionEvents, MatchSessionOptions, MatchSessionReconnectState, MatchSessionSnapshotPredicate, MatchSessionState, MatchSessionWaitOptions } from './types.js';
+/** Dependencies required to construct match sessions. */
+export interface MatchSessionControllerOptions {
+    /** Initial private access. */
+    access?: MatchSessionAccess | undefined;
+    /** Default connection/session options. */
+    options?: MatchSessionOptions | undefined;
+    /** Match HTTP resource used by session lifecycle helpers. */
+    matches: MatchesResource;
+    /** Opens the internal raw socket connection. */
+    openConnection: (access: MatchConnectionAccessInput, options?: MatchSessionConnectOptions) => Promise<MatchConnection>;
+}
+/** SDK-owned live match session implementation. */
+export declare class MatchSessionController implements MatchSession {
+    #private;
+    /**
+     * Vue reactivity opt-out. The controller relies on `#private` class fields
+     * which are unreachable through a `Proxy`, so Vue must not wrap it. This
+     * is Vue's documented escape hatch (`ReactiveFlags.SKIP`) and is a no-op
+     * in non-Vue runtimes.
+     */
+    readonly __v_skip = true;
+    /** Creates one match session controller. */
+    constructor(options: MatchSessionControllerOptions);
+    get connectionState(): ConnectionState;
+    get aiStatus(): AiStatusPayload | undefined;
+    get errors(): readonly ErrorPayload[];
+    get events(): readonly GameEvent[];
+    get history(): readonly MatchHistoryFeedEntry[];
+    get errorMessages(): readonly string[];
+    get matchId(): string | undefined;
+    get reconnectState(): MatchSessionReconnectState;
+    get snapshot(): GameState | undefined;
+    get seat(): MatchSeat | undefined;
+    get state(): MatchSessionState;
+    get welcome(): WelcomePayload | undefined;
+    connect(access?: MatchSessionAccess, options?: MatchSessionConnectOptions): Promise<MatchSession>;
+    createMatch(request: CreateMatchRequest, options?: MatchSessionConnectOptions): Promise<MatchAccess>;
+    joinMatch(match: string | MatchReference, request: JoinMatchRequest, options?: MatchSessionConnectOptions): Promise<MatchAccess>;
+    spectateMatch(match: string | MatchReference, request: SpectateMatchRequest, options?: MatchSessionConnectOptions): Promise<MatchSpectatorAccess>;
+    close(): void;
+    reconnect(options?: MatchSessionConnectOptions): Promise<MatchSession>;
+    ready(): void;
+    undo(): void;
+    respondUndo(approve: boolean): void;
+    setAiPaused(paused: boolean): void;
+    sync(): void;
+    ping(nonce?: string | null): void;
+    sendCommand(command: GameCommand): void;
+    sendFormatEvent(command: FormatEventCommand): void;
+    sendAiFormatEvent(command: FormatEventCommand): void;
+    sendChat(message: string): void;
+    sendInteractionCue(cue: CardInteractionCueRequest): void;
+    on<TKey extends keyof MatchSessionEvents>(event: TKey, listener: (value: MatchSessionEvents[TKey]) => void): () => void;
+    waitForSnapshot(predicate?: MatchSessionSnapshotPredicate, options?: MatchSessionWaitOptions): Promise<GameState>;
+}