@my-swu/simulator-client 0.1.0

package/dist/resources/session.d.ts

@@ -0,0 +1,62 @@
+import type { MatchSession, MatchSessionAccess, MatchSessionOptions } from '../match-session.js';
+import type { WebSocketFactory } from '../internal/transport.js';
+import type { SchemaValidator } from '../validators/validator.js';
+import type { MatchesResource } from './matches.js';
+/**
+ * Session resource for creating SDK-owned match sessions.
+ *
+ * A `MatchSession` stores private access, owns one live socket at a time, and
+ * keeps renderable token-free state for UI consumers.
+ *
+ * @example
+ * ```ts
+ * import { createSimulatorClient } from '@my-swu/simulator-client'
+ *
+ * const simulatorClient = createSimulatorClient({
+ *   baseUrl: 'http://127.0.0.1:4000',
+ * })
+ * const hostAccess = { matchId: 'match_123', seatToken: 'seat_token_123' }
+ *
+ * const matchSession = simulatorClient.session.create(hostAccess)
+ * console.log(matchSession.connectionState)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-session
+ */
+export interface SessionResource {
+    /**
+     * Creates one idle or access-seeded match session.
+     *
+     * Seed with access when you already created or joined a match. Omit access
+     * when the session will call `createMatch()` or `joinMatch()` itself.
+     *
+     * @example
+     * ```ts
+     * import { createSimulatorClient } from '@my-swu/simulator-client'
+     *
+     * const simulatorClient = createSimulatorClient({
+     *   baseUrl: 'http://127.0.0.1:4000',
+     * })
+     * const hostAccess = { matchId: 'match_123', seatToken: 'seat_token_123' }
+     *
+     * const matchSession = simulatorClient.session.create(hostAccess)
+     * await matchSession.connect()
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle#session
+     */
+    create(access?: MatchSessionAccess, options?: MatchSessionOptions): MatchSession;
+}
+/** Dependencies required by the session resource. */
+export interface SessionResourceOptions {
+    /** HTTP match resource used by session lifecycle helpers. */
+    matches: MatchesResource;
+    /** Boundary validator applied to match socket frames and envelopes. */
+    validate?: SchemaValidator | undefined;
+    /** Optional socket factory for runtimes without global `WebSocket`. */
+    webSocketFactory?: WebSocketFactory | undefined;
+    /** Base WebSocket URL ending at `/ws`. */
+    wsUrl: string;
+}
+/** Creates the high-level match session resource. */
+export declare function createSessionResource(options: SessionResourceOptions): SessionResource;

package/dist/resources/session.js

@@ -0,0 +1,26 @@
+import { MatchConnection } from '../connection.js';
+import { MatchSessionController } from '../match-session.js';
+/** Creates the high-level match session resource. */
+export function createSessionResource(options) {
+    return {
+        create: (access, sessionOptions) => new MatchSessionController({
+            access,
+            matches: options.matches,
+            openConnection: (connectionAccess, connectOptions) => MatchConnection.connect({
+                matchId: connectionAccess.matchId,
+                ...connectionAccessToken(connectionAccess),
+                wsUrl: options.wsUrl,
+                ...(options.validate == null ? {} : { validate: options.validate }),
+                ...(connectOptions?.handshakeTimeoutMs == null ? {} : { handshakeTimeoutMs: connectOptions.handshakeTimeoutMs }),
+                ...(options.webSocketFactory == null ? {} : { webSocketFactory: options.webSocketFactory }),
+            }),
+            options: sessionOptions,
+        }),
+    };
+}
+/** Extracts the socket credential from a player or spectator access object. */
+function connectionAccessToken(access) {
+    return 'spectatorToken' in access
+        ? { spectatorToken: access.spectatorToken }
+        : { seatToken: access.seatToken };
+}

package/dist/resources/system.d.ts

@@ -0,0 +1,51 @@
+import type { HealthResponse, SimulatorAvailabilityResponse } from '../generated/index.js';
+import type { SimulatorRequestOptions } from '../http/options.js';
+import type { EngineHttpRequester } from '../http/request.js';
+/**
+ * System-level API methods.
+ *
+ * Use these calls for lightweight reachability checks and operational status
+ * before starting match flows.
+ *
+ * @example
+ * ```ts
+ * import { createSimulatorClient } from '@my-swu/simulator-client'
+ *
+ * const simulatorClient = createSimulatorClient({
+ *   baseUrl: 'http://127.0.0.1:4000',
+ * })
+ *
+ * const health = await simulatorClient.system.health()
+ * console.log(health.status)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/http-client
+ */
+export interface SystemResource {
+    /**
+     * Calls the simulator liveness probe.
+     *
+     * @example
+     * ```ts
+     * import { createSimulatorClient } from '@my-swu/simulator-client'
+     *
+     * const simulatorClient = createSimulatorClient({
+     *   baseUrl: 'http://127.0.0.1:4000',
+     * })
+     *
+     * const health = await simulatorClient.system.health()
+     * console.log(health.status)
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/http-client#health-checks
+     */
+    health(options?: SimulatorRequestOptions): Promise<HealthResponse>;
+    /**
+     * Returns whether the simulator is accepting new matches/sessions.
+     */
+    availability(options?: SimulatorRequestOptions): Promise<SimulatorAvailabilityResponse>;
+}
+/**
+ * Creates the system resource client.
+ */
+export declare function createSystemResource(requester: EngineHttpRequester): SystemResource;

package/dist/resources/system.js

@@ -0,0 +1,9 @@
+/**
+ * Creates the system resource client.
+ */
+export function createSystemResource(requester) {
+    return {
+        health: options => requester.request('health-response', '/health', {}, options),
+        availability: options => requester.request('simulator-availability-response', '/api/availability', {}, options),
+    };
+}

package/dist/resources/tournament-room-session.d.ts

@@ -0,0 +1,9 @@
+import type { WebSocketFactory } from '../internal/transport.js';
+import type { SchemaValidator } from '../validators/validator.js';
+import type { TournamentRoomAccessInput, TournamentRoomAccessResponse, TournamentRoomSession } from './tournament-room-types.js';
+export declare function createTournamentRoomSession(options: {
+    access: TournamentRoomAccessInput | TournamentRoomAccessResponse;
+    validate?: SchemaValidator | undefined;
+    webSocketFactory: WebSocketFactory;
+    wsUrl: string;
+}): TournamentRoomSession;

package/dist/resources/tournament-room-session.js

@@ -0,0 +1,53 @@
+import { AuthenticatedSocketSessionController, authenticatedSocketUrl, } from '../internal/authenticated-socket-session.js';
+import { simulatorSocketErrorPayload } from '../internal/errors.js';
+export function createTournamentRoomSession(options) {
+    return new TournamentRoomSessionController({
+        access: normalizeTournamentRoomAccess(options.access),
+        webSocketFactory: options.webSocketFactory,
+        wsUrl: options.wsUrl,
+        ...(options.validate == null ? {} : { validate: options.validate }),
+    });
+}
+function normalizeTournamentRoomAccess(access) {
+    return {
+        roomId: access.roomId,
+        playerToken: access.playerToken,
+    };
+}
+class TournamentRoomSessionController extends AuthenticatedSocketSessionController {
+    constructor(options) {
+        super({
+            messageSchema: 'tournament-room-server-message',
+            playerToken: options.access.playerToken,
+            socketError: info => simulatorSocketErrorPayload(info),
+            socketUrl: authenticatedSocketUrl(options.wsUrl, `tournament-rooms/${encodeURIComponent(options.access.roomId)}`),
+            webSocketFactory: options.webSocketFactory,
+            ...(options.validate == null ? {} : { validate: options.validate }),
+        });
+    }
+    handleServerMessage(message) {
+        switch (message.type) {
+            case 'welcome':
+                this.emit('welcome', message.payload);
+                break;
+            case 'snapshot':
+                this.setSnapshot(message.payload);
+                break;
+            case 'chatMessage':
+                this.emit('chatMessage', message.payload);
+                break;
+            case 'playerPresence':
+                this.emit('playerPresence', message.payload);
+                break;
+            case 'matchReady':
+                this.emit('matchReady', message.payload);
+                break;
+            case 'error':
+                this.pushError(message.payload);
+                break;
+            case 'pong':
+                this.emit('pong', message.payload);
+                break;
+        }
+    }
+}

package/dist/resources/tournament-room-types.d.ts

@@ -0,0 +1,44 @@
+import type { CloseTournamentRoomRequest, CreateTournamentRoomRequest, CreateTournamentTableRequest, JoinTournamentRoomRequest, JoinTournamentTableRequest, LeaveTournamentRoomRequest, ReturnTournamentMatchRequest, StartTournamentEventRequest, SubmitTournamentDeckRequest, TournamentEventCommandRequest, TournamentRoomAccessResponse, TournamentRoomChatRequest, TournamentRoomChatResponse, TournamentRoomListResponse, TournamentRoomResponse, TournamentRoomServerMessage, TournamentRoomSyncRequest, UpdateTournamentRoomPlayerRequest, UpdateTournamentRoomSettingsRequest } from '../generated/index.js';
+import type { PublicTournamentRoomSummary } from '../generated/types/tournament-room-list-response.js';
+import type { TournamentRoomSnapshot } from '../generated/types/tournament-room-response.js';
+import type { ErrorPayload, LobbyChatMessage, TournamentRoomMatchReadyPayload, TournamentRoomWelcomePayload } from '../generated/types/tournament-room-server-message.js';
+import type { ConnectionState } from '../session.js';
+import type { RoomPlayerPresenceEvent } from './lobby-types.js';
+export type { CloseTournamentRoomRequest, CreateTournamentRoomRequest, CreateTournamentTableRequest, JoinTournamentRoomRequest, JoinTournamentTableRequest, LeaveTournamentRoomRequest, ReturnTournamentMatchRequest, StartTournamentEventRequest, SubmitTournamentDeckRequest, TournamentEventCommandRequest, TournamentRoomAccessResponse, TournamentRoomChatRequest, TournamentRoomChatResponse, TournamentRoomListResponse, TournamentRoomResponse, TournamentRoomServerMessage, TournamentRoomSyncRequest, UpdateTournamentRoomPlayerRequest, UpdateTournamentRoomSettingsRequest, };
+export type { PublicTournamentRoomSummary, TournamentRoomSnapshot };
+export type { RoomPlayerPresenceEvent } from './lobby-types.js';
+/** Minimal private tournament room credentials. */
+export interface TournamentRoomAccessInput {
+    roomId: string;
+    playerToken: string;
+}
+/** Events emitted by a tournament room websocket session. */
+export interface TournamentRoomSessionEvents {
+    welcome: TournamentRoomWelcomePayload;
+    snapshot: TournamentRoomSnapshot;
+    chatMessage: LobbyChatMessage;
+    playerPresence: RoomPlayerPresenceEvent;
+    matchReady: TournamentRoomMatchReadyPayload;
+    error: ErrorPayload;
+    pong: Extract<TournamentRoomServerMessage, {
+        type: 'pong';
+    }>['payload'];
+    message: TournamentRoomServerMessage;
+    connectionState: ConnectionState;
+    change: {
+        connectionState: ConnectionState;
+        errors: readonly ErrorPayload[];
+        snapshot: TournamentRoomSnapshot | undefined;
+    };
+}
+/** Live tournament room websocket controller. */
+export interface TournamentRoomSession {
+    readonly connectionState: ConnectionState;
+    readonly errorMessages: readonly string[];
+    readonly errors: readonly TournamentRoomSessionEvents['error'][];
+    readonly snapshot: TournamentRoomSnapshot | undefined;
+    connect(): Promise<TournamentRoomSession>;
+    close(): void;
+    on<TKey extends keyof TournamentRoomSessionEvents>(event: TKey, listener: (value: TournamentRoomSessionEvents[TKey]) => void): () => void;
+    ping(nonce?: string): void;
+}

package/dist/resources/tournament-room-types.js

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

package/dist/resources/tournament-rooms.d.ts

@@ -0,0 +1,33 @@
+import type { SimulatorRequestOptions } from '../http/options.js';
+import type { EngineHttpRequester } from '../http/request.js';
+import type { WebSocketFactory } from '../internal/transport.js';
+import type { SchemaValidator } from '../validators/validator.js';
+import type { CloseTournamentRoomRequest, CreateTournamentRoomRequest, CreateTournamentTableRequest, JoinTournamentRoomRequest, JoinTournamentTableRequest, LeaveTournamentRoomRequest, ReturnTournamentMatchRequest, StartTournamentEventRequest, SubmitTournamentDeckRequest, TournamentEventCommandRequest, TournamentRoomAccessInput, TournamentRoomAccessResponse, TournamentRoomChatRequest, TournamentRoomChatResponse, TournamentRoomListResponse, TournamentRoomResponse, TournamentRoomSession, TournamentRoomSnapshot, TournamentRoomSyncRequest, UpdateTournamentRoomPlayerRequest, UpdateTournamentRoomSettingsRequest } from './tournament-room-types.js';
+export type * from './tournament-room-types.js';
+export interface TournamentRoomsResource {
+    create(request: CreateTournamentRoomRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    list(options?: SimulatorRequestOptions): Promise<TournamentRoomListResponse>;
+    get(roomId: string, options?: SimulatorRequestOptions): Promise<TournamentRoomSnapshot>;
+    join(roomId: string, request: JoinTournamentRoomRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    sync(roomId: string, request: TournamentRoomSyncRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    updatePlayer(roomId: string, request: UpdateTournamentRoomPlayerRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    updateSettings(roomId: string, request: UpdateTournamentRoomSettingsRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    sendChat(roomId: string, request: TournamentRoomChatRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomChatResponse>;
+    startEvent(roomId: string, request: StartTournamentEventRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    applyEventCommand(roomId: string, request: TournamentEventCommandRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    submitDeck(roomId: string, request: SubmitTournamentDeckRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    createTable(roomId: string, request: CreateTournamentTableRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    joinTable(roomId: string, tableId: string, request: JoinTournamentTableRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    returnMatch(roomId: string, request: ReturnTournamentMatchRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    leave(roomId: string, request: LeaveTournamentRoomRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomAccessResponse>;
+    close(roomId: string, request: CloseTournamentRoomRequest, options?: SimulatorRequestOptions): Promise<TournamentRoomResponse>;
+    createSession(access: TournamentRoomAccessInput | TournamentRoomAccessResponse): TournamentRoomSession;
+}
+export interface TournamentRoomsResourceOptions {
+    requester: EngineHttpRequester;
+    /** Boundary validator applied to the tournament-room socket. */
+    validate?: SchemaValidator | undefined;
+    webSocketFactory?: WebSocketFactory | undefined;
+    wsUrl: string;
+}
+export declare function createTournamentRoomsResource(options: TournamentRoomsResourceOptions): TournamentRoomsResource;

package/dist/resources/tournament-rooms.js

@@ -0,0 +1,33 @@
+import { createValidatedJsonPost } from '../http/validated-json.js';
+import { getDefaultWebSocketFactory } from '../internal/transport.js';
+import { createTournamentRoomSession } from './tournament-room-session.js';
+export function createTournamentRoomsResource(options) {
+    const { requester } = options;
+    const webSocketFactory = options.webSocketFactory ?? getDefaultWebSocketFactory();
+    const jsonPost = createValidatedJsonPost(requester);
+    return {
+        applyEventCommand: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/event/commands`, jsonPost('tournament-event-command-request', request), options),
+        create: (request, options) => requester.request('tournament-room-access-response', '/api/tournament-rooms', jsonPost('create-tournament-room-request', request), options),
+        close: (roomId, request, options) => requester.request('tournament-room-response', `/api/tournament-rooms/${roomId}/close`, jsonPost('close-tournament-room-request', request), options),
+        createSession: access => createTournamentRoomSession({
+            access,
+            webSocketFactory,
+            wsUrl: options.wsUrl,
+            ...(options.validate == null ? {} : { validate: options.validate }),
+        }),
+        createTable: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/tables`, jsonPost('create-tournament-table-request', request), options),
+        get: (roomId, options) => requester.request('tournament-room-response', `/api/tournament-rooms/${roomId}`, {}, options)
+            .then(response => response.snapshot),
+        join: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/join`, jsonPost('join-tournament-room-request', request), options),
+        joinTable: (roomId, tableId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/tables/${tableId}/join`, jsonPost('join-tournament-table-request', request), options),
+        list: options => requester.request('tournament-room-list-response', '/api/tournament-rooms', {}, options),
+        leave: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/leave`, jsonPost('leave-tournament-room-request', request), options),
+        returnMatch: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/return-match`, jsonPost('return-tournament-match-request', request), options),
+        sendChat: (roomId, request, options) => requester.request('tournament-room-chat-response', `/api/tournament-rooms/${roomId}/chat`, jsonPost('tournament-room-chat-request', request), options),
+        startEvent: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/start-event`, jsonPost('start-tournament-event-request', request), options),
+        submitDeck: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/deck`, jsonPost('submit-tournament-deck-request', request), options),
+        sync: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/sync`, jsonPost('tournament-room-sync-request', request), options),
+        updatePlayer: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/players/me`, jsonPost('update-tournament-room-player-request', request), options),
+        updateSettings: (roomId, request, options) => requester.request('tournament-room-access-response', `/api/tournament-rooms/${roomId}/settings`, jsonPost('update-tournament-room-settings-request', request), options),
+    };
+}

package/dist/session.d.ts

@@ -0,0 +1,56 @@
+import type { AiStatusPayload, ErrorPayload, GameEvent, GameState, ServerMessage, WelcomePayload } from './generated/index.js';
+import type { CardInteractionCue, MatchHistoryFeedEntry, MatchHistorySnapshot } from './generated/types/server-message.js';
+/**
+ * Transport lifecycle state for one simulator socket session.
+ *
+ * `idle` means no socket has been opened yet, `connecting` means handshake is
+ * in progress, `open` means messages can flow, and `closed` means no active
+ * socket is attached.
+ *
+ * @example
+ * ```ts
+ * import type { ConnectionState } from '@my-swu/simulator-client'
+ *
+ * const currentConnectionState: ConnectionState = 'idle'
+ * console.log(currentConnectionState)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-session
+ */
+export type ConnectionState = 'idle' | 'connecting' | 'open' | 'closed';
+/**
+ * Payload emitted on each server `pong` frame.
+ *
+ * The `nonce` echoes back whatever was sent in the matching `ping`, allowing
+ * consumers to measure round-trip latency.
+ *
+ * @example
+ * ```ts
+ * import type { PongPayload } from '@my-swu/simulator-client'
+ *
+ * const latencyPong: PongPayload = { nonce: 'latency-check-1' }
+ * console.log(latencyPong.nonce)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket#pong
+ */
+export interface PongPayload {
+    nonce?: string | null;
+    [k: string]: unknown;
+}
+/**
+ * Internal typed event map used by the raw match socket connection.
+ */
+export interface MatchConnectionEvents {
+    aiStatus: AiStatusPayload;
+    connectionState: ConnectionState;
+    error: ErrorPayload;
+    event: GameEvent;
+    interactionCue: CardInteractionCue;
+    historyEntry: MatchHistoryFeedEntry;
+    historySnapshot: MatchHistorySnapshot;
+    message: ServerMessage;
+    pong: PongPayload;
+    snapshot: GameState;
+    welcome: WelcomePayload;
+}

package/dist/session.js

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

package/dist/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Hand-written re-exports for the inner view types defined inside the
+ * generated response files.
+ *
+ * The JSON Schema generator emits a separate `.ts` file per HTTP response
+ * (`get-match-response.ts`, `match-access-response.ts`,
+ * `format-event-response.ts`, …) and inlines every nested `$defs`
+ * definition into each one; the dedupe pass then collapses the copies into
+ * `generated/types/common.ts` and leaves the per-response files as pure
+ * re-exports. Nothing in that pipeline decides which nested types are
+ * *public*, so this module names them: each alias is sourced from the
+ * response module the type most obviously belongs to
+ * (`get-match-response.ts` mirrors `/api/matches/:id` and owns the gameplay
+ * views). Consumers that previously had to recover these via indexed access
+ * (`GameState["players"][number]`, `NonNullable<SeatState["hand"]>[number]`,
+ * …) can now `import type` directly from the SDK root.
+ *
+ * The set is closed under reference: if a type exported here names another
+ * generated type in one of its fields, that one is exported too, so a
+ * consumer never lands on an unnameable shape one level down.
+ *
+ * Add new aliases here when consumers ask for them — do not edit the
+ * generated files (they are rewritten on every `pnpm sdk:generate`) — and
+ * add the same name to the `./types.js` block in `index.ts`, which
+ * `test/type-smoke.test.ts` enforces.
+ */
+export type { AiDifficulty, AiOpponentConfig, AiTrilogyFormatMode, FormatSetupInput, MatchScenarioInput, MctsConfigOverride, } from "./generated/types/create-match-request.js";
+export type { AbilityWindow, ActionAbilitySource, ActionAbilityView, ActiveEffectDescriptionView, ActiveEffectView, AbilityTarget, AttachmentMode, AttackChoiceView, AttackTarget, AvailableAttackView, CapturedUnitView, CaptureOptionsView, CaptureSelection, CardArena, CardChoiceResourcePaymentOptionView, CardInstanceView, ConstructedFormat, CurrentAttackStateView, CurrentAttackView, DeckRegistrationView, DelayedEffectDescriptionView, DelayedEffectTimingView, DelayedEffectView, DistributionAssignment, DistributionDamageKindView, DistributionItemView, DistributionTargetView, DistributionTokenKindView, DynamicPowerLimit, EffectCardScopeView, EffectDurationView, EffectRestrictionView, EffectSourceView, EffectTargetView, ExploitOptionsView, FormatSeatView, GameTimerActiveClockView, GameTimerReserveView, GameTimerStateView, HiddenCardChoiceMode, HiddenZoneKind, InitiativeChoiceReason, InitiativeState, InstructedAttackView, LeaderActionView, LeaderDeployActionView, LeaderDeployCostView, LeaderDeployMode, LeaderDeployThresholdBonus, LeaderStateView, LimitedEventView, MatchEndReason, MatchFormat, MatchPhase, MatchResult, MatchSeriesView, MatchStatus, ModeChoiceView, NamedCardEffectDescriptionView, PendingAbilityAspectChoiceView, PendingAbilityAttackChoiceView, PendingAbilityCardChoiceView, PendingAbilityFamily, PendingAbilityModeChoiceView, PendingAbilityNameChoiceView, PendingAbilityOrderAbilityView, PendingAbilityOrderChoiceView, PendingAbilityOrderGroupView, PendingAbilityView, PendingChoiceView, PendingDistributionView, PendingUndoRequest, PlayActionView, PlayCardSourceView, PlayCardZone, PlayerTargetPattern, PresenceFilter, PromptState, RejectedPlayView, RelationFilter, ResourceCardView, ResourcePaymentOptionView, Seat, SeatDirection, SeatOfferIntent, SeatState, SelectionScope, SeriesEndReason, SeriesGameRecord, SeriesResultView, SharedCounterState, SmuggleActionView, SmuggleKind, TargetGroupPurpose, TargetSelectionGroup, TargetSelectionPlanView, TriggerWindowView, TwinSunsCounter, TwinSunsCountersView, UndoRequestReason, UniquenessFilter, UnitAbilitySuppressionView, UnitExtremum, UnitFilter, UnitStateView, UpgradeStateView, } from "./generated/types/get-match-response.js";
+export type { AspectCount } from "./generated/types/cards-response.js";
+export type { CloseTournamentRoomActiveMatches } from "./generated/types/close-tournament-room-request.js";
+export type { CardDrawSource, TurnPassSource, UnitDefeatCause, } from "./generated/types/game-event.js";
+export type { LimitedEventPreflightIssue } from "./generated/types/limited-event-preflight-response.js";
+export type { DraftRoundConfig, LimitedCardSlot, LimitedCardTreatment, LimitedDeckSourceView, LimitedEventKind, LimitedEventPhaseView, LimitedEventSeatView, LimitedEventViewerView, LimitedPackCardView, } from "./generated/types/limited-event-response.js";
+export type { ActiveAiMatchLimitScope } from "./generated/types/list-active-ai-matches-request.js";
+export type { ActiveAiMatchRecoveryEntry } from "./generated/types/list-active-ai-matches-response.js";
+export type { LobbyWelcomePayload } from "./generated/types/lobby-server-message.js";
+export type { MatchHistoryDeckSummary } from "./generated/types/match-history-entry.js";
+export type { MatchSaveSeat, UnitCopiedCardEntry, } from "./generated/types/match-save-payload.js";
+export type { CardReferenceMatchView } from "./generated/types/resolve-card-ids-response.js";
+export type { MaintenanceStatus, SimulatorRuntimeStats, } from "./generated/types/simulator-admin-status-response.js";
+export type { TournamentRoomPrivateView } from "./generated/types/tournament-room-access-response.js";
+export type { TournamentRoomPlayerView, TournamentRoomStatus, TournamentTableStatus, TournamentTableView, } from "./generated/types/tournament-room-response.js";
+export type { TournamentRoomMatchReadyPayload, TournamentRoomWelcomePayload, } from "./generated/types/tournament-room-server-message.js";
+export type { AiSeatStatusPayload } from "./generated/types/welcome-payload.js";
+/**
+ * The SDK exposes `PromptState` as a tagged union (`"lobbyReady" | { mulligan: … } | …`),
+ * which is correct but inconvenient for UIs that walk every prompt
+ * variant with optional chaining and gate each branch with a separate
+ * `if (prompt.chooseAbilityCards) { … }`.
+ *
+ * `PromptShape` flattens the union into a record where every variant is
+ * an optional field. Consumers can read `prompt.chooseAbilityCards`
+ * without first narrowing through the discriminator. Cast a runtime
+ * `PromptState` to `PromptShape` at the boundary of UI code:
+ *
+ * ```ts
+ * import type { PromptShape, PromptState } from "@my-swu/simulator-client";
+ * const promptState: PromptState = {
+ *   chooseAbilityCards: { abilityId: 1, max: 1, min: 1, seat: "one" },
+ * };
+ * const promptView = promptState as PromptShape;
+ * if (promptView.chooseAbilityCards) {
+ *   // … access promptView.chooseAbilityCards.{abilityId,max,min,seat}
+ * }
+ * ```
+ *
+ * This is unsafe for fan-out narrowing (you can read every field on the
+ * `"lobbyReady"` branch and TypeScript won't catch it), so prefer the
+ * discriminated union when you need exhaustiveness checking.
+ */
+export type PromptShape = {
+    [K in Exclude<import("./generated/types/get-match-response.js").PromptState, string> as keyof K]?: K[keyof K];
+};

package/dist/types.js

@@ -0,0 +1,27 @@
+/**
+ * Hand-written re-exports for the inner view types defined inside the
+ * generated response files.
+ *
+ * The JSON Schema generator emits a separate `.ts` file per HTTP response
+ * (`get-match-response.ts`, `match-access-response.ts`,
+ * `format-event-response.ts`, …) and inlines every nested `$defs`
+ * definition into each one; the dedupe pass then collapses the copies into
+ * `generated/types/common.ts` and leaves the per-response files as pure
+ * re-exports. Nothing in that pipeline decides which nested types are
+ * *public*, so this module names them: each alias is sourced from the
+ * response module the type most obviously belongs to
+ * (`get-match-response.ts` mirrors `/api/matches/:id` and owns the gameplay
+ * views). Consumers that previously had to recover these via indexed access
+ * (`GameState["players"][number]`, `NonNullable<SeatState["hand"]>[number]`,
+ * …) can now `import type` directly from the SDK root.
+ *
+ * The set is closed under reference: if a type exported here names another
+ * generated type in one of its fields, that one is exported too, so a
+ * consumer never lands on an unnameable shape one level down.
+ *
+ * Add new aliases here when consumers ask for them — do not edit the
+ * generated files (they are rewritten on every `pnpm sdk:generate`) — and
+ * add the same name to the `./types.js` block in `index.ts`, which
+ * `test/type-smoke.test.ts` enforces.
+ */
+export {};

package/dist/validators/ajv.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Ajv instances backing `parseSchema`.
+ *
+ * Every WebSocket frame, outbound envelope and HTTP body is validated here, so
+ * the hot path uses an instance that short-circuits at the first error
+ * (`allErrors: false`). `allErrors: true` costs at least 4.7x more: on one real
+ * `server-message` snapshot frame it measured 95.5 µs against 20.3 µs, and on a
+ * 13 KB mid-game snapshot frame 41.1 µs against 5.7 µs — in the first case more
+ * than ten times the cost of `JSON.parse`-ing the very frame being validated.
+ *
+ * The complete error list is still worth having, but only for a payload that
+ * already failed — and a failure throws, so it is off the hot path by
+ * construction. A second `allErrors: true` instance is therefore built lazily
+ * on the first failure and reused afterwards; building it eagerly would double
+ * this module's startup cost and heap for errors that usually never happen.
+ */
+import { type ErrorObject } from 'ajv/dist/2020.js';
+/**
+ * Looks up the compiled fast validator for one generated schema name.
+ *
+ * @param name Generated schema name.
+ * @returns The validator, or `undefined` when no such schema is registered.
+ */
+export declare function getFastValidator(name: string): import("ajv/dist/core.js").AnyValidateFunction<unknown> | undefined;
+/**
+ * Compiles the named schemas into the fast instance ahead of first use.
+ *
+ * Ajv compiles a registered schema the first time it is looked up, and that
+ * first compile drags in every shared definition it references — measured at
+ * ~215 ms for `server-message` against 2-42 ms for each schema after it. This
+ * exists so that cost can be paid at a moment of the caller's choosing rather
+ * than on the first frame off the wire. Unknown names are skipped; compiling
+ * an already-compiled schema is a no-op.
+ *
+ * @param names Generated schema names to compile.
+ */
+export declare function compileSchemas(names: readonly string[]): void;
+/**
+ * Rebuilds the complete, human-readable detail list for a failed payload.
+ *
+ * The fast validator reports only the first error, so the payload is replayed
+ * through the verbose instance. Both instances hold the same schemas, so the
+ * replay is expected to fail again with every error; if it somehow passes, or
+ * reports nothing, the fast instance's own errors are used so the thrown error
+ * is never empty.
+ *
+ * @param name Generated schema name the payload failed against.
+ * @param value The payload that failed fast validation.
+ * @param fastErrors Errors reported by the fast validator.
+ */
+export declare function describeValidationErrors(name: string, value: unknown, fastErrors: ErrorObject[] | null | undefined): string[];