@vgai/p2p-colyseus 0.1.0

package/src/platform.ts

@@ -0,0 +1,866 @@
+import { ClientArray, type CompatClient, Room, room, validate } from './room';
+
+export type Type<T = unknown> = new (...args: unknown[]) => T;
+
+class MiniEventEmitter {
+  private readonly handlers = new Map<string, Set<(...args: unknown[]) => void>>();
+
+  on(event: string, handler: (...args: unknown[]) => void): this {
+    let eventHandlers = this.handlers.get(event);
+    if (!eventHandlers) {
+      eventHandlers = new Set();
+      this.handlers.set(event, eventHandlers);
+    }
+    eventHandlers.add(handler);
+    return this;
+  }
+
+  once(event: string, handler: (...args: unknown[]) => void): this {
+    const wrapped = (...args: unknown[]) => {
+      this.off(event, wrapped);
+      handler(...args);
+    };
+    return this.on(event, wrapped);
+  }
+
+  off(event: string, handler: (...args: unknown[]) => void): this {
+    this.handlers.get(event)?.delete(handler);
+    return this;
+  }
+
+  emit(event: string, ...args: unknown[]): boolean {
+    const eventHandlers = this.handlers.get(event);
+    if (!eventHandlers || eventHandlers.size === 0) return false;
+    for (const handler of [...eventHandlers]) handler(...args);
+    return true;
+  }
+}
+
+export const ClientState = {
+  JOINING: 0,
+  JOINED: 1,
+  RECONNECTING: 2,
+  RECONNECTED: 3,
+  LEAVING: 4,
+  CLOSED: 5,
+} as const;
+
+export const Protocol = {
+  JOIN_ROOM: 10,
+  ERROR: 11,
+  LEAVE_ROOM: 12,
+  ROOM_DATA: 13,
+  ROOM_STATE: 14,
+  ROOM_STATE_PATCH: 15,
+  ROOM_DATA_BYTES: 16,
+  PING: 17,
+  PONG: 18,
+} as const;
+
+export const ErrorCode = {
+  MATCHMAKE_NO_HANDLER: 4210,
+  MATCHMAKE_INVALID_CRITERIA: 4211,
+  MATCHMAKE_INVALID_ROOM_ID: 4212,
+  MATCHMAKE_UNHANDLED: 4213,
+  MATCHMAKE_EXPIRED: 4214,
+  AUTH_FAILED: 4215,
+  APPLICATION_ERROR: 4216,
+} as const;
+
+export const CloseCode = {
+  CONSENTED: 4000,
+  DEVMODE_RESTART: 4010,
+} as const;
+
+export const RoomInternalState = {
+  CREATING: 0,
+  CREATED: 1,
+  DISPOSING: 2,
+} as const;
+
+export class ServerError extends Error {
+  constructor(
+    readonly code: number,
+    message?: string,
+  ) {
+    super(message ?? String(code));
+    this.name = 'ServerError';
+  }
+}
+
+export class OnCreateException extends Error {}
+export class OnAuthException extends Error {}
+export class OnJoinException extends Error {}
+export class OnLeaveException extends Error {}
+export class OnDisposeException extends Error {}
+export class OnMessageException extends Error {}
+export class SimulationIntervalException extends Error {}
+export class TimedEventException extends Error {}
+
+export class Deferred<T = unknown> implements Promise<T> {
+  readonly [Symbol.toStringTag] = 'Promise';
+  private resolvePromise!: (value: T | PromiseLike<T>) => void;
+  private rejectPromise!: (reason?: unknown) => void;
+  private readonly promise = new Promise<T>((resolve, reject) => {
+    this.resolvePromise = resolve;
+    this.rejectPromise = reject;
+  });
+
+  resolve(value: T | PromiseLike<T>): void {
+    this.resolvePromise(value);
+  }
+
+  reject(reason?: unknown): void {
+    this.rejectPromise(reason);
+  }
+
+  // biome-ignore lint/suspicious/noThenProperty: Colyseus exposes Deferred as a Promise-compatible thenable.
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+  ): Promise<TResult1 | TResult2> {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+
+  catch<TResult = never>(
+    onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null,
+  ): Promise<T | TResult> {
+    return this.promise.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null): Promise<T> {
+    return this.promise.finally(onfinally);
+  }
+}
+
+export abstract class Transport {
+  protocol?: string;
+  server?: unknown;
+
+  listen(
+    _port?: number | string,
+    _hostname?: string,
+    _backlog?: number,
+    _listeningListener?: () => void,
+  ): this {
+    return this;
+  }
+
+  shutdown(): void {}
+
+  simulateLatency(_milliseconds?: number): void {}
+}
+
+export class LocalPresence {
+  private readonly values = new Map<string, string>();
+  private readonly subscriptions = new Map<string, Set<(message: unknown) => void>>();
+
+  async subscribe(topic: string, callback: (message: unknown) => void): Promise<void> {
+    let handlers = this.subscriptions.get(topic);
+    if (!handlers) {
+      handlers = new Set();
+      this.subscriptions.set(topic, handlers);
+    }
+    handlers.add(callback);
+  }
+
+  async unsubscribe(topic: string, callback?: (message: unknown) => void): Promise<void> {
+    if (callback) this.subscriptions.get(topic)?.delete(callback);
+    else this.subscriptions.delete(topic);
+  }
+
+  publish(topic: string, message: unknown): void {
+    for (const callback of this.subscriptions.get(topic) ?? []) callback(message);
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    this.values.set(key, value);
+  }
+
+  async get(key: string): Promise<string | undefined> {
+    return this.values.get(key);
+  }
+
+  async del(key: string): Promise<void> {
+    this.values.delete(key);
+  }
+
+  async exists(key: string): Promise<boolean> {
+    return this.values.has(key);
+  }
+
+  async setex(key: string, value: string, _seconds: number): Promise<void> {
+    await this.set(key, value);
+  }
+
+  async expire(_key: string, _seconds: number): Promise<boolean> {
+    return true;
+  }
+}
+
+export class Clock {
+  setTimeout(callback: () => void, ms: number): ReturnType<typeof setTimeout> {
+    return setTimeout(callback, ms);
+  }
+
+  setInterval(callback: () => void, ms: number): ReturnType<typeof setInterval> {
+    return setInterval(callback, ms);
+  }
+
+  clear(): void {}
+}
+
+export class Delayed {
+  constructor(
+    readonly callback: () => void = () => {},
+    readonly time = 0,
+  ) {}
+
+  clear(): void {}
+}
+
+export class RedisPresence extends LocalPresence {
+  shutdown(): void {}
+
+  setMaxListeners(): void {}
+}
+
+export class RedisDriver {
+  rooms: RoomCache[] = [];
+
+  async findOne(conditions: Partial<RoomCache>): Promise<RoomCache | undefined> {
+    return this.rooms.find((room) =>
+      Object.entries(conditions).every(
+        ([key, value]) =>
+          value === undefined || (room as unknown as Record<string, unknown>)[key] === value,
+      ),
+    );
+  }
+
+  query(conditions: Partial<RoomCache> = {}): RoomCache[] {
+    return this.rooms.filter((room) =>
+      Object.entries(conditions).every(
+        ([key, value]) =>
+          value === undefined || (room as unknown as Record<string, unknown>)[key] === value,
+      ),
+    );
+  }
+
+  persist(room: RoomCache): boolean {
+    const index = this.rooms.findIndex((candidate) => candidate.roomId === room.roomId);
+    if (index >= 0) this.rooms[index] = room;
+    else this.rooms.push(room);
+    return true;
+  }
+
+  remove(roomId: string): boolean {
+    const before = this.rooms.length;
+    this.rooms = this.rooms.filter((room) => room.roomId !== roomId);
+    return this.rooms.length !== before;
+  }
+
+  clear(): void {
+    this.rooms = [];
+  }
+
+  shutdown(): void {
+    this.clear();
+  }
+}
+
+export class LocalDriver extends RedisDriver {}
+
+export class SchemaSerializer<T = unknown> {
+  state?: T;
+
+  reset(newState: T): void {
+    this.state = newState;
+  }
+}
+
+export interface RoomCache<Metadata = unknown> {
+  name: string;
+  roomId: string;
+  processId: string;
+  clients: number;
+  maxClients: number;
+  locked: boolean;
+  private: boolean;
+  metadata?: Metadata;
+}
+
+export interface SeatReservation {
+  name: string;
+  sessionId: string;
+  roomId: string;
+  publicAddress?: string;
+  processId?: string;
+  reconnectionToken?: string;
+  devMode?: boolean;
+}
+
+export class RegisteredHandler<RoomType extends Room = Room> extends MiniEventEmitter {
+  '~room'!: RoomType;
+  name = '';
+  filterOptions: string[] = [];
+  sortOptions?: Record<string, 1 | -1>;
+  realtimeListingEnabled = false;
+
+  constructor(
+    readonly klass: Type<RoomType>,
+    readonly options?: unknown,
+  ) {
+    super();
+  }
+
+  enableRealtimeListing(): this {
+    this.realtimeListingEnabled = true;
+    return this;
+  }
+
+  filterBy(options: string[]): this {
+    this.filterOptions = options;
+    return this;
+  }
+
+  sortBy(options: Record<string, 1 | -1>): this {
+    this.sortOptions = options;
+    return this;
+  }
+
+  getMetadataFromOptions(options: unknown): { metadata?: Record<string, unknown> } {
+    const record = asRecord(options);
+    if (!record) return {};
+    const metadata: Record<string, unknown> = {};
+    for (const key of this.filterOptions) {
+      if (key in record) metadata[key] = record[key];
+    }
+    return Object.keys(metadata).length > 0 ? { metadata } : {};
+  }
+
+  getFilterOptions(options: unknown): Record<string, unknown> {
+    const record = asRecord(options);
+    if (!record) return {};
+    const out: Record<string, unknown> = {};
+    for (const key of this.filterOptions) {
+      if (key in record) out[key] = record[key];
+    }
+    return out;
+  }
+}
+
+const handlers = new Map<string, RegisteredHandler>();
+const rooms = new Map<string, RoomCache>();
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value !== null
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+export const processId = 'p2p-colyseus-local';
+export let publicAddress = 'localhost';
+export const presence = new LocalPresence();
+export const driver = {
+  rooms: [...rooms.values()],
+  clear: () => rooms.clear(),
+};
+
+export async function setup(
+  _presence?: LocalPresence,
+  _driver?: unknown,
+  address?: string,
+): Promise<void> {
+  if (address) publicAddress = address;
+}
+
+export async function accept(): Promise<void> {}
+
+export function defineRoomType<T extends Room>(
+  roomName: string,
+  klass: Type<T>,
+  defaultOptions?: Parameters<NonNullable<T['onCreate']>>[0],
+): RegisteredHandler<T> {
+  const handler = new RegisteredHandler(klass, defaultOptions);
+  handler.name = roomName;
+  handlers.set(roomName, handler);
+  return handler;
+}
+
+export function addRoomType(handler: RegisteredHandler): void {
+  handlers.set(handler.name, handler);
+}
+
+export function removeRoomType(roomName: string): void {
+  handlers.delete(roomName);
+}
+
+export function getAllHandlers(): Record<string, RegisteredHandler> {
+  return Object.fromEntries(handlers);
+}
+
+export function getHandler(roomName: string): RegisteredHandler {
+  const handler = handlers.get(roomName);
+  if (!handler) throw new ServerError(404, `Room not defined: ${roomName}`);
+  return handler;
+}
+
+export function getRoomClass(roomName: string): Type<Room> {
+  return getHandler(roomName).klass;
+}
+
+export async function createRoom(roomName: string, clientOptions?: unknown): Promise<RoomCache> {
+  const handler = getHandler(roomName);
+  const roomId = generateId(9);
+  const cache: RoomCache = {
+    name: roomName,
+    roomId,
+    processId,
+    clients: 0,
+    maxClients: Number.POSITIVE_INFINITY,
+    locked: false,
+    private: false,
+    metadata: handler.getMetadataFromOptions(clientOptions).metadata,
+  };
+  rooms.set(roomId, cache);
+  return cache;
+}
+
+export const handleCreateRoom = createRoom;
+
+export async function getRoomById(roomId: string): Promise<RoomCache> {
+  const room = rooms.get(roomId);
+  if (!room) throw new ServerError(404, `Room not found: ${roomId}`);
+  return room;
+}
+
+export function getLocalRoomById(_roomId: string): Room | undefined {
+  return undefined;
+}
+
+export async function query(conditions: Partial<RoomCache> = {}): Promise<RoomCache[]> {
+  return [...rooms.values()].filter((room) =>
+    Object.entries(conditions).every(
+      ([key, value]) =>
+        value === undefined || (room as unknown as Record<string, unknown>)[key] === value,
+    ),
+  );
+}
+
+export async function findOneRoomAvailable(roomName: string): Promise<RoomCache> {
+  const room = [...rooms.values()].find(
+    (candidate) => candidate.name === roomName && !candidate.locked && !candidate.private,
+  );
+  if (room) return room;
+  return createRoom(roomName);
+}
+
+export async function reserveSeatFor(
+  room: RoomCache,
+  _options?: unknown,
+): Promise<SeatReservation> {
+  const sessionId = generateId();
+  room.clients++;
+  return buildSeatReservation(room, sessionId);
+}
+
+export async function reserveMultipleSeatsFor(
+  room: RoomCache,
+  clientsData: Array<{ sessionId: string; options: unknown; auth: unknown }>,
+): Promise<boolean[]> {
+  room.clients += clientsData.length;
+  return clientsData.map(() => true);
+}
+
+export function buildSeatReservation(room: RoomCache, sessionId: string): SeatReservation {
+  return {
+    name: room.name,
+    roomId: room.roomId,
+    sessionId,
+    processId: room.processId,
+    publicAddress,
+  };
+}
+
+export async function create(roomName: string, clientOptions?: unknown): Promise<SeatReservation> {
+  return reserveSeatFor(await createRoom(roomName, clientOptions), clientOptions);
+}
+
+export async function joinOrCreate(
+  roomName: string,
+  clientOptions?: unknown,
+): Promise<SeatReservation> {
+  return reserveSeatFor(await findOneRoomAvailable(roomName), clientOptions);
+}
+
+export async function join(roomName: string, clientOptions?: unknown): Promise<SeatReservation> {
+  return joinOrCreate(roomName, clientOptions);
+}
+
+export async function joinById(roomId: string, clientOptions?: unknown): Promise<SeatReservation> {
+  return reserveSeatFor(await getRoomById(roomId), clientOptions);
+}
+
+export async function reconnect(roomId: string, clientOptions?: unknown): Promise<SeatReservation> {
+  const reservation = await joinById(roomId, clientOptions);
+  reservation.reconnectionToken = String(
+    asRecord(clientOptions)?.['reconnectionToken'] ?? reservation.sessionId,
+  );
+  return reservation;
+}
+
+export async function remoteRoomCall(_roomId: string, _method: string): Promise<unknown> {
+  return undefined;
+}
+
+export function disconnectAll(): Promise<void>[] {
+  rooms.clear();
+  return [];
+}
+
+export async function gracefullyShutdown(): Promise<void> {
+  rooms.clear();
+  handlers.clear();
+}
+
+export async function healthCheckAllProcesses(): Promise<void> {}
+
+export async function healthCheckProcessId(): Promise<boolean> {
+  return true;
+}
+
+export const MatchMakerState = {
+  INITIALIZING: 0,
+  READY: 1,
+  SHUTTING_DOWN: 2,
+} as const;
+export const state = MatchMakerState.READY;
+export const onReady = new Deferred<void>();
+onReady.resolve();
+
+export function setHealthChecksEnabled(): void {}
+
+export const controller = {
+  async invokeMethod(method: string, roomName: string, clientOptions?: unknown): Promise<unknown> {
+    if (method === 'joinOrCreate') return joinOrCreate(roomName, clientOptions);
+    if (method === 'create') return create(roomName, clientOptions);
+    if (method === 'join') return join(roomName, clientOptions);
+    return undefined;
+  },
+};
+
+export const stats = {};
+
+export const matchMaker = {
+  setup,
+  accept,
+  joinOrCreate,
+  create,
+  join,
+  reconnect,
+  joinById,
+  query,
+  findOneRoomAvailable,
+  remoteRoomCall,
+  defineRoomType,
+  addRoomType,
+  removeRoomType,
+  getAllHandlers,
+  getHandler,
+  getRoomClass,
+  createRoom,
+  handleCreateRoom,
+  getRoomById,
+  getLocalRoomById,
+  disconnectAll,
+  gracefullyShutdown,
+  reserveSeatFor,
+  reserveMultipleSeatsFor,
+  buildSeatReservation,
+  healthCheckAllProcesses,
+  healthCheckProcessId,
+  setHealthChecksEnabled,
+  controller,
+  stats,
+  processId,
+  presence,
+  driver,
+  publicAddress,
+  MatchMakerState,
+  state,
+  onReady,
+};
+
+export const __globalEndpoints: unknown[] = [];
+
+export interface Router {
+  routes?: unknown[];
+}
+
+export function createRouter(): Router {
+  return { routes: [] };
+}
+
+export function createEndpoint(
+  handler: (...args: unknown[]) => unknown,
+): (...args: unknown[]) => unknown {
+  return handler;
+}
+
+export function createInternalContext(context: unknown): unknown {
+  return context;
+}
+
+export function createMiddleware(
+  middleware: (...args: unknown[]) => unknown,
+): (...args: unknown[]) => unknown {
+  return middleware;
+}
+
+export function toNodeHandler(
+  handler: (...args: unknown[]) => unknown,
+): (...args: unknown[]) => unknown {
+  return handler;
+}
+
+export function isDevMode(): boolean {
+  return false;
+}
+
+export async function subscribeIPC(): Promise<void> {}
+
+export async function requestFromIPC<T = unknown>(): Promise<T | undefined> {
+  return undefined;
+}
+
+export interface ServerOptions {
+  publicAddress?: string;
+  transport?: Transport;
+  presence?: LocalPresence;
+  greet?: boolean;
+  beforeListen?: () => Promise<void> | void;
+}
+
+export class Server<
+  RoomTypes extends Record<string, RegisteredHandler> = Record<string, RegisteredHandler>,
+> {
+  '~rooms'!: RoomTypes;
+  '~routes'!: unknown;
+  transport: Transport;
+  router = {};
+  readonly options: ServerOptions;
+  // biome-ignore lint/suspicious/noConfusingVoidType: mirrors Colyseus's onShutdown contract — sync callbacks return nothing, async ones a promise
+  private readonly shutdownCallbacks = new Set<() => void | Promise<unknown>>();
+  // biome-ignore lint/suspicious/noConfusingVoidType: same contract as shutdownCallbacks
+  private readonly beforeShutdownCallbacks = new Set<() => void | Promise<unknown>>();
+
+  constructor(options: ServerOptions = {}) {
+    this.options = options;
+    this.transport = options.transport ?? new NoopTransport();
+  }
+
+  async attach(options: ServerOptions): Promise<void> {
+    Object.assign(this.options, options);
+    if (options.transport) this.transport = options.transport;
+  }
+
+  async listen(
+    port: number | string,
+    hostname?: string,
+    backlog?: number,
+    listeningListener?: () => void,
+  ): Promise<unknown> {
+    await this.options.beforeListen?.();
+    this.transport.listen(port, hostname, backlog, listeningListener);
+    listeningListener?.();
+    return this.transport;
+  }
+
+  define<T extends Type<Room>>(
+    roomClass: T,
+    defaultOptions?: unknown,
+  ): RegisteredHandler<InstanceType<T>>;
+  define<T extends Type<Room>>(
+    name: string,
+    roomClass: T,
+    defaultOptions?: unknown,
+  ): RegisteredHandler<InstanceType<T>>;
+  define<T extends Type<Room>>(
+    nameOrClass: string | T,
+    roomClassOrOptions?: T | unknown,
+    defaultOptions?: unknown,
+  ): RegisteredHandler<InstanceType<T>> {
+    const name = typeof nameOrClass === 'string' ? nameOrClass : nameOrClass.name;
+    const klass = (typeof nameOrClass === 'string' ? roomClassOrOptions : nameOrClass) as T;
+    return defineRoomType(
+      name,
+      klass,
+      defaultOptions ?? (typeof nameOrClass === 'string' ? undefined : roomClassOrOptions),
+    ) as RegisteredHandler<InstanceType<T>>;
+  }
+
+  removeRoomType(name: string): void {
+    removeRoomType(name);
+  }
+
+  simulateLatency(milliseconds: number): void {
+    this.transport.simulateLatency(milliseconds);
+  }
+
+  // biome-ignore lint/suspicious/noConfusingVoidType: mirrors Colyseus's onShutdown signature verbatim
+  onShutdown(callback: () => void | Promise<unknown>): void {
+    this.shutdownCallbacks.add(callback);
+  }
+
+  // biome-ignore lint/suspicious/noConfusingVoidType: mirrors Colyseus's onBeforeShutdown signature verbatim
+  onBeforeShutdown(callback: () => void | Promise<unknown>): void {
+    this.beforeShutdownCallbacks.add(callback);
+  }
+
+  async gracefullyShutdown(): Promise<void> {
+    for (const callback of this.beforeShutdownCallbacks) await callback();
+    await gracefullyShutdown();
+    for (const callback of this.shutdownCallbacks) await callback();
+    this.transport.shutdown();
+  }
+}
+
+export function defineRoom<T extends Type<Room>>(
+  roomKlass: T,
+  defaultOptions?: unknown,
+): RegisteredHandler<InstanceType<T>> {
+  return new RegisteredHandler(roomKlass, defaultOptions) as RegisteredHandler<InstanceType<T>>;
+}
+
+export function defineServer(
+  options: ServerOptions & { rooms?: Record<string, RegisteredHandler> },
+): Server {
+  const server = new Server(options);
+  for (const [name, handler] of Object.entries(options.rooms ?? {})) {
+    handler.name = name;
+    addRoomType(handler);
+  }
+  return server;
+}
+
+export class NoopTransport extends Transport {}
+
+export class WebSocketClient {}
+
+export interface TransportOptions {
+  server?: unknown;
+}
+
+export class WebSocketTransport extends Transport {
+  constructor(readonly options: TransportOptions = {}) {
+    super();
+    this.server = options.server;
+  }
+}
+
+export function generateId(length = 9): string {
+  const id = Math.random().toString(36).slice(2);
+  return id.length >= length ? id.slice(0, length) : id.padEnd(length, '0');
+}
+
+export function spliceOne<T>(array: T[], index: number): boolean {
+  if (index < 0 || index >= array.length) return false;
+  array.splice(index, 1);
+  return true;
+}
+
+export function getBearerToken(value?: string): string | undefined {
+  return value?.startsWith('Bearer ') ? value.slice('Bearer '.length) : undefined;
+}
+
+export async function dynamicImport<T = unknown>(path: string): Promise<T> {
+  return import(path) as Promise<T>;
+}
+
+export function getMessageBytes(message: Uint8Array): Uint8Array {
+  return message;
+}
+
+export function updateLobby(): void {}
+
+export function subscribeLobby(): () => void {
+  return () => {};
+}
+
+export function initializeRoomCache(cache: RoomCache): RoomCache {
+  return cache;
+}
+
+export function connectClientToRoom(): Promise<void> {
+  return Promise.resolve();
+}
+
+export function debugMatchMaking(): void {}
+export function debugMessage(): void {}
+export function debugPatch(): void {}
+export function debugError(): void {}
+export function debugConnection(): void {}
+export function debugDriver(): void {}
+export function debugPresence(): void {}
+export function debugAndPrintError(error: unknown): void {
+  // biome-ignore lint/suspicious/noConsole: printing IS this compat shim's purpose (mirrors colyseus's debugAndPrintError)
+  if (error) console.error(error);
+}
+
+export const logger = console;
+
+export class LobbyRoom extends Room {}
+export class RelayRoom extends Room {}
+export class QueueRoom extends Room {}
+
+// biome-ignore lint/complexity/noStaticOnlyClass: mirrors @colyseus/auth's Hash export shape — consumers call Hash.make/Hash.compare statically
+export class Hash {
+  static async make(password: string): Promise<string> {
+    return password;
+  }
+
+  static async compare(password: string, hash: string): Promise<boolean> {
+    return password === hash;
+  }
+}
+
+export const JWT = {
+  async sign(payload: unknown): Promise<string> {
+    return btoa(JSON.stringify(payload));
+  },
+  async verify(token: string): Promise<unknown> {
+    return JSON.parse(atob(token));
+  },
+};
+
+export const auth = {
+  settings: {},
+  prefix: '/auth',
+  routes: {},
+};
+
+export function monitor(): { use?: (...args: unknown[]) => unknown } {
+  return {};
+}
+
+export function playground(): { use?: (...args: unknown[]) => unknown } {
+  return {};
+}
+
+export async function listen<
+  RoomTypes extends Record<string, RegisteredHandler> = Record<string, RegisteredHandler>,
+>(
+  optionsOrServer: Server<RoomTypes> | (ServerOptions & { rooms?: RoomTypes }),
+  port = Number(process.env['PORT'] ?? 2567),
+): Promise<Server<RoomTypes>> {
+  const server =
+    optionsOrServer instanceof Server ? optionsOrServer : defineServer(optionsOrServer);
+  await server.listen(port);
+  return server as Server<RoomTypes>;
+}
+
+export async function getTransport(options: ServerOptions = {}): Promise<Transport> {
+  return options.transport ?? new NoopTransport();
+}
+
+export { Room, ClientArray, room, validate, type CompatClient as Client };