@sametnurel/game-server 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryClient = exports.MemoryTransport = exports.ErrorCodes = exports.SystemEvents = exports.silentLogger = exports.ConsoleLogger = exports.IdGenerator = exports.TurnTimer = exports.SessionManager = exports.MatchQueue = exports.Player = exports.GameManager = exports.Game = exports.RoomRegistry = exports.ConnectionManager = exports.Connection = exports.PayloadError = exports.BaseCommand = exports.GameServer = void 0;
+var server_1 = require("./server");
+Object.defineProperty(exports, "GameServer", { enumerable: true, get: function () { return server_1.GameServer; } });
+var command_1 = require("./command");
+Object.defineProperty(exports, "BaseCommand", { enumerable: true, get: function () { return command_1.BaseCommand; } });
+Object.defineProperty(exports, "PayloadError", { enumerable: true, get: function () { return command_1.PayloadError; } });
+var connection_1 = require("./connection");
+Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return connection_1.Connection; } });
+var connection_manager_1 = require("./connection-manager");
+Object.defineProperty(exports, "ConnectionManager", { enumerable: true, get: function () { return connection_manager_1.ConnectionManager; } });
+var rooms_1 = require("./rooms");
+Object.defineProperty(exports, "RoomRegistry", { enumerable: true, get: function () { return rooms_1.RoomRegistry; } });
+var game_1 = require("./game");
+Object.defineProperty(exports, "Game", { enumerable: true, get: function () { return game_1.Game; } });
+var game_manager_1 = require("./game-manager");
+Object.defineProperty(exports, "GameManager", { enumerable: true, get: function () { return game_manager_1.GameManager; } });
+var player_1 = require("./player");
+Object.defineProperty(exports, "Player", { enumerable: true, get: function () { return player_1.Player; } });
+var matchmaking_1 = require("./matchmaking");
+Object.defineProperty(exports, "MatchQueue", { enumerable: true, get: function () { return matchmaking_1.MatchQueue; } });
+var sessions_1 = require("./sessions");
+Object.defineProperty(exports, "SessionManager", { enumerable: true, get: function () { return sessions_1.SessionManager; } });
+var turn_timer_1 = require("./turn-timer");
+Object.defineProperty(exports, "TurnTimer", { enumerable: true, get: function () { return turn_timer_1.TurnTimer; } });
+var ids_1 = require("./ids");
+Object.defineProperty(exports, "IdGenerator", { enumerable: true, get: function () { return ids_1.IdGenerator; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return logger_1.ConsoleLogger; } });
+Object.defineProperty(exports, "silentLogger", { enumerable: true, get: function () { return logger_1.silentLogger; } });
+var events_1 = require("./events");
+Object.defineProperty(exports, "SystemEvents", { enumerable: true, get: function () { return events_1.SystemEvents; } });
+Object.defineProperty(exports, "ErrorCodes", { enumerable: true, get: function () { return events_1.ErrorCodes; } });
+var memory_1 = require("./transport/memory");
+Object.defineProperty(exports, "MemoryTransport", { enumerable: true, get: function () { return memory_1.MemoryTransport; } });
+Object.defineProperty(exports, "MemoryClient", { enumerable: true, get: function () { return memory_1.MemoryClient; } });

package/dist/logger.d.ts

@@ -0,0 +1,19 @@
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+export interface Logger {
+    error(message: string, ...meta: unknown[]): void;
+    warn(message: string, ...meta: unknown[]): void;
+    info(message: string, ...meta: unknown[]): void;
+    debug(message: string, ...meta: unknown[]): void;
+}
+/** Console logger with a minimum level. Defaults to LOG_LEVEL or 'info'. */
+export declare class ConsoleLogger implements Logger {
+    private readonly level;
+    constructor(level?: LogLevel);
+    error(message: string, ...meta: unknown[]): void;
+    warn(message: string, ...meta: unknown[]): void;
+    info(message: string, ...meta: unknown[]): void;
+    debug(message: string, ...meta: unknown[]): void;
+    private write;
+}
+/** Logger that discards everything. Useful in tests. */
+export declare const silentLogger: Logger;

package/dist/logger.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.silentLogger = exports.ConsoleLogger = void 0;
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+function isLogLevel(value) {
+    return value !== undefined && value in LEVELS;
+}
+/** Console logger with a minimum level. Defaults to LOG_LEVEL or 'info'. */
+class ConsoleLogger {
+    level;
+    constructor(level) {
+        const fromEnv = process.env.LOG_LEVEL;
+        this.level = level ?? (isLogLevel(fromEnv) ? fromEnv : 'info');
+    }
+    error(message, ...meta) {
+        this.write('error', message, meta);
+    }
+    warn(message, ...meta) {
+        this.write('warn', message, meta);
+    }
+    info(message, ...meta) {
+        this.write('info', message, meta);
+    }
+    debug(message, ...meta) {
+        this.write('debug', message, meta);
+    }
+    write(level, message, meta) {
+        if (LEVELS[level] > LEVELS[this.level])
+            return;
+        const line = `${new Date().toISOString()} [${level.toUpperCase()}] ${message}`;
+        const out = level === 'error' ? console.error : level === 'warn' ? console.warn : console.log;
+        out(line, ...meta);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+/** Logger that discards everything. Useful in tests. */
+exports.silentLogger = {
+    error: () => { },
+    warn: () => { },
+    info: () => { },
+    debug: () => { },
+};

package/dist/matchmaking.d.ts

@@ -0,0 +1,22 @@
+export interface QueueEntry<T> {
+    item: T;
+    enqueuedAt: number;
+}
+/**
+ * First-come matchmaking per mode. When `groupSize` players wait in the same
+ * mode, enqueue() returns them as a group and removes them from the queue.
+ */
+export declare class MatchQueue<T, TKey = number> {
+    private readonly keyOf;
+    private readonly groupSize;
+    private readonly queues;
+    constructor(keyOf: (item: T) => TKey, groupSize?: number);
+    enqueue(mode: string, item: T, now?: number): T[] | null;
+    /** Removes the item from every mode. Returns true if it was queued. */
+    remove(key: TKey): boolean;
+    has(key: TKey): boolean;
+    /** Removes and returns entries that waited at least `ms`, e.g. to pair them with a bot. */
+    takeWaitingLongerThan(mode: string, ms: number, now?: number): T[];
+    length(mode: string): number;
+    private queueFor;
+}

package/dist/matchmaking.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchQueue = void 0;
+/**
+ * First-come matchmaking per mode. When `groupSize` players wait in the same
+ * mode, enqueue() returns them as a group and removes them from the queue.
+ */
+class MatchQueue {
+    keyOf;
+    groupSize;
+    queues = new Map();
+    constructor(keyOf, groupSize = 2) {
+        this.keyOf = keyOf;
+        this.groupSize = groupSize;
+        if (groupSize < 2)
+            throw new RangeError('MatchQueue: groupSize must be >= 2');
+    }
+    enqueue(mode, item, now = Date.now()) {
+        this.remove(this.keyOf(item));
+        const queue = this.queueFor(mode);
+        queue.push({ item, enqueuedAt: now });
+        if (queue.length < this.groupSize)
+            return null;
+        return queue.splice(0, this.groupSize).map((entry) => entry.item);
+    }
+    /** Removes the item from every mode. Returns true if it was queued. */
+    remove(key) {
+        for (const queue of this.queues.values()) {
+            const index = queue.findIndex((entry) => this.keyOf(entry.item) === key);
+            if (index !== -1) {
+                queue.splice(index, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    has(key) {
+        for (const queue of this.queues.values()) {
+            if (queue.some((entry) => this.keyOf(entry.item) === key))
+                return true;
+        }
+        return false;
+    }
+    /** Removes and returns entries that waited at least `ms`, e.g. to pair them with a bot. */
+    takeWaitingLongerThan(mode, ms, now = Date.now()) {
+        const queue = this.queueFor(mode);
+        const stale = queue.filter((entry) => now - entry.enqueuedAt >= ms);
+        this.queues.set(mode, queue.filter((entry) => now - entry.enqueuedAt < ms));
+        return stale.map((entry) => entry.item);
+    }
+    length(mode) {
+        return this.queues.get(mode)?.length ?? 0;
+    }
+    queueFor(mode) {
+        let queue = this.queues.get(mode);
+        if (!queue) {
+            queue = [];
+            this.queues.set(mode, queue);
+        }
+        return queue;
+    }
+}
+exports.MatchQueue = MatchQueue;

package/dist/player.d.ts

@@ -0,0 +1,16 @@
+/** Minimal player record. Extend it for game-specific state. */
+export declare class Player {
+    readonly id: number;
+    readonly name: string;
+    /** Stable client identifier, used to find the player again after a reconnect. */
+    readonly identifier?: string | undefined;
+    /** Bots have no network client; the app drives them in-process. */
+    readonly isBot: boolean;
+    gameId: number | undefined;
+    connected: boolean;
+    constructor(id: number, name: string, 
+    /** Stable client identifier, used to find the player again after a reconnect. */
+    identifier?: string | undefined, 
+    /** Bots have no network client; the app drives them in-process. */
+    isBot?: boolean);
+}

package/dist/player.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = void 0;
+/** Minimal player record. Extend it for game-specific state. */
+class Player {
+    id;
+    name;
+    identifier;
+    isBot;
+    gameId;
+    connected = true;
+    constructor(id, name, 
+    /** Stable client identifier, used to find the player again after a reconnect. */
+    identifier, 
+    /** Bots have no network client; the app drives them in-process. */
+    isBot = false) {
+        this.id = id;
+        this.name = name;
+        this.identifier = identifier;
+        this.isBot = isBot;
+    }
+}
+exports.Player = Player;

package/dist/rooms.d.ts

@@ -0,0 +1,11 @@
+import type { Connection } from './connection';
+/** Named groups of connections, independent of the transport. */
+export declare class RoomRegistry {
+    private readonly rooms;
+    join(room: string, conn: Connection<any>): void;
+    leave(room: string, conn: Connection<any>): void;
+    leaveAll(conn: Connection<any>): void;
+    members(room: string): Connection<any>[];
+    broadcast(room: string, event: string, data?: unknown, except?: Connection<any>): void;
+    delete(room: string): void;
+}

package/dist/rooms.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomRegistry = void 0;
+/** Named groups of connections, independent of the transport. */
+class RoomRegistry {
+    rooms = new Map();
+    join(room, conn) {
+        let members = this.rooms.get(room);
+        if (!members) {
+            members = new Set();
+            this.rooms.set(room, members);
+        }
+        members.add(conn);
+        conn.rooms.add(room);
+    }
+    leave(room, conn) {
+        const members = this.rooms.get(room);
+        members?.delete(conn);
+        if (members?.size === 0)
+            this.rooms.delete(room);
+        conn.rooms.delete(room);
+    }
+    leaveAll(conn) {
+        for (const room of [...conn.rooms])
+            this.leave(room, conn);
+    }
+    members(room) {
+        return [...(this.rooms.get(room) ?? [])];
+    }
+    broadcast(room, event, data, except) {
+        for (const conn of this.rooms.get(room) ?? []) {
+            if (conn !== except)
+                conn.send(event, data);
+        }
+    }
+    delete(room) {
+        for (const conn of this.rooms.get(room) ?? [])
+            conn.rooms.delete(room);
+        this.rooms.delete(room);
+    }
+}
+exports.RoomRegistry = RoomRegistry;

package/dist/server.d.ts

@@ -0,0 +1,88 @@
+import { type Server as HttpServer } from 'node:http';
+import type { Command, CommandContext } from './command';
+import type { Connection } from './connection';
+import { ConnectionManager } from './connection-manager';
+import { type ErrorPayload } from './events';
+import type { Game } from './game';
+import { GameManager } from './game-manager';
+import { IdGenerator } from './ids';
+import { type Logger } from './logger';
+import { RoomRegistry } from './rooms';
+import { type MemoryClient } from './transport/memory';
+import type { CorsOptions, Transport } from './transport/types';
+export interface GameServerOptions {
+    /** Network transports, e.g. [new SocketIOTransport(), new WebSocketTransport()]. */
+    transports?: Transport[];
+    /**
+     * Existing HTTP server (e.g. from an Express app) to attach to. When given,
+     * the app is responsible for calling listen() unless `port` is also set.
+     */
+    httpServer?: HttpServer;
+    /** Port to listen on. 0 picks a free port. Default 5200 when no httpServer is given. */
+    port?: number;
+    host?: string;
+    /** Allowed browser origins for network transports. Default: none restricted ('*'). */
+    cors?: CorsOptions;
+    logger?: Logger;
+    /** Interval for Game.update() calls in ms. 0 disables ticking. Default 1000. */
+    tickIntervalMs?: number;
+    /** Id range for games. */
+    gameIds?: IdGenerator;
+}
+type ConnectionHook<TData> = (connection: Connection<TData>) => void;
+type DisconnectHook<TData> = (connection: Connection<TData>, reason: string) => void;
+/**
+ * Wires transports, connections, commands, rooms and games together.
+ * Create one per process (or several in tests); nothing is global.
+ */
+export declare class GameServer<TGame extends Game<any> = Game<any>, TData = unknown> {
+    readonly connections: ConnectionManager<TData>;
+    readonly rooms: RoomRegistry;
+    readonly games: GameManager<TGame>;
+    readonly logger: Logger;
+    private readonly commands;
+    private readonly pending;
+    private readonly connectHooks;
+    private readonly disconnectHooks;
+    private readonly transports;
+    private readonly memory;
+    private readonly options;
+    private httpServer;
+    private ownsHttpServer;
+    private tickTimer;
+    private tickCount;
+    private started;
+    constructor(options?: GameServerOptions);
+    /** Registers a handler for a client event. Accepts a Command or a plain function. */
+    command<TPayload>(event: string, command: Command<TPayload, TData> | ((context: CommandContext<TData>, payload: TPayload) => void | Promise<void>)): this;
+    onConnect(hook: ConnectionHook<TData>): this;
+    /** Called after a client is gone. The connection has already left its rooms. */
+    onDisconnect(hook: DisconnectHook<TData>): this;
+    start(): Promise<{
+        port: number | null;
+    }>;
+    stop(): Promise<void>;
+    /** Runs one tick now. Called automatically every `tickIntervalMs`. */
+    tick(now?: number): void;
+    /**
+     * An in-process client that talks to this server like a network client.
+     * Use it for bots and tests. Requires start().
+     */
+    createVirtualClient(): MemoryClient;
+    broadcast(room: string, event: string, data?: unknown, except?: Connection<TData>): void;
+    /** Sends a SystemEvents.Error to one connection. */
+    sendError(connection: Connection<TData>, error: ErrorPayload): void;
+    get http(): HttpServer | null;
+    private createHandlers;
+    private handleConnect;
+    /**
+     * Messages from one client are handled strictly in order: if a command is
+     * async, the next message from the same socket waits for it.
+     */
+    private enqueueMessage;
+    /** Runs one message. Returns a promise only when the command is async. Never throws. */
+    private dispatch;
+    private handleDisconnect;
+    private runHooks;
+}
+export {};

package/dist/server.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameServer = void 0;
+const node_http_1 = require("node:http");
+const command_1 = require("./command");
+const connection_manager_1 = require("./connection-manager");
+const events_1 = require("./events");
+const game_manager_1 = require("./game-manager");
+const logger_1 = require("./logger");
+const rooms_1 = require("./rooms");
+const memory_1 = require("./transport/memory");
+/**
+ * Wires transports, connections, commands, rooms and games together.
+ * Create one per process (or several in tests); nothing is global.
+ */
+class GameServer {
+    connections = new connection_manager_1.ConnectionManager();
+    rooms = new rooms_1.RoomRegistry();
+    games;
+    logger;
+    commands = new Map();
+    pending = new WeakMap();
+    connectHooks = [];
+    disconnectHooks = [];
+    transports;
+    memory = new memory_1.MemoryTransport();
+    options;
+    httpServer;
+    ownsHttpServer = false;
+    tickTimer = null;
+    tickCount = 0;
+    started = false;
+    constructor(options = {}) {
+        this.options = options;
+        this.logger = options.logger ?? new logger_1.ConsoleLogger();
+        this.games = new game_manager_1.GameManager(options.gameIds);
+        this.transports = [...(options.transports ?? []), this.memory];
+        this.httpServer = options.httpServer ?? null;
+    }
+    /** Registers a handler for a client event. Accepts a Command or a plain function. */
+    command(event, command) {
+        if (event === events_1.SystemEvents.Error)
+            throw new Error(`'${event}' is reserved`);
+        if (this.commands.has(event))
+            throw new Error(`A command for '${event}' is already registered`);
+        this.commands.set(event, typeof command === 'function' ? { handle: command } : command);
+        return this;
+    }
+    onConnect(hook) {
+        this.connectHooks.push(hook);
+        return this;
+    }
+    /** Called after a client is gone. The connection has already left its rooms. */
+    onDisconnect(hook) {
+        this.disconnectHooks.push(hook);
+        return this;
+    }
+    async start() {
+        if (this.started)
+            throw new Error('GameServer already started');
+        this.started = true;
+        const needsHttp = this.transports.some((t) => t.needsHttp);
+        if (needsHttp && !this.httpServer) {
+            this.httpServer = (0, node_http_1.createServer)((_req, res) => {
+                res.writeHead(404).end();
+            });
+            this.ownsHttpServer = true;
+        }
+        const handlers = this.createHandlers();
+        for (const transport of this.transports) {
+            transport.attach({
+                httpServer: transport.needsHttp ? this.httpServer : null,
+                handlers,
+                cors: this.options.cors,
+            });
+        }
+        let port = null;
+        const listenPort = this.options.port ?? (this.ownsHttpServer ? 5200 : undefined);
+        if (this.httpServer && listenPort !== undefined && !this.httpServer.listening) {
+            await new Promise((resolve, reject) => {
+                this.httpServer.once('error', reject);
+                this.httpServer.listen(listenPort, this.options.host, () => {
+                    this.httpServer.off('error', reject);
+                    resolve();
+                });
+            });
+        }
+        if (this.httpServer?.listening)
+            port = this.httpServer.address().port;
+        const tickMs = this.options.tickIntervalMs ?? 1000;
+        if (tickMs > 0) {
+            this.tickTimer = setInterval(() => this.tick(), tickMs);
+            this.tickTimer.unref();
+        }
+        this.logger.info(`GameServer started (${this.transports.map((t) => t.name).join(', ')})${port !== null ? ` on port ${port}` : ''}`);
+        return { port };
+    }
+    async stop() {
+        if (this.tickTimer)
+            clearInterval(this.tickTimer);
+        this.tickTimer = null;
+        for (const transport of this.transports)
+            await transport.close();
+        if (this.ownsHttpServer && this.httpServer?.listening) {
+            await new Promise((resolve) => this.httpServer.close(() => resolve()));
+        }
+        for (const game of [...this.games.all()])
+            this.games.remove(game.id);
+        this.started = false;
+    }
+    /** Runs one tick now. Called automatically every `tickIntervalMs`. */
+    tick(now = Date.now()) {
+        this.tickCount += 1;
+        this.games.tick(this.tickCount, now, (game, error) => this.logger.error(`Game ${game.id} update failed`, error));
+    }
+    /**
+     * An in-process client that talks to this server like a network client.
+     * Use it for bots and tests. Requires start().
+     */
+    createVirtualClient() {
+        return this.memory.connect();
+    }
+    broadcast(room, event, data, except) {
+        this.rooms.broadcast(room, event, data, except);
+    }
+    /** Sends a SystemEvents.Error to one connection. */
+    sendError(connection, error) {
+        connection.send(events_1.SystemEvents.Error, error);
+    }
+    get http() {
+        return this.httpServer;
+    }
+    createHandlers() {
+        return {
+            onConnect: (socket) => this.handleConnect(socket),
+            onMessage: (socket, event, data) => this.enqueueMessage(socket, event, data),
+            onDisconnect: (socket, reason) => this.handleDisconnect(socket, reason),
+        };
+    }
+    handleConnect(socket) {
+        const connection = this.connections.add(socket);
+        this.logger.debug(`connect ${socket.transport}:${socket.id}`);
+        this.runHooks(this.connectHooks, connection);
+    }
+    /**
+     * Messages from one client are handled strictly in order: if a command is
+     * async, the next message from the same socket waits for it.
+     */
+    enqueueMessage(socket, event, raw) {
+        const busy = this.pending.get(socket);
+        const result = busy
+            ? busy.then(() => this.dispatch(socket, event, raw))
+            : this.dispatch(socket, event, raw);
+        if (!result)
+            return;
+        this.pending.set(socket, result);
+        void result.finally(() => {
+            if (this.pending.get(socket) === result)
+                this.pending.delete(socket);
+        });
+    }
+    /** Runs one message. Returns a promise only when the command is async. Never throws. */
+    dispatch(socket, event, raw) {
+        const connection = this.connections.get(socket.id);
+        if (!connection)
+            return;
+        this.logger.debug(`message ${socket.id} ${event}`);
+        const command = this.commands.get(event);
+        if (!command) {
+            this.sendError(connection, { code: events_1.ErrorCodes.UnknownEvent, event });
+            return;
+        }
+        let payload = raw;
+        if (command.parse) {
+            try {
+                payload = command.parse(raw);
+            }
+            catch (error) {
+                const message = error instanceof command_1.PayloadError ? error.message : undefined;
+                this.sendError(connection, { code: events_1.ErrorCodes.InvalidPayload, event, message });
+                return;
+            }
+        }
+        const fail = (error) => {
+            this.logger.error(`Command '${event}' failed`, error);
+            this.sendError(connection, { code: events_1.ErrorCodes.InternalError, event });
+        };
+        try {
+            const result = command.handle({ server: this, connection, event }, payload);
+            if (result instanceof Promise)
+                return result.catch(fail);
+        }
+        catch (error) {
+            fail(error);
+        }
+    }
+    handleDisconnect(socket, reason) {
+        const connection = this.connections.get(socket.id);
+        if (!connection || connection.socket !== socket)
+            return; // already re-bound to a newer socket
+        this.rooms.leaveAll(connection);
+        this.connections.remove(connection);
+        this.logger.debug(`disconnect ${socket.id} (${reason})`);
+        for (const hook of this.disconnectHooks) {
+            try {
+                hook(connection, reason);
+            }
+            catch (error) {
+                this.logger.error('onDisconnect hook failed', error);
+            }
+        }
+    }
+    runHooks(hooks, connection) {
+        for (const hook of hooks) {
+            try {
+                hook(connection);
+            }
+            catch (error) {
+                this.logger.error('onConnect hook failed', error);
+            }
+        }
+    }
+}
+exports.GameServer = GameServer;

package/dist/sessions.d.ts

@@ -0,0 +1,39 @@
+import type { Connection } from './connection';
+export interface Session<TState = unknown> {
+    readonly identifier: string;
+    connection: Connection<any> | undefined;
+    /** App state that must survive a reconnect, e.g. { playerId, gameId }. */
+    state: TState | undefined;
+    disconnectedAt: number | undefined;
+}
+export interface SessionManagerOptions<TState> {
+    /** How long a dropped client may take to come back. Default 30000 ms. */
+    reconnectWindowMs?: number;
+    /** Called when a disconnected session was not resumed in time. */
+    onExpire?: (session: Session<TState>) => void;
+}
+/**
+ * Keeps a client's identity across reconnects. A session is keyed by a stable
+ * identifier (device or account id). When its connection drops, the session is
+ * kept for `reconnectWindowMs`; attaching the same identifier again resumes it.
+ */
+export declare class SessionManager<TState = unknown> {
+    private readonly sessions;
+    private readonly timers;
+    private readonly windowMs;
+    private readonly onExpire;
+    constructor(options?: SessionManagerOptions<TState>);
+    /** Binds a connection to an identifier. `resumed` is true if it came back in time. */
+    attach(identifier: string, connection: Connection<any>): {
+        session: Session<TState>;
+        resumed: boolean;
+    };
+    /** Marks the session of this connection as disconnected and starts the reconnect window. */
+    detach(connection: Connection<any>, now?: number): Session<TState> | undefined;
+    get(identifier: string): Session<TState> | undefined;
+    /** Ends a session for good (e.g. after the game is over). */
+    end(identifier: string): void;
+    clear(): void;
+    get size(): number;
+    private clearTimer;
+}