@my-swu/simulator-client 0.1.0

package/dist/validators/ajv.js

@@ -0,0 +1,121 @@
+/**
+ * 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 { Ajv2020 } from 'ajv/dist/2020.js';
+import { sdkSchemaCommon, sdkSchemas } from '../generated/schemas.js';
+/**
+ * Schemars emits non-standard numeric `format` keywords (uint8, uint16, ...) and
+ * `uuid` on string fields. We validate shape (required fields, discriminators,
+ * enum values, types) but intentionally skip numeric-range enforcement because
+ * the engine is the source of truth for those bounds. Treat these formats as
+ * always-valid so Ajv does not emit strict-mode warnings nor reject payloads.
+ */
+const SCHEMARS_FORMATS = [
+    'double',
+    'float',
+    'int16',
+    'int32',
+    'uint',
+    'uint8',
+    'uint16',
+    'uint32',
+    'uint64',
+    'uuid',
+];
+/**
+ * Builds one fully configured Ajv instance holding every generated schema.
+ *
+ * @param allErrors Whether validation collects every error or stops at the first.
+ */
+function createAjv(allErrors) {
+    const instance = new Ajv2020({
+        allErrors,
+        strict: false,
+    });
+    for (const format of SCHEMARS_FORMATS) {
+        instance.addFormat(format, true);
+    }
+    // The roots reference their shared definitions by absolute `$id` rather than
+    // inlining a private copy each, so the shared document has to be registered
+    // before them for those references to resolve.
+    instance.addSchema(sdkSchemaCommon);
+    for (const [name, schema] of Object.entries(sdkSchemas)) {
+        instance.addSchema(schema, name);
+    }
+    return instance;
+}
+/** Short-circuiting instance used for every successful validation. */
+const fastAjv = createAjv(false);
+/** Verbose instance, created on the first validation failure only. */
+let verboseAjv;
+/**
+ * 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 function getFastValidator(name) {
+    return fastAjv.getSchema(name);
+}
+/**
+ * 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 function compileSchemas(names) {
+    for (const name of names) {
+        // A residual ~10 ms stays on the first frame regardless: Ajv emits
+        // JavaScript source, and the engine only parses each `$ref`ed sub-validator
+        // when a payload first reaches it. Exercising those would mean synthesizing
+        // a valid instance of every branch, which is not worth the ~4% left over.
+        fastAjv.getSchema(name);
+    }
+}
+/**
+ * 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 function describeValidationErrors(name, value, fastErrors) {
+    verboseAjv ??= createAjv(true);
+    let errors = fastErrors ?? [];
+    const verbose = verboseAjv.getSchema(name);
+    if (verbose != null && !verbose(value)) {
+        const verboseErrors = verbose.errors ?? [];
+        if (verboseErrors.length > 0) {
+            errors = verboseErrors;
+        }
+    }
+    return errors.map((error) => {
+        const path = error.instancePath || '/';
+        return `${path} ${error.message ?? 'is invalid'}`;
+    });
+}

package/dist/validators/discriminants.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Forward-compatibility helper for tagged-union wire schemas.
+ *
+ * Every socket protocol in this SDK is a `oneOf` of branches pinned by a
+ * `type` const. The server may add a branch at any time, and a client built
+ * against an older contract must drop that frame rather than reject it —
+ * otherwise one new `ServerMessage` variant breaks every deployed client.
+ *
+ * A frame that is malformed in any other way is still a real contract
+ * violation and must keep failing validation loudly.
+ */
+import { type SchemaName } from '../generated/schemas.js';
+/**
+ * Builds the discriminant sets for the named schemas ahead of first use.
+ *
+ * Collecting them walks every `oneOf` branch of a root schema, which for
+ * `server-message` is measured at ~10 ms — small next to the Ajv compile it
+ * sits beside, but it is the same kind of lazy cost landing on the same first
+ * frame, so warm-up covers both or it does not move the whole cost off the
+ * connect path.
+ *
+ * @param names Generated schema names to pre-scan.
+ */
+export declare function warmDiscriminants(names: readonly SchemaName[]): void;
+/**
+ * Whether one payload carries a `type` this build's schema does not declare.
+ *
+ * Only a string `type` that no branch pins counts: a payload that is not an
+ * object, or that carries no usable discriminant at all, is left to normal
+ * validation so genuinely broken frames still surface as errors. A schema
+ * without discriminated branches never reports an unknown type.
+ *
+ * @param name Generated schema name the payload is destined for.
+ * @param value Parsed payload from the wire.
+ */
+export declare function hasUnknownDiscriminant(name: SchemaName, value: unknown): boolean;

package/dist/validators/discriminants.js

@@ -0,0 +1,89 @@
+/**
+ * Forward-compatibility helper for tagged-union wire schemas.
+ *
+ * Every socket protocol in this SDK is a `oneOf` of branches pinned by a
+ * `type` const. The server may add a branch at any time, and a client built
+ * against an older contract must drop that frame rather than reject it —
+ * otherwise one new `ServerMessage` variant breaks every deployed client.
+ *
+ * A frame that is malformed in any other way is still a real contract
+ * violation and must keep failing validation loudly.
+ */
+import { sdkSchemas } from '../generated/schemas.js';
+/**
+ * Per-schema discriminant sets, derived from the generated schema on first use.
+ *
+ * Building these is a walk over every branch of a root schema, so it happens
+ * once per schema name and never per frame.
+ */
+const discriminantCache = new Map();
+/**
+ * Collects every `type` const pinned by one root schema's `oneOf` branches.
+ *
+ * @param name Generated schema name.
+ */
+function collectDiscriminants(name) {
+    const schema = sdkSchemas[name];
+    const branches = Array.isArray(schema?.oneOf) ? schema.oneOf : [];
+    const values = new Set();
+    for (const branch of branches) {
+        const discriminant = branch?.properties?.type?.const;
+        if (typeof discriminant === 'string') {
+            values.add(discriminant);
+        }
+    }
+    return values;
+}
+/**
+ * Known `type` discriminants of one generated schema.
+ *
+ * @param name Generated schema name.
+ */
+function knownDiscriminants(name) {
+    let known = discriminantCache.get(name);
+    if (known == null) {
+        known = collectDiscriminants(name);
+        discriminantCache.set(name, known);
+    }
+    return known;
+}
+/**
+ * Builds the discriminant sets for the named schemas ahead of first use.
+ *
+ * Collecting them walks every `oneOf` branch of a root schema, which for
+ * `server-message` is measured at ~10 ms — small next to the Ajv compile it
+ * sits beside, but it is the same kind of lazy cost landing on the same first
+ * frame, so warm-up covers both or it does not move the whole cost off the
+ * connect path.
+ *
+ * @param names Generated schema names to pre-scan.
+ */
+export function warmDiscriminants(names) {
+    for (const name of names) {
+        if (sdkSchemas[name] != null) {
+            knownDiscriminants(name);
+        }
+    }
+}
+/**
+ * Whether one payload carries a `type` this build's schema does not declare.
+ *
+ * Only a string `type` that no branch pins counts: a payload that is not an
+ * object, or that carries no usable discriminant at all, is left to normal
+ * validation so genuinely broken frames still surface as errors. A schema
+ * without discriminated branches never reports an unknown type.
+ *
+ * @param name Generated schema name the payload is destined for.
+ * @param value Parsed payload from the wire.
+ */
+export function hasUnknownDiscriminant(name, value) {
+    if (typeof value !== 'object' || value == null) {
+        return false;
+    }
+    const discriminant = value.type;
+    if (typeof discriminant !== 'string') {
+        return false;
+    }
+    const known = knownDiscriminants(name);
+    return known.size > 0 && !known.has(discriminant);
+}

package/dist/validators/validator.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The validation seam the SDK's network boundary talks to.
+ *
+ * Runtime schema validation is opt-in. This module is what makes "off" mean
+ * *absent* rather than *skipped*: it holds no schema, imports Ajv nowhere, and
+ * only depends on `SchemaTypeMap` / `SchemaName` as erased types. Every boundary
+ * (HTTP responses, HTTP request bodies, socket frames in both directions) goes
+ * through a `SchemaValidator` handed in at client construction, so a build that
+ * never asks for validation never references `../generated/schemas.js` nor
+ * `ajv`, and a bundler drops both — about 90% of the SDK's minified weight.
+ *
+ * The schema-backed implementation lives behind `createSchemaValidator()` in
+ * `../validators.js`; naming it is what pulls the schema map into a bundle.
+ */
+import type { SchemaName } from '../generated/schemas.js';
+import type { SchemaTypeMap } from '../validators.js';
+/**
+ * Validates SDK payloads at the network boundary.
+ *
+ * Pass one as `validate` to `createSimulatorClient` to turn boundary validation
+ * on. Custom implementations are supported: anything that narrows an unknown
+ * payload to the generated type — or throws — satisfies the contract.
+ */
+export interface SchemaValidator {
+    /**
+     * Narrows one payload to its generated type, throwing when it does not match.
+     *
+     * @param name Generated schema name.
+     * @param value Payload arriving from (or heading to) the wire.
+     */
+    parse: <TName extends keyof SchemaTypeMap>(name: TName, value: unknown) => SchemaTypeMap[TName];
+    /**
+     * Whether one payload carries a `type` discriminant this build does not know.
+     *
+     * Tagged-union socket frames answering `true` here are dropped before
+     * `parse`, so a server that grows a message variant does not break older
+     * clients. Leave it undefined when the implementation cannot enumerate the
+     * known discriminants: frames then reach the dispatcher, which ignores any
+     * `type` it has no case for.
+     *
+     * @param name Generated schema name the payload is destined for.
+     * @param value Parsed payload from the wire.
+     */
+    hasUnknownDiscriminant?: ((name: SchemaName, value: unknown) => boolean) | undefined;
+    /**
+     * Compiles the named schemas now, instead of when a payload first needs them.
+     *
+     * Schema-backed validation compiles lazily, and the first compile is by far
+     * the most expensive one because it pulls in the whole shared definition
+     * pool. Left alone that cost lands on the first frame a socket receives —
+     * during connect, on the browser's main thread. `createSimulatorClient`
+     * therefore calls this on an idle callback right after construction; call it
+     * yourself to warm a different set, or at a moment you choose.
+     *
+     * Implementations must be synchronous and safe to call repeatedly: a schema
+     * already compiled is a no-op. Leave it undefined when there is nothing to
+     * compile — the pass-through does, which is what makes warm-up free when
+     * validation is off.
+     *
+     * @param names Schemas to compile; defaults to the SDK's connect-path roots.
+     */
+    warmUp?: ((names?: readonly SchemaName[]) => void) | undefined;
+}
+/**
+ * The default validator: a typed pass-through that checks nothing.
+ *
+ * `parse` is the identity, so payloads are trusted exactly as the server sent
+ * them (or as the caller built them). It reports no unknown discriminants,
+ * because without a schema map there is nothing to compare a `type` against —
+ * unknown frames therefore fall through to the message dispatchers, whose
+ * `switch` statements have no case for them and ignore them.
+ */
+export declare const passthroughValidator: SchemaValidator;

package/dist/validators/validator.js

@@ -0,0 +1,26 @@
+/**
+ * The validation seam the SDK's network boundary talks to.
+ *
+ * Runtime schema validation is opt-in. This module is what makes "off" mean
+ * *absent* rather than *skipped*: it holds no schema, imports Ajv nowhere, and
+ * only depends on `SchemaTypeMap` / `SchemaName` as erased types. Every boundary
+ * (HTTP responses, HTTP request bodies, socket frames in both directions) goes
+ * through a `SchemaValidator` handed in at client construction, so a build that
+ * never asks for validation never references `../generated/schemas.js` nor
+ * `ajv`, and a bundler drops both — about 90% of the SDK's minified weight.
+ *
+ * The schema-backed implementation lives behind `createSchemaValidator()` in
+ * `../validators.js`; naming it is what pulls the schema map into a bundle.
+ */
+/**
+ * The default validator: a typed pass-through that checks nothing.
+ *
+ * `parse` is the identity, so payloads are trusted exactly as the server sent
+ * them (or as the caller built them). It reports no unknown discriminants,
+ * because without a schema map there is nothing to compare a `type` against —
+ * unknown frames therefore fall through to the message dispatchers, whose
+ * `switch` statements have no case for them and ignore them.
+ */
+export const passthroughValidator = {
+    parse: (_name, value) => value,
+};

package/dist/validators/warm-up.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Moving the validator's first-compile cost off the connect path.
+ *
+ * Schema-backed validation compiles lazily. The first schema compiled pays for
+ * the whole shared definition pool — ~215 ms measured for `server-message`,
+ * against 2-42 ms for every schema after it — and without this it is the first
+ * server frame that pays it, which means during connect, on the main thread.
+ *
+ * Nothing here references Ajv or the schema map: warm-up is requested through
+ * the injected validator's optional `warmUp`, so a client built without
+ * validation still drops both from the bundle.
+ */
+import type { SchemaValidator } from './validator.js';
+/**
+ * Compiles a validator's connect-path schemas during idle time.
+ *
+ * A no-op when the validator has nothing to compile, which is the case for the
+ * pass-through the SDK uses by default. Never blocks the caller, and never
+ * produces a rejected promise: the work is synchronous, deferred, and its
+ * failures are swallowed because a failed warm-up only costs the lazy compile
+ * it was trying to avoid.
+ *
+ * @param validator Boundary validator configured on the client.
+ */
+export declare function scheduleValidatorWarmUp(validator: SchemaValidator): void;

package/dist/validators/warm-up.js

@@ -0,0 +1,59 @@
+/**
+ * Moving the validator's first-compile cost off the connect path.
+ *
+ * Schema-backed validation compiles lazily. The first schema compiled pays for
+ * the whole shared definition pool — ~215 ms measured for `server-message`,
+ * against 2-42 ms for every schema after it — and without this it is the first
+ * server frame that pays it, which means during connect, on the main thread.
+ *
+ * Nothing here references Ajv or the schema map: warm-up is requested through
+ * the injected validator's optional `warmUp`, so a client built without
+ * validation still drops both from the bundle.
+ */
+/** How long an idle callback may be deferred before it is forced to run. */
+const WARM_UP_IDLE_TIMEOUT_MS = 2_000;
+/**
+ * Compiles a validator's connect-path schemas during idle time.
+ *
+ * A no-op when the validator has nothing to compile, which is the case for the
+ * pass-through the SDK uses by default. Never blocks the caller, and never
+ * produces a rejected promise: the work is synchronous, deferred, and its
+ * failures are swallowed because a failed warm-up only costs the lazy compile
+ * it was trying to avoid.
+ *
+ * @param validator Boundary validator configured on the client.
+ */
+export function scheduleValidatorWarmUp(validator) {
+    const warmUp = validator.warmUp;
+    if (warmUp == null) {
+        return;
+    }
+    scheduleIdleTask(() => {
+        try {
+            warmUp();
+        }
+        catch {
+            // Warm-up is an optimization: whatever failed to compile here fails the
+            // same way on first use, where it is reported against a real payload.
+        }
+    });
+}
+/**
+ * Runs one task after the current work, without holding the runtime open.
+ *
+ * Prefers `requestIdleCallback` so a browser can place the compile between
+ * frames; the timeout keeps a background tab from deferring it forever.
+ * Elsewhere a zero-delay timer is enough, `unref`ed so a Node process (or a
+ * test run) is never kept alive waiting for it.
+ *
+ * @param task Synchronous work to defer.
+ */
+function scheduleIdleTask(task) {
+    const idle = globalThis.requestIdleCallback;
+    if (typeof idle === 'function') {
+        idle(task, { timeout: WARM_UP_IDLE_TIMEOUT_MS });
+        return;
+    }
+    const timer = setTimeout(task, 0);
+    timer.unref?.();
+}

package/dist/validators.d.ts

@@ -0,0 +1,173 @@
+import type { SimulatorReportListResponse, SimulatorReportResponse, CloseTournamentRoomRequest, AbandonMatchRequest, AbandonMatchResponse, AddLobbyAiPlayerRequest, ApiErrorResponse, CardCatalogRefreshResponse, CardsResponse, ClientMessage, CreateLimitedEventRequest, CreateLobbyRequest, CreateMetaWindowRequest, CreateMatchRequest, CreateTournamentRoomRequest, CreateTournamentTableRequest, ErrorPayload, FormatEventRequest, FormatEventResponse, GameCommand, GameEvent, GameState, GetMatchResponse, HealthResponse, JoinLimitedEventRequest, JoinLobbyRequest, JoinMatchRequest, JoinTournamentRoomRequest, JoinTournamentTableRequest, KickLobbyPlayerRequest, KickLobbySpectatorRequest, LeaveLobbyRequest, LeaveMatchRequest, LeaveMatchResponse, LeaveTournamentRoomRequest, LimitedEventAccessResponse, LimitedEventCommandRequest, LimitedEventPreflightResponse, LimitedEventResponse, LobbyAccessResponse, LobbyChatRequest, LobbyChatResponse, LobbyListResponse, LobbyListServerMessage, LobbyMatchmakingDecisionRequest, PrepareLobbyLimitedAiDecksRequest, LobbyResponse, LobbyServerMessage, LobbySyncRequest, ListActiveAiMatchesRequest, ListActiveAiMatchesResponse, MatchAccessResponse, MatchChatLookupResponse, MatchConnectionRole, MatchHistoryDeckStatsRequest, MatchHistoryDeckStatsResponse, MatchHistoryEntry, MatchHistoryListRequest, MatchHistoryListResponse, MatchHistoryReplayRequest, MatchHistoryReplayResponse, MatchHistoryRestoreRequest, RestoreHistoryResponse, MatchSavePayload, MatchSpectatorAccessResponse, MetaWindow, MetaWindowsResponse, LobbyMatchmakingRequest, ResolveCardIdsRequest, ResolveCardIdsResponse, RankedAdminStatus, RankedLeaderboardEntry, RankedLeaderboardQuery, RankedLeaderboardResponse, RankedMatchmakingView, RankedProfileRequest, RankedProfileResponse, RankedQueue, RematchMatchRequest, RematchMatchResponse, SaveMatchRequest, ReturnLobbyMatchRequest, ReturnTournamentMatchRequest, RestoreMatchSaveRequest, RestoreMatchSaveResponse, ServerMessage, AiStatusPayload, SetRankedAdmissionRequest, SetSimulatorMaintenanceRequest, SetAiPausedRequest, SimulatorAdminStatusResponse, SimulatorAvailabilityResponse, SpectateLobbyRequest, SpectateMatchRequest, StartLobbyLimitedMatchRequest, StartLobbyRequest, StartTournamentEventRequest, SubmitLobbyLimitedDeckRequest, SubmitMatchDeckRequest, SubmitMatchDeckResponse, SubmitTournamentDeckRequest, TournamentEventCommandRequest, TournamentRoomAccessResponse, TournamentRoomChatRequest, TournamentRoomChatResponse, TournamentRoomListResponse, TournamentRoomResponse, TournamentRoomServerMessage, TournamentRoomSyncRequest, UndoMatchRequest, UndoMatchResponse, UndoRespondMatchRequest, UpdateLobbyAiPlayerRequest, UpdateLobbyPlayerRequest, UpdateLobbySettingsRequest, UpdateTournamentRoomPlayerRequest, UpdateTournamentRoomSettingsRequest, WelcomePayload } from './generated/index.js';
+import type { SchemaValidator } from './validators/validator.js';
+/**
+ * Exact schema-to-type map generated from Rust public wire contracts.
+ *
+ * Keys match generated schema names. Values are the TypeScript types returned
+ * after runtime validation succeeds.
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/versioning
+ */
+export interface SchemaTypeMap {
+    'simulator-report-list-response': SimulatorReportListResponse;
+    'simulator-report-response': SimulatorReportResponse;
+    'close-tournament-room-request': CloseTournamentRoomRequest;
+    'abandon-match-request': AbandonMatchRequest;
+    'abandon-match-response': AbandonMatchResponse;
+    'leave-match-request': LeaveMatchRequest;
+    'leave-match-response': LeaveMatchResponse;
+    'leave-tournament-room-request': LeaveTournamentRoomRequest;
+    'list-active-ai-matches-request': ListActiveAiMatchesRequest;
+    'list-active-ai-matches-response': ListActiveAiMatchesResponse;
+    'api-error-response': ApiErrorResponse;
+    'cards-response': CardsResponse;
+    'card-catalog-refresh-response': CardCatalogRefreshResponse;
+    'client-message': ClientMessage;
+    'create-limited-event-request': CreateLimitedEventRequest;
+    'create-lobby-request': CreateLobbyRequest;
+    'create-meta-window-request': CreateMetaWindowRequest;
+    'create-match-request': CreateMatchRequest;
+    'create-tournament-room-request': CreateTournamentRoomRequest;
+    'create-tournament-table-request': CreateTournamentTableRequest;
+    'error-payload': ErrorPayload;
+    'format-event-request': FormatEventRequest;
+    'format-event-response': FormatEventResponse;
+    'game-command': GameCommand;
+    'game-event': GameEvent;
+    'game-state': GameState;
+    'get-match-response': GetMatchResponse;
+    'health-response': HealthResponse;
+    'join-limited-event-request': JoinLimitedEventRequest;
+    'join-lobby-request': JoinLobbyRequest;
+    'join-match-request': JoinMatchRequest;
+    'join-tournament-room-request': JoinTournamentRoomRequest;
+    'join-tournament-table-request': JoinTournamentTableRequest;
+    'kick-lobby-player-request': KickLobbyPlayerRequest;
+    'kick-lobby-spectator-request': KickLobbySpectatorRequest;
+    'leave-lobby-request': LeaveLobbyRequest;
+    'limited-event-access-response': LimitedEventAccessResponse;
+    'limited-event-command-request': LimitedEventCommandRequest;
+    'limited-event-preflight-response': LimitedEventPreflightResponse;
+    'limited-event-response': LimitedEventResponse;
+    'add-lobby-ai-player-request': AddLobbyAiPlayerRequest;
+    'lobby-access-response': LobbyAccessResponse;
+    'lobby-chat-request': LobbyChatRequest;
+    'lobby-chat-response': LobbyChatResponse;
+    'lobby-list-response': LobbyListResponse;
+    'lobby-list-server-message': LobbyListServerMessage;
+    'lobby-matchmaking-decision-request': LobbyMatchmakingDecisionRequest;
+    'lobby-response': LobbyResponse;
+    'lobby-server-message': LobbyServerMessage;
+    'lobby-sync-request': LobbySyncRequest;
+    'match-access-response': MatchAccessResponse;
+    'match-chat-lookup-response': MatchChatLookupResponse;
+    'match-connection-role': MatchConnectionRole;
+    'match-history-deck-stats-request': MatchHistoryDeckStatsRequest;
+    'match-history-deck-stats-response': MatchHistoryDeckStatsResponse;
+    'match-history-entry': MatchHistoryEntry;
+    'match-history-list-request': MatchHistoryListRequest;
+    'match-history-list-response': MatchHistoryListResponse;
+    'match-history-replay-request': MatchHistoryReplayRequest;
+    'match-history-replay-response': MatchHistoryReplayResponse;
+    'match-history-restore-request': MatchHistoryRestoreRequest;
+    'restore-history-response': RestoreHistoryResponse;
+    'match-save-payload': MatchSavePayload;
+    'save-match-request': SaveMatchRequest;
+    'match-spectator-access-response': MatchSpectatorAccessResponse;
+    'meta-window': MetaWindow;
+    'meta-windows-response': MetaWindowsResponse;
+    'lobby-matchmaking-request': LobbyMatchmakingRequest;
+    'resolve-card-ids-request': ResolveCardIdsRequest;
+    'resolve-card-ids-response': ResolveCardIdsResponse;
+    'ranked-admin-status': RankedAdminStatus;
+    'ranked-leaderboard-entry': RankedLeaderboardEntry;
+    'ranked-leaderboard-query': RankedLeaderboardQuery;
+    'ranked-leaderboard-response': RankedLeaderboardResponse;
+    'ranked-matchmaking-view': RankedMatchmakingView;
+    'ranked-profile-request': RankedProfileRequest;
+    'ranked-profile-response': RankedProfileResponse;
+    'ranked-queue': RankedQueue;
+    'rematch-match-request': RematchMatchRequest;
+    'rematch-match-response': RematchMatchResponse;
+    'return-lobby-match-request': ReturnLobbyMatchRequest;
+    'return-tournament-match-request': ReturnTournamentMatchRequest;
+    'restore-match-save-request': RestoreMatchSaveRequest;
+    'restore-match-save-response': RestoreMatchSaveResponse;
+    'server-message': ServerMessage;
+    'set-ai-paused-request': SetAiPausedRequest;
+    'set-ai-paused-response': AiStatusPayload;
+    'set-ranked-admission-request': SetRankedAdmissionRequest;
+    'set-simulator-maintenance-request': SetSimulatorMaintenanceRequest;
+    'simulator-admin-status-response': SimulatorAdminStatusResponse;
+    'simulator-availability-response': SimulatorAvailabilityResponse;
+    'spectate-lobby-request': SpectateLobbyRequest;
+    'spectate-match-request': SpectateMatchRequest;
+    'start-lobby-limited-match-request': StartLobbyLimitedMatchRequest;
+    'prepare-lobby-limited-ai-decks-request': PrepareLobbyLimitedAiDecksRequest;
+    'start-lobby-request': StartLobbyRequest;
+    'start-tournament-event-request': StartTournamentEventRequest;
+    'submit-lobby-limited-deck-request': SubmitLobbyLimitedDeckRequest;
+    'submit-match-deck-request': SubmitMatchDeckRequest;
+    'submit-match-deck-response': SubmitMatchDeckResponse;
+    'submit-tournament-deck-request': SubmitTournamentDeckRequest;
+    'tournament-event-command-request': TournamentEventCommandRequest;
+    'tournament-room-access-response': TournamentRoomAccessResponse;
+    'tournament-room-chat-request': TournamentRoomChatRequest;
+    'tournament-room-chat-response': TournamentRoomChatResponse;
+    'tournament-room-list-response': TournamentRoomListResponse;
+    'tournament-room-response': TournamentRoomResponse;
+    'tournament-room-server-message': TournamentRoomServerMessage;
+    'tournament-room-sync-request': TournamentRoomSyncRequest;
+    'undo-match-request': UndoMatchRequest;
+    'undo-match-response': UndoMatchResponse;
+    'undo-respond-match-request': UndoRespondMatchRequest;
+    'update-lobby-ai-player-request': UpdateLobbyAiPlayerRequest;
+    'update-lobby-player-request': UpdateLobbyPlayerRequest;
+    'update-lobby-settings-request': UpdateLobbySettingsRequest;
+    'update-tournament-room-player-request': UpdateTournamentRoomPlayerRequest;
+    'update-tournament-room-settings-request': UpdateTournamentRoomSettingsRequest;
+    'welcome-payload': WelcomePayload;
+}
+/**
+ * Validates one unknown payload against one generated schema.
+ *
+ * Use this for custom transports, persisted payload checks, tests, or tools that
+ * need the same runtime validation the SDK applies at the network boundary.
+ *
+ * @example
+ * ```ts
+ * import { parseSchema } from '@my-swu/simulator-client'
+ *
+ * const health = parseSchema('health-response', { status: 'ok' })
+ * console.log(health.status)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/errors
+ * @see https://simulator-sdk.my-swu.com/guide/versioning
+ */
+export declare function parseSchema<TName extends keyof SchemaTypeMap>(name: TName, value: unknown): SchemaTypeMap[TName];
+/**
+ * Builds the schema-backed validator for `createSimulatorClient`.
+ *
+ * Boundary validation is off by default. Naming this function is what opts a
+ * build in — and what makes the generated schema map plus Ajv reachable from
+ * the client, which is roughly 90% of the SDK's minified bundle. Leave it
+ * unreferenced and a bundler removes both.
+ *
+ * The returned validator carries a `warmUp`, which `createSimulatorClient`
+ * schedules on an idle callback so the first schema compile does not land on
+ * the first server frame.
+ *
+ * @example
+ * ```ts
+ * import { createSchemaValidator, createSimulatorClient } from '@my-swu/simulator-client'
+ *
+ * const simulatorClient = createSimulatorClient({
+ *   baseUrl: 'http://127.0.0.1:4000',
+ *   validate: createSchemaValidator(),
+ * })
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/client-api
+ */
+export declare function createSchemaValidator(): SchemaValidator;