@my-swu/simulator-client 0.1.0

package/dist/connection.js

@@ -0,0 +1,358 @@
+import { TypedEmitter } from './internal/emitter.js';
+import { DEFAULT_MATCH_HISTORY_LIMIT } from './internal/limits.js';
+import { getDefaultWebSocketFactory } from './internal/transport.js';
+import { aiFormatEventMessage, commandMessage, chatMessage, formatEventMessage, interactionCueMessage, pingMessage, readyMessage, setAiPausedMessage, syncRequestMessage, undoMessage, undoResponseMessage, } from './messages.js';
+import { passthroughValidator } from './validators/validator.js';
+import { decodeSocketFrame } from './internal/socket-frame.js';
+import { waitForSocketHandshake } from './connection/handshake.js';
+import { DEFAULT_WAIT_TIMEOUT_MS, anySnapshot } from './connection/wait.js';
+import { buildMatchSocketUrl, matchSocketProtocols } from './connection/url.js';
+const DEFAULT_HANDSHAKE_TIMEOUT_MS = 10_000;
+/**
+ * Stateful typed connection to one simulator match socket.
+ */
+export class MatchConnection {
+    #emitter = new TypedEmitter();
+    #matchId;
+    #token;
+    #validator;
+    #webSocketFactory;
+    #wsUrl;
+    #handshakeTimeoutMs;
+    #socket;
+    #detachSocket;
+    #connectionState = 'idle';
+    #aiStatus;
+    #history = [];
+    #historySnapshotReceived = false;
+    /**
+     * Highest revision this connection has accepted as authoritative snapshot
+     * state, including the fence carried by a full recovery history snapshot.
+     */
+    #latestSnapshotUpdateRevision;
+    #snapshot;
+    #welcome;
+    constructor(options) {
+        this.#matchId = options.matchId;
+        this.#token = options.spectatorToken != null
+            ? { spectatorToken: options.spectatorToken }
+            : { seatToken: options.seatToken };
+        this.#validator = options.validate ?? passthroughValidator;
+        this.#webSocketFactory = options.webSocketFactory ?? getDefaultWebSocketFactory();
+        this.#wsUrl = options.wsUrl;
+        this.#handshakeTimeoutMs = options.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS;
+    }
+    /**
+     * Opens one socket and waits for initial welcome plus snapshot.
+     */
+    static async connect(options) {
+        const connection = new MatchConnection(options);
+        await connection.#open();
+        return connection;
+    }
+    /**
+     * Latest connection state.
+     */
+    get connectionState() {
+        return this.#connectionState;
+    }
+    /**
+     * Latest AI attachment/pause status announced by the server.
+     */
+    get aiStatus() {
+        return this.#aiStatus;
+    }
+    /**
+     * Revision of the latest authoritative snapshot accepted by this connection.
+     */
+    get snapshotRevision() {
+        return this.#latestSnapshotUpdateRevision ?? 0;
+    }
+    /**
+     * Latest known match snapshot.
+     */
+    get snapshot() {
+        return this.#snapshot;
+    }
+    /**
+     * Latest match-history entries announced by the server.
+     */
+    get history() {
+        return [...this.#history];
+    }
+    /** Whether this socket received its full recovery history, even if empty. */
+    get historySnapshotReceived() {
+        return this.#historySnapshotReceived;
+    }
+    /**
+     * Latest welcome payload.
+     */
+    get welcome() {
+        return this.#welcome;
+    }
+    /**
+     * Registers one typed event listener.
+     */
+    on(event, listener) {
+        return this.#emitter.on(event, listener);
+    }
+    /**
+     * Sends one `ready` message.
+     */
+    ready() {
+        this.#sendEnvelope(readyMessage());
+    }
+    /**
+     * Requests a rollback of the latest accepted player action.
+     */
+    undo() {
+        this.#sendEnvelope(undoMessage());
+    }
+    /**
+     * Answers (or withdraws, when sent by the requester) the pending undo
+     * approval request carried by `GameState.pendingUndo`.
+     */
+    respondUndo(approve) {
+        this.#sendEnvelope(undoResponseMessage(approve));
+    }
+    /**
+     * Pauses or resumes an attached AI opponent for this match.
+     */
+    setAiPaused(paused) {
+        this.#sendEnvelope(setAiPausedMessage(paused));
+    }
+    /**
+     * Sends one typed game command.
+     *
+     * When the client validates, the envelope is checked against
+     * `client-message`, which already references the `game-command` schema, so no
+     * extra validation is required.
+     */
+    sendCommand(command) {
+        this.#sendEnvelope(commandMessage(command));
+    }
+    /**
+     * Sends one typed out-of-game format-event command.
+     */
+    sendFormatEvent(command) {
+        this.#sendEnvelope(formatEventMessage(command));
+    }
+    /**
+     * Sends one host-authorized AI format-event command.
+     */
+    sendAiFormatEvent(command) {
+        this.#sendEnvelope(aiFormatEventMessage(command));
+    }
+    /**
+     * Sends one in-match chat message.
+     */
+    sendChat(message) {
+        this.#sendEnvelope(chatMessage(message));
+    }
+    /**
+     * Sends one transient hand-card interaction cue.
+     */
+    sendInteractionCue(cue) {
+        this.#sendEnvelope(interactionCueMessage(cue));
+    }
+    /**
+     * Requests one fresh snapshot.
+     */
+    sync() {
+        this.#sendEnvelope(syncRequestMessage());
+    }
+    /**
+     * Sends one ping frame with optional nonce.
+     */
+    ping(nonce) {
+        this.#sendEnvelope(pingMessage(nonce));
+    }
+    /**
+     * Closes the current socket and detaches its listeners.
+     */
+    close() {
+        this.#teardownSocket();
+        this.#setConnectionState('closed');
+    }
+    /**
+     * Reconnects and then requests one explicit sync snapshot.
+     */
+    async reconnect(options = {}) {
+        const previousTimeout = this.#handshakeTimeoutMs;
+        this.#handshakeTimeoutMs = options.handshakeTimeoutMs ?? previousTimeout;
+        this.#teardownSocket();
+        try {
+            await this.#open();
+            this.sync();
+        }
+        finally {
+            this.#handshakeTimeoutMs = previousTimeout;
+        }
+    }
+    /**
+     * Resolves with the current or next snapshot that matches the predicate.
+     */
+    waitForSnapshot(predicate = anySnapshot(), options = {}) {
+        if (this.#snapshot != null && predicate(this.#snapshot)) {
+            return Promise.resolve(this.#snapshot);
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+            const timer = setTimeout(() => {
+                stop();
+                reject(new Error('timed out waiting for snapshot'));
+            }, timeoutMs);
+            const stop = this.on('snapshot', (snapshot) => {
+                if (!predicate(snapshot)) {
+                    return;
+                }
+                clearTimeout(timer);
+                stop();
+                resolve(snapshot);
+            });
+        });
+    }
+    async #open() {
+        this.#setConnectionState('connecting');
+        const socket = this.#webSocketFactory(buildMatchSocketUrl({
+            matchId: this.#matchId,
+            wsUrl: this.#wsUrl,
+        }), 
+        // The auth token travels off-URL via the Sec-WebSocket-Protocol header.
+        matchSocketProtocols(this.#token));
+        this.#socket = socket;
+        // Persistent per-socket handlers. Owned by the socket, torn down together.
+        const onMessage = (event) => this.#parseIncomingMessage(event);
+        const onLifetimeClose = () => {
+            // Only transition to closed if this is still the active socket.
+            if (this.#socket === socket) {
+                this.#detachSocket = undefined;
+                this.#socket = undefined;
+                this.#setConnectionState('closed');
+            }
+        };
+        socket.addEventListener('message', onMessage);
+        socket.addEventListener('close', onLifetimeClose);
+        this.#detachSocket = () => {
+            socket.removeEventListener('message', onMessage);
+            socket.removeEventListener('close', onLifetimeClose);
+            try {
+                socket.close();
+            }
+            catch {
+                // Ignore double close.
+            }
+            if (this.#socket === socket) {
+                this.#socket = undefined;
+            }
+            this.#detachSocket = undefined;
+        };
+        try {
+            await waitForSocketHandshake({
+                onSnapshot: listener => this.on('snapshot', listener),
+                onTransportOpen: () => this.#setConnectionState('open'),
+                onWelcome: listener => this.on('welcome', listener),
+                socket,
+                timeoutMs: this.#handshakeTimeoutMs,
+            });
+        }
+        catch (error) {
+            if (this.#socket === socket) {
+                this.#teardownSocket();
+                this.#setConnectionState('closed');
+            }
+            throw error;
+        }
+    }
+    #teardownSocket() {
+        this.#detachSocket?.();
+    }
+    #parseIncomingMessage(event) {
+        const decoded = decodeSocketFrame(event, this.#validator, 'server-message');
+        if (decoded.type === 'ignored') {
+            return undefined;
+        }
+        if (decoded.type === 'error') {
+            this.#emitter.emit('error', decoded.error);
+            return undefined;
+        }
+        const parsed = decoded.message;
+        this.#emitter.emit('message', parsed);
+        switch (parsed.type) {
+            case 'welcome':
+                this.#welcome = parsed.payload;
+                if (parsed.payload.aiStatus != null) {
+                    this.#aiStatus = parsed.payload.aiStatus;
+                    this.#emitter.emit('aiStatus', parsed.payload.aiStatus);
+                }
+                this.#emitter.emit('welcome', parsed.payload);
+                break;
+            case 'snapshot':
+                this.#snapshot = parsed.payload;
+                this.#emitter.emit('snapshot', parsed.payload);
+                break;
+            case 'snapshotUpdate':
+                if (this.#latestSnapshotUpdateRevision != null
+                    && parsed.payload.revision <= this.#latestSnapshotUpdateRevision) {
+                    break;
+                }
+                this.#latestSnapshotUpdateRevision = parsed.payload.revision;
+                this.#snapshot = parsed.payload.snapshot;
+                this.#emitter.emit('snapshot', parsed.payload.snapshot);
+                break;
+            case 'historySnapshot':
+                // Full recovery sends Snapshot followed by HistorySnapshot. Raising
+                // this floor prevents delayed pub/sub SnapshotUpdate frames from
+                // replacing that recovered state.
+                this.#latestSnapshotUpdateRevision = Math.max(this.#latestSnapshotUpdateRevision ?? 0, parsed.payload.snapshotRevision);
+                this.#historySnapshotReceived = true;
+                this.#history = [...parsed.payload.entries];
+                this.#emitter.emit('historySnapshot', parsed.payload);
+                break;
+            case 'historyEntry': {
+                // Same retention contract as `MatchSession`: a re-delivered entry
+                // replaces its earlier copy, and the feed stays bounded so a long
+                // match cannot grow it (and its copy-on-append cost) without limit.
+                const withoutDuplicate = this.#history.filter(existing => existing.id !== parsed.payload.id);
+                this.#history = [...withoutDuplicate, parsed.payload].slice(-DEFAULT_MATCH_HISTORY_LIMIT);
+                this.#emitter.emit('historyEntry', parsed.payload);
+                break;
+            }
+            case 'event':
+                this.#emitter.emit('event', parsed.payload);
+                break;
+            case 'interactionCue':
+                this.#emitter.emit('interactionCue', parsed.payload);
+                break;
+            case 'aiStatus':
+                this.#aiStatus = parsed.payload;
+                this.#emitter.emit('aiStatus', parsed.payload);
+                break;
+            case 'error':
+                this.#emitter.emit('error', parsed.payload);
+                break;
+            case 'pong':
+                this.#emitter.emit('pong', parsed.payload);
+                break;
+            default:
+                parsed;
+        }
+        return parsed;
+    }
+    #sendEnvelope(message) {
+        // Liveness first: a send on a closed connection fails for that reason
+        // alone, so it must not pay for full envelope validation on the way out.
+        if (this.#socket == null || this.#connectionState !== 'open') {
+            throw new Error('match connection is not open');
+        }
+        this.#validator.parse('client-message', message);
+        this.#socket.send(JSON.stringify(message));
+    }
+    #setConnectionState(state) {
+        if (this.#connectionState === state) {
+            return;
+        }
+        this.#connectionState = state;
+        this.#emitter.emit('connectionState', state);
+    }
+}

package/dist/generated/index.d.ts

@@ -0,0 +1,121 @@
+/** Generated SDK wire types. */
+export type { SimulatorReportListResponse } from './types/simulator-report-list-response.js';
+export type { SimulatorReportResponse } from './types/simulator-report-response.js';
+export type { HealthResponse } from './types/health-response.js';
+export type { SimulatorAvailabilityResponse } from './types/simulator-availability-response.js';
+export type { SimulatorAdminStatusResponse } from './types/simulator-admin-status-response.js';
+export type { CardCatalogRefreshResponse } from './types/card-catalog-refresh-response.js';
+export type { SetSimulatorMaintenanceRequest } from './types/set-simulator-maintenance-request.js';
+export type { SetRankedAdmissionRequest } from './types/set-ranked-admission-request.js';
+export type { ApiErrorResponse } from './types/api-error-response.js';
+export type { MetaWindow } from './types/meta-window.js';
+export type { RankedQueue } from './types/ranked-queue.js';
+export type { RankedAdminStatus } from './types/ranked-admin-status.js';
+export type { RankedMatchmakingView } from './types/ranked-matchmaking-view.js';
+export type { RankedLeaderboardEntry } from './types/ranked-leaderboard-entry.js';
+export type { CreateMetaWindowRequest } from './types/create-meta-window-request.js';
+export type { MetaWindowsResponse } from './types/meta-windows-response.js';
+export type { RankedProfileRequest } from './types/ranked-profile-request.js';
+export type { RankedProfileResponse } from './types/ranked-profile-response.js';
+export type { RankedLeaderboardQuery } from './types/ranked-leaderboard-query.js';
+export type { RankedLeaderboardResponse } from './types/ranked-leaderboard-response.js';
+export type { CreateMatchRequest } from './types/create-match-request.js';
+export type { CreateLobbyRequest } from './types/create-lobby-request.js';
+export type { JoinLobbyRequest } from './types/join-lobby-request.js';
+export type { SpectateLobbyRequest } from './types/spectate-lobby-request.js';
+export type { LobbyMatchmakingRequest } from './types/lobby-matchmaking-request.js';
+export type { LobbySyncRequest } from './types/lobby-sync-request.js';
+export type { LobbyMatchmakingDecisionRequest } from './types/lobby-matchmaking-decision-request.js';
+export type { UpdateLobbyPlayerRequest } from './types/update-lobby-player-request.js';
+export type { UpdateLobbyAiPlayerRequest } from './types/update-lobby-ai-player-request.js';
+export type { AddLobbyAiPlayerRequest } from './types/add-lobby-ai-player-request.js';
+export type { LobbyChatRequest } from './types/lobby-chat-request.js';
+export type { StartLobbyRequest } from './types/start-lobby-request.js';
+export type { ReturnLobbyMatchRequest } from './types/return-lobby-match-request.js';
+export type { SubmitLobbyLimitedDeckRequest } from './types/submit-lobby-limited-deck-request.js';
+export type { PrepareLobbyLimitedAiDecksRequest } from './types/prepare-lobby-limited-ai-decks-request.js';
+export type { StartLobbyLimitedMatchRequest } from './types/start-lobby-limited-match-request.js';
+export type { LeaveLobbyRequest } from './types/leave-lobby-request.js';
+export type { KickLobbyPlayerRequest } from './types/kick-lobby-player-request.js';
+export type { KickLobbySpectatorRequest } from './types/kick-lobby-spectator-request.js';
+export type { UpdateLobbySettingsRequest } from './types/update-lobby-settings-request.js';
+export type { LobbyResponse } from './types/lobby-response.js';
+export type { LobbyListResponse } from './types/lobby-list-response.js';
+export type { LobbyAccessResponse } from './types/lobby-access-response.js';
+export type { LobbyChatResponse } from './types/lobby-chat-response.js';
+export type { LobbyServerMessage } from './types/lobby-server-message.js';
+export type { LobbyListServerMessage } from './types/lobby-list-server-message.js';
+export type { CreateTournamentRoomRequest } from './types/create-tournament-room-request.js';
+export type { JoinTournamentRoomRequest } from './types/join-tournament-room-request.js';
+export type { TournamentRoomSyncRequest } from './types/tournament-room-sync-request.js';
+export type { UpdateTournamentRoomPlayerRequest } from './types/update-tournament-room-player-request.js';
+export type { UpdateTournamentRoomSettingsRequest } from './types/update-tournament-room-settings-request.js';
+export type { TournamentRoomChatRequest } from './types/tournament-room-chat-request.js';
+export type { StartTournamentEventRequest } from './types/start-tournament-event-request.js';
+export type { TournamentEventCommandRequest } from './types/tournament-event-command-request.js';
+export type { SubmitTournamentDeckRequest } from './types/submit-tournament-deck-request.js';
+export type { CreateTournamentTableRequest } from './types/create-tournament-table-request.js';
+export type { JoinTournamentTableRequest } from './types/join-tournament-table-request.js';
+export type { ReturnTournamentMatchRequest } from './types/return-tournament-match-request.js';
+export type { LeaveTournamentRoomRequest } from './types/leave-tournament-room-request.js';
+export type { CloseTournamentRoomRequest } from './types/close-tournament-room-request.js';
+export type { TournamentRoomResponse } from './types/tournament-room-response.js';
+export type { TournamentRoomListResponse } from './types/tournament-room-list-response.js';
+export type { TournamentRoomAccessResponse } from './types/tournament-room-access-response.js';
+export type { TournamentRoomChatResponse } from './types/tournament-room-chat-response.js';
+export type { TournamentRoomServerMessage } from './types/tournament-room-server-message.js';
+export type { CreateLimitedEventRequest } from './types/create-limited-event-request.js';
+export type { LimitedEventAccessResponse } from './types/limited-event-access-response.js';
+export type { LimitedEventPreflightResponse } from './types/limited-event-preflight-response.js';
+export type { LimitedEventResponse } from './types/limited-event-response.js';
+export type { LimitedEventCommandRequest } from './types/limited-event-command-request.js';
+export type { JoinLimitedEventRequest } from './types/join-limited-event-request.js';
+export type { MatchAccessResponse } from './types/match-access-response.js';
+export type { AbandonMatchRequest } from './types/abandon-match-request.js';
+export type { AbandonMatchResponse } from './types/abandon-match-response.js';
+export type { ListActiveAiMatchesRequest } from './types/list-active-ai-matches-request.js';
+export type { ListActiveAiMatchesResponse } from './types/list-active-ai-matches-response.js';
+export type { LeaveMatchRequest } from './types/leave-match-request.js';
+export type { LeaveMatchResponse } from './types/leave-match-response.js';
+export type { MatchSpectatorAccessResponse } from './types/match-spectator-access-response.js';
+export type { JoinMatchRequest } from './types/join-match-request.js';
+export type { SpectateMatchRequest } from './types/spectate-match-request.js';
+export type { SubmitMatchDeckRequest } from './types/submit-match-deck-request.js';
+export type { SubmitMatchDeckResponse } from './types/submit-match-deck-response.js';
+export type { FormatEventRequest } from './types/format-event-request.js';
+export type { FormatEventResponse } from './types/format-event-response.js';
+export type { UndoMatchRequest } from './types/undo-match-request.js';
+export type { UndoMatchResponse } from './types/undo-match-response.js';
+export type { UndoRespondMatchRequest } from './types/undo-respond-match-request.js';
+export type { RematchMatchRequest } from './types/rematch-match-request.js';
+export type { RematchMatchResponse } from './types/rematch-match-response.js';
+export type { SetAiPausedRequest } from './types/set-ai-paused-request.js';
+export type { AiStatusPayload } from './types/set-ai-paused-response.js';
+export type { GetMatchResponse } from './types/get-match-response.js';
+export type { MatchHistoryListRequest } from './types/match-history-list-request.js';
+export type { MatchHistoryListResponse } from './types/match-history-list-response.js';
+export type { MatchHistoryDeckStatsRequest } from './types/match-history-deck-stats-request.js';
+export type { MatchHistoryDeckStatsResponse } from './types/match-history-deck-stats-response.js';
+export type { MatchHistoryEntry } from './types/match-history-entry.js';
+export type { MatchHistoryReplayRequest } from './types/match-history-replay-request.js';
+export type { MatchHistoryReplayResponse } from './types/match-history-replay-response.js';
+export type { MatchChatLookupResponse } from './types/match-chat-lookup-response.js';
+export type { MatchHistoryRestoreRequest } from './types/match-history-restore-request.js';
+export type { RestoreHistoryResponse } from './types/restore-history-response.js';
+export type { CardsResponse } from './types/cards-response.js';
+export type { ResolveCardIdsRequest } from './types/resolve-card-ids-request.js';
+export type { ResolveCardIdsResponse } from './types/resolve-card-ids-response.js';
+export type { ClientMessage } from './types/client-message.js';
+export type { ServerMessage } from './types/server-message.js';
+export type { GameCommand } from './types/game-command.js';
+export type { GameEvent } from './types/game-event.js';
+export type { GameState } from './types/game-state.js';
+export type { MatchConnectionRole } from './types/match-connection-role.js';
+export type { WelcomePayload } from './types/welcome-payload.js';
+export type { ErrorPayload } from './types/error-payload.js';
+export type { MatchSavePayload } from './types/match-save-payload.js';
+export type { SaveMatchRequest } from './types/save-match-request.js';
+export type { RestoreMatchSaveRequest } from './types/restore-match-save-request.js';
+export type { RestoreMatchSaveResponse } from './types/restore-match-save-response.js';
+export type * from './public-types.js';
+export { schemaVersion } from './version.js';

package/dist/generated/index.js

@@ -0,0 +1 @@
+export { schemaVersion } from './version.js';

package/dist/generated/public-types.d.ts

@@ -0,0 +1,2 @@
+/** Generated dependency-closed public wire types. */
+export type * from './types/common.js';

package/dist/generated/public-types.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/schemas.d.ts

@@ -0,0 +1,27 @@
+export { schemaVersion } from './version.js';
+/**
+ * Kebab-case names of every generated schema file stem.
+ *
+ * Declared separately from `sdkSchemas` so the public `SchemaName` union is
+ * a small, serializable tuple type. Deriving it from `keyof typeof
+ * sdkSchemas` would force TypeScript to serialize the entire inlined schema
+ * map in the emitted declaration file, overflowing its serializer.
+ */
+export declare const schemaNames: readonly ["simulator-report-list-response", "simulator-report-response", "health-response", "simulator-availability-response", "simulator-admin-status-response", "card-catalog-refresh-response", "set-simulator-maintenance-request", "set-ranked-admission-request", "api-error-response", "meta-window", "ranked-queue", "ranked-admin-status", "ranked-matchmaking-view", "ranked-leaderboard-entry", "create-meta-window-request", "meta-windows-response", "ranked-profile-request", "ranked-profile-response", "ranked-leaderboard-query", "ranked-leaderboard-response", "create-match-request", "create-lobby-request", "join-lobby-request", "spectate-lobby-request", "lobby-matchmaking-request", "lobby-sync-request", "lobby-matchmaking-decision-request", "update-lobby-player-request", "update-lobby-ai-player-request", "add-lobby-ai-player-request", "lobby-chat-request", "start-lobby-request", "return-lobby-match-request", "submit-lobby-limited-deck-request", "prepare-lobby-limited-ai-decks-request", "start-lobby-limited-match-request", "leave-lobby-request", "kick-lobby-player-request", "kick-lobby-spectator-request", "update-lobby-settings-request", "lobby-response", "lobby-list-response", "lobby-access-response", "lobby-chat-response", "lobby-server-message", "lobby-list-server-message", "create-tournament-room-request", "join-tournament-room-request", "tournament-room-sync-request", "update-tournament-room-player-request", "update-tournament-room-settings-request", "tournament-room-chat-request", "start-tournament-event-request", "tournament-event-command-request", "submit-tournament-deck-request", "create-tournament-table-request", "join-tournament-table-request", "return-tournament-match-request", "leave-tournament-room-request", "close-tournament-room-request", "tournament-room-response", "tournament-room-list-response", "tournament-room-access-response", "tournament-room-chat-response", "tournament-room-server-message", "create-limited-event-request", "limited-event-access-response", "limited-event-preflight-response", "limited-event-response", "limited-event-command-request", "join-limited-event-request", "match-access-response", "abandon-match-request", "abandon-match-response", "list-active-ai-matches-request", "list-active-ai-matches-response", "leave-match-request", "leave-match-response", "match-spectator-access-response", "join-match-request", "spectate-match-request", "submit-match-deck-request", "submit-match-deck-response", "format-event-request", "format-event-response", "undo-match-request", "undo-match-response", "undo-respond-match-request", "rematch-match-request", "rematch-match-response", "set-ai-paused-request", "set-ai-paused-response", "get-match-response", "match-history-list-request", "match-history-list-response", "match-history-deck-stats-request", "match-history-deck-stats-response", "match-history-entry", "match-history-replay-request", "match-history-replay-response", "match-chat-lookup-response", "match-history-restore-request", "restore-history-response", "cards-response", "resolve-card-ids-request", "resolve-card-ids-response", "client-message", "server-message", "game-command", "game-event", "game-state", "match-connection-role", "welcome-payload", "error-payload", "match-save-payload", "save-match-request", "restore-match-save-request", "restore-match-save-response"];
+export type SchemaName = (typeof schemaNames)[number];
+/**
+ * Definitions shared by every generated root schema.
+ *
+ * The roots reference these by absolute `$id` instead of inlining a private
+ * copy each, so a validator must register this document before them. Shipping
+ * the pool once rather than once per root is what keeps the bundled schema map
+ * small enough for a browser bundle.
+ */
+export declare const sdkSchemaCommon: Record<string, unknown>;
+/**
+ * Generated schema map keyed by kebab-case schema file stem.
+ *
+ * Each entry references {@link sdkSchemaCommon} for shared definitions, so it
+ * only validates once that document is registered alongside it.
+ */
+export declare const sdkSchemas: Record<SchemaName, Record<string, unknown>>;