@my-swu/simulator-client 0.1.6 → 0.1.7

package/dist/i18n/generated/message-types.d.ts

@@ -0,0 +1,91 @@
+/** Generated from i18n/messages.schema.json. Do not edit. */
+export declare const simulatorMessageIds: readonly ["abilityUnavailable", "action.exhaust", "amount.resources", "choice.none", "chooseTarget", "chooseTargets", "controls.cancel", "controls.confirm", "controls.decline", "controls.done", "duration.phase", "duration.rounds", "keyword.name", "keyword.overwhelm", "keyword.raid", "keyword.sentinel", "legacyText", "targetPurpose.attachUpgrade", "targetPurpose.chooseTarget", "targetPurpose.dealDamage", "targetPurpose.giveShield", "targetPurpose.heal", "timing.onceEachRound"];
+export declare const simulatorMessageParameterTypes: {
+    readonly abilityUnavailable: {};
+    readonly "action.exhaust": {};
+    readonly "amount.resources": {
+        readonly count: "integer";
+    };
+    readonly "choice.none": {};
+    readonly chooseTarget: {};
+    readonly chooseTargets: {
+        readonly min: "integer";
+        readonly max: "integer";
+    };
+    readonly "controls.cancel": {};
+    readonly "controls.confirm": {};
+    readonly "controls.decline": {};
+    readonly "controls.done": {};
+    readonly "duration.phase": {};
+    readonly "duration.rounds": {
+        readonly count: "integer";
+    };
+    readonly "keyword.name": {
+        readonly keyword: "string";
+    };
+    readonly "keyword.overwhelm": {};
+    readonly "keyword.raid": {};
+    readonly "keyword.sentinel": {};
+    readonly legacyText: {
+        readonly text: "string";
+    };
+    readonly "targetPurpose.attachUpgrade": {};
+    readonly "targetPurpose.chooseTarget": {};
+    readonly "targetPurpose.dealDamage": {
+        readonly amount: "integer";
+    };
+    readonly "targetPurpose.giveShield": {
+        readonly amount: "integer";
+    };
+    readonly "targetPurpose.heal": {
+        readonly amount: "integer";
+    };
+    readonly "timing.onceEachRound": {};
+};
+export type SimulatorMessageId = (typeof simulatorMessageIds)[number];
+export interface SimulatorMessageParams {
+    "abilityUnavailable": {};
+    "action.exhaust": {};
+    "amount.resources": {
+        count: number;
+    };
+    "choice.none": {};
+    "chooseTarget": {};
+    "chooseTargets": {
+        min: number;
+        max: number;
+    };
+    "controls.cancel": {};
+    "controls.confirm": {};
+    "controls.decline": {};
+    "controls.done": {};
+    "duration.phase": {};
+    "duration.rounds": {
+        count: number;
+    };
+    "keyword.name": {
+        keyword: string;
+    };
+    "keyword.overwhelm": {};
+    "keyword.raid": {};
+    "keyword.sentinel": {};
+    "legacyText": {
+        text: string;
+    };
+    "targetPurpose.attachUpgrade": {};
+    "targetPurpose.chooseTarget": {};
+    "targetPurpose.dealDamage": {
+        amount: number;
+    };
+    "targetPurpose.giveShield": {
+        amount: number;
+    };
+    "targetPurpose.heal": {
+        amount: number;
+    };
+    "timing.onceEachRound": {};
+}
+/** A message id whose parameter map has no required keys. */
+export type ParameterlessSimulatorMessageId = {
+    [TId in SimulatorMessageId]: keyof SimulatorMessageParams[TId] extends never ? TId : never;
+}[SimulatorMessageId];

package/dist/i18n/generated/message-types.js

@@ -0,0 +1,3 @@
+/** Generated from i18n/messages.schema.json. Do not edit. */
+export const simulatorMessageIds = ["abilityUnavailable", "action.exhaust", "amount.resources", "choice.none", "chooseTarget", "chooseTargets", "controls.cancel", "controls.confirm", "controls.decline", "controls.done", "duration.phase", "duration.rounds", "keyword.name", "keyword.overwhelm", "keyword.raid", "keyword.sentinel", "legacyText", "targetPurpose.attachUpgrade", "targetPurpose.chooseTarget", "targetPurpose.dealDamage", "targetPurpose.giveShield", "targetPurpose.heal", "timing.onceEachRound"];
+export const simulatorMessageParameterTypes = { "abilityUnavailable": {}, "action.exhaust": {}, "amount.resources": { "count": "integer" }, "choice.none": {}, "chooseTarget": {}, "chooseTargets": { "min": "integer", "max": "integer" }, "controls.cancel": {}, "controls.confirm": {}, "controls.decline": {}, "controls.done": {}, "duration.phase": {}, "duration.rounds": { "count": "integer" }, "keyword.name": { "keyword": "string" }, "keyword.overwhelm": {}, "keyword.raid": {}, "keyword.sentinel": {}, "legacyText": { "text": "string" }, "targetPurpose.attachUpgrade": {}, "targetPurpose.chooseTarget": {}, "targetPurpose.dealDamage": { "amount": "integer" }, "targetPurpose.giveShield": { "amount": "integer" }, "targetPurpose.heal": { "amount": "integer" }, "timing.onceEachRound": {} };

package/dist/i18n/icu.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parses a plain ICU template and verifies its argument names and specialized types.
+ * Bare interpolation accepts every declared scalar type; only ICU format operators constrain it.
+ *
+ * @param {string} locale Locale used only to parse and compile plural syntax.
+ * @param {string} id Stable message id used in errors.
+ * @param {string} template ICU message source.
+ * @param {Record<string, 'string' | 'number' | 'integer' | 'boolean'>} declaration Exact typed parameter map.
+ * @returns {IntlMessageFormat} Prepared formatter for the checked template.
+ */
+export function validateIcuMessage(locale: string, id: string, template: string, declaration: Record<string, "string" | "number" | "integer" | "boolean">): IntlMessageFormat;
+import IntlMessageFormat from 'intl-messageformat';

package/dist/i18n/icu.js

@@ -0,0 +1,75 @@
+import IntlMessageFormat from 'intl-messageformat';
+/**
+ * Parses a plain ICU template and verifies its argument names and specialized types.
+ * Bare interpolation accepts every declared scalar type; only ICU format operators constrain it.
+ *
+ * @param {string} locale Locale used only to parse and compile plural syntax.
+ * @param {string} id Stable message id used in errors.
+ * @param {string} template ICU message source.
+ * @param {Record<string, 'string' | 'number' | 'integer' | 'boolean'>} declaration Exact typed parameter map.
+ * @returns {IntlMessageFormat} Prepared formatter for the checked template.
+ */
+export function validateIcuMessage(locale, id, template, declaration) {
+    if (typeof template !== 'string')
+        throw new Error(`${locale}:${id} is not a string`);
+    if (/<\/?[a-z][^>]*>/i.test(template))
+        throw new Error(`${locale}:${id} uses unsafe rich tags`);
+    let formatter;
+    try {
+        formatter = new IntlMessageFormat(template, locale);
+    }
+    catch (error) {
+        throw new Error(`${locale}:${id} has malformed ICU: ${error.message}`);
+    }
+    const names = new Set();
+    const constraints = new Map();
+    collectArguments(formatter.getAst(), names, constraints);
+    const expected = Object.keys(declaration).sort();
+    if ([...names].sort().join('\0') !== expected.join('\0')) {
+        throw new Error(`${locale}:${id} has arguments that differ from schema`);
+    }
+    for (const [name, type] of constraints) {
+        // ICU's `number` formatter accepts both general SDK numbers and the
+        // integer-only values used by persisted engine messages.
+        if (declaration[name] !== type && !(type === 'number' && declaration[name] === 'integer')) {
+            throw new Error(`${locale}:${id} argument ${name} must be ${type}`);
+        }
+    }
+    return formatter;
+}
+/**
+ * Collects all argument names and only constraints imposed by ICU operators.
+ *
+ * @param {unknown[]} elements FormatJS parser nodes.
+ * @param {Set<string>} names Observed arguments.
+ * @param {Map<string, 'string' | 'number'>} constraints Specialized value requirements.
+ */
+function collectArguments(elements, names, constraints) {
+    for (const element of elements) {
+        if (element.type === 8)
+            throw new Error('ICU rich tags are not allowed in SDK catalogs');
+        if (element.type >= 1 && element.type <= 6) {
+            names.add(element.value);
+            const type = element.type === 5 ? 'string' : element.type === 1 ? null : 'number';
+            if (type != null)
+                addConstraint(element.value, type, constraints);
+        }
+        if (element.options != null) {
+            for (const option of Object.values(element.options))
+                collectArguments(option.value, names, constraints);
+        }
+    }
+}
+/**
+ * Adds a specialized ICU value requirement, rejecting incompatible reuse.
+ *
+ * @param {string} name Argument name.
+ * @param {'string' | 'number'} type Required value type.
+ * @param {Map<string, 'string' | 'number'>} constraints Collected requirements.
+ */
+function addConstraint(name, type, constraints) {
+    const prior = constraints.get(name);
+    if (prior != null && prior !== type)
+        throw new Error(`ICU argument ${name} has conflicting types`);
+    constraints.set(name, type);
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,9 @@
+export { prepareCardTextCatalog, prepareMessageCatalog } from './catalog.js';
+export { createCardTextResolver } from './diagnostics.js';
+export { formatLegacyLiteral, formatMessage } from './format.js';
+export { resolveCardText } from './fallback.js';
+export { resolveLocale } from './locale.js';
+export type { CardTextCatalogInput, CardTextCatalogManifestInput, CardTextCatalogSlotInput, CardTextCatalogSlotStatus, CardPrintEffectiveBaseline, CardPrintRequestedField, CardPrintResolvedField, CardPrintSourceField, CardPrintSourceFieldPresence, CardPrintTextCatalogField, CardPrintTextCatalogInput, CardPrintTextCatalogStatus, CardPrintTextField, CardTextDiagnostic, CardTextDiagnosticSink, CardTextCatalogShardInfo, CardTextFallbackReason, CardTextResolver, LegacyLiteralText, PreparedCardTextCatalog, PreparedMessageCatalog, ResolvedCardText, SimulatorMessageCatalogInput, SimulatorMessageId, SimulatorMessageParams, } from './types.js';
+export type { CardTextRef } from '../generated/types/common.js';
+export type { SimulatorLocale } from './locale.js';
+export type { ParameterlessSimulatorMessageId } from './generated/message-types.js';

package/dist/i18n/index.js

@@ -0,0 +1,5 @@
+export { prepareCardTextCatalog, prepareMessageCatalog } from './catalog.js';
+export { createCardTextResolver } from './diagnostics.js';
+export { formatLegacyLiteral, formatMessage } from './format.js';
+export { resolveCardText } from './fallback.js';
+export { resolveLocale } from './locale.js';

package/dist/i18n/locale.d.ts

@@ -0,0 +1,9 @@
+/** SDK locales with reviewed simulator message and card catalogs. */
+export type SimulatorLocale = 'de' | 'en' | 'es' | 'fr' | 'it';
+/**
+ * Converts a browser, HTTP, or persisted locale input to one supported base locale.
+ *
+ * Regional variants use their base language. Malformed and unsupported inputs use
+ * English so callers never depend on ambient runtime locale state.
+ */
+export declare function resolveLocale(value: string | null | undefined): SimulatorLocale;

package/dist/i18n/locale.js

@@ -0,0 +1,19 @@
+const supportedLocales = new Set(['de', 'en', 'es', 'fr', 'it']);
+/**
+ * Converts a browser, HTTP, or persisted locale input to one supported base locale.
+ *
+ * Regional variants use their base language. Malformed and unsupported inputs use
+ * English so callers never depend on ambient runtime locale state.
+ */
+export function resolveLocale(value) {
+    if (value == null)
+        return 'en';
+    try {
+        const canonical = Intl.getCanonicalLocales(value.trim())[0];
+        const base = canonical == null ? undefined : new Intl.Locale(canonical).language;
+        return base != null && supportedLocales.has(base) ? base : 'en';
+    }
+    catch {
+        return 'en';
+    }
+}

package/dist/i18n/types.d.ts

@@ -0,0 +1,151 @@
+import type IntlMessageFormat from 'intl-messageformat';
+import type { CardTextRef } from '../generated/types/common.js';
+import type { SimulatorLocale } from './locale.js';
+import type { SimulatorMessageId, SimulatorMessageParams } from './generated/message-types.js';
+/** Stable semantic reference generated from the simulator wire contract. */
+export type { CardTextRef } from '../generated/types/common.js';
+/** One checked-in ICU message pack before validation and formatter compilation. */
+export interface SimulatorMessageCatalogInput {
+    formatVersion: number;
+    locale: string;
+    messages: Record<string, string>;
+}
+/** Immutable prepared UI catalog for one locale. */
+export interface PreparedMessageCatalog {
+    readonly locale: SimulatorLocale;
+    readonly messages: Readonly<Record<SimulatorMessageId, string>>;
+    readonly formatters: ReadonlyMap<SimulatorMessageId, IntlMessageFormat>;
+}
+/** Stable exact reference to reviewed literal printed card text. */
+/** Tagged pre-reference text retained only for old saves and history payloads. */
+export interface LegacyLiteralText {
+    readonly kind: 'legacyLiteral';
+    readonly text: string;
+}
+/** Literal card catalog source loaded through an explicit asset boundary. */
+export interface CardTextCatalogInput {
+    formatVersion: number;
+    locale: string;
+    cards: Record<string, Record<string, CardTextCatalogSlotInput>>;
+    /** Present and required in format 2 full-print catalogs. */
+    prints?: Record<string, CardPrintTextCatalogInput>;
+}
+/** One compiler-emitted literal slot. */
+export interface CardTextCatalogSlotInput {
+    plainText: string;
+    sourceLocale: string;
+    status: CardTextCatalogSlotStatus;
+}
+/** Compiler-declared source state retained for exact fallback diagnostics. */
+export type CardTextCatalogSlotStatus = {
+    kind: 'source';
+} | {
+    kind: 'fallback';
+    reason: CardTextFallbackReason;
+} | {
+    kind: 'notApplicable';
+};
+/** Plain printed fields exposed for one requested physical production print. */
+export type CardPrintTextField = 'title' | 'subtitle' | 'text' | 'deployBox' | 'epicAction' | 'rules';
+/** Lossless resolved source field state from the production localization payload. */
+export type CardPrintSourceField = {
+    state: 'missing';
+} | {
+    state: 'null';
+} | {
+    state: 'value';
+    value: string;
+};
+/** Requested field state retained without shipping stale source prose twice. */
+export type CardPrintRequestedField = {
+    kind: 'missingLocale';
+    requestedPrintId: number;
+} | {
+    kind: 'source';
+    sourcePrintId: number;
+    sourceLocale: string;
+    sourceRevision: string;
+    presence: CardPrintSourceFieldPresence;
+};
+/** Exact requested source-field state, including explicit empty `value` separately. */
+export type CardPrintSourceFieldPresence = 'missing' | 'null' | 'value';
+/** Identity of an effective English replacement for stale raw source. */
+export interface CardPrintEffectiveBaseline {
+    canonicalCardId: number;
+    semanticFingerprint: string;
+}
+/** Exact source selected for a full printed field. */
+export interface CardPrintResolvedField {
+    sourcePrintId: number;
+    sourceLocale: string;
+    sourceRevision: string;
+    field: CardPrintSourceField;
+    effectiveBaseline?: CardPrintEffectiveBaseline;
+}
+/** Full-field fallback policy keeps optional absence and explicit empty distinct. */
+export type CardPrintTextCatalogStatus = {
+    kind: 'source';
+} | {
+    kind: 'fallback';
+    reason: 'missingLocale' | 'missingRequiredTitle' | 'missingSourceField' | 'staleEffectiveText';
+};
+/** Requested and resolved provenance for one full printed field. */
+export interface CardPrintTextCatalogField {
+    requested: CardPrintRequestedField;
+    resolved: CardPrintResolvedField;
+    status: CardPrintTextCatalogStatus;
+}
+/** Full printed fields for one physical production print. */
+export interface CardPrintTextCatalogInput {
+    canonicalCardId: number;
+    requestedPrintId: number;
+    fields: Record<CardPrintTextField, CardPrintTextCatalogField>;
+}
+/** Reviewed reason why one localized printed slot resolves to English. */
+export type CardTextFallbackReason = 'missingLocale' | 'staleEffectiveText' | 'unreviewedSegmentation';
+/** Identity asset shared by separately loaded locale shards. */
+export interface CardTextCatalogManifestInput {
+    formatVersion: number;
+    contentHash: string;
+    sourceGeneration: string;
+    englishBaseline: string;
+    localeShards: Record<SimulatorLocale, CardTextCatalogShardInfo>;
+    canonicalAliases: Record<string, number>;
+    contractFingerprints: Record<string, string>;
+}
+/** Canonical byte identity of one independently loaded locale shard. */
+export interface CardTextCatalogShardInfo {
+    contentHash: string;
+    byteSize: number;
+}
+/** Prepared literal card catalog, after structural validation. */
+export interface PreparedCardTextCatalog {
+    readonly locale: SimulatorLocale;
+    readonly manifest: CardTextCatalogManifestInput;
+    readonly cards: Readonly<Record<string, Readonly<Record<string, CardTextCatalogSlotInput>>>>;
+    readonly prints: Readonly<Record<string, Readonly<CardPrintTextCatalogInput>>>;
+}
+/** Readable result for one exact reference lookup. */
+export interface ResolvedCardText {
+    readonly plainText: string;
+    readonly resolvedLocale: SimulatorLocale;
+    readonly status: 'source' | 'fallback' | 'notApplicable' | 'unavailable';
+    readonly fallbackReason?: CardTextFallbackReason;
+    readonly diagnostic?: 'fingerprintMismatch' | 'notApplicable' | 'unknownReference';
+}
+/** Machine-readable unavailable-reference record for consumer-owned diagnostics. */
+export interface CardTextDiagnostic {
+    readonly kind: 'fingerprintMismatch' | 'unknownReference';
+    readonly cardId: number;
+    readonly slot: string;
+    readonly contractFingerprint: string;
+}
+/** Receives a deduplicated unavailable-reference record from one resolver instance. */
+export type CardTextDiagnosticSink = (diagnostic: CardTextDiagnostic) => void;
+/** Instance-scoped literal-card resolver with a consumer-selected diagnostic boundary. */
+export interface CardTextResolver {
+    /** Resolves one exact literal-card reference without exposing unavailable raw keys. */
+    resolve(catalog: PreparedCardTextCatalog, reference: CardTextRef): ResolvedCardText;
+}
+/** Exact generated parameter map for one UI message id. */
+export type { SimulatorMessageId, SimulatorMessageParams };

package/dist/i18n/types.js

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

package/dist/index.d.ts

@@ -6,13 +6,14 @@ export type { CloseTournamentRoomRequest, CreateTournamentRoomRequest, CreateTou
 export { canDeployAnyLeader, flattenTargetGroups, getDeployableLeaderIndices, getLeaderDeployCommands, isSingleTargetPlan, leaderDeployCommand, targetGroupsOf, } from './actionable.js';
 export type { TargetingActionView } from './actionable.js';
 export type { SimulatorClient, SimulatorClientOptions } from './client.js';
-export type { AbandonMatchRequest, AbandonMatchResponse, ApiErrorResponse, AiStatusPayload, CardsResponse, CardCatalogRefreshResponse, ClientMessage, CreateLimitedEventRequest, CreateMetaWindowRequest, CreateMatchRequest, ErrorPayload, FormatEventResponse, FormatEventRequest, GameCommand, GameEvent, GameState, GetMatchResponse, HealthResponse, JoinLimitedEventRequest, JoinMatchRequest, LeaveMatchRequest, LeaveMatchResponse, LimitedEventAccessResponse, LimitedEventCommandRequest, LimitedEventPreflightResponse, LimitedEventResponse, ListActiveAiMatchesRequest, ListActiveAiMatchesResponse, MatchAccessResponse, MatchChatLookupResponse, MatchConnectionRole, MatchHistoryDeckStatsRequest, MatchHistoryDeckStatsResponse, MatchHistoryListRequest, MatchHistoryListResponse, MatchHistoryReplayRequest, MatchHistoryReplayResponse, MatchHistoryRestoreRequest, MatchRecoveryRequest, MatchRecoveryResponse, RestoreHistoryResponse, MatchSavePayload, MatchSpectatorAccessResponse, MetaWindow, MetaWindowsResponse, ResolveCardIdsRequest, ResolveCardIdsResponse, RankedAdminStatus, RankedLeaderboardEntry, RankedLeaderboardQuery, RankedLeaderboardResponse, RankedMatchmakingView, RankedProfileRequest, RankedProfileResponse, RankedQueue, RematchMatchRequest, RematchMatchResponse, RestoreMatchSaveRequest, RestoreMatchSaveResponse, SaveMatchRequest, ServerMessage, SetAiPausedRequest, SetRankedAdmissionRequest, SetSimulatorMaintenanceRequest, SimulatorAdminStatusResponse, SimulatorAvailabilityResponse, SpectateMatchRequest, SubmitMatchDeckRequest, SubmitMatchDeckResponse, UndoMatchRequest, UndoMatchResponse, UndoRespondMatchRequest, WelcomePayload, } from './generated/index.js';
+export type { AbandonMatchRequest, AbandonMatchResponse, ApiErrorResponse, AiStatusPayload, CardsResponse, CardCatalogRefreshResponse, ClientMessage, CreateLimitedEventRequest, CreateMetaWindowRequest, CreateMatchRequest, ErrorPayload, FormatEventResponse, FormatEventRequest, GameCommand, GameEvent, GameState, GetMatchResponse, HealthResponse, JoinLimitedEventRequest, JoinMatchRequest, LeaveMatchRequest, LeaveMatchResponse, LimitedEventAccessResponse, LimitedEventServerMessage, LimitedEventCommandRequest, LimitedEventPreflightResponse, LimitedEventResponse, ListActiveAiMatchesRequest, ListActiveAiMatchesResponse, MatchAccessResponse, MatchChatLookupResponse, MatchConnectionRole, MatchHistoryDeckStatsRequest, MatchHistoryDeckStatsResponse, MatchHistoryListRequest, MatchHistoryListResponse, MatchHistoryReplayRequest, MatchHistoryReplayResponse, MatchHistoryRestoreRequest, MatchRecoveryRequest, MatchRecoveryResponse, RestoreHistoryResponse, MatchSavePayload, MatchSpectatorAccessResponse, MetaWindow, MetaWindowsResponse, ResolveCardIdsRequest, ResolveCardIdsResponse, RankedAdminStatus, RankedLeaderboardEntry, RankedLeaderboardQuery, RankedLeaderboardResponse, RankedMatchmakingView, RankedProfileRequest, RankedProfileResponse, RankedQueue, RematchMatchRequest, RematchMatchResponse, RestoreMatchSaveRequest, RestoreMatchSaveResponse, SaveMatchRequest, ServerMessage, SetAiPausedRequest, SetRankedAdmissionRequest, SetSimulatorMaintenanceRequest, SimulatorAdminStatusResponse, SimulatorAvailabilityResponse, SpectateMatchRequest, SubmitAiGameFeedbackRequest, SubmitAiGameFeedbackResponse, SubmitMatchDeckRequest, SubmitMatchDeckResponse, UndoMatchRequest, UndoMatchResponse, UndoRespondMatchRequest, WelcomePayload, } from './generated/index.js';
 export type { PlaygroundCommand, PlaygroundDamageTarget, PlaygroundDefeatTarget, } from './generated/types/game-command.js';
 export type { UndoCancelReason } from './generated/types/game-event.js';
 export type { LimitedSideboardPoolView } from './generated/types/game-state.js';
 export type { HistoryIdentityInput, HistorySection, HistoryStatus, } from './generated/types/match-history-list-request.js';
 export type { MatchHistoryEntry, MatchHistoryPlayerSummary, } from './generated/types/match-history-entry.js';
 export type { MatchHistoryReplayArchive } from './generated/types/match-history-replay-response.js';
+export type { AiGameFeedback, AiGameFeedbackRating, } from './generated/types/submit-ai-game-feedback-response.js';
 export type { DeckArchetype, DeckArchetypeMatchup, DeckEndReasonCount, DeckFormatStats, DeckOpponentStats, DeckStats, DeckStatsArchetype, DeckStatsOpponentKind, WinLossDrawRecord, } from './generated/types/match-history-deck-stats-response.js';
 export { schemaVersion } from './generated/version.js';
 export type { FormatEventCommand } from './generated/types/format-event-request.js';
@@ -27,8 +28,8 @@ export type { CardInteractionCueRequest, } from './generated/types/client-messag
 export type { CardInteractionCue, CardInteractionCueKind, CardInteractionCueState, CardInteractionDragOffset, MatchChatMessage, MatchHistoryFeedEntry, MatchHistorySnapshot, MatchQuickPhrase, } from './generated/types/server-message.js';
 export type { CardIdResolution, CardMetadata, CardReferenceInput, CardReferenceType, DeckInput, DeckJson, DeckJsonCard, } from './resources/card-types.js';
 export type { CardsResource } from './resources/card-resource.js';
-export type { LimitedEventAccess, LimitedEventAccessInput, LimitedEventCommand, LimitedEventPreflight, LimitedEventReference, LimitedEventSnapshot, LimitedEventsResource, } from './resources/limited-events.js';
-export type { MatchHistoryResource, MatchRecoveryInput, MatchHistoryReplayInput, MatchHistoryRestoreInput, } from './resources/match-history.js';
+export type { LimitedEventAccess, LimitedEventAccessInput, LimitedEventCommand, LimitedEventPreflight, LimitedEventReference, LimitedEventSession, LimitedEventSessionEvents, LimitedEventSessionState, LimitedEventSnapshot, LimitedEventsResource, } from './resources/limited-events.js';
+export type { MatchHistoryResource, MatchRecoveryInput, MatchHistoryReplayInput, MatchHistoryRestoreInput, SubmitAiGameFeedbackInput, } from './resources/match-history.js';
 export type { MatchAccess, MatchAccessInput, MatchConnectionAccessInput, MatchReference, MatchSpectatorAccess, MatchSpectatorAccessInput, MatchesResource, } from './resources/matches.js';
 export type { SessionResource } from './resources/session.js';
 export type { SystemResource } from './resources/system.js';

package/dist/internal/authenticated-socket-session.d.ts

@@ -41,6 +41,8 @@ export declare abstract class AuthenticatedSocketSessionController<TMessage, TSn
         /** Boundary validator; defaults to the pass-through, which checks nothing. */
         validate?: SchemaValidator | undefined;
         webSocketFactory: WebSocketFactory;
+        /** Encodes credential kind and token as WebSocket subprotocols. */
+        tokenProtocols?: ((token: string) => string[]) | undefined;
     });
     get connectionState(): ConnectionState;
     get errorMessages(): readonly string[];

package/dist/internal/authenticated-socket-session.js

@@ -22,6 +22,7 @@ export class AuthenticatedSocketSessionController {
     #socketUrl;
     #validator;
     #webSocketFactory;
+    #tokenProtocols;
     #connectionState = 'idle';
     #errors = [];
     /** Previous live socket held until its replacement has opened. */
@@ -34,6 +35,7 @@ export class AuthenticatedSocketSessionController {
         this.#socketUrl = options.socketUrl;
         this.#validator = options.validate ?? passthroughValidator;
         this.#webSocketFactory = options.webSocketFactory;
+        this.#tokenProtocols = options.tokenProtocols ?? playerTokenProtocols;
         this.#playerToken = options.playerToken;
     }
     #playerToken;
@@ -57,7 +59,7 @@ export class AuthenticatedSocketSessionController {
         const previousSocket = this.#socket;
         this.#replacedSocket = previousSocket;
         this.#setConnectionState('connecting');
-        const socket = this.#webSocketFactory(this.#socketUrl, playerTokenProtocols(this.#playerToken));
+        const socket = this.#webSocketFactory(this.#socketUrl, this.#tokenProtocols(this.#playerToken));
         this.#socket = socket;
         let opened = false;
         socket.addEventListener('open', () => {

package/dist/local/client.js

@@ -4,6 +4,10 @@
  * `createSimulatorClient` lights up the entire existing SDK (resources,
  * `MatchSession`, reconnect) against the in-browser engine with zero changes.
  */
+/** Whether an HTTP response status permits a message body. */
+function responseMayHaveBody(status) {
+    return status !== 204 && status !== 205 && status !== 304;
+}
 /**
  * Creates the transport over a running engine worker (or a test double).
  */
@@ -98,8 +102,9 @@ export function createWorkerTransport(port) {
             path: `${parsed.pathname}${parsed.search}`,
             body,
         });
-        return new Response(result.body, {
-            status: result.status ?? 200,
+        const status = result.status ?? 200;
+        return new Response(responseMayHaveBody(status) ? result.body : null, {
+            status,
             headers: { 'content-type': 'application/json' },
         });
     };

package/dist/local/server/http-router.js

@@ -25,6 +25,14 @@ function retainOnlyMatch(registry, kept) {
         }
     }
 }
+/** Removes reverse limited-event ownership entries for one discarded lobby. */
+function deleteLobbyEventMappings(registry, lobbyId) {
+    for (const [eventId, owningLobbyId] of registry.eventLobbies) {
+        if (owningLobbyId === lobbyId) {
+            registry.eventLobbies.delete(eventId);
+        }
+    }
+}
 /**
  * Routes one HTTP request against the engine.
  */
@@ -62,6 +70,15 @@ export function routeHttpRequest(engine, registry, method, path, body, nowMs) {
             const seatToken = url.searchParams.get('seatToken');
             return { status: 200, body: lobby.eventSnapshot(seatToken, nowMs) };
         }
+        if (segments[3] === 'leave' && segments.length === 4 && method === 'POST') {
+            if (body == null) {
+                return jsonError(400, 'invalidRequest', 'missing leave request body');
+            }
+            // Local Limited events are always started from a lobby, so the lobby
+            // owns departure and replacement. Mirror the online direct-event guard
+            // without deleting the event mapping behind the active offline lobby.
+            return jsonError(409, 'limited_event_presence_owned_by_room', 'limited event presence is owned by its room');
+        }
         if (segments[3] === 'commands' && method === 'POST') {
             if (body == null) {
                 return jsonError(400, 'invalidRequest', 'missing command body');
@@ -186,6 +203,7 @@ function routeLobbyRequest(engine, registry, segments, method, body, nowMs) {
         }
         case 'POST leave': {
             const response = lobby.accessJson();
+            deleteLobbyEventMappings(registry, lobbyId);
             registry.lobbies.delete(lobbyId);
             return { status: 200, body: response };
         }

package/dist/resources/admin.d.ts

@@ -36,6 +36,14 @@ export interface AdminResource {
     getGameDebugBundle(auth: SimulatorAdminAuth, historyId: string, options?: SimulatorRequestOptions): Promise<AdminMatchDebugBundle>;
     /** Returns a completed replay archive for one match. */
     getGameReplay(auth: SimulatorAdminAuth, historyId: string, options?: SimulatorRequestOptions): Promise<AdminMatchReplayResponse>;
+    /**
+     * Returns all diagnostics for one match by runtime match id, including a
+     * match that is still in progress (the live runtime is exported first, the
+     * durable row serves once the runtime is gone).
+     */
+    getMatchDebugBundle(auth: SimulatorAdminAuth, matchId: string, options?: SimulatorRequestOptions): Promise<AdminMatchDebugBundle>;
+    /** Returns the replay archive for one match by runtime match id, live matches included. */
+    getMatchReplay(auth: SimulatorAdminAuth, matchId: string, options?: SimulatorRequestOptions): Promise<AdminMatchReplayResponse>;
     /** Creates or returns the hidden-information replay capability for one completed game. */
     createGameReplayShare(auth: SimulatorAdminAuth, historyId: string, options?: SimulatorRequestOptions): Promise<CreateMatchHistoryReplayShareResponse>;
     /** Lists safe metadata for retained simulator diagnostic reports. */

package/dist/resources/admin.js

@@ -7,6 +7,8 @@ export function createAdminResource(requester) {
         listGames: (auth, query, options) => requester.request('admin-match-list-response', adminGamesPath(query ?? {}), { headers: authHeaders(auth) }, options),
         getGameDebugBundle: (auth, historyId, options) => requester.request('admin-match-debug-bundle', `/api/admin/games/${encodeURIComponent(historyId)}/debug`, { headers: authHeaders(auth) }, options),
         getGameReplay: (auth, historyId, options) => requester.request('admin-match-replay-response', `/api/admin/games/${encodeURIComponent(historyId)}/replay`, { headers: authHeaders(auth) }, options),
+        getMatchDebugBundle: (auth, matchId, options) => requester.request('admin-match-debug-bundle', `/api/admin/matches/${encodeURIComponent(matchId)}/debug`, { headers: authHeaders(auth) }, options),
+        getMatchReplay: (auth, matchId, options) => requester.request('admin-match-replay-response', `/api/admin/matches/${encodeURIComponent(matchId)}/replay`, { headers: authHeaders(auth) }, options),
         createGameReplayShare: (auth, historyId, options) => requester.request('create-match-history-replay-share-response', `/api/admin/games/${encodeURIComponent(historyId)}/replay-shares`, { headers: authHeaders(auth), method: 'POST' }, options),
         listSimulatorReports: (auth, query, options) => requester.request('simulator-report-list-response', simulatorReportsPath(query ?? {}), { headers: authHeaders(auth) }, options),
         getSimulatorReport: (auth, reportId, options) => requester.request('simulator-report-response', `/api/admin/reports/${encodeURIComponent(reportId)}`, { headers: authHeaders(auth) }, options),

package/dist/resources/limited-event-session.d.ts

@@ -0,0 +1,10 @@
+import type { WebSocketFactory } from '../internal/transport.js';
+import type { SchemaValidator } from '../validators/validator.js';
+import type { LimitedEventAccess, LimitedEventAccessInput, LimitedEventSession } from './limited-event-types.js';
+/** Creates one direct Limited Event presence session. */
+export declare function createLimitedEventSession(options: {
+    access: LimitedEventAccessInput | LimitedEventAccess;
+    validate?: SchemaValidator | undefined;
+    webSocketFactory: WebSocketFactory;
+    wsUrl: string;
+}): LimitedEventSession;

package/dist/resources/limited-event-session.js

@@ -0,0 +1,35 @@
+import { seatTokenProtocols } from '../connection/url.js';
+import { AuthenticatedSocketSessionController, authenticatedSocketUrl, } from '../internal/authenticated-socket-session.js';
+import { simulatorSocketErrorPayload } from '../internal/errors.js';
+/** Creates one direct Limited Event presence session. */
+export function createLimitedEventSession(options) {
+    return new LimitedEventSessionController(options);
+}
+class LimitedEventSessionController extends AuthenticatedSocketSessionController {
+    /** Creates one seat-token authenticated session controller. */
+    constructor(options) {
+        super({
+            messageSchema: 'limited-event-server-message',
+            playerToken: options.access.seatToken,
+            socketError: info => simulatorSocketErrorPayload(info),
+            socketUrl: authenticatedSocketUrl(options.wsUrl, `limited-events/${encodeURIComponent(options.access.eventId)}`),
+            tokenProtocols: seatTokenProtocols,
+            webSocketFactory: options.webSocketFactory,
+            ...(options.validate == null ? {} : { validate: options.validate }),
+        });
+    }
+    /** Routes Limited Event protocol messages into observable session events. */
+    handleServerMessage(message) {
+        switch (message.type) {
+            case 'snapshot':
+                this.setSnapshot(message.payload);
+                break;
+            case 'error':
+                this.pushError(message.payload);
+                break;
+            case 'pong':
+                this.emit('pong', message.payload);
+                break;
+        }
+    }
+}