@lagless/relay-server 0.0.33

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './lib/types.js';
+export { ServerClock } from './lib/server-clock.js';
+export { PlayerConnection } from './lib/player-connection.js';
+export { InputHandler, type ValidatedInput, type ValidationResult } from './lib/input-handler.js';
+export { StateTransfer, type StateResponse, type StateTransferResult } from './lib/state-transfer.js';
+export { RelayRoom } from './lib/relay-room.js';
+export { RoomRegistry } from './lib/room-registry.js';
+export { LatencySimulator, type LatencySimulatorConfig } from './lib/latency-simulator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACtG,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,KAAK,sBAAsB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './lib/types.js';
+export { ServerClock } from './lib/server-clock.js';
+export { PlayerConnection } from './lib/player-connection.js';
+export { InputHandler } from './lib/input-handler.js';
+export { StateTransfer } from './lib/state-transfer.js';
+export { RelayRoom } from './lib/relay-room.js';
+export { RoomRegistry } from './lib/room-registry.js';
+export { LatencySimulator } from './lib/latency-simulator.js';

package/dist/lib/input-handler.d.ts

@@ -0,0 +1,48 @@
+import { TickInputKind, CancelReason } from '@lagless/net-wire';
+import type { ServerClock } from './server-clock.js';
+import type { PlayerConnection } from './player-connection.js';
+import type { RoomTypeConfig, PlayerSlot } from './types.js';
+export interface ValidatedInput {
+    readonly tick: number;
+    readonly playerSlot: PlayerSlot;
+    readonly seq: number;
+    readonly kind: TickInputKind;
+    readonly payload: Uint8Array;
+}
+export type ValidationResult = {
+    readonly accepted: true;
+    readonly input: ValidatedInput;
+} | {
+    readonly accepted: false;
+    readonly reason: CancelReason;
+    readonly tick: number;
+    readonly seq: number;
+};
+export declare class InputHandler {
+    private readonly _clock;
+    private readonly _config;
+    constructor(_clock: ServerClock, _config: RoomTypeConfig);
+    /**
+     * Parse and validate a TickInputBatch message from a client.
+     * Returns one ValidationResult per input in the batch.
+     */
+    validateClientInputBatch(senderSlot: PlayerSlot, raw: ArrayBuffer): ValidationResult[];
+    /**
+     * Broadcast a validated input to all connected players as TickInputFanout.
+     */
+    broadcastInput(input: ValidatedInput, connections: ReadonlyMap<PlayerSlot, PlayerConnection>): void;
+    /**
+     * Broadcast multiple inputs in a single fanout message.
+     */
+    broadcastInputBatch(inputs: ValidatedInput[], connections: ReadonlyMap<PlayerSlot, PlayerConnection>): void;
+    /**
+     * Send a batch of inputs to a single player as TickInputFanout.
+     * Used for replaying server event journal on connect.
+     */
+    sendInputBatchToPlayer(inputs: ValidatedInput[], connection: PlayerConnection): void;
+    /**
+     * Send CancelInput to a specific player.
+     */
+    sendCancel(connection: PlayerConnection, tick: number, seq: number, reason: CancelReason): void;
+}
+//# sourceMappingURL=input-handler.d.ts.map

package/dist/lib/input-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-handler.d.ts","sourceRoot":"","sources":["../../src/lib/input-handler.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EAAE,YAAY,EAG5B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAQ7D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;CAC9B;AAED,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAI7G,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,cAAc;IAG1C;;;OAGG;IACI,wBAAwB,CAC7B,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,WAAW,GACf,gBAAgB,EAAE;IA+ErB;;OAEG;IACI,cAAc,CACnB,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,WAAW,CAAC,UAAU,EAAE,gBAAgB,CAAC,GACrD,IAAI;IAcP;;OAEG;IACI,mBAAmB,CACxB,MAAM,EAAE,cAAc,EAAE,EACxB,WAAW,EAAE,WAAW,CAAC,UAAU,EAAE,gBAAgB,CAAC,GACrD,IAAI;IAaP;;;OAGG;IACI,sBAAsB,CAC3B,MAAM,EAAE,cAAc,EAAE,EACxB,UAAU,EAAE,gBAAgB,GAC3B,IAAI;IAWP;;OAEG;IACI,UAAU,CACf,UAAU,EAAE,gBAAgB,EAC5B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,YAAY,GACnB,IAAI;CASR"}

package/dist/lib/input-handler.js

@@ -0,0 +1,143 @@
+import { createLogger } from '@lagless/misc';
+import { TickInputKind, CancelReason, HeaderSchema, packTickInputFanout, packCancelInput, } from '@lagless/net-wire';
+import { LE } from '@lagless/binary';
+const log = createLogger('InputHandler');
+const TICK_INPUT_HEADER_SIZE = 12; // tick(4) + slot(1) + seq(4) + kind(1) + payloadLength(2)
+// ─── InputHandler ───────────────────────────────────────────
+export class InputHandler {
+    _clock;
+    _config;
+    constructor(_clock, _config) {
+        this._clock = _clock;
+        this._config = _config;
+    }
+    /**
+     * Parse and validate a TickInputBatch message from a client.
+     * Returns one ValidationResult per input in the batch.
+     */
+    validateClientInputBatch(senderSlot, raw) {
+        const view = new DataView(raw);
+        let offset = HeaderSchema.byteLength; // skip header
+        if (offset + 1 > raw.byteLength) {
+            log.warn(`validateClientInputBatch: message too short for batch header (${raw.byteLength} bytes)`);
+            return [];
+        }
+        const inputCount = view.getUint8(offset);
+        offset += 1;
+        const results = [];
+        for (let i = 0; i < inputCount; i++) {
+            if (offset + TICK_INPUT_HEADER_SIZE > raw.byteLength) {
+                log.warn(`validateClientInputBatch: truncated at input ${i}/${inputCount} (offset=${offset}, byteLength=${raw.byteLength})`);
+                break;
+            }
+            const tick = view.getUint32(offset, LE);
+            offset += 4;
+            const claimedSlot = view.getUint8(offset);
+            offset += 1;
+            const seq = view.getUint32(offset, LE);
+            offset += 4;
+            const kind = view.getUint8(offset);
+            offset += 1;
+            const payloadLength = view.getUint16(offset, LE);
+            offset += 2;
+            if (offset + payloadLength > raw.byteLength) {
+                log.warn(`validateClientInputBatch: truncated payload at input ${i}/${inputCount} (need=${payloadLength}, remaining=${raw.byteLength - offset})`);
+                break;
+            }
+            if (claimedSlot !== senderSlot) {
+                log.warn(`Batch slot mismatch: sender=${senderSlot}, claimed=${claimedSlot}`);
+                results.push({ accepted: false, reason: CancelReason.InvalidSlot, tick, seq });
+                offset += payloadLength;
+                continue;
+            }
+            if (kind === TickInputKind.Server) {
+                log.warn(`Client sent Server-kind input in batch, slot=${senderSlot}`);
+                results.push({ accepted: false, reason: CancelReason.InvalidSlot, tick, seq });
+                offset += payloadLength;
+                continue;
+            }
+            const serverTick = this._clock.tick;
+            if (tick < serverTick) {
+                log.warn(`REJECT TooOld: slot=${senderSlot} inputTick=${tick} serverTick=${serverTick} delta=${tick - serverTick} seq=${seq}`);
+                results.push({ accepted: false, reason: CancelReason.TooOld, tick, seq });
+                offset += payloadLength;
+                continue;
+            }
+            if (tick > serverTick + this._config.maxFutureTicks) {
+                log.warn(`REJECT TooFarFuture: slot=${senderSlot} inputTick=${tick} serverTick=${serverTick} delta=${tick - serverTick} maxFuture=${this._config.maxFutureTicks} seq=${seq}`);
+                results.push({ accepted: false, reason: CancelReason.TooFarFuture, tick, seq });
+                offset += payloadLength;
+                continue;
+            }
+            const payload = new Uint8Array(raw.slice(offset, offset + payloadLength));
+            offset += payloadLength;
+            log.debug(`ACCEPT: slot=${senderSlot} inputTick=${tick} serverTick=${serverTick} delta=${tick - serverTick} seq=${seq} payloadLen=${payloadLength}`);
+            results.push({
+                accepted: true,
+                input: {
+                    tick,
+                    playerSlot: senderSlot,
+                    seq,
+                    kind: TickInputKind.Client,
+                    payload,
+                },
+            });
+        }
+        return results;
+    }
+    /**
+     * Broadcast a validated input to all connected players as TickInputFanout.
+     */
+    broadcastInput(input, connections) {
+        const fanout = packTickInputFanout({
+            serverTick: this._clock.tick,
+            inputs: [input],
+        });
+        let sentCount = 0;
+        for (const conn of connections.values()) {
+            if (conn.isConnected)
+                sentCount++;
+            conn.send(fanout);
+        }
+        log.debug(`BROADCAST: tick=${input.tick} slot=${input.playerSlot} kind=${input.kind} → ${sentCount} connected clients`);
+    }
+    /**
+     * Broadcast multiple inputs in a single fanout message.
+     */
+    broadcastInputBatch(inputs, connections) {
+        if (inputs.length === 0)
+            return;
+        const fanout = packTickInputFanout({
+            serverTick: this._clock.tick,
+            inputs,
+        });
+        for (const conn of connections.values()) {
+            conn.send(fanout);
+        }
+    }
+    /**
+     * Send a batch of inputs to a single player as TickInputFanout.
+     * Used for replaying server event journal on connect.
+     */
+    sendInputBatchToPlayer(inputs, connection) {
+        if (inputs.length === 0)
+            return;
+        const fanout = packTickInputFanout({
+            serverTick: this._clock.tick,
+            inputs,
+        });
+        connection.send(fanout);
+    }
+    /**
+     * Send CancelInput to a specific player.
+     */
+    sendCancel(connection, tick, seq, reason) {
+        const msg = packCancelInput({
+            tick,
+            playerSlot: connection.slot,
+            seq,
+            reason,
+        });
+        connection.send(msg);
+    }
+}

package/dist/lib/latency-simulator.d.ts

@@ -0,0 +1,22 @@
+export interface LatencySimulatorConfig {
+    delayMs: number;
+    jitterMs: number;
+    packetLossPercent: number;
+}
+/**
+ * Wraps callbacks with artificial delay, jitter, and packet loss.
+ * Used for testing network adaptation under poor conditions.
+ */
+export declare class LatencySimulator {
+    private _delayMs;
+    private _jitterMs;
+    private _packetLossPercent;
+    constructor(config: LatencySimulatorConfig);
+    /** Wraps a callback with artificial delay; drops it on simulated packet loss. */
+    apply(fn: () => void): void;
+    setDelay(ms: number): void;
+    setJitter(ms: number): void;
+    setPacketLoss(percent: number): void;
+    get config(): LatencySimulatorConfig;
+}
+//# sourceMappingURL=latency-simulator.d.ts.map

package/dist/lib/latency-simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latency-simulator.d.ts","sourceRoot":"","sources":["../../src/lib/latency-simulator.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,kBAAkB,CAAS;gBAEvB,MAAM,EAAE,sBAAsB;IAM1C,iFAAiF;IACjF,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI;IAkB3B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI1B,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI3B,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIpC,IAAI,MAAM,IAAI,sBAAsB,CAMnC;CACF"}

package/dist/lib/latency-simulator.js

@@ -0,0 +1,47 @@
+/**
+ * Wraps callbacks with artificial delay, jitter, and packet loss.
+ * Used for testing network adaptation under poor conditions.
+ */
+export class LatencySimulator {
+    _delayMs;
+    _jitterMs;
+    _packetLossPercent;
+    constructor(config) {
+        this._delayMs = config.delayMs;
+        this._jitterMs = config.jitterMs;
+        this._packetLossPercent = config.packetLossPercent;
+    }
+    /** Wraps a callback with artificial delay; drops it on simulated packet loss. */
+    apply(fn) {
+        // Simulate packet loss
+        if (this._packetLossPercent > 0 && Math.random() * 100 < this._packetLossPercent) {
+            return;
+        }
+        const jitter = this._jitterMs > 0
+            ? (Math.random() * 2 - 1) * this._jitterMs
+            : 0;
+        const delay = Math.max(0, this._delayMs + jitter);
+        if (delay === 0) {
+            fn();
+        }
+        else {
+            setTimeout(fn, delay);
+        }
+    }
+    setDelay(ms) {
+        this._delayMs = Math.max(0, ms);
+    }
+    setJitter(ms) {
+        this._jitterMs = Math.max(0, ms);
+    }
+    setPacketLoss(percent) {
+        this._packetLossPercent = Math.max(0, Math.min(100, percent));
+    }
+    get config() {
+        return {
+            delayMs: this._delayMs,
+            jitterMs: this._jitterMs,
+            packetLossPercent: this._packetLossPercent,
+        };
+    }
+}

package/dist/lib/player-connection.d.ts

@@ -0,0 +1,29 @@
+import type { PlayerId, PlayerSlot, PlayerInfo, IWebSocket } from './types.js';
+import { ConnectionState } from './types.js';
+/**
+ * Represents a player's connection to a relay room.
+ * Manages connection state, WebSocket reference, and reconnect timing.
+ */
+export declare class PlayerConnection {
+    private readonly _info;
+    private _state;
+    private _disconnectedAt;
+    private _ws;
+    private _hasConnectedBefore;
+    constructor(_info: PlayerInfo, ws: IWebSocket | null);
+    get info(): PlayerInfo;
+    get playerId(): PlayerId;
+    get slot(): PlayerSlot;
+    get isBot(): boolean;
+    get state(): ConnectionState;
+    get isConnected(): boolean;
+    get isDisconnected(): boolean;
+    get isGone(): boolean;
+    send(data: Uint8Array): void;
+    get hasConnectedBefore(): boolean;
+    connect(ws: IWebSocket): void;
+    markDisconnected(): void;
+    markGone(): void;
+    isReconnectExpired(timeoutMs: number): boolean;
+}
+//# sourceMappingURL=player-connection.d.ts.map

package/dist/lib/player-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"player-connection.d.ts","sourceRoot":"","sources":["../../src/lib/player-connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C;;;GAGG;AACH,qBAAa,gBAAgB;IAOzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IANxB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,GAAG,CAAoB;IAC/B,OAAO,CAAC,mBAAmB,CAAS;gBAGjB,KAAK,EAAE,UAAU,EAClC,EAAE,EAAE,UAAU,GAAG,IAAI;IAMvB,IAAW,IAAI,IAAI,UAAU,CAAuB;IACpD,IAAW,QAAQ,IAAI,QAAQ,CAAgC;IAC/D,IAAW,IAAI,IAAI,UAAU,CAA4B;IACzD,IAAW,KAAK,IAAI,OAAO,CAA6B;IACxD,IAAW,KAAK,IAAI,eAAe,CAAwB;IAE3D,IAAW,WAAW,IAAI,OAAO,CAEhC;IAED,IAAW,cAAc,IAAI,OAAO,CAEnC;IAED,IAAW,MAAM,IAAI,OAAO,CAE3B;IAEM,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAKnC,IAAW,kBAAkB,IAAI,OAAO,CAEvC;IAEM,OAAO,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI;IAO7B,gBAAgB,IAAI,IAAI;IAMxB,QAAQ,IAAI,IAAI;IAMhB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;CAKtD"}

package/dist/lib/player-connection.js

@@ -0,0 +1,62 @@
+import { ConnectionState } from './types.js';
+/**
+ * Represents a player's connection to a relay room.
+ * Manages connection state, WebSocket reference, and reconnect timing.
+ */
+export class PlayerConnection {
+    _info;
+    _state;
+    _disconnectedAt = null;
+    _ws;
+    _hasConnectedBefore = false;
+    constructor(_info, ws) {
+        this._info = _info;
+        this._ws = ws;
+        this._state = _info.isBot ? ConnectionState.Gone : ConnectionState.Disconnected;
+    }
+    get info() { return this._info; }
+    get playerId() { return this._info.playerId; }
+    get slot() { return this._info.slot; }
+    get isBot() { return this._info.isBot; }
+    get state() { return this._state; }
+    get isConnected() {
+        return this._state === ConnectionState.Connected;
+    }
+    get isDisconnected() {
+        return this._state === ConnectionState.Disconnected;
+    }
+    get isGone() {
+        return this._state === ConnectionState.Gone;
+    }
+    send(data) {
+        if (this._state !== ConnectionState.Connected || !this._ws)
+            return;
+        this._ws.sendBinary(data);
+    }
+    get hasConnectedBefore() {
+        return this._hasConnectedBefore;
+    }
+    connect(ws) {
+        this._state = ConnectionState.Connected;
+        this._disconnectedAt = null;
+        this._ws = ws;
+        this._hasConnectedBefore = true;
+    }
+    markDisconnected() {
+        this._state = ConnectionState.Disconnected;
+        this._disconnectedAt = performance.now();
+        this._ws = null;
+    }
+    markGone() {
+        this._state = ConnectionState.Gone;
+        this._disconnectedAt = null;
+        this._ws = null;
+    }
+    isReconnectExpired(timeoutMs) {
+        if (this._state !== ConnectionState.Disconnected)
+            return false;
+        if (this._disconnectedAt === null)
+            return false;
+        return performance.now() - this._disconnectedAt > timeoutMs;
+    }
+}

package/dist/lib/relay-room.d.ts

@@ -0,0 +1,71 @@
+import { LatencySimulator } from './latency-simulator.js';
+import { type MatchId, type PlayerId, type PlayerSlot, type PlayerInfo, type RoomTypeConfig, type RoomHooks, type RoomContext, type IWebSocket, type InputRegistry } from './types.js';
+/**
+ * Manages one match room. Sealed by design — use RoomHooks for game-specific behavior.
+ */
+export declare class RelayRoom {
+    readonly matchId: MatchId;
+    readonly roomType: string;
+    private readonly _config;
+    private readonly _hooks;
+    private readonly _clock;
+    private readonly _inputHandler;
+    private readonly _stateTransfer;
+    private readonly _connections;
+    private readonly _playersByPlayerId;
+    private readonly _results;
+    private readonly _serverEventJournal;
+    private readonly _context;
+    private readonly _createdAt;
+    private readonly _seed;
+    private readonly _scopeJson;
+    private readonly _inputRegistry;
+    private _disposed;
+    private _reconnectTimer;
+    private _serverSeq;
+    private _latencySimulator;
+    private _nextSlot;
+    constructor(matchId: MatchId, roomType: string, _config: RoomTypeConfig, _hooks: RoomHooks<unknown>, inputRegistry: InputRegistry, players: ReadonlyArray<{
+        playerId: PlayerId;
+        isBot: boolean;
+        metadata: Record<string, unknown>;
+    }>, seed: Uint8Array, scopeJson?: string);
+    init(): Promise<void>;
+    get isDisposed(): boolean;
+    get tick(): number;
+    get config(): Readonly<RoomTypeConfig>;
+    get context(): RoomContext;
+    get createdAt(): number;
+    get hasOpenSlots(): boolean;
+    get latencySimulator(): LatencySimulator | null;
+    set latencySimulator(sim: LatencySimulator | null);
+    getConnectedHumanCount(): number;
+    getTotalHumanCount(): number;
+    addPlayer(playerId: PlayerId, isBot: boolean, metadata: Readonly<Record<string, unknown>>): PlayerInfo | null;
+    /** @internal */
+    getPlayerInfos(): ReadonlyArray<PlayerInfo>;
+    /** @internal */
+    isSlotConnected(slot: PlayerSlot): boolean;
+    /** @internal */
+    sendToSlot(slot: PlayerSlot, message: Uint8Array): void;
+    /** @internal */
+    broadcastToAll(message: Uint8Array): void;
+    /** @internal */
+    requestEndMatch(): void;
+    handlePlayerConnect(playerId: PlayerId, ws: IWebSocket): Promise<boolean>;
+    handlePlayerDisconnect(playerId: PlayerId): Promise<void>;
+    handleMessage(playerId: PlayerId, data: ArrayBuffer): void;
+    dispose(): Promise<void>;
+    /** @internal - called by RoomContextImpl */
+    _emitServerEvent(inputId: number, data: Record<string, number | ArrayLike<number>>, tick: number): void;
+    private handleTickInputBatch;
+    private handlePing;
+    private handlePlayerFinished;
+    private handleStateResponse;
+    private checkMatchEnd;
+    private endMatch;
+    private checkReconnectTimeouts;
+    private buildServerHello;
+    private sendStateToPlayer;
+}
+//# sourceMappingURL=relay-room.d.ts.map

package/dist/lib/relay-room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-room.d.ts","sourceRoot":"","sources":["../../src/lib/relay-room.ts"],"names":[],"mappings":"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"}