@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/strategies.d.ts

@@ -0,0 +1,210 @@
+import { Schema } from 'effect';
+
+export declare const defaultLockstepDesync: (_incident: LockstepDesyncContext, configuredAction: LockstepDesyncAction) => LockstepDesyncAction;
+
+export declare const defaultLockstepRefereeLag: (configuredTicks: number) => number;
+
+export declare const defaultLockstepStallPolicy: (offered: LockstepStallPolicyOptions) => LockstepStallPolicy;
+
+/** Actual default budget slot; every value is configuration, not a proof. */
+export declare const defaultRoomBudgets: (overrides?: Partial<RoomBudgets>) => RoomBudgets;
+
+export declare const defaultRoomReconnectPolicy: (options?: Partial<{
+    readonly graceMs: number;
+}>) => {
+    readonly graceMs: number;
+};
+
+/** Pure resource-lifetime scheduler, not a store or simulation hot-data backend.
+ * FIFO head reservation prevents a stream of small snapshots starving a large
+ * one. Durable boundaries account debt instead of losing committed intentions. */
+export declare const defaultRoomSnapshotBudget: RoomSnapshotBudgetFactory;
+
+/** Actual checkpoint cadence/encoding default, captured when the Room is defined.
+ * Commands, initial publication and terminal persistence bypass this cadence. */
+export declare const defaultRoomSnapshotPolicy: <S>(options?: Readonly<Partial<RoomSnapshotPolicy<S>>>) => RoomSnapshotPolicy<S>;
+
+/** Configuration only; no capacity assertion, history allocation or authority. */
+export declare const defaultRoomSpectatorPolicy: (input?: Readonly<Partial<RoomSpectatorPolicy>>) => RoomSpectatorPolicy;
+
+/** Per-client output remains detached even for the full-state default. */
+export declare const defaultRoomView: <S>(context: RoomViewContext<S>) => S;
+
+/** Pure exported default. SQL/borrowed membership supply eligible candidates;
+ * this function neither allocates a room nor mutates advertised capacity. */
+export declare const leastLoadedRoomHostInRegion: (hosts: ReadonlyArray<RoomHostListing>, region: string) => RoomHostListing | null;
+
+declare type LockstepDesyncAction = 'resync' | 'end' | 'flag';
+
+declare interface LockstepDesyncContext {
+    readonly tick: number;
+    readonly playerId: number;
+    readonly expected: Uint64Words;
+    readonly received: Uint64Words;
+}
+
+declare interface LockstepStallPolicy {
+    readonly afterTicks: number;
+    readonly action: 'pause' | 'drop-player';
+}
+
+declare interface LockstepStallPolicyOptions {
+    readonly afterTicks?: number;
+    readonly action?: 'pause' | 'drop-player';
+}
+
+/** Actual default prediction. Caller supplies bounded captured input and owns
+ * copy/authority; returning the last value does not confirm a server tick. */
+export declare const repeatLastLockstepInput: <I>(last: I, _context: {
+    readonly playerId: number;
+    readonly tick: number;
+}) => I;
+
+export declare interface RoomAuthoringStrategies<S = unknown> {
+    readonly budgets?: (options: Readonly<Partial<RoomBudgets>>) => RoomBudgets;
+    readonly reconnectPolicy?: (options: Readonly<Partial<{
+        readonly graceMs: number;
+    }>>) => {
+        readonly graceMs: number;
+    };
+    readonly snapshotPolicy?: (options: Readonly<Partial<RoomSnapshotPolicy<S>>>) => RoomSnapshotPolicy<S>;
+    readonly spectatorPolicy?: (options: Readonly<Partial<RoomSpectatorPolicy>>) => RoomSpectatorPolicy;
+}
+
+export declare interface RoomBudgets {
+    readonly inputsPerSecond: number;
+    readonly bytesPerSecond: number;
+    readonly burst: number;
+    readonly maxQueuedInputs: number;
+    readonly maxOutboxCommands: number;
+    readonly maxScheduledHooks: number;
+    readonly maxQueuedLifecycleHooks: number;
+    readonly maxNpcs: number;
+    /** A player input acting on state older than this many milliseconds behind the newest state
+     * the Host sent that client is dropped (it arrived too late to apply fairly). */
+    readonly inputLatencyBudgetMs: number;
+}
+
+declare interface RoomClient {
+    readonly sessionId: string;
+    readonly subjectId: string | null;
+    readonly tenantId: string;
+    /** App data the API resolved for this seat (`seatAttributes` on the Rooms API binding), signed into
+     * the seat; absent without one. Not a secret from the player: it travels in their seat token. */
+    readonly attributes?: RoomSeatAttributes | undefined;
+    /** Actor-owned classification, never accepted from a socket input. */
+    readonly isBot?: boolean | undefined;
+    readonly countsAsPlayer?: boolean | undefined;
+    send(channel: string, payload: unknown): void;
+    kick(reason: string): void;
+}
+
+declare interface RoomCodecLimits {
+    readonly maxBytes: number;
+    readonly maxCollectionLength: number;
+    readonly maxFieldId: number;
+}
+
+declare interface RoomHostListing {
+    readonly pool?: string | undefined;
+    readonly clientCapacity?: number | undefined;
+    readonly id: string;
+    readonly address: string;
+    readonly webTransportAddress?: string | undefined;
+    readonly webTransportCertificateHash?: string | undefined;
+    readonly region: string;
+    readonly capacity: number;
+    readonly rooms: number;
+    readonly clients: number;
+    readonly cpu: number;
+    readonly lastHeartbeatAt: number;
+    /** Last registered SQL routing admission, not proof of membership liveness. */
+    readonly ready: boolean;
+    /** Process identity, never a sender-clock liveness deadline. */
+    readonly membership?: {
+        readonly instanceId: string | undefined;
+        readonly startedAt: number;
+    } | undefined;
+}
+
+declare type RoomScalar = string | number | boolean | null;
+
+/** App data for one seat, resolved by the API when the seat is reserved (`seatAttributes`) and signed
+ * into it; scalars only, at most 16 keys and 2 KiB. */
+declare type RoomSeatAttributes = Readonly<Record<string, RoomScalar>>;
+
+export declare type RoomSnapshotBudgetFactory = (options: Readonly<RoomSnapshotBudgetOptions>) => RoomSnapshotBudgetService;
+
+export declare interface RoomSnapshotBudgetOptions {
+    readonly budgetBytesPerSec?: number;
+    readonly burstBytes?: number;
+}
+
+export declare interface RoomSnapshotBudgetService {
+    /** Account a durable boundary without dropping commands/initial/terminal
+     * state. Its debt defers subsequent periodic snapshots. */
+    forced(bytes: number, now: number): void;
+    periodic(roomId: string, bytes: number, now: number): boolean;
+    /** A blocked periodic head cannot be bypassed by smaller periodic payloads. */
+    blocked(roomId: string): boolean;
+    forget(roomId: string): void;
+    metrics(): {
+        readonly deferred: number;
+        readonly forcedBytes: number;
+        readonly periodicBytes: number;
+        readonly debtBytes: number;
+    };
+}
+
+export declare interface RoomSnapshotPolicy<S> {
+    readonly everyMs: number;
+    readonly onlyIfChanged: boolean;
+    readonly mode: 'full' | 'delta';
+    readonly fullEvery: number;
+    readonly keepFulls: number;
+    readonly store: 'auto';
+    /** Maximum inline codec payload; the host may impose a smaller cutoff. */
+    readonly maxInlineBytes: number;
+    /** Full-schema projection of volatile data; never a partial-state format. */
+    readonly pick: (state: S) => S;
+}
+
+export declare interface RoomSpectatorPolicy {
+    readonly delayMs: number;
+    readonly retentionMs: number;
+    readonly maxFrames: number;
+    readonly maxBytes: number;
+    readonly maxFrameBytes: number;
+    readonly checkpointEveryMs: number;
+    readonly maxDeliveryFrames: number;
+}
+
+export declare interface RoomViewContext<S> {
+    readonly state: S;
+    readonly client: Pick<RoomClient, 'sessionId' | 'subjectId' | 'tenantId' | 'isBot' | 'countsAsPlayer' | 'attributes'>;
+    readonly role: 'player' | 'spectator';
+    readonly tick: number;
+}
+
+/** Exported default hash slot, reusing the admitted schema state codec. */
+export declare const schemaSimulationHash: <S extends Schema.Codec<unknown, unknown>>(codec: SimulationStateCodec<S>, state: S["Type"]) => Uint64Words;
+
+declare interface SimulationStateCodec<S extends Schema.Codec<unknown, unknown>> {
+    readonly limits: SimulationValueLimits;
+    /** Admitted capture/hash plan, not a binary Room wire schema. */
+    schemaDescription?(): string;
+    capture(value: unknown): (S)["Type"];
+    hash(value: (S)["Type"]): Uint64Words;
+}
+
+declare interface SimulationValueLimits extends RoomCodecLimits {
+    readonly maxNodes: number;
+}
+
+/** Exact unsigned 64-bit integer as independent 32-bit words. */
+declare interface Uint64Words {
+    readonly hi: number;
+    readonly lo: number;
+}
+
+export { }

package/dist/strategies.js

@@ -0,0 +1,8 @@
+import { schemaSimulationHash as e } from "./simulationState.js";
+import { defaultLockstepDesync as t, defaultLockstepRefereeLag as n, defaultLockstepStallPolicy as r } from "./lockstepPolicies.js";
+import { defaultRoomSpectatorPolicy as i } from "./spectatorPolicy.js";
+import { defaultRoomBudgets as a, defaultRoomReconnectPolicy as o, defaultRoomSnapshotPolicy as s, defaultRoomView as c } from "./room.js";
+import { defaultRoomSnapshotBudget as l } from "./snapshotBudget.js";
+import { leastLoadedRoomHostInRegion as u } from "./hostSelection.js";
+import { repeatLastLockstepInput as d } from "./lockstepStrategies.js";
+export { t as defaultLockstepDesync, n as defaultLockstepRefereeLag, r as defaultLockstepStallPolicy, a as defaultRoomBudgets, o as defaultRoomReconnectPolicy, l as defaultRoomSnapshotBudget, s as defaultRoomSnapshotPolicy, i as defaultRoomSpectatorPolicy, c as defaultRoomView, u as leastLoadedRoomHostInRegion, d as repeatLastLockstepInput, e as schemaSimulationHash };

package/dist/strategiesServer.d.ts

@@ -0,0 +1,286 @@
+import { Schema } from 'effect';
+import { SessionSecrets } from '@voltro/protocol/session';
+
+export declare const captureRoomLockstepInitialStrategies: (offered?: Partial<RoomLockstepInitialStrategies>) => RoomLockstepInitialStrategies;
+
+export declare const defaultLockstepDesync: (_incident: LockstepDesyncContext, configuredAction: LockstepDesyncAction) => LockstepDesyncAction;
+
+export declare const defaultLockstepRefereeLag: (configuredTicks: number) => number;
+
+export declare const defaultLockstepStallPolicy: (offered: LockstepStallPolicyOptions) => LockstepStallPolicy;
+
+/** Actual default budget slot; every value is configuration, not a proof. */
+export declare const defaultRoomBudgets: (overrides?: Partial<RoomBudgets>) => RoomBudgets;
+
+export declare const defaultRoomReconnectPolicy: (options?: Partial<{
+    readonly graceMs: number;
+}>) => {
+    readonly graceMs: number;
+};
+
+/** Pure resource-lifetime scheduler, not a store or simulation hot-data backend.
+ * FIFO head reservation prevents a stream of small snapshots starving a large
+ * one. Durable boundaries account debt instead of losing committed intentions. */
+export declare const defaultRoomSnapshotBudget: RoomSnapshotBudgetFactory;
+
+/** Actual checkpoint cadence/encoding default, captured when the Room is defined.
+ * Commands, initial publication and terminal persistence bypass this cadence. */
+export declare const defaultRoomSnapshotPolicy: <S>(options?: Readonly<Partial<RoomSnapshotPolicy<S>>>) => RoomSnapshotPolicy<S>;
+
+/** Configuration only; no capacity assertion, history allocation or authority. */
+export declare const defaultRoomSpectatorPolicy: (input?: Readonly<Partial<RoomSpectatorPolicy>>) => RoomSpectatorPolicy;
+
+/** Per-client output remains detached even for the full-state default. */
+export declare const defaultRoomView: <S>(context: RoomViewContext<S>) => S;
+
+/** Public opaque ordinal selected by the actual server, never identity authority. */
+export declare const firstFreeRoomLockstepPlayerId: (offered: RoomLockstepInitialPlayerContext) => number;
+
+/** Pure exported default. SQL/borrowed membership supply eligible candidates;
+ * this function neither allocates a room nor mutates advertised capacity. */
+export declare const leastLoadedRoomHostInRegion: (hosts: ReadonlyArray<RoomHostListing>, region: string) => RoomHostListing | null;
+
+declare type LockstepDesyncAction = 'resync' | 'end' | 'flag';
+
+declare interface LockstepDesyncContext {
+    readonly tick: number;
+    readonly playerId: number;
+    readonly expected: Uint64Words;
+    readonly received: Uint64Words;
+}
+
+declare interface LockstepStallPolicy {
+    readonly afterTicks: number;
+    readonly action: 'pause' | 'drop-player';
+}
+
+declare interface LockstepStallPolicyOptions {
+    readonly afterTicks?: number;
+    readonly action?: 'pause' | 'drop-player';
+}
+
+/** Outside-tick server creation slot. Public simulation seed, recorded once in
+ * SQL before Seats; never a credential, clock-derived seed or player state. */
+export declare const randomRoomLockstepSeed: () => number;
+
+/** Actual default prediction. Caller supplies bounded captured input and owns
+ * copy/authority; returning the last value does not confirm a server tick. */
+export declare const repeatLastLockstepInput: <I>(last: I, _context: {
+    readonly playerId: number;
+    readonly tick: number;
+}) => I;
+
+export declare const resolveRoomLockstepInitialPlayerId: (offered: RoomLockstepInitialPlayerContext, strategy?: RoomLockstepInitialStrategies["playerId"]) => number;
+
+export declare const resolveRoomLockstepInitialStart: (offered: RoomLockstepInitialRosterContext, strategy?: RoomLockstepInitialStrategies["start"]) => boolean;
+
+export declare const resolveRoomLockstepSeed: (source?: typeof randomRoomLockstepSeed) => number;
+
+export declare interface RoomAuthoringStrategies<S = unknown> {
+    readonly budgets?: (options: Readonly<Partial<RoomBudgets>>) => RoomBudgets;
+    readonly reconnectPolicy?: (options: Readonly<Partial<{
+        readonly graceMs: number;
+    }>>) => {
+        readonly graceMs: number;
+    };
+    readonly snapshotPolicy?: (options: Readonly<Partial<RoomSnapshotPolicy<S>>>) => RoomSnapshotPolicy<S>;
+    readonly spectatorPolicy?: (options: Readonly<Partial<RoomSpectatorPolicy>>) => RoomSpectatorPolicy;
+}
+
+export declare interface RoomBudgets {
+    readonly inputsPerSecond: number;
+    readonly bytesPerSecond: number;
+    readonly burst: number;
+    readonly maxQueuedInputs: number;
+    readonly maxOutboxCommands: number;
+    readonly maxScheduledHooks: number;
+    readonly maxQueuedLifecycleHooks: number;
+    readonly maxNpcs: number;
+    /** A player input acting on state older than this many milliseconds behind the newest state
+     * the Host sent that client is dropped (it arrived too late to apply fairly). */
+    readonly inputLatencyBudgetMs: number;
+}
+
+declare interface RoomClient {
+    readonly sessionId: string;
+    readonly subjectId: string | null;
+    readonly tenantId: string;
+    /** App data the API resolved for this seat (`seatAttributes` on the Rooms API binding), signed into
+     * the seat; absent without one. Not a secret from the player: it travels in their seat token. */
+    readonly attributes?: RoomSeatAttributes | undefined;
+    /** Actor-owned classification, never accepted from a socket input. */
+    readonly isBot?: boolean | undefined;
+    readonly countsAsPlayer?: boolean | undefined;
+    send(channel: string, payload: unknown): void;
+    kick(reason: string): void;
+}
+
+declare interface RoomCodecLimits {
+    readonly maxBytes: number;
+    readonly maxCollectionLength: number;
+    readonly maxFieldId: number;
+}
+
+declare interface RoomHostListing {
+    readonly pool?: string | undefined;
+    readonly clientCapacity?: number | undefined;
+    readonly id: string;
+    readonly address: string;
+    readonly webTransportAddress?: string | undefined;
+    readonly webTransportCertificateHash?: string | undefined;
+    readonly region: string;
+    readonly capacity: number;
+    readonly rooms: number;
+    readonly clients: number;
+    readonly cpu: number;
+    readonly lastHeartbeatAt: number;
+    /** Last registered SQL routing admission, not proof of membership liveness. */
+    readonly ready: boolean;
+    /** Process identity, never a sender-clock liveness deadline. */
+    readonly membership?: {
+        readonly instanceId: string | undefined;
+        readonly startedAt: number;
+    } | undefined;
+}
+
+export declare interface RoomLockstepInitialPlayerContext extends RoomLockstepInitialRosterContext {
+    /** Server-private current admitted identity, never projected to the roster wire. */
+    readonly subjectId: string;
+    readonly sessionId: string;
+}
+
+export declare interface RoomLockstepInitialRosterContext extends RoomLockstepRosterScope {
+    readonly maxPlayers: number;
+    readonly players: ReadonlyArray<RoomLockstepRosterPlayer>;
+}
+
+export declare interface RoomLockstepInitialStrategies {
+    readonly playerId: (context: RoomLockstepInitialPlayerContext) => number;
+    readonly start: (context: RoomLockstepInitialRosterContext) => boolean;
+}
+
+declare interface RoomLockstepRosterPlayer {
+    readonly slot: number;
+    readonly playerId: number;
+}
+
+declare interface RoomLockstepRosterScope {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly epoch: number;
+}
+
+declare type RoomScalar = string | number | boolean | null;
+
+/** App data for one seat, resolved by the API when the seat is reserved (`seatAttributes`) and signed
+ * into it; scalars only, at most 16 keys and 2 KiB. */
+declare type RoomSeatAttributes = Readonly<Record<string, RoomScalar>>;
+
+export declare type RoomSeatClaims = Omit<(typeof SeatClaimsSchema)["Type"], 'purpose'>;
+
+export declare interface RoomSeatTokenStrategies {
+    readonly sign: typeof signRoomSeat;
+    readonly verify: typeof verifiedRoomSeatClaims;
+}
+
+export declare type RoomSnapshotBudgetFactory = (options: Readonly<RoomSnapshotBudgetOptions>) => RoomSnapshotBudgetService;
+
+export declare interface RoomSnapshotBudgetOptions {
+    readonly budgetBytesPerSec?: number;
+    readonly burstBytes?: number;
+}
+
+export declare interface RoomSnapshotBudgetService {
+    /** Account a durable boundary without dropping commands/initial/terminal
+     * state. Its debt defers subsequent periodic snapshots. */
+    forced(bytes: number, now: number): void;
+    periodic(roomId: string, bytes: number, now: number): boolean;
+    /** A blocked periodic head cannot be bypassed by smaller periodic payloads. */
+    blocked(roomId: string): boolean;
+    forget(roomId: string): void;
+    metrics(): {
+        readonly deferred: number;
+        readonly forcedBytes: number;
+        readonly periodicBytes: number;
+        readonly debtBytes: number;
+    };
+}
+
+export declare interface RoomSnapshotPolicy<S> {
+    readonly everyMs: number;
+    readonly onlyIfChanged: boolean;
+    readonly mode: 'full' | 'delta';
+    readonly fullEvery: number;
+    readonly keepFulls: number;
+    readonly store: 'auto';
+    /** Maximum inline codec payload; the host may impose a smaller cutoff. */
+    readonly maxInlineBytes: number;
+    /** Full-schema projection of volatile data; never a partial-state format. */
+    readonly pick: (state: S) => S;
+}
+
+export declare interface RoomSpectatorPolicy {
+    readonly delayMs: number;
+    readonly retentionMs: number;
+    readonly maxFrames: number;
+    readonly maxBytes: number;
+    readonly maxFrameBytes: number;
+    readonly checkpointEveryMs: number;
+    readonly maxDeliveryFrames: number;
+}
+
+export declare interface RoomViewContext<S> {
+    readonly state: S;
+    readonly client: Pick<RoomClient, 'sessionId' | 'subjectId' | 'tenantId' | 'isBot' | 'countsAsPlayer' | 'attributes'>;
+    readonly role: 'player' | 'spectator';
+    readonly tick: number;
+}
+
+/** Exported default hash slot, reusing the admitted schema state codec. */
+export declare const schemaSimulationHash: <S extends Schema.Codec<unknown, unknown>>(codec: SimulationStateCodec<S>, state: S["Type"]) => Uint64Words;
+
+declare const SeatClaimsSchema: Schema.Struct<{
+    readonly purpose: Schema.Literal<"voltro.rooms.seat.v1">;
+    readonly roomId: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+    readonly subjectId: Schema.NullOr<Schema.NonEmptyString>;
+    readonly subjectType: Schema.optionalKey<Schema.Literals<readonly ["user", "apiKey", "serviceAccount"]>>;
+    readonly subjectKind: Schema.optionalKey<Schema.Literal<"guest">>;
+    readonly tenantId: Schema.NonEmptyString;
+    readonly epoch: Schema.Int;
+    readonly nonce: Schema.NonEmptyString;
+    readonly expiresAt: Schema.Number;
+    readonly role: Schema.Literals<readonly ["player", "spectator"]>;
+    readonly attributes: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>>;
+}>;
+
+/** The caller supplies project-owned Rooms keys, never API-session keys.
+ * This is the ordinary framework HMAC primitive with a dedicated purpose and
+ * identity carrier, not an additional signature implementation. */
+export declare const signRoomSeat: (claims: RoomSeatClaims, secrets: SessionSecrets, nowMs: number) => Uint8Array;
+
+declare interface SimulationStateCodec<S extends Schema.Codec<unknown, unknown>> {
+    readonly limits: SimulationValueLimits;
+    /** Admitted capture/hash plan, not a binary Room wire schema. */
+    schemaDescription?(): string;
+    capture(value: unknown): (S)["Type"];
+    hash(value: (S)["Type"]): Uint64Words;
+}
+
+declare interface SimulationValueLimits extends RoomCodecLimits {
+    readonly maxNodes: number;
+}
+
+export declare const startFullRoomLockstepRoster: (offered: RoomLockstepInitialRosterContext) => boolean;
+
+/** Exact unsigned 64-bit integer as independent 32-bit words. */
+declare interface Uint64Words {
+    readonly hi: number;
+    readonly lo: number;
+}
+
+/** Signature, purpose and exact millisecond expiry are checked before any
+ * durable seat operation. A valid token grants no application scopes. */
+export declare const verifiedRoomSeatClaims: (token: Uint8Array, secrets: SessionSecrets, nowMs: number) => RoomSeatClaims;
+
+export { }

package/dist/strategiesServer.js

@@ -0,0 +1,11 @@
+import { schemaSimulationHash as e } from "./simulationState.js";
+import { defaultLockstepDesync as t, defaultLockstepRefereeLag as n, defaultLockstepStallPolicy as r } from "./lockstepPolicies.js";
+import { defaultRoomSpectatorPolicy as i } from "./spectatorPolicy.js";
+import { defaultRoomBudgets as a, defaultRoomReconnectPolicy as o, defaultRoomSnapshotPolicy as s, defaultRoomView as c } from "./room.js";
+import { signRoomSeat as l, verifiedRoomSeatClaims as u } from "./seats.js";
+import { defaultRoomSnapshotBudget as d } from "./snapshotBudget.js";
+import { captureRoomLockstepInitialStrategies as f, firstFreeRoomLockstepPlayerId as p, resolveRoomLockstepInitialPlayerId as m, resolveRoomLockstepInitialStart as h, startFullRoomLockstepRoster as g } from "./lockstepInitialAdmission.js";
+import { randomRoomLockstepSeed as _, resolveRoomLockstepSeed as v } from "./lockstepSeed.js";
+import { leastLoadedRoomHostInRegion as y } from "./hostSelection.js";
+import { repeatLastLockstepInput as b } from "./lockstepStrategies.js";
+export { f as captureRoomLockstepInitialStrategies, t as defaultLockstepDesync, n as defaultLockstepRefereeLag, r as defaultLockstepStallPolicy, a as defaultRoomBudgets, o as defaultRoomReconnectPolicy, d as defaultRoomSnapshotBudget, s as defaultRoomSnapshotPolicy, i as defaultRoomSpectatorPolicy, c as defaultRoomView, p as firstFreeRoomLockstepPlayerId, y as leastLoadedRoomHostInRegion, _ as randomRoomLockstepSeed, b as repeatLastLockstepInput, m as resolveRoomLockstepInitialPlayerId, h as resolveRoomLockstepInitialStart, v as resolveRoomLockstepSeed, e as schemaSimulationHash, l as signRoomSeat, g as startFullRoomLockstepRoster, u as verifiedRoomSeatClaims };