@vgai/p2p-colyseus 0.1.0

package/src/client.ts

@@ -0,0 +1,480 @@
+import type { PacketChannel } from './channels';
+import { applyStatePatch } from './codec';
+import type { P2PColyseusMode } from './engine';
+import { createSignal } from './events';
+import { createLoopbackPair } from './loopback';
+import { type Envelope, P2P_CLOSE_CODES } from './protocol';
+import { ClientReplication } from './replication';
+import { type RoomClass, UniversalRoomRuntime } from './runtime';
+import { createWebSocketPacketChannel } from './websocket';
+
+const loopbackRooms = new Map<string, RoomClass>();
+let configuredP2P:
+  | {
+      mode: Extract<P2PColyseusMode, { kind: 'p2p-host' | 'p2p-join' }>;
+      rooms?: Record<string, RoomClass> | undefined;
+      maxLocalClientsPerRoom?: number | undefined;
+    }
+  | undefined;
+const hostedP2PRoomIds = new Map<string, string>();
+const localP2PClientCounts = new Map<string, number>();
+
+export function registerLoopbackRoom(roomName: string, roomClass: RoomClass): void {
+  loopbackRooms.set(roomName, roomClass);
+}
+
+export function configureP2PColyseusClient(options: {
+  mode: Extract<P2PColyseusMode, { kind: 'p2p-host' | 'p2p-join' }>;
+  rooms?: Record<string, RoomClass> | undefined;
+  maxLocalClientsPerRoom?: number | undefined;
+}): void {
+  configuredP2P = options;
+  publishP2PMode(options.mode.kind);
+  hostedP2PRoomIds.clear();
+  localP2PClientCounts.clear();
+  for (const [roomName, roomClass] of Object.entries(options.rooms ?? {})) {
+    registerLoopbackRoom(roomName, roomClass);
+  }
+}
+
+export function resetP2PColyseusClient(): void {
+  configuredP2P = undefined;
+  hostedP2PRoomIds.clear();
+  localP2PClientCounts.clear();
+  publishP2PMode('');
+}
+
+export class AbortError extends Error {
+  constructor(message = 'aborted') {
+    super(message);
+    this.name = 'AbortError';
+  }
+}
+
+export class MatchMakeError extends Error {
+  constructor(
+    message: string,
+    readonly code?: number,
+  ) {
+    super(message);
+    this.name = 'MatchMakeError';
+  }
+}
+
+export class Auth<UserData = unknown> {
+  token: string | undefined;
+  userData: UserData | undefined;
+
+  constructor(readonly client?: Client) {}
+
+  async login(options?: { token?: string; userData?: UserData }): Promise<UserData | undefined> {
+    this.token = options?.token;
+    this.userData = options?.userData;
+    return this.userData;
+  }
+
+  async logout(): Promise<void> {
+    this.token = undefined;
+    this.userData = undefined;
+  }
+}
+
+export interface AvailableRoom {
+  clients: number;
+  maxClients: number;
+  metadata: unknown;
+  name: string;
+  roomId: string;
+}
+
+export class Client {
+  static VERSION = 'p2p-colyseus-compat';
+  readonly auth = new Auth(this);
+
+  constructor(readonly url: string) {}
+
+  async create(roomName: string, options?: unknown): Promise<CompatRoom> {
+    return this.joinOrCreate(roomName, options);
+  }
+
+  async join(roomName: string, options?: unknown): Promise<CompatRoom> {
+    return this.joinOrCreate(roomName, options);
+  }
+
+  async joinById(roomId: string, options?: unknown): Promise<CompatRoom> {
+    return this.joinOrCreate(roomId, options);
+  }
+
+  async reconnect(reconnectionToken: string): Promise<CompatRoom> {
+    const [roomId, token] = reconnectionToken.split(':');
+    if (!roomId || !token) {
+      throw new Error(
+        'Invalid reconnection token format.\nThe format should be roomId:reconnectionToken',
+      );
+    }
+    const room = await this.joinById(roomId, { reconnectionToken: token });
+    room.reconnectionToken = reconnectionToken;
+    return room;
+  }
+
+  async consumeSeatReservation(response: {
+    name: string;
+    sessionId: string;
+    roomId: string;
+    reconnectionToken?: string;
+    expiresAt?: number | string | Date;
+  }): Promise<CompatRoom> {
+    if (isExpiredReservation(response.expiresAt)) {
+      throw new MatchMakeError('Seat reservation expired', P2P_CLOSE_CODES.unauthorized);
+    }
+    const room = await this.joinOrCreate(response.name, {
+      sessionId: response.sessionId,
+      reconnectionToken: response.reconnectionToken,
+    });
+    room.roomId = response.roomId;
+    room.sessionId = response.sessionId;
+    room.reconnectionToken =
+      response.reconnectionToken ?? `${response.roomId}:${response.sessionId}`;
+    return room;
+  }
+
+  async getLatency(options: { pingCount?: number } = {}): Promise<number> {
+    if (this.url.startsWith('loopback://')) return 0;
+    const pingCount = Math.max(1, options.pingCount ?? 1);
+    const room = await this.joinOrCreate('__latency__').catch(() => undefined);
+    if (!room) return Number.POSITIVE_INFINITY;
+    const latencies: number[] = [];
+    for (let i = 0; i < pingCount; i++) {
+      latencies.push(await new Promise<number>((resolve) => room.ping(resolve)));
+    }
+    await room.leave();
+    return latencies.reduce((sum, latency) => sum + latency, 0) / latencies.length;
+  }
+
+  async getAvailableRooms(roomName?: string): Promise<AvailableRoom[]> {
+    const roomNames = configuredP2P
+      ? Object.keys(configuredP2P.rooms ?? {})
+      : [...loopbackRooms.keys()];
+    return roomNames
+      .filter((name) => roomName === undefined || name === roomName)
+      .map((name) => ({
+        clients: localP2PClientCounts.get(name) ?? 0,
+        maxClients: Number.POSITIVE_INFINITY,
+        metadata: {},
+        name,
+        roomId: hostedP2PRoomIds.get(name) ?? name,
+      }));
+  }
+
+  async joinOrCreate(roomName: string, options?: unknown): Promise<CompatRoom> {
+    if (configuredP2P) {
+      reserveLocalP2PClient(roomName);
+      const engine = await import('./engine');
+      if (configuredP2P.mode.kind === 'p2p-host') {
+        const hostedRoomId = hostedP2PRoomIds.get(roomName);
+        if (hostedRoomId) {
+          const room = await engine.connectP2PJoinRoom(
+            { ...configuredP2P.mode, kind: 'p2p-join', roomId: hostedRoomId },
+            {
+              url: this.url,
+              room: roomName,
+              joinOptions: options as Record<string, unknown> | undefined,
+            },
+          );
+          releaseLocalP2PClientOnLeave(roomName, room);
+          return room;
+        }
+        const room = await engine.connectP2PHostRoom(configuredP2P.mode, configuredP2P.rooms, {
+          url: this.url,
+          room: roomName,
+          joinOptions: options as Record<string, unknown> | undefined,
+        });
+        hostedP2PRoomIds.set(roomName, room.roomId);
+        publishHostedP2PRoomId(room.roomId);
+        releaseLocalP2PClientOnLeave(roomName, room);
+        return room;
+      }
+      const room = await engine.connectP2PJoinRoom(configuredP2P.mode, {
+        url: this.url,
+        room: roomName,
+        joinOptions: options as Record<string, unknown> | undefined,
+      });
+      releaseLocalP2PClientOnLeave(roomName, room);
+      return room;
+    }
+
+    if (this.url.startsWith('ws://') || this.url.startsWith('wss://')) {
+      const socket = await openWebSocket(this.url);
+      return connectRoomOverChannel(
+        createWebSocketPacketChannel(`client-${randomId()}`, socket),
+        roomName,
+        options,
+      );
+    }
+
+    if (!this.url.startsWith('loopback://')) {
+      throw new Error(`Unsupported @vgai/p2p-colyseus client URL: ${this.url}`);
+    }
+    const roomClass = loopbackRooms.get(roomName);
+    if (!roomClass) throw new Error(`Loopback room not registered: ${roomName}`);
+
+    // joinOrCreate semantics: the creating client's options reach onCreate.
+    const runtime = new UniversalRoomRuntime(roomClass, roomName, options);
+    const [hostChannel, clientChannel] = createLoopbackPair('client-1', 'host');
+    runtime.attach(hostChannel);
+    return connectRoomOverChannel(clientChannel, roomName, options);
+  }
+}
+
+function reserveLocalP2PClient(roomName: string): void {
+  const max = configuredP2P?.maxLocalClientsPerRoom;
+  if (max === undefined) {
+    localP2PClientCounts.set(roomName, (localP2PClientCounts.get(roomName) ?? 0) + 1);
+    return;
+  }
+  const current = localP2PClientCounts.get(roomName) ?? 0;
+  if (current >= max) {
+    throw new Error(`P2P local client limit reached for room: ${roomName}`);
+  }
+  localP2PClientCounts.set(roomName, current + 1);
+}
+
+function releaseLocalP2PClientOnLeave(roomName: string, room: CompatRoom): void {
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    localP2PClientCounts.set(roomName, Math.max(0, (localP2PClientCounts.get(roomName) ?? 1) - 1));
+  };
+  room.onLeave.add(release);
+  const originalLeave = room.leave.bind(room);
+  room.leave = async (consented = true) => {
+    try {
+      return await originalLeave(consented);
+    } finally {
+      release();
+    }
+  };
+}
+
+function publishHostedP2PRoomId(roomId: string): void {
+  const maybeWindow = globalThis as unknown as {
+    window?: { __VGAI_P2P_COLYSEUS_ROOM_ID__?: string };
+    __VGAI_P2P_COLYSEUS_ROOM_ID__?: string;
+  };
+  maybeWindow.__VGAI_P2P_COLYSEUS_ROOM_ID__ = roomId;
+  if (maybeWindow.window) maybeWindow.window.__VGAI_P2P_COLYSEUS_ROOM_ID__ = roomId;
+}
+
+function publishP2PMode(mode: string): void {
+  const maybeWindow = globalThis as unknown as {
+    window?: { __VGAI_P2P_COLYSEUS_MODE__?: string };
+    __VGAI_P2P_COLYSEUS_MODE__?: string;
+  };
+  maybeWindow.__VGAI_P2P_COLYSEUS_MODE__ = mode;
+  if (maybeWindow.window) maybeWindow.window.__VGAI_P2P_COLYSEUS_MODE__ = mode;
+}
+
+export const ColyseusSDK = Client;
+
+export function getStateCallbacks(room: CompatRoom): ClientReplication {
+  return room.replication;
+}
+
+export function registerSerializer(): void {}
+
+export class CompatRoom {
+  readonly replication = new ClientReplication();
+  readonly onLeave = createSignal<(code?: number, reason?: string) => void>();
+  readonly onError = createSignal<(code: number, message?: string) => void>();
+  readonly onReconnect = createSignal<() => void>();
+  readonly onDrop = createSignal<(code?: number, reason?: string) => void>();
+  readonly onStateChange = createSignal<(state: Record<string, unknown>) => void>();
+  roomId = '';
+  sessionId = '';
+  reconnectionToken = '';
+  state: Record<string, unknown> = this.replication.state;
+  private readonly messages = new Map<string, Set<(payload: unknown) => void>>();
+  private readonly wildcardMessages = new Set<(type: string, payload: unknown) => void>();
+  private readonly pendingPings = new Map<number, (ms: number) => void>();
+  private clock = 0;
+
+  constructor(
+    readonly name: string,
+    private readonly channel: PacketChannel,
+  ) {
+    this.channel.onEnvelope((envelope) => this.handleEnvelope(envelope));
+    this.channel.onClose((reason) => {
+      this.onDrop.emit(undefined, reason);
+      this.onLeave.emit(undefined, reason);
+    });
+  }
+
+  async join(options?: unknown): Promise<void> {
+    const requestId = crypto.randomUUID?.() ?? `join-${Date.now()}`;
+    const joined = new Promise<void>((resolve, reject) => {
+      const off = this.channel.onEnvelope((envelope) => {
+        if (envelope.kind === 'join-ok' && envelope.requestId === requestId) {
+          off();
+          this.roomId = this.name;
+          this.sessionId = envelope.sessionId;
+          this.reconnectionToken = `${this.roomId}:${this.sessionId}`;
+          this.clock = envelope.clock;
+          this.replication.applySnapshot(envelope.snapshot.state);
+          this.state = this.replication.state;
+          resolve();
+        } else if (envelope.kind === 'join-error' && envelope.requestId === requestId) {
+          off();
+          reject(new Error(envelope.message));
+        }
+      });
+    });
+    this.channel.send({ kind: 'join', requestId, room: this.name, options });
+    await joined;
+  }
+
+  send(type: string, payload?: unknown): void {
+    this.channel.send({ kind: 'message', type, payload });
+  }
+
+  sendUnreliable<T = unknown>(type: string, payload?: T): void {
+    this.send(type, payload);
+  }
+
+  sendBytes(type: string | number, bytes: Uint8Array): void {
+    this.send(String(type), bytes);
+  }
+
+  ping(callback: (ms: number) => void): void {
+    const t = Date.now();
+    this.pendingPings.set(t, callback);
+    this.channel.send({ kind: 'ping', t });
+  }
+
+  onMessage<T = unknown>(type: '*', handler: (type: string, payload: T) => void): () => void;
+  onMessage<T = unknown>(type: string, handler: (payload: T) => void): () => void;
+  onMessage<T = unknown>(
+    type: string,
+    handler: ((payload: T) => void) | ((type: string, payload: T) => void),
+  ): () => void {
+    if (type === '*') {
+      const wrapped = handler as (type: string, payload: unknown) => void;
+      this.wildcardMessages.add(wrapped);
+      return () => this.wildcardMessages.delete(wrapped);
+    }
+    const handlers = this.messages.get(type) ?? new Set<(payload: unknown) => void>();
+    const wrapped = handler as (payload: unknown) => void;
+    handlers.add(wrapped);
+    this.messages.set(type, handlers);
+    return () => handlers.delete(wrapped);
+  }
+
+  async leave(_consented = true): Promise<number> {
+    const left = new Promise<number>((resolve) => {
+      this.onLeave.once((code) => resolve(code ?? 1000));
+    });
+    this.channel.send({ kind: 'leave', code: 1000 });
+    return left;
+  }
+
+  removeAllListeners(): void {
+    this.messages.clear();
+    this.wildcardMessages.clear();
+    this.onLeave.clear();
+    this.onDrop.clear();
+    this.onError.clear();
+    this.onReconnect.clear();
+    this.onStateChange.clear();
+  }
+
+  private handleEnvelope(envelope: Envelope): void {
+    if (envelope.kind === 'state-snapshot') {
+      if (envelope.clock <= this.clock) return;
+      this.clock = envelope.clock;
+      this.replication.applySnapshot(envelope.snapshot.state);
+      this.state = this.replication.state;
+      this.onStateChange.emit(this.state);
+    } else if (envelope.kind === 'state-patch') {
+      if (envelope.clock <= this.clock) return;
+      if (envelope.clock > this.clock + 1) {
+        this.channel.send({ kind: 'state-resync', clock: this.clock });
+        return;
+      }
+      this.clock = envelope.clock;
+      const patched = applyStatePatch(this.replication.state, envelope.patch);
+      this.replication.applySnapshot(patched);
+      this.state = this.replication.state;
+      this.onStateChange.emit(this.state);
+    } else if (envelope.kind === 'message') {
+      if (envelope.type === 'error' && isErrorPayload(envelope.payload)) {
+        this.onError.emit(envelope.payload.code, envelope.payload.message);
+        return;
+      }
+      for (const handler of this.messages.get(envelope.type) ?? []) handler(envelope.payload);
+      for (const handler of this.wildcardMessages) handler(envelope.type, envelope.payload);
+    } else if (envelope.kind === 'leave') {
+      this.onLeave.emit(envelope.code, envelope.reason);
+      queueMicrotask(() => this.channel.close('left'));
+    } else if (envelope.kind === 'ping') {
+      this.channel.send({ kind: 'pong', t: envelope.t });
+    } else if (envelope.kind === 'pong') {
+      const callback = this.pendingPings.get(envelope.t);
+      if (callback) {
+        this.pendingPings.delete(envelope.t);
+        callback(Math.max(0, Date.now() - envelope.t));
+      }
+    }
+  }
+}
+
+function isExpiredReservation(expiresAt: number | string | Date | undefined): boolean {
+  if (expiresAt === undefined) return false;
+  const timestamp =
+    expiresAt instanceof Date
+      ? expiresAt.getTime()
+      : typeof expiresAt === 'string'
+        ? Date.parse(expiresAt)
+        : expiresAt;
+  return Number.isFinite(timestamp) && timestamp <= Date.now();
+}
+
+function isErrorPayload(value: unknown): value is { code: number; message?: string } {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { code?: unknown }).code === 'number'
+  );
+}
+
+export async function connectRoomOverChannel(
+  channel: PacketChannel,
+  roomName: string,
+  options?: unknown,
+): Promise<CompatRoom> {
+  const room = new CompatRoom(roomName, channel);
+  await room.join(options);
+  return room;
+}
+
+async function openWebSocket(url: string): Promise<WebSocket> {
+  if (typeof WebSocket === 'undefined') {
+    throw new Error('WebSocket is not available in this JavaScript runtime');
+  }
+  const socket = new WebSocket(url);
+  if (socket.readyState === WebSocket.OPEN) return socket;
+  await new Promise<void>((resolve, reject) => {
+    socket.addEventListener('open', () => resolve(), { once: true });
+    socket.addEventListener(
+      'error',
+      () => reject(new Error(`WebSocket connection failed: ${url}`)),
+      {
+        once: true,
+      },
+    );
+  });
+  return socket;
+}
+
+function randomId(): string {
+  return crypto.randomUUID?.() ?? Math.random().toString(36).slice(2);
+}