@indiegems/gem-web-sdk 5.9.0

package/dist/index.d.ts

@@ -0,0 +1,1981 @@
+declare const PROTOCOL: "gem-web-bridge";
+declare const SUPPORTED_VERSIONS: {
+    readonly min: 1;
+    readonly max: 1;
+};
+declare const MAX_MESSAGE_BYTES = 65536;
+declare const MAX_MESSAGE_DEPTH = 8;
+declare const MAX_MESSAGE_NODES = 5000;
+declare const MAX_ARRAY_LENGTH = 1024;
+declare const HANDSHAKE_TIMEOUT_MS = 10000;
+declare const RATE_LIMITS: Readonly<Record<string, number>>;
+declare const MALFORMED_INBOUND_KEY = "__malformed";
+declare const PARENT_TO_FRAME: readonly [
+    "gem.handshake",
+    "gem.token",
+    "gem.token.denied",
+    "gem.player",
+    "gem.pause",
+    "gem.prefs",
+    "gem.cohorts",
+    "gem.viewport",
+    "gem.deviceSettings",
+    "gem.willTerminate",
+    "gem.roomEvent",
+    "gem.socketState",
+    "gem.seatedEvent",
+    "gem.signalEvent",
+    "gem.dedicatedEvent",
+    "gem.partyResult",
+    "gem.clusterTarget",
+    "gem.devtools",
+    "gem.screenshot",
+    "gem.requestContext",
+    "gem.localServer",
+    "gem.localServer.denied",
+    "gem.error",
+    "gem.purchaseResult",
+    "gem.deviceSettings.result",
+    "gem.adResult",
+    "gem.signInResult"
+];
+declare const FRAME_TO_PARENT: readonly [
+    "gem.handshake.accept",
+    "gem.screenshot.denied",
+    "gem.gameContext",
+    "gem.signal",
+    "gem.dedicatedOffer",
+    "gem.partyRequest",
+    "gem.ready",
+    "gem.progress",
+    "gem.requestToken",
+    "gem.requestLocalServer",
+    "gem.exit",
+    "gem.openExternal",
+    "gem.requestFullscreen",
+    "gem.audioState",
+    "gem.rewardCue",
+    "gem.frameStats",
+    "gem.error",
+    "gem.requestPurchase",
+    "gem.deviceSettings.put",
+    "gem.requestAd",
+    "gem.requestSignIn"
+];
+type GemCapability = "ads" | "signIn" | "purchases" | "devtools" | "screenshot" | "feedbackContext" | "rooms" | "p2p" | "dedicated" | "clusterTarget" | "parties" | "partySeating" | "socketState" | "audioState" | "rewardCue" | "frameStats" | "viewport" | "localHost" | "cohorts" | "deviceSettings" | "asyncOpponents";
+declare const CAPABILITY_GATES: Readonly<Record<string, string>>;
+declare const CAPABILITY_NAMESPACE_GATES: ReadonlyArray<readonly [
+    string,
+    string
+]>;
+declare function capabilityFor(type: string): string | undefined;
+type GemErrorCode = "version_mismatch" | "handshake_timeout" | "handshake_duplicate" | "invalid_message" | "rate_limited" | "token_unavailable" | "unsupported" | "unsupported_capability" | "internal";
+interface GemHandshake {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.handshake";
+    readonly versions: {
+        min: number;
+        max: number;
+    };
+    readonly capabilities?: string[];
+    readonly embedder: string;
+}
+interface GemHandshakeAccept {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.handshake.accept";
+    readonly v: number;
+    readonly capabilities?: string[];
+}
+interface GemToken {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.token";
+    readonly token: string;
+    readonly requestId?: string;
+    readonly generation: number;
+    readonly apiBaseUrl?: string;
+    readonly playerId: string;
+    readonly gameId: string;
+    readonly channel: "dev" | "test" | "release";
+    readonly gameVersion?: string;
+    readonly expiresAt: number;
+    readonly chainEndsAt: number;
+    readonly allowDevTools?: boolean;
+}
+interface GemTokenDenied {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.token.denied";
+    readonly requestId: string;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number;
+    readonly reason: "chain_exhausted" | "unavailable";
+    readonly correlationId: string;
+}
+interface GemPlayer {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.player";
+    readonly untrusted: {
+        displayName: string;
+        displayHandle: string;
+    };
+    readonly displayTag: string;
+    readonly avatarUrl?: string;
+}
+interface GemPause {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.pause";
+    readonly paused: boolean;
+}
+interface GemPrefs {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.prefs";
+    readonly reducedMotion: boolean;
+    readonly muted: boolean;
+    readonly showFrameStats?: boolean;
+    readonly locale: string;
+}
+interface GemCohorts {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.cohorts";
+    readonly cohorts: {
+        experimentId: string;
+        variantKey: string;
+    }[];
+}
+interface GemViewport {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.viewport";
+    readonly insets: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}
+interface GemDeviceSettings {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.deviceSettings";
+    readonly settings?: unknown;
+}
+interface GemWillTerminate {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.willTerminate";
+    readonly reason: "grant_expiring" | "session_ended" | "navigating" | "kill_switch";
+    readonly graceMs: number;
+}
+interface GemRoomEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.roomEvent";
+    readonly event: "updated" | "match_started" | "match_ready" | "match_failed" | "version_stale";
+    readonly roomId: string;
+    readonly matchId?: string;
+    readonly version?: number;
+    readonly reason?: string;
+    readonly platform?: "universal" | "mobile";
+}
+interface GemSocketState {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.socketState";
+    readonly connected: boolean;
+    readonly reason?: "connecting" | "dropped" | "watchdog" | "terminal";
+}
+interface GemSeatedEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.seatedEvent";
+    readonly roomId: string;
+}
+interface GemSignalEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.signalEvent";
+    readonly event: "hello" | "offer" | "answer" | "ice" | "peerJoined" | "peerLeft" | "migration" | "matchEnded" | "error";
+    readonly matchId: string;
+    readonly data: unknown;
+}
+interface GemDedicatedEvent {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.dedicatedEvent";
+    readonly event: "answer" | "error" | "matchEnded";
+    readonly matchId: string;
+    readonly sdp?: string;
+    readonly sessionId?: string;
+    readonly code?: string;
+    readonly message?: string;
+    readonly reason?: string;
+}
+interface GemPartyResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.partyResult";
+    readonly requestId: string;
+    readonly partyId?: string;
+}
+interface GemClusterTarget {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.clusterTarget";
+    readonly clusterTargetId: string;
+}
+interface GemDevtools {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.devtools";
+    readonly action: "open" | "close" | "toggle";
+}
+interface GemScreenshot {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.screenshot";
+    readonly maxWidth: number;
+    readonly maxHeight: number;
+}
+interface GemScreenshotDenied {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.screenshot.denied";
+    readonly reason: "not_wired" | "no_source" | "unsupported" | "unreadable" | "tainted" | "too_large" | "busy" | "declined" | "failed";
+    readonly retryable: boolean;
+}
+interface GemRequestContext {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestContext";
+}
+interface GemGameContext {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.gameContext";
+    readonly context: unknown;
+}
+interface GemSignal {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.signal";
+    readonly signal: "join" | "offer" | "answer" | "ice" | "migrationAck" | "hostUnreachable";
+    readonly matchId: string;
+    readonly data: unknown;
+}
+interface GemDedicatedOffer {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.dedicatedOffer";
+    readonly matchId: string;
+    readonly sdp: string;
+    readonly intent: "initial" | "ice_restart" | "full_reconnect";
+}
+interface GemPartyRequest {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.partyRequest";
+    readonly requestId: string;
+}
+interface GemReady {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.ready";
+}
+interface GemProgress {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.progress";
+    readonly loaded: number;
+    readonly total: number;
+}
+interface GemRequestToken {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestToken";
+    readonly requestId: string;
+    readonly reason: "initial" | "expiring" | "rejected";
+}
+interface GemRequestLocalServer {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestLocalServer";
+    readonly requestId: string;
+    readonly gameRoomId: string;
+}
+interface GemLocalServer {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.localServer";
+    readonly requestId: string;
+    readonly serverId?: string;
+}
+interface GemLocalServerDenied {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.localServer.denied";
+    readonly requestId: string;
+    readonly retryable: boolean;
+    readonly reason: "refused" | "unavailable";
+}
+interface GemExit {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.exit";
+    readonly reason?: string;
+}
+interface GemOpenExternal {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.openExternal";
+    readonly url: string;
+}
+interface GemRequestFullscreen {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestFullscreen";
+    readonly enabled: boolean;
+}
+interface GemAudioState {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.audioState";
+    readonly muted: boolean;
+}
+interface GemRewardCue {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.rewardCue";
+    readonly currencySlug: string;
+    readonly expected?: number;
+    readonly origin?: {
+        x: number;
+        y: number;
+    };
+}
+interface GemFrameStats {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.frameStats";
+    readonly fps: number;
+    readonly frameTimeP95Ms: number;
+}
+interface GemError {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.error";
+    readonly code: "version_mismatch" | "handshake_timeout" | "handshake_duplicate" | "invalid_message" | "rate_limited" | "token_unavailable" | "unsupported" | "unsupported_capability" | "internal";
+    readonly message?: string;
+}
+interface GemRequestPurchase {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestPurchase";
+    readonly requestId: string;
+    readonly purchaseKind: "item" | "recipe";
+    readonly targetId: string;
+    readonly currencySlug: string;
+    readonly quantity?: number;
+    readonly catalogId?: string;
+}
+interface GemPurchaseResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.purchaseResult";
+    readonly requestId: string;
+    readonly outcome: "ok" | "declined" | "unavailable";
+    readonly purchaseId?: string;
+}
+interface GemDeviceSettingsPut {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.deviceSettings.put";
+    readonly requestId: string;
+    readonly settings: unknown;
+}
+interface GemDeviceSettingsResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.deviceSettings.result";
+    readonly requestId: string;
+    readonly outcome: "stored" | "too_large" | "unavailable";
+}
+interface GemRequestAd {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestAd";
+    readonly requestId: string;
+    readonly placement: string;
+    readonly format: "interstitial" | "rewarded";
+}
+interface GemAdResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.adResult";
+    readonly requestId: string;
+    readonly outcome: "shown" | "no_ad" | "unavailable";
+}
+interface GemRequestSignIn {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.requestSignIn";
+    readonly requestId: string;
+}
+interface GemSignInResult {
+    readonly gem: typeof PROTOCOL;
+    readonly type: "gem.signInResult";
+    readonly requestId: string;
+    readonly outcome: "signed_in" | "declined" | "unavailable";
+}
+type ParentMessage = GemHandshake | GemToken | GemTokenDenied | GemPlayer | GemPause | GemPrefs | GemCohorts | GemViewport | GemDeviceSettings | GemWillTerminate | GemRoomEvent | GemSocketState | GemSeatedEvent | GemSignalEvent | GemDedicatedEvent | GemPartyResult | GemClusterTarget | GemDevtools | GemScreenshot | GemRequestContext | GemLocalServer | GemLocalServerDenied | GemError | GemPurchaseResult | GemDeviceSettingsResult | GemAdResult | GemSignInResult;
+type FrameMessage = GemHandshakeAccept | GemScreenshotDenied | GemGameContext | GemSignal | GemDedicatedOffer | GemPartyRequest | GemReady | GemProgress | GemRequestToken | GemRequestLocalServer | GemExit | GemOpenExternal | GemRequestFullscreen | GemAudioState | GemRewardCue | GemFrameStats | GemError | GemRequestPurchase | GemDeviceSettingsPut | GemRequestAd | GemRequestSignIn;
+type GemMessage = ParentMessage | FrameMessage;
+type Rejection = string | null;
+declare function isOrigin(s: string): boolean;
+declare function validateSize(raw: unknown): Rejection;
+declare const validateGemHandshake: (raw: unknown) => Rejection;
+declare const validateGemHandshakeAccept: (raw: unknown) => Rejection;
+declare const validateGemToken: (raw: unknown) => Rejection;
+declare const validateGemTokenDenied: (raw: unknown) => Rejection;
+declare const validateGemPlayer: (raw: unknown) => Rejection;
+declare const validateGemPause: (raw: unknown) => Rejection;
+declare const validateGemPrefs: (raw: unknown) => Rejection;
+declare const validateGemCohorts: (raw: unknown) => Rejection;
+declare const validateGemViewport: (raw: unknown) => Rejection;
+declare const validateGemDeviceSettings: (raw: unknown) => Rejection;
+declare const validateGemWillTerminate: (raw: unknown) => Rejection;
+declare const validateGemRoomEvent: (raw: unknown) => Rejection;
+declare const validateGemSocketState: (raw: unknown) => Rejection;
+declare const validateGemSeatedEvent: (raw: unknown) => Rejection;
+declare const validateGemSignalEvent: (raw: unknown) => Rejection;
+declare const validateGemDedicatedEvent: (raw: unknown) => Rejection;
+declare const validateGemPartyResult: (raw: unknown) => Rejection;
+declare const validateGemClusterTarget: (raw: unknown) => Rejection;
+declare const validateGemDevtools: (raw: unknown) => Rejection;
+declare const validateGemScreenshot: (raw: unknown) => Rejection;
+declare const validateGemScreenshotDenied: (raw: unknown) => Rejection;
+declare const validateGemRequestContext: (raw: unknown) => Rejection;
+declare const validateGemGameContext: (raw: unknown) => Rejection;
+declare const validateGemSignal: (raw: unknown) => Rejection;
+declare const validateGemDedicatedOffer: (raw: unknown) => Rejection;
+declare const validateGemPartyRequest: (raw: unknown) => Rejection;
+declare const validateGemReady: (raw: unknown) => Rejection;
+declare const validateGemProgress: (raw: unknown) => Rejection;
+declare const validateGemRequestToken: (raw: unknown) => Rejection;
+declare const validateGemRequestLocalServer: (raw: unknown) => Rejection;
+declare const validateGemLocalServer: (raw: unknown) => Rejection;
+declare const validateGemLocalServerDenied: (raw: unknown) => Rejection;
+declare const validateGemExit: (raw: unknown) => Rejection;
+declare const validateGemOpenExternal: (raw: unknown) => Rejection;
+declare const validateGemRequestFullscreen: (raw: unknown) => Rejection;
+declare const validateGemAudioState: (raw: unknown) => Rejection;
+declare const validateGemRewardCue: (raw: unknown) => Rejection;
+declare const validateGemFrameStats: (raw: unknown) => Rejection;
+declare const validateGemError: (raw: unknown) => Rejection;
+declare const validateGemRequestPurchase: (raw: unknown) => Rejection;
+declare const validateGemPurchaseResult: (raw: unknown) => Rejection;
+declare const validateGemDeviceSettingsPut: (raw: unknown) => Rejection;
+declare const validateGemDeviceSettingsResult: (raw: unknown) => Rejection;
+declare const validateGemRequestAd: (raw: unknown) => Rejection;
+declare const validateGemAdResult: (raw: unknown) => Rejection;
+declare const validateGemRequestSignIn: (raw: unknown) => Rejection;
+declare const validateGemSignInResult: (raw: unknown) => Rejection;
+declare const VALIDATORS: Readonly<Record<string, (raw: unknown) => Rejection>>;
+interface OfferRefusal {
+    readonly reason: string;
+}
+declare function buildDedicatedOfferFrame(matchId: string, gameId: string, data: unknown): {
+    frame: Record<string, unknown>;
+} | OfferRefusal;
+declare const INBOUND_EVENTS: Readonly<Record<string, string>>;
+interface RelayedDedicatedEvent {
+    readonly event: string;
+    readonly matchId: string;
+    readonly sdp?: string;
+    readonly sessionId?: string;
+    readonly code?: string;
+    readonly message?: string;
+    readonly reason?: string;
+}
+declare function projectDedicatedEvent(raw: unknown, gameId: string, knowsMatch: (matchId: string) => boolean): RelayedDedicatedEvent | null;
+declare const MAX_SOCKET_FRAME_BYTES = 16384;
+declare const MAX_SIGNALS_PER_SECOND = 24;
+interface SignalRefusal {
+    readonly reason: string;
+}
+declare function buildSocketFrame(signal: string, matchId: string, gameId: string, data: unknown): {
+    frame: Record<string, unknown>;
+} | SignalRefusal;
+interface RelayedSignal {
+    readonly event: string;
+    readonly matchId: string;
+    readonly data: Record<string, unknown>;
+}
+declare function projectSignal(raw: unknown, gameId: string, knowsMatch: (matchId: string) => boolean): RelayedSignal | null;
+interface PartyEventRelay {
+    readonly event: string;
+    readonly partyId: string;
+    readonly version?: number;
+    readonly gameRoomId?: string;
+    readonly gameId?: string;
+    readonly inviterPlayerId?: string;
+    readonly inviterDisplayTag?: string;
+    readonly partyName?: string;
+}
+declare function projectPartyEvent(raw: unknown): PartyEventRelay | null;
+type PortMessageHandler = {
+    handle(event: {
+        data: unknown;
+        ports?: ReadonlyArray<MessagePort>;
+    }): void;
+}["handle"];
+interface PortLike {
+    postMessage(data: unknown, transfer?: unknown[]): void;
+    close(): void;
+    onmessage: PortMessageHandler | null;
+    start?(): void;
+}
+interface WindowLike {
+    postMessage(data: unknown, targetOrigin: string, transfer?: unknown[]): void;
+}
+interface HandshakeEvent {
+    readonly data: unknown;
+    readonly origin: string;
+    readonly source?: unknown;
+    readonly ports?: readonly PortLike[];
+}
+interface Clock {
+    now(): number;
+    setTimeout(fn: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+declare const systemClock: Clock;
+declare class RateLimiter {
+    private readonly clock;
+    private readonly tokens;
+    private readonly lastRefill;
+    constructor(clock?: Clock);
+    allow(type: string): boolean;
+}
+declare function originsEqual(a: string, b: string): boolean;
+declare function negotiateVersion(ours: {
+    min: number;
+    max: number;
+}, theirs: {
+    min: number;
+    max: number;
+}): number | null;
+interface TokenGrant {
+    readonly token: string;
+    readonly expiresAt: number;
+    readonly chainEndsAt: number;
+    readonly generation: number;
+    readonly playerId: string;
+    readonly gameId: string;
+    readonly channel: "dev" | "test" | "release";
+    readonly gameVersion?: string;
+    readonly requestId?: string;
+    readonly apiBaseUrl?: string;
+    readonly allowDevTools?: boolean;
+    readonly garden?: string;
+}
+interface TokenDenial {
+    readonly requestId: string;
+    readonly retryable: boolean;
+    readonly reason: "chain_exhausted" | "unavailable";
+    readonly correlationId: string;
+    readonly retryAfterMs?: number;
+}
+interface LocalServerGrant {
+    readonly requestId: string;
+    readonly serverId?: string;
+}
+interface LocalServerDenial {
+    readonly requestId: string;
+    readonly retryable: boolean;
+    readonly reason: "refused" | "unavailable";
+}
+interface PlayerIdentity {
+    readonly untrusted: {
+        readonly displayName: string;
+        readonly displayHandle: string;
+    };
+    readonly displayTag: string;
+    readonly avatarUrl?: string;
+}
+interface RoomEventRelay {
+    readonly event: "updated" | "match_started" | "match_ready" | "match_failed" | "version_stale";
+    readonly roomId: string;
+    readonly matchId?: string;
+    readonly version?: number;
+    readonly reason?: string;
+    readonly platform?: GemRoomEvent["platform"];
+}
+type RelayDestination = "room" | "signal" | "dedicated" | "party";
+type HostState = "idle" | "handshaking" | "connected" | "unsupported" | "closed";
+interface HostCallbacks {
+    onReady?(): void;
+    onProgress?(msg: GemProgress): void;
+    onRequestToken?(msg: GemRequestToken): void;
+    onRequestLocalServer?(msg: GemRequestLocalServer): void;
+    onExit?(msg: GemExit): void;
+    onOpenExternal?(msg: GemOpenExternal): void;
+    onRequestFullscreen?(msg: GemRequestFullscreen): void;
+    onAudioState?(msg: GemAudioState): void;
+    onRewardCue?(msg: GemRewardCue): void;
+    onFrameStats?(msg: GemFrameStats): void;
+    onScreenshotDenied?(msg: GemScreenshotDenied): void;
+    onGameContext?(msg: GemGameContext): void;
+    onSendSignal?(frame: Record<string, unknown>): void;
+    onPartyRequest?(msg: GemPartyRequest): void;
+    onRequestPurchase?(msg: GemRequestPurchase): void;
+    onDeviceSettingsPut?(msg: GemDeviceSettingsPut): void;
+    onRequestAd?(msg: GemRequestAd): void;
+    onRequestSignIn?(msg: GemRequestSignIn): void;
+    onPartyEvent?(event: PartyEventRelay): void;
+    onError?(code: GemErrorCode, message?: string): void;
+    onDropped?(code: GemErrorCode, message?: string): void;
+    onStateChange?(state: HostState): void;
+}
+interface HostOptions extends HostCallbacks {
+    frame: WindowLike;
+    frameOrigin: string;
+    embedderOrigin: string;
+    capabilities?: readonly string[];
+    clock?: Clock;
+}
+declare class GemHost {
+    private readonly options;
+    private state;
+    private port;
+    private version;
+    private timeoutHandle;
+    private reofferHandle;
+    private makeChannel;
+    private readonly offered;
+    private offersMade;
+    private localDenials;
+    private chainEndsAt;
+    private gameId;
+    private peerCapabilities;
+    private readonly knownMatches;
+    private readonly askedMatches;
+    private readonly clock;
+    private readonly inbound;
+    private readonly outbound;
+    private readonly socketWindow;
+    constructor(options: HostOptions);
+    get currentState(): HostState;
+    get frameCapabilities(): readonly string[];
+    frameSupports(capability: string): boolean;
+    get protocolVersion(): number | null;
+    start(makeChannel?: (() => {
+        port1: PortLike;
+        port2: PortLike;
+    }) | {
+        port1: PortLike;
+        port2: PortLike;
+    }): void;
+    private offer;
+    private scheduleReoffer;
+    private pruneStaleOffers;
+    private adopt;
+    static checkHandshakeOrigin(event: HandshakeEvent, expectedOrigin: string, expectedSource: unknown): string | null;
+    sendToken(grant: TokenGrant): void;
+    relayRoomEvent(raw: unknown): boolean;
+    sendRoomEvent(relay: RoomEventRelay): boolean;
+    sendSocketState(state: {
+        readonly connected: true;
+    } | {
+        readonly connected: false;
+        readonly reason: GemSocketState["reason"];
+    }): boolean;
+    sendSeatedEvent(roomId: string): boolean;
+    relaySeatedEvent(raw: unknown): boolean;
+    relaySocketEvent(raw: unknown): readonly RelayDestination[];
+    relaySignalEvent(raw: unknown): boolean;
+    sendSignalEvent(relay: RelayedSignal): boolean;
+    relayDedicatedEvent(raw: unknown): boolean;
+    sendDedicatedEvent(relay: RelayedDedicatedEvent): boolean;
+    private knowsMatch;
+    private rememberMatch;
+    private rememberAsked;
+    answerPartyRequest(requestId: string, partyId?: string): boolean;
+    answerPurchase(requestId: string, outcome: "ok" | "declined" | "unavailable", purchaseId?: string): boolean;
+    answerDeviceSettingsPut(requestId: string, outcome: "stored" | "too_large" | "unavailable"): boolean;
+    sendDeviceSettings(settings?: Readonly<Record<string, unknown>>): boolean;
+    answerAd(requestId: string, outcome: "shown" | "no_ad" | "unavailable"): boolean;
+    answerSignIn(requestId: string, outcome: "signed_in" | "declined" | "unavailable"): boolean;
+    denyToken(denial: TokenDenial): void;
+    grantLocalServer(grant: LocalServerGrant): boolean;
+    denyLocalServer(denial: LocalServerDenial): boolean;
+    sendClusterTarget(clusterTargetId: string): boolean;
+    sendPlayer(player: PlayerIdentity): void;
+    private chainExpired;
+    private localCorrelationId;
+    sendPause(paused: boolean): void;
+    sendDevtools(action: "open" | "close" | "toggle"): void;
+    requestScreenshot(port: MessagePort, caps: {
+        maxWidth: number;
+        maxHeight: number;
+    }): boolean;
+    requestContext(): boolean;
+    sendPrefs(prefs: {
+        reducedMotion: boolean;
+        muted: boolean;
+        locale: string;
+        showFrameStats?: boolean;
+    }): void;
+    sendCohorts(cohorts: ReadonlyArray<{
+        experimentId: string;
+        variantKey: string;
+    }>): boolean;
+    sendViewport(viewport: {
+        insets: {
+            top: number;
+            right: number;
+            bottom: number;
+            left: number;
+        };
+    }): boolean;
+    sendWillTerminate(reason: "grant_expiring" | "session_ended" | "navigating" | "kill_switch", graceMs: number): void;
+    close(): void;
+    private transition;
+    private fail;
+    private send;
+    private receive;
+    private refuseMalformed;
+    private versionMatches;
+    private forwardSignal;
+    private forwardDedicatedOffer;
+    private withinFrameSize;
+    private dispatch;
+}
+declare class PlayerText {
+    #private;
+    constructor(value: string);
+    toString(): string;
+    toJSON(): string;
+    get [Symbol.toStringTag](): string;
+    static unwrap(t: PlayerText): string;
+}
+declare function asPlayerText(value: string): PlayerText;
+declare const text: {
+    toPlain(t: PlayerText): string;
+    compare(a: PlayerText | string, b: PlayerText | string, locale?: string): number;
+    equals(a: PlayerText | string, b: PlayerText | string): boolean;
+};
+type ClusterTargetLike = string | null | undefined;
+type ClusterTargetResolver = () => Promise<ClusterTargetLike>;
+declare function normaliseClusterTarget(value: ClusterTargetLike): string | undefined;
+interface ClusterTargetBridge {
+    parentSupports(capability: string): boolean;
+}
+interface ClusterTargetSourceOptions {
+    readonly bridge: ClusterTargetBridge;
+    readonly clock: Clock;
+    readonly timeoutMs?: number;
+}
+interface ClusterTargetSource {
+    resolve: ClusterTargetResolver;
+    accept(clusterTargetId: ClusterTargetLike): void;
+}
+declare function createClusterTargetSource(options: ClusterTargetSourceOptions): ClusterTargetSource;
+interface RewardCue {
+    currencySlug: string;
+    expected?: number;
+    origin?: {
+        x: number;
+        y: number;
+    };
+}
+type FrameState = "waiting" | "connected" | "refused" | "closed";
+interface FrameCallbacks {
+    onToken?(msg: GemToken): void;
+    onPause?(msg: GemPause): void;
+    onPrefs?(msg: GemPrefs): void;
+    onCohorts?(msg: GemCohorts): void;
+    onViewport?(msg: GemViewport): void;
+    onWillTerminate?(msg: GemWillTerminate): void;
+    onDevtools?(action: "open" | "close" | "toggle"): void;
+    onScreenshot?(request: {
+        maxWidth: number;
+        maxHeight: number;
+    }, port: MessagePort, deny: (reason: GemScreenshotDenied["reason"], retryable: boolean) => void): void;
+    onRequestContext?(): void;
+    onTokenDenied?(msg: GemTokenDenied): void;
+    onLocalServer?(msg: GemLocalServer): void;
+    onLocalServerDenied?(msg: GemLocalServerDenied): void;
+    onPlayer?(player: {
+        displayName: PlayerText;
+        displayHandle: PlayerText;
+        displayTag: string;
+        avatarUrl?: string;
+    }): void;
+    onRoomEvent?(msg: GemRoomEvent): void;
+    onSeatedEvent?(msg: GemSeatedEvent): void;
+    onSocketState?(msg: GemSocketState): void;
+    onSignalEvent?(msg: GemSignalEvent): void;
+    onDedicatedEvent?(msg: GemDedicatedEvent): void;
+    onClusterTarget?(msg: GemClusterTarget): void;
+    onPartyResult?(msg: GemPartyResult): void;
+    onPurchaseResult?(msg: GemPurchaseResult): void;
+    onDeviceSettings?(msg: GemDeviceSettings): void;
+    onDeviceSettingsResult?(msg: GemDeviceSettingsResult): void;
+    onAdResult?(msg: GemAdResult): void;
+    onSignInResult?(msg: GemSignInResult): void;
+    onError?(code: GemErrorCode, message?: string): void;
+    onDropped?(code: GemErrorCode, message?: string): void;
+    onStateChange?(state: FrameState): void;
+    onRefused?(reason: string): void;
+}
+interface FrameOptions extends FrameCallbacks {
+    allowedEmbedders: readonly string[];
+    selfOrigin?: string;
+    expectedSource: unknown;
+    capabilities?: readonly string[];
+    clock?: Clock;
+}
+declare class GemFrame {
+    private readonly options;
+    private state;
+    private port;
+    private version;
+    private peerCapabilities;
+    private readyPending;
+    private readySent;
+    private settleWaiters;
+    private readonly clock;
+    private readonly inbound;
+    private readonly outbound;
+    private readonly expectedSource;
+    constructor(options: FrameOptions);
+    get currentState(): FrameState;
+    get parentCapabilities(): readonly string[];
+    parentSupports(capability: string): boolean;
+    get protocolVersion(): number | null;
+    handleWindowMessage(event: HandshakeEvent): boolean;
+    ready(): void;
+    settled(timeoutMs?: number): Promise<FrameState>;
+    progress(loaded: number, total: number): void;
+    requestToken(requestId: string, reason: "initial" | "expiring" | "rejected"): void;
+    requestLocalServer(requestId: string, gameRoomId: string): boolean;
+    exit(reason?: string): void;
+    openExternal(url: string): void;
+    requestFullscreen(enabled: boolean): void;
+    reportMuted(muted: boolean): boolean;
+    cueReward(cue: RewardCue): boolean;
+    reportFrameStats(stats: {
+        fps: number;
+        frameTimeP95Ms: number;
+    }): boolean;
+    sendGameContext(context: Record<string, unknown>): boolean;
+    signal(signal: string, matchId: string, data: Record<string, unknown>): void;
+    dedicatedOffer(matchId: string, sdp: string, intent: GemDedicatedOffer["intent"]): void;
+    requestParty(requestId: string): boolean;
+    requestPurchase(requestId: string, purchaseKind: "item" | "recipe", targetId: string, currencySlug: string, quantity?: number, catalogId?: string): boolean;
+    putDeviceSettings(requestId: string, settings: Readonly<Record<string, unknown>>): boolean;
+    requestAd(requestId: string, placement: string, format: "interstitial" | "rewarded"): boolean;
+    requestSignIn(requestId: string): boolean;
+    close(): void;
+    private transition;
+    private refuseMalformed;
+    private dropUnknownType;
+    private refuse;
+    private fail;
+    private send;
+    private receive;
+    private dispatchInbound;
+    private screenshotDenied;
+}
+declare const DEVICE_SETTINGS_MAX_BYTES = 16384;
+declare function deviceSettingsByteLength(settings: unknown): number | null;
+declare const CONDITIONAL_HEADERS: readonly [
+    "if-match",
+    "if-none-match"
+];
+type ConditionalRequestHeaders = Partial<Record<(typeof CONDITIONAL_HEADERS)[number], string>>;
+interface TransportRequest {
+    readonly method: "GET" | "PUT" | "POST" | "PATCH" | "DELETE";
+    readonly path: string;
+    readonly body?: unknown;
+    readonly headers?: ConditionalRequestHeaders;
+    readonly signal?: AbortSignal;
+    readonly keepalive?: boolean;
+}
+interface TransportResponse {
+    readonly status: number;
+    readonly body: unknown;
+    readonly etag?: string;
+    readonly retryAfterSeconds?: number;
+}
+interface Transport {
+    request(request: TransportRequest): Promise<TransportResponse>;
+}
+interface ClientOptions {
+    readonly transport: Transport;
+    readonly clock: Clock;
+    readonly maxRetries?: number;
+}
+interface RequestOptions {
+    readonly keepalive?: boolean;
+    readonly ifMatch?: string;
+    readonly replaySafe?: boolean;
+}
+interface VersionedGetOptions {
+    readonly signal?: AbortSignal;
+    readonly ifNoneMatch?: string;
+}
+type VersionedResponse<T> = {
+    readonly modified: true;
+    readonly body: T;
+    readonly etag?: string;
+} | {
+    readonly modified: false;
+    readonly etag?: string;
+};
+declare class GemClient {
+    private readonly options;
+    constructor(options: ClientOptions);
+    get<T>(path: string, signal?: AbortSignal): Promise<T>;
+    getWithEtag<T>(path: string, options?: VersionedGetOptions): Promise<VersionedResponse<T>>;
+    put<T>(path: string, body: unknown, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    post<T>(path: string, body: unknown, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    patch<T>(path: string, body: unknown, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    delete<T>(path: string, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    private send;
+    private sendRaw;
+    private backoff;
+}
+type TransportLabel = "p2p" | "dedicated" | "unknown";
+declare const TRANSPORT_LABELS: readonly TransportLabel[];
+declare const TELEMETRY_EVENTS: readonly string[];
+interface TelemetrySample {
+    readonly type: string;
+    readonly value?: number;
+    readonly transport?: TransportLabel;
+}
+interface ClientTelemetryOptions {
+    readonly client: GemClient;
+    readonly gameId: () => string | null;
+    readonly transport?: TransportLabel;
+    readonly now?: () => number;
+}
+declare class ClientTelemetry {
+    private readonly options;
+    constructor(options: ClientTelemetryOptions);
+    post(samples: readonly TelemetrySample[], signal?: AbortSignal): Promise<void>;
+    report(samples: readonly TelemetrySample[]): void;
+}
+type MatchEndedReason = "explicit" | "stale_cleanup" | "game_room_closed" | "replaced" | "migration_failed" | "host_left" | "insufficient_players" | "all_left" | "expired" | "migration_rate_exceeded" | "game_room_gone" | "failed" | "idle" | "reclaimed";
+declare const WEBRTC_DEDICATED = "webrtc_dedicated";
+declare const CLIENT_PLATFORMS: readonly [
+    "universal",
+    "mobile",
+    "web"
+];
+type ClientPlatform = (typeof CLIENT_PLATFORMS)[number];
+interface ClientVersion {
+    readonly platform?: ClientPlatform;
+    readonly gameVersion: string;
+    readonly engineVersion?: string;
+}
+type ResolvedClientVersion = ClientVersion & {
+    readonly platform: ClientPlatform;
+    readonly engineVersion: string;
+};
+interface StartedMatch$1 {
+    readonly matchId: string;
+    readonly status: string;
+}
+interface ReadyMatch {
+    readonly status: "ready";
+    readonly matchId: string;
+    readonly protocol: string;
+    readonly joinCredential?: string;
+    readonly credentialExpiresAt?: number;
+    readonly host?: string;
+    readonly port?: number;
+}
+interface FailedMatch {
+    readonly status: "failed";
+    readonly matchId: string;
+    readonly reason: string;
+}
+interface EndedMatch {
+    readonly status: "ended";
+    readonly matchId: string;
+    readonly reason: MatchEndedReason | "unknown";
+}
+type MatchOutcome = ReadyMatch | FailedMatch | EndedMatch;
+interface AllocationTarget {
+    readonly client: GemClient;
+    readonly gameId: string;
+    readonly roomId: string;
+}
+interface StartMatchOptions$1 extends AllocationTarget {
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly clock?: Clock;
+    readonly retry?: StartMatchRetryOptions;
+    readonly signal?: AbortSignal;
+}
+interface StartMatchWaiting {
+    readonly attempt: number;
+    readonly elapsedMs: number;
+    readonly budgetMs: number;
+    readonly nextAttemptInMs: number;
+    readonly status: number;
+    readonly message: string;
+}
+interface StartMatchRetryOptions {
+    readonly budgetMs?: number;
+    readonly initialDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly onWaiting?: (waiting: StartMatchWaiting) => void;
+}
+declare function startMatch(options: StartMatchOptions$1): Promise<StartedMatch$1>;
+interface MatchOutcomeWaitOptions extends AllocationTarget {
+    readonly matchId: string;
+    readonly clock: Clock;
+    readonly version: ResolvedClientVersion;
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly knownToExist?: boolean;
+    readonly signal?: AbortSignal;
+}
+declare function awaitMatchOutcome(options: MatchOutcomeWaitOptions): Promise<MatchOutcome>;
+interface ClusterTargetsOptions {
+    readonly client: GemClient;
+    readonly signal?: AbortSignal;
+}
+interface ClusterTarget {
+    readonly id: string;
+    readonly pressure: string;
+}
+declare function listClusterTargets(options: ClusterTargetsOptions): Promise<readonly ClusterTarget[]>;
+type RoomArgScalar = string | number | boolean;
+type RoomArgValue = RoomArgScalar | readonly RoomArgScalar[];
+type RoomArgs = Readonly<Record<string, RoomArgValue>>;
+type RoomArgType = "string" | "int" | "float" | "bool" | (string & {});
+interface RoomArgEntry {
+    readonly name: string;
+    readonly type: RoomArgType;
+    readonly list: boolean;
+    readonly required: boolean;
+    readonly mutable: boolean;
+    readonly fixed?: RoomArgValue;
+    readonly default?: RoomArgValue;
+    readonly description?: string;
+    readonly allowed?: readonly RoomArgScalar[];
+    readonly min?: number;
+    readonly max?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly maxLength?: number;
+}
+declare function roomArgValuesFromWire(body: unknown): RoomArgs | undefined;
+declare function roomArgsTemplateFromWire(body: unknown): readonly RoomArgEntry[] | undefined;
+type DedicatedServerFailure = "timeout" | "aborted" | "allocation_failed" | "no_server_ready" | "start_rate_limited" | "p2p_unavailable" | "unsupported_protocol" | "credential_expired" | "credential_reused" | "join_rate_limited" | "signaling_unavailable" | "signaling_failed" | "offer_refused" | "invalid_sdp" | "media_refused" | "connection_failed" | "join_refused" | "match_ended" | "misconfigured";
+declare class DedicatedServerError extends Error {
+    readonly reason: DedicatedServerFailure;
+    readonly retryable: boolean;
+    readonly platformCode: string | undefined;
+    constructor(reason: DedicatedServerFailure, message: string, options?: {
+        cause?: unknown;
+        platformCode?: string;
+    });
+}
+type SignalingIntent = "initial" | "ice_restart" | "full_reconnect";
+interface OfferRequest {
+    readonly matchId: string;
+    readonly sdp: string;
+    readonly intent: SignalingIntent;
+}
+interface SignalingAnswer {
+    readonly sdp: string;
+}
+interface SignalingChannel {
+    exchange(request: OfferRequest, signal?: AbortSignal): Promise<SignalingAnswer>;
+    close(): void;
+}
+declare function unavailableSignaling(): SignalingChannel;
+type SdpType$1 = "offer" | "answer" | "pranswer" | "rollback";
+interface SessionDescriptionLike$1 {
+    readonly type: SdpType$1;
+    readonly sdp?: string;
+}
+interface DataChannelInitLike$1 {
+    readonly ordered?: boolean;
+    readonly maxRetransmits?: number;
+}
+interface EventTargetLike$1 {
+    addEventListener(type: string, listener: (event: unknown) => void): void;
+    removeEventListener(type: string, listener: (event: unknown) => void): void;
+}
+interface DataChannelLike$1 extends EventTargetLike$1 {
+    readonly readyState: string;
+    send(data: string | Uint8Array): void;
+    close(): void;
+}
+interface PeerConnectionLike$1 extends EventTargetLike$1 {
+    readonly localDescription: SessionDescriptionLike$1 | null;
+    readonly iceGatheringState: string;
+    createDataChannel(label: string, init?: DataChannelInitLike$1): DataChannelLike$1;
+    createOffer(): Promise<SessionDescriptionLike$1>;
+    setLocalDescription(description: SessionDescriptionLike$1): Promise<void>;
+    setRemoteDescription(description: SessionDescriptionLike$1): Promise<void>;
+    close(): void;
+}
+interface EstablishOptions {
+    readonly peerConnection: PeerConnectionLike$1;
+    readonly signaling: SignalingChannel;
+    readonly matchId: string;
+    readonly clock: Clock;
+    readonly intent?: SignalingIntent;
+    readonly channelLabel?: string;
+    readonly gatherTimeoutMs?: number;
+    readonly exchangeTimeoutMs?: number;
+    readonly openTimeoutMs?: number;
+    readonly credentialExpiresAt?: number;
+    readonly signal?: AbortSignal;
+    readonly extraChannels?: readonly {
+        readonly label: string;
+        readonly ordered?: boolean;
+        readonly maxRetransmits?: number;
+    }[];
+    readonly onExtraChannel?: (label: string, channel: DataChannelLike$1) => void;
+}
+declare function establishDataChannel(options: EstablishOptions): Promise<DataChannelLike$1>;
+declare const DEFAULT_WELCOME_CEILING_MS = 25000;
+interface JoinWelcome {
+    readonly playerId?: string;
+    readonly matchId?: string;
+    readonly heartbeatIntervalMs?: number;
+}
+interface JoinExchange {
+    readonly welcome: JoinWelcome;
+    detach(): void;
+}
+interface PresentCredentialOptions {
+    readonly channel: DataChannelLike$1;
+    readonly credential: string;
+    readonly credentialExpiresAt: number;
+    readonly clock: Clock;
+    readonly ceilingMs?: number;
+    readonly wire?: number;
+    readonly heartbeat?: boolean;
+    readonly onMessage?: (data: unknown) => void;
+    readonly signal?: AbortSignal;
+}
+declare function presentJoinCredential(options: PresentCredentialOptions): Promise<JoinExchange>;
+type TransportKind = "webtransport" | "webrtc" | "websocket";
+interface SendOptions {
+    readonly reliable?: boolean;
+    readonly ordered?: boolean;
+}
+interface MessageMeta {
+    readonly reliable: boolean;
+    readonly ordered: boolean;
+}
+interface GameServerLink {
+    readonly transport: TransportKind;
+    send(data: Uint8Array | string, options?: SendOptions): void;
+    onMessage(handler: (data: Uint8Array | string, meta: MessageMeta) => void): void;
+    onClose(handler: (reason?: string) => void): void;
+    close(): void;
+}
+type RoomStatus = "open" | "in_game" | "closed" | (string & {});
+type MatchConnectionState = "disconnected" | "connecting" | "connected" | "suspended";
+type MatchSessionPhase = "none" | "starting" | "ready" | "connected" | "suspended" | "ended" | (string & {});
+interface MatchSession {
+    readonly phase: MatchSessionPhase;
+    readonly matchId?: string;
+    readonly reason?: string;
+    readonly roomReopened?: boolean;
+}
+interface MatchEnded {
+    readonly matchId: string;
+    readonly reason: string;
+    readonly roomReopened: boolean;
+}
+interface MatchSuspended {
+    readonly matchId: string;
+    readonly cause: string;
+}
+interface MatchReconnecting {
+    readonly matchId: string;
+    readonly attempt: number;
+    readonly attempts: number;
+    readonly remainingMs: number;
+}
+interface MatchReconnected {
+    readonly matchId: string;
+    readonly attempt: number;
+}
+interface AutoReconnectOptions {
+    readonly budgetMs?: number;
+    readonly attempts?: number;
+    readonly maxDelayMs?: number;
+}
+interface RoomMember {
+    readonly playerId: string;
+    readonly isReady: boolean;
+    readonly role: string;
+    readonly joinedAt: number;
+    readonly groupId?: string;
+    readonly platform?: string;
+    readonly displayName?: PlayerText;
+    readonly displayTag?: PlayerText;
+    readonly discriminator?: string;
+}
+interface Room {
+    readonly id: string;
+    readonly gameId: string;
+    readonly name: string;
+    readonly status: RoomStatus;
+    readonly hostPlayerId: string;
+    readonly maxPlayers: number;
+    readonly memberCount: number;
+    readonly members: readonly RoomMember[];
+    readonly isPublic: boolean;
+    readonly joinCode?: string;
+    readonly settings?: unknown;
+    readonly roomArgs?: RoomArgs;
+    readonly roomArgsTemplate?: readonly RoomArgEntry[];
+    readonly gameChannel: string;
+    readonly region?: string;
+    readonly matchId?: string;
+    readonly version: number;
+    readonly templateId?: string;
+    readonly roomType: string;
+    readonly transports?: readonly TransportKind[];
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly startedAt?: number;
+}
+interface RoomSummary {
+    readonly id: string;
+    readonly gameId: string;
+    readonly name: string;
+    readonly status: RoomStatus;
+    readonly hostPlayerId: string;
+    readonly maxPlayers: number;
+    readonly memberCount: number;
+    readonly isPublic: boolean;
+    readonly gameChannel: string;
+    readonly roomType: string;
+    readonly createdAt: number;
+}
+interface RoomPage {
+    readonly rooms: readonly RoomSummary[];
+    readonly nextCursor?: string;
+}
+interface RoomOperationError {
+    readonly operation: string;
+    readonly code: number;
+    readonly reason: string;
+    readonly message: string;
+    readonly retryable: boolean;
+}
+declare function roomFromWire(body: unknown): Room;
+declare function memberFromWire(body: unknown): RoomMember;
+declare function summaryFromWire(body: unknown): RoomSummary;
+interface RoomsApiOptions {
+    readonly client: GemClient;
+    readonly gameId: () => string;
+}
+interface CreateRoomOptions {
+    readonly name: string;
+    readonly maxPlayers?: number;
+    readonly isPublic?: boolean;
+    readonly settings?: unknown;
+    readonly region?: string;
+    readonly templateId?: string;
+    readonly templateSlug?: string;
+    readonly partyId?: string;
+    readonly roomArgs?: RoomArgs;
+    readonly signal?: AbortSignal;
+}
+interface JoinRoomOptions {
+    readonly partyId?: string;
+    readonly signal?: AbortSignal;
+}
+interface QuickJoinOptions extends JoinRoomOptions {
+    readonly templateSlug?: string;
+    readonly templateId?: string;
+    readonly region?: string;
+    readonly name?: string;
+}
+interface ListRoomsOptions {
+    readonly status?: "open" | "in_game";
+    readonly templateSlug?: string;
+    readonly limit?: number;
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
+}
+interface UpdateRoomOptions {
+    readonly name?: string;
+    readonly maxPlayers?: number;
+    readonly isPublic?: boolean;
+    readonly settings?: unknown;
+    readonly roomArgs?: RoomArgs;
+    readonly signal?: AbortSignal;
+}
+declare class RoomsApi {
+    private readonly options;
+    constructor(options: RoomsApiOptions);
+    list(options: ListRoomsOptions): Promise<RoomPage>;
+    myRooms(signal?: AbortSignal): Promise<RoomPage>;
+    create(options: CreateRoomOptions, version: ResolvedClientVersion): Promise<Room>;
+    get(roomId: string, signal?: AbortSignal): Promise<Room>;
+    join(roomId: string, options: JoinRoomOptions, version: ResolvedClientVersion): Promise<Room>;
+    joinByCode(code: string, options: JoinRoomOptions, version: ResolvedClientVersion): Promise<Room>;
+    quickJoin(options: QuickJoinOptions, version: ResolvedClientVersion): Promise<Room>;
+    leave(roomId: string, asGroup: boolean, signal?: AbortSignal, keepalive?: boolean): Promise<void>;
+    close(roomId: string, signal?: AbortSignal): Promise<void>;
+    update(roomId: string, options: UpdateRoomOptions): Promise<Room>;
+    setReady(roomId: string, isReady: boolean, signal?: AbortSignal): Promise<Room>;
+    kick(roomId: string, playerId: string, signal?: AbortSignal): Promise<Room>;
+    transferHost(roomId: string, playerId: string, signal?: AbortSignal): Promise<Room>;
+    leaveMatch(matchId: string, keepalive: boolean): Promise<void>;
+    private baseV2;
+    private baseV1;
+    private roomV2;
+    private roomV1;
+}
+interface RoomEventMap {
+    created: [
+        Room
+    ];
+    joined: [
+        Room
+    ];
+    left: [
+    ];
+    closed: [
+    ];
+    updated: [
+        Room
+    ];
+    seated: [
+        Room
+    ];
+    listed: [
+        RoomPage
+    ];
+    mineListed: [
+        readonly RoomSummary[]
+    ];
+    memberJoined: [
+        string
+    ];
+    memberLeft: [
+        string
+    ];
+    kicked: [
+    ];
+    readyChanged: [
+        string,
+        boolean
+    ];
+    hostChanged: [
+        string
+    ];
+    matchStartWaiting: [
+        StartMatchWaiting
+    ];
+    matchAllocationStarted: [
+        string
+    ];
+    matchReady: [
+        ReadyMatch
+    ];
+    matchFailed: [
+        string,
+        string
+    ];
+    matchEnded: [
+        MatchEnded
+    ];
+    matchSuspended: [
+        MatchSuspended
+    ];
+    matchReconnecting: [
+        MatchReconnecting
+    ];
+    matchReconnected: [
+        MatchReconnected
+    ];
+    versionUpdateAvailable: [
+        ClientPlatform | undefined
+    ];
+    error: [
+        RoomOperationError
+    ];
+}
+type RoomEventName = keyof RoomEventMap;
+type Listener<K extends RoomEventName> = (...args: RoomEventMap[K]) => void;
+declare class RoomEmitter {
+    private readonly listeners;
+    private retainedMatch;
+    on<K extends RoomEventName>(event: K, listener: Listener<K>): () => void;
+    hasListeners(event: RoomEventName): boolean;
+    off<K extends RoomEventName>(event: K, listener: Listener<K>): void;
+    once<K extends RoomEventName>(event: K, listener: Listener<K>): () => void;
+    emit<K extends RoomEventName>(event: K, ...args: RoomEventMap[K]): void;
+    get retained(): ReadyMatch | null;
+    retain(match: ReadyMatch): void;
+    clearRetained(): void;
+    clear(): void;
+}
+type PartyResolver = () => Promise<string | undefined>;
+interface PartyBridge {
+    requestParty(requestId: string): boolean;
+    parentSupports(capability: string): boolean;
+}
+interface PartyResolverOptions {
+    readonly bridge: PartyBridge;
+    readonly clock: Clock;
+    readonly timeoutMs?: number;
+}
+declare function createPartyResolver(options: PartyResolverOptions): {
+    resolve: PartyResolver;
+    settle(requestId: string, partyId?: string): void;
+};
+interface MatchEndHint {
+    readonly matchId?: string;
+    readonly reason?: string;
+}
+interface AutoReconnectWiring {
+    readonly attempts: number;
+    readonly maxDelayMs: number;
+    readonly budgetMs: number;
+    readonly redial: (matchId: string, deadlineAt: number) => Promise<"connected" | "closed">;
+    readonly abandon: (matchId: string, reason: string) => void;
+}
+interface RelayedRoomEvent {
+    readonly event: "updated" | "match_started" | "match_ready" | "match_failed" | "version_stale";
+    readonly roomId: string;
+    readonly matchId?: string;
+    readonly version?: number;
+    readonly reason?: string;
+    readonly platform?: ClientPlatform;
+}
+interface RoomManagerOptions {
+    readonly client: GemClient;
+    readonly clock: Clock;
+    readonly gameId: string | (() => string | null);
+    readonly awaitGameId?: () => Promise<string>;
+    readonly playerId: string | (() => string | null);
+    readonly clientVersion?: ClientVersion;
+    readonly platformGameVersion?: () => string | null;
+    readonly poll?: boolean;
+    readonly pollIntervalMs?: number;
+    readonly pushedPollIntervalMs?: number;
+    readonly notifyOnUnload?: boolean;
+    readonly followMatch?: boolean;
+    readonly resolveParty?: PartyResolver;
+    readonly resolveClusterTarget?: ClusterTargetResolver;
+    readonly ensureLocalServer?: (gameRoomId: string) => Promise<void>;
+    readonly autoReconnect?: AutoReconnectWiring;
+    readonly recoverStaleMembership?: boolean;
+    readonly watchSeats?: boolean;
+    readonly seatPollIntervalMs?: number;
+}
+interface StartMatchOptions {
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly retry?: StartMatchRetryOptions;
+    readonly signal?: AbortSignal;
+}
+interface AwaitMatchOptions {
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+}
+interface StartedMatch {
+    readonly matchId: string;
+    readonly status: string;
+}
+interface RoomManager {
+    create(options: CreateRoomOptions): Promise<Room>;
+    join(roomId: string, options?: JoinRoomOptions): Promise<Room>;
+    joinByCode(code: string, options?: JoinRoomOptions): Promise<Room>;
+    quickJoin(options: QuickJoinOptions): Promise<Room>;
+    list(options?: ListRoomsOptions): Promise<RoomPage>;
+    myRooms(signal?: AbortSignal): Promise<readonly RoomSummary[]>;
+    leave(options?: {
+        asGroup?: boolean;
+        signal?: AbortSignal;
+        keepalive?: boolean;
+    }): Promise<void>;
+    leaveAll(signal?: AbortSignal): Promise<readonly string[]>;
+    close(signal?: AbortSignal): Promise<void>;
+    refresh(signal?: AbortSignal): Promise<Room | null>;
+    setReady(isReady: boolean, signal?: AbortSignal): Promise<Room>;
+    kick(playerId: string, signal?: AbortSignal): Promise<Room>;
+    transferHost(playerId: string, signal?: AbortSignal): Promise<Room>;
+    update(options: UpdateRoomOptions): Promise<Room>;
+    startMatch(options?: StartMatchOptions): Promise<StartedMatch>;
+    awaitMatch(options?: AwaitMatchOptions): Promise<ReadyMatch>;
+    pollMatchStatus(options?: AwaitMatchOptions): Promise<ReadyMatch>;
+    notifyMatchConnected(matchId: string): void;
+    notifyMatchDisconnected(cause?: string): Promise<void>;
+    reconnectToMatch(options?: AwaitMatchOptions): Promise<ReadyMatch>;
+    notifyLeavingMatch(options?: {
+        keepalive?: boolean;
+    }): Promise<void>;
+    readonly gameId: string | null;
+    readonly currentRoom: Room | null;
+    readonly currentMatch: ReadyMatch | null;
+    readonly matchConnectionState: MatchConnectionState;
+    readonly matchSession: MatchSession;
+    readonly isInRoom: boolean;
+    readonly isHost: boolean;
+    readonly members: readonly Room["members"][number][];
+    on<K extends RoomEventName>(event: K, listener: (...args: RoomEventMap[K]) => void): () => void;
+    off<K extends RoomEventName>(event: K, listener: (...args: RoomEventMap[K]) => void): void;
+    once<K extends RoomEventName>(event: K, listener: (...args: RoomEventMap[K]) => void): () => void;
+    handleRoomEvent(event: RelayedRoomEvent): void;
+    handleSeated(roomId: string): void;
+    reconcileSeats(): Promise<void>;
+    reconcile(hint?: MatchEndHint): Promise<void>;
+    startPolling(intervalMs?: number): void;
+    stopPolling(): void;
+    settled(): Promise<void>;
+    dispose(): void;
+}
+declare function createRoomManager(options: RoomManagerOptions): RoomManager;
+declare const WEB_ENGINE_VERSION = "0.1.0-beta";
+interface DedicatedSignalTransport {
+    dedicatedOffer(matchId: string, sdp: string, intent: OfferRequest["intent"]): void;
+    parentSupports(capability: string): boolean;
+}
+interface DedicatedSignalingOptions {
+    readonly bridge: DedicatedSignalTransport | null;
+}
+interface Pending {
+    readonly settle: (answer: SignalingAnswer) => void;
+    readonly refuse: (error: DedicatedServerError) => void;
+}
+declare class DedicatedSignalingHub {
+    private readonly options;
+    private readonly pending;
+    constructor(options: DedicatedSignalingOptions);
+    channel(): SignalingChannel;
+    handleEvent(event: GemDedicatedEvent): void;
+    register(matchId: string, waiter: Pending): void;
+    release(matchId: string, waiter: Pending): void;
+    transport(): DedicatedSignalTransport;
+}
+interface DedicatedServerApiOptions {
+    readonly client: GemClient;
+    readonly clock: Clock;
+    readonly rooms: RoomManager;
+    readonly signaling?: () => SignalingChannel;
+    readonly log?: (message: string) => void;
+    readonly signalingReady?: (timeoutMs: number) => Promise<boolean>;
+}
+interface ConnectOptions {
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly retry?: StartMatchRetryOptions;
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+    readonly signaling?: SignalingChannel;
+    readonly peerConnection?: PeerConnectionLike$1;
+    readonly intent?: SignalingIntent;
+    readonly channelLabel?: string;
+    readonly gatherTimeoutMs?: number;
+    readonly exchangeTimeoutMs?: number;
+    readonly openTimeoutMs?: number;
+    readonly reportDisconnect?: boolean;
+    readonly reportConnected?: boolean;
+    readonly presentCredential?: boolean;
+    readonly onMessage?: (data: unknown) => void;
+    readonly onMatchEnded?: (reason?: string) => void;
+    readonly welcomeTimeoutMs?: number;
+    readonly transports?: readonly TransportKind[];
+    readonly transportAttemptTimeoutMs?: number;
+    readonly redial?: boolean;
+    readonly deadlineAt?: number;
+}
+interface DedicatedServerSession {
+    readonly matchId: string;
+    readonly channel: RTCDataChannel;
+    readonly peerConnection: PeerConnectionLike$1;
+    readonly joinCredential: string;
+    readonly credentialExpiresAt: number;
+    readonly welcome: JoinWelcome | null;
+    close(): void;
+}
+interface MultiTransportSession {
+    readonly matchId: string;
+    readonly transport: TransportKind;
+    readonly link: GameServerLink;
+    readonly joinCredential: string;
+    readonly credentialExpiresAt: number;
+    readonly welcome: JoinWelcome | null;
+    readonly channel?: RTCDataChannel;
+    readonly peerConnection?: PeerConnectionLike$1;
+    close(): void;
+}
+interface DedicatedServerConnect {
+    (options?: ConnectOptions & {
+        transports?: undefined;
+    }): Promise<DedicatedServerSession>;
+    (options: ConnectOptions & {
+        transports: readonly TransportKind[];
+    }): Promise<MultiTransportSession>;
+    (options?: ConnectOptions): Promise<DedicatedServerSession | MultiTransportSession>;
+}
+interface DedicatedServerApi {
+    readonly connect: DedicatedServerConnect;
+    listClusterTargets(options?: {
+        signal?: AbortSignal;
+    }): Promise<readonly ClusterTarget[]>;
+    handleMatchEnded(matchId: string, reason?: string): void;
+}
+declare function createDedicatedServerApi(options: DedicatedServerApiOptions): DedicatedServerApi;
+interface BootMark {
+    readonly name: string;
+    readonly at: number;
+}
+interface BootTimeline {
+    mark(name: string, at?: number): boolean;
+    timeline(): string;
+    readonly marks: readonly BootMark[];
+}
+interface P2pApiOptions$1 {
+    readonly client: GemClient;
+    readonly gameId: () => string;
+}
+interface JoinCredential {
+    readonly credential: string;
+    readonly hostFingerprint: string;
+    readonly hostEpoch: number;
+    readonly expiresAt: number;
+}
+interface IceServer {
+    readonly urls: readonly string[];
+    readonly username: string;
+    readonly credential: string;
+}
+interface TurnLease {
+    readonly iceServers: readonly IceServer[];
+    readonly expiresAt: number;
+}
+type P2pTelemetryEvent = TelemetrySample;
+declare class P2pApi {
+    private readonly options;
+    private readonly reporter;
+    constructor(options: P2pApiOptions$1);
+    joinCredential(matchId: string, fingerprint: string, signal?: AbortSignal): Promise<JoinCredential>;
+    turnLease(matchId: string, clusterTargetId: string, signal?: AbortSignal): Promise<TurnLease>;
+    kick(matchId: string, playerId: string, signal?: AbortSignal): Promise<void>;
+    leave(matchId: string, keepalive?: boolean): Promise<void>;
+    telemetry(events: readonly P2pTelemetryEvent[], signal?: AbortSignal): Promise<void>;
+    private match;
+}
+type P2pFailure = "timeout" | "aborted" | "unsupported_protocol" | "signaling_unavailable" | "signaling_failed" | "invalid_sdp" | "media_refused" | "peer_unauthenticated" | "not_expected_player" | "keys_unavailable" | "migration_failed" | "kicked" | "match_ended" | "connection_failed" | "misconfigured";
+declare class P2pError extends Error {
+    readonly reason: P2pFailure;
+    readonly retryable: boolean;
+    constructor(reason: P2pFailure, message: string, options?: {
+        cause?: unknown;
+    });
+}
+interface P2pEventMap {
+    peerJoined: [
+        P2pPeer
+    ];
+    peerLeft: [
+        string,
+        string
+    ];
+    migrating: [
+        string,
+        number
+    ];
+    hostChanged: [
+        string,
+        number
+    ];
+    matchEnded: [
+        string
+    ];
+    candidatesDropped: [
+        number
+    ];
+    error: [
+        P2pError
+    ];
+}
+type P2pEventName = keyof P2pEventMap;
+declare function fingerprintOf(sdp: string): string | null;
+declare function normaliseFingerprint(raw: string): string | null;
+declare function fingerprintsMatch(a: string, b: string): boolean;
+interface VerifiedCredential {
+    readonly playerId: string;
+    readonly matchId: string;
+    readonly gameId: string;
+    readonly hostEpoch: number;
+    readonly role: "host" | "client";
+    readonly fingerprint: string;
+    readonly hostFingerprint: string;
+    readonly jti: string;
+    readonly expiresAt: number;
+}
+interface VerifyContext {
+    readonly matchId: string;
+    readonly gameId: string;
+    readonly hostEpoch: number;
+    readonly peerFingerprint: string;
+    readonly hostFingerprint: string;
+    readonly now: number;
+}
+interface KeySource {
+    key(kid: string): Promise<CryptoKey | null>;
+}
+interface JwksOptions {
+    readonly baseUrl: string;
+    readonly now: () => number;
+    readonly fetch?: (url: string, init?: RequestInit) => Promise<{
+        ok: boolean;
+        text(): Promise<string>;
+    }>;
+    readonly subtle?: SubtleCrypto;
+}
+declare function createKeySource(options: JwksOptions): KeySource;
+declare class ReplaySet {
+    private readonly seen;
+    admit(jti: string, now: number): boolean;
+}
+declare function verifyCredential(jwt: string, context: VerifyContext, keys: KeySource, replays: ReplaySet, options: {
+    issuer: string;
+    subtle?: SubtleCrypto;
+}): Promise<VerifiedCredential>;
+interface SignalTransport {
+    signal(signal: string, matchId: string, data: Record<string, unknown>): void;
+    parentSupports(capability: string): boolean;
+}
+interface SignalingOptions {
+    readonly bridge: SignalTransport;
+    readonly matchId: string;
+    readonly clock: {
+        now(): number;
+        setTimeout(fn: () => void, ms: number): unknown;
+        clearTimeout(handle: unknown): void;
+    };
+    readonly maxQueuedCandidates?: number;
+    readonly candidateIntervalMs?: number;
+    readonly onCandidatesDropped?: (dropped: number) => void;
+}
+declare class SignalingClient {
+    private readonly options;
+    private readonly queue;
+    private drainHandle;
+    private dropped;
+    private closed;
+    private dropListener;
+    constructor(options: SignalingOptions);
+    onDropped(listener: (dropped: number) => void): void;
+    join(): void;
+    offer(sdp: string, intent: "initial" | "ice_restart" | "full_reconnect"): void;
+    answer(peerId: string, sdp: string, assignedPeerId: number): void;
+    candidate(peerId: string, candidate: string, sdpMid?: string, sdpMLineIndex?: number): void;
+    migrationAck(hostEpoch: number): void;
+    reportHostUnreachable(hostEpoch: number, iceState: "disconnected" | "failed" | "closed"): void;
+    discardQueued(): void;
+    close(): void;
+    private assertUsable;
+    private schedule;
+}
+type SdpType = "offer" | "answer" | "pranswer" | "rollback";
+interface SessionDescriptionLike {
+    readonly type: SdpType;
+    readonly sdp?: string;
+}
+interface IceCandidateLike {
+    readonly candidate: string;
+    readonly sdpMid?: string | null;
+    readonly sdpMLineIndex?: number | null;
+}
+interface EventTargetLike {
+    addEventListener(type: string, listener: (event: never) => void): void;
+    removeEventListener(type: string, listener: (event: never) => void): void;
+}
+interface DataChannelLike extends EventTargetLike {
+    readonly readyState: string;
+    readonly label: string;
+    binaryType: string;
+    send(data: string | ArrayBuffer): void;
+    close(): void;
+}
+interface DataChannelInitLike {
+    readonly ordered?: boolean;
+    readonly maxRetransmits?: number;
+    readonly negotiated?: boolean;
+    readonly id?: number;
+}
+interface PeerConnectionLike extends EventTargetLike {
+    readonly localDescription: SessionDescriptionLike | null;
+    readonly remoteDescription: SessionDescriptionLike | null;
+    readonly iceConnectionState: string;
+    readonly connectionState: string;
+    createDataChannel(label: string, init?: DataChannelInitLike): DataChannelLike;
+    createOffer(): Promise<SessionDescriptionLike>;
+    createAnswer(): Promise<SessionDescriptionLike>;
+    setLocalDescription(description?: SessionDescriptionLike): Promise<void>;
+    setRemoteDescription(description: SessionDescriptionLike): Promise<void>;
+    addIceCandidate(candidate: IceCandidateLike): Promise<void>;
+    close(): void;
+}
+interface PeerConnectionConfig {
+    readonly iceServers: readonly {
+        urls: readonly string[];
+        username?: string;
+        credential?: string;
+    }[];
+    readonly certificates?: readonly unknown[];
+}
+type PeerConnectionFactory = (config: PeerConnectionConfig) => PeerConnectionLike;
+type ChannelKind = "reliable" | "ordered" | "unreliable";
+declare const CHANNELS: Readonly<Record<ChannelKind, DataChannelInitLike & {
+    id: number;
+}>>;
+declare const CHANNEL_KINDS: readonly ChannelKind[];
+declare function browserPeerConnection(config: PeerConnectionConfig): PeerConnectionLike;
+declare function generateCertificate(): Promise<unknown | null>;
+declare class CredentialPacing {
+    private readonly perMinute;
+    private readonly sent;
+    constructor(perMinute?: number);
+    delayUntilAllowed(now: number): number;
+    record(now: number): void;
+    private prune;
+}
+interface P2pPeer {
+    readonly playerId: string;
+    readonly assignedPeerId: number;
+    readonly connection: PeerConnectionLike;
+    readonly channels: Readonly<Record<ChannelKind, DataChannelLike>>;
+    send(data: string | ArrayBuffer, kind?: ChannelKind): void;
+}
+interface P2pSessionOptions {
+    readonly api: P2pApi;
+    readonly clock: Clock;
+    readonly matchId: string;
+    readonly gameId: string;
+    readonly baseUrl: string;
+    readonly signaling: SignalingClient;
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly peerConnectionFactory?: PeerConnectionFactory;
+    readonly certificate?: unknown;
+    readonly connectTimeoutMs?: number;
+    readonly keys?: KeySource;
+    readonly boot?: BootTimeline;
+    readonly log?: ((message: string) => void) | null;
+    readonly credentialPacing?: CredentialPacing;
+}
+declare class P2pSession {
+    private readonly options;
+    private readonly emitter;
+    private readonly links;
+    private readonly replays;
+    private readonly keys;
+    private localPlayerId;
+    private migration;
+    private iceServers;
+    private credential;
+    private nextPeerId;
+    private ended;
+    private closed;
+    private ready;
+    private helloSeen;
+    private reportedUnreachableEpoch;
+    private reportedStallEpoch;
+    private counted;
+    private readonly pendingOffers;
+    private readonly answeredSessions;
+    private credentialGeneration;
+    private credentialDeadline;
+    constructor(options: P2pSessionOptions);
+    get matchId(): string;
+    get playerId(): string;
+    get isHost(): boolean;
+    get hostPlayerId(): string;
+    get hostEpoch(): number;
+    get peers(): readonly P2pPeer[];
+    peer(playerId: string): P2pPeer | null;
+    on<K extends P2pEventName>(event: K, listener: (...args: P2pEventMap[K]) => void): () => void;
+    off<K extends P2pEventName>(event: K, listener: (...args: P2pEventMap[K]) => void): void;
+    once<K extends P2pEventName>(event: K, listener: (...args: P2pEventMap[K]) => void): () => void;
+    start(signal?: AbortSignal): Promise<void>;
+    kick(playerId: string): Promise<void>;
+    leave(): Promise<void>;
+    close(): void;
+    report(events: readonly TelemetrySample[]): void;
+    notifyCandidatesDropped(dropped: number): void;
+    handleSignal(event: string, data: Record<string, unknown>): void;
+    private route;
+    private onHello;
+    private drainPendingOffers;
+    private offerToHost;
+    private fetchCredential;
+    private waitForCredential;
+    private onOffer;
+    private onAnswer;
+    private hostVerified;
+    private maybeAuthenticate;
+    private applyAnswer;
+    private onIce;
+    private onPeerLeft;
+    private onMigration;
+    private watchMigration;
+    private onMatchEnded;
+    private onSignalingError;
+    private openLink;
+    private flushCandidates;
+    private onReliableOpen;
+    private onHandshakeMessage;
+    private admit;
+    private refuseLink;
+    private finishAdmission;
+    private onIceState;
+    private onConnectionState;
+    private expose;
+    private dropLink;
+    private settle;
+    private fail;
+    private report_;
+    private count;
+    private refuseMedia;
+    private mark;
+    private sleep;
+    private warn;
+    get endedReason(): string | null;
+}
+declare const WEB_PROTOCOL_VERSION = 32769;
+type MigrationState = "idle" | "preparing" | "reconnecting";
+interface MigrationEvent {
+    readonly hostPlayerId: string;
+    readonly hostEpoch: number;
+    readonly reason?: string;
+    readonly kickedPlayerIds?: readonly string[];
+    readonly migrationComplete?: boolean;
+}
+type MigrationOutcome = {
+    readonly kind: "accepted";
+    readonly state: MigrationState;
+} | {
+    readonly kind: "completed";
+} | {
+    readonly kind: "duplicate";
+} | {
+    readonly kind: "refused";
+    readonly why: string;
+};
+declare const MIGRATION_TIMEOUT_MS = 30000;
+declare class HostMigration {
+    private readonly localPlayerId;
+    private state;
+    private epoch;
+    private hostPlayerId;
+    private kicked;
+    private startedAt;
+    constructor(localPlayerId: string, hostPlayerId: string, epoch: number);
+    get currentState(): MigrationState;
+    get currentEpoch(): number;
+    get currentHostPlayerId(): string;
+    get isLocalHost(): boolean;
+    isKicked(playerId: string): boolean;
+    stalled(now: number): boolean;
+    apply(event: MigrationEvent, now: number): MigrationOutcome;
+    complete(): void;
+}
+declare const WEBRTC_P2P = "webrtc_p2p";
+interface P2pApiOptions {
+    readonly client: GemClient;
+    readonly clock: Clock;
+    readonly rooms: RoomManager;
+    readonly bridge: SignalTransport | null;
+    readonly gameId: () => string;
+    readonly baseUrl: string | (() => string);
+    readonly resolveClusterTarget?: ClusterTargetResolver;
+    readonly boot?: BootTimeline;
+    readonly log?: ((message: string) => void) | null;
+}
+interface P2pConnectOptions {
+    readonly clusterTargetId?: ClusterTargetLike;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+    readonly peerConnectionFactory?: PeerConnectionFactory;
+    readonly certificate?: unknown;
+}
+interface P2pMatchApi {
+    connect(options?: P2pConnectOptions): Promise<P2pSession>;
+    handleSignalEvent(matchId: string, event: string, data: Record<string, unknown>): void;
+    session(matchId: string): P2pSession | null;
+}
+declare function createP2pApi(options: P2pApiOptions): P2pMatchApi;
+export { type AutoReconnectOptions, type AwaitMatchOptions, CAPABILITY_GATES, CAPABILITY_NAMESPACE_GATES, CHANNELS, CHANNEL_KINDS, type ChannelKind, type ClientPlatform, ClientTelemetry, type ClientTelemetryOptions, type ClientVersion, type Clock, type ClusterTarget, type ClusterTargetBridge, type ClusterTargetLike, type ClusterTargetResolver, type ClusterTargetSource, type ClusterTargetSourceOptions, type ConnectOptions, type CreateRoomOptions, INBOUND_EVENTS as DEDICATED_INBOUND_EVENTS, DEFAULT_WELCOME_CEILING_MS, DEVICE_SETTINGS_MAX_BYTES, type DataChannelLike$1 as DataChannelLike, type DedicatedServerApi, type DedicatedServerApiOptions, DedicatedServerError, type DedicatedServerFailure, type DedicatedServerSession, type DedicatedSignalTransport, DedicatedSignalingHub, type DedicatedSignalingOptions, type EstablishOptions, FRAME_TO_PARENT, type FailedMatch, type FrameCallbacks, type FrameMessage, type FrameOptions, type FrameState, type GemAdResult, type GemAudioState, type GemCapability, type GemClusterTarget, type GemCohorts, type GemDedicatedEvent, type GemDedicatedOffer, type GemDeviceSettings, type GemDeviceSettingsPut, type GemDeviceSettingsResult, type GemDevtools, type GemError, type GemErrorCode, type GemExit, GemFrame, type GemFrameStats, type GemGameContext, type GemHandshake, type GemHandshakeAccept, GemHost, type GemLocalServer, type GemLocalServerDenied, type GemMessage, type GemOpenExternal, type GemPartyRequest, type GemPartyResult, type GemPause, type GemPlayer, type GemPrefs, type GemProgress, type GemPurchaseResult, type GemReady, type GemRequestAd, type GemRequestContext, type GemRequestFullscreen, type GemRequestLocalServer, type GemRequestPurchase, type GemRequestSignIn, type GemRequestToken, type GemRewardCue, type GemRoomEvent, type GemScreenshot, type GemScreenshotDenied, type GemSeatedEvent, type GemSignInResult, type GemSignal, type GemSignalEvent, type GemSocketState, type GemToken, type GemTokenDenied, type GemViewport, type GemWillTerminate, HANDSHAKE_TIMEOUT_MS, type HandshakeEvent, type HostCallbacks, HostMigration, type HostOptions, type HostState, type JoinCredential, type JoinExchange, type JoinRoomOptions, type JoinWelcome, type KeySource, type ListRoomsOptions, MALFORMED_INBOUND_KEY, MAX_ARRAY_LENGTH, MAX_MESSAGE_BYTES, MAX_MESSAGE_DEPTH, MAX_MESSAGE_NODES, MAX_SIGNALS_PER_SECOND, MAX_SOCKET_FRAME_BYTES, MIGRATION_TIMEOUT_MS, type MatchConnectionState, type MatchEnded, type MatchOutcome, type MatchOutcomeWaitOptions, type MatchReconnected, type MatchReconnecting, type MatchSession, type MatchSessionPhase, type MatchSuspended, type MigrationState, type OfferRefusal, type OfferRequest, P2pApi, type P2pConnectOptions, P2pError, type P2pEventMap, type P2pEventName, type P2pFailure, type P2pMatchApi, type P2pPeer, P2pSession, PARENT_TO_FRAME, PROTOCOL, type ParentMessage, type PartyBridge, type PartyEventRelay, type PartyResolver, type PartyResolverOptions, type PeerConnectionLike$1 as PeerConnectionLike, type PlayerIdentity, PlayerText, type PortLike, type PortMessageHandler, type PresentCredentialOptions, type QuickJoinOptions, RATE_LIMITS, RateLimiter, type ReadyMatch, type Rejection, type RelayedDedicatedEvent, type RelayedRoomEvent, type RelayedSignal, type ResolvedClientVersion, type Room, type RoomArgEntry, type RoomArgScalar, type RoomArgType, type RoomArgValue, type RoomArgs, RoomEmitter, type RoomEventMap, type RoomEventName, type RoomManager, type RoomManagerOptions, type RoomMember, type RoomOperationError, type RoomPage, type RoomStatus, type RoomSummary, RoomsApi, type RoomsApiOptions, SUPPORTED_VERSIONS, type SdpType$1 as SdpType, type SessionDescriptionLike$1 as SessionDescriptionLike, type SignalTransport, type SignalingAnswer, type SignalingChannel, SignalingClient, type SignalingIntent, type StartMatchOptions, type StartedMatch$1 as StartedMatch, TELEMETRY_EVENTS, TRANSPORT_LABELS, type TelemetrySample, type TokenDenial, type TokenGrant, type TransportLabel, type TurnLease, type UpdateRoomOptions, VALIDATORS, type VerifiedCredential, WEBRTC_DEDICATED, WEBRTC_P2P, WEB_ENGINE_VERSION, WEB_PROTOCOL_VERSION, type WindowLike, asPlayerText, awaitMatchOutcome, browserPeerConnection, buildDedicatedOfferFrame, buildSocketFrame, capabilityFor, createClusterTargetSource, createDedicatedServerApi, createKeySource, createP2pApi, createPartyResolver, createRoomManager, deviceSettingsByteLength, establishDataChannel, fingerprintOf, fingerprintsMatch, generateCertificate, isOrigin, listClusterTargets, memberFromWire, negotiateVersion, normaliseClusterTarget, normaliseFingerprint, originsEqual, presentJoinCredential, projectDedicatedEvent, projectPartyEvent, projectSignal, roomArgValuesFromWire, roomArgsTemplateFromWire, roomFromWire, startMatch, summaryFromWire, systemClock, text, unavailableSignaling, validateGemAdResult, validateGemAudioState, validateGemClusterTarget, validateGemCohorts, validateGemDedicatedEvent, validateGemDedicatedOffer, validateGemDeviceSettings, validateGemDeviceSettingsPut, validateGemDeviceSettingsResult, validateGemDevtools, validateGemError, validateGemExit, validateGemFrameStats, validateGemGameContext, validateGemHandshake, validateGemHandshakeAccept, validateGemLocalServer, validateGemLocalServerDenied, validateGemOpenExternal, validateGemPartyRequest, validateGemPartyResult, validateGemPause, validateGemPlayer, validateGemPrefs, validateGemProgress, validateGemPurchaseResult, validateGemReady, validateGemRequestAd, validateGemRequestContext, validateGemRequestFullscreen, validateGemRequestLocalServer, validateGemRequestPurchase, validateGemRequestSignIn, validateGemRequestToken, validateGemRewardCue, validateGemRoomEvent, validateGemScreenshot, validateGemScreenshotDenied, validateGemSeatedEvent, validateGemSignInResult, validateGemSignal, validateGemSignalEvent, validateGemSocketState, validateGemToken, validateGemTokenDenied, validateGemViewport, validateGemWillTerminate, validateSize, verifyCredential };