@vgai/p2p-colyseus 0.1.0

package/src/events.ts

@@ -0,0 +1,58 @@
+export class Signal<T extends (...args: never[]) => void> {
+  private readonly handlers = new Set<T>();
+
+  add(handler: T): () => void {
+    this.handlers.add(handler);
+    return () => this.remove(handler);
+  }
+
+  remove(handler: T): void {
+    this.handlers.delete(handler);
+  }
+
+  emit(...args: Parameters<T>): void {
+    for (const handler of [...this.handlers]) handler(...args);
+  }
+}
+
+export interface CallableSignal<T extends (...args: never[]) => void> {
+  (handler: T): () => void;
+  add(handler: T): () => void;
+  once(handler: T): void;
+  remove(handler: T): void;
+  clear(): void;
+  invoke(...args: Parameters<T>): void;
+  invokeAsync(...args: Parameters<T>): Promise<unknown[]>;
+  emit(...args: Parameters<T>): void;
+}
+
+export function createSignal<T extends (...args: never[]) => void>(): CallableSignal<T> {
+  const handlers = new Set<T>();
+  const signal = ((handler: T) => signal.add(handler)) as CallableSignal<T>;
+  signal.add = (handler: T) => {
+    handlers.add(handler);
+    return () => signal.remove(handler);
+  };
+  signal.once = (handler: T) => {
+    const wrapped = ((...args: Parameters<T>) => {
+      signal.remove(wrapped as T);
+      handler(...args);
+    }) as T;
+    signal.add(wrapped);
+  };
+  signal.remove = (handler: T) => {
+    handlers.delete(handler);
+  };
+  signal.clear = () => {
+    handlers.clear();
+  };
+  signal.invoke = (...args: Parameters<T>) => {
+    signal.emit(...args);
+  };
+  signal.invokeAsync = async (...args: Parameters<T>) =>
+    Promise.all([...handlers].map((handler) => handler(...args)));
+  signal.emit = (...args: Parameters<T>) => {
+    for (const handler of [...handlers]) handler(...args);
+  };
+  return signal;
+}

package/src/index.ts

@@ -0,0 +1,196 @@
+export type { P2PAccessTokenClaims } from './access-token';
+export { createP2PAccessToken, verifyP2PAccessToken } from './access-token';
+export { Callbacks } from './callbacks';
+export type { PacketChannel, PacketChannelMode } from './channels';
+export {
+  AbortError,
+  Auth,
+  Client,
+  ColyseusSDK,
+  CompatRoom,
+  configureP2PColyseusClient,
+  connectRoomOverChannel,
+  getStateCallbacks,
+  MatchMakeError,
+  registerLoopbackRoom,
+  registerSerializer,
+  resetP2PColyseusClient,
+} from './client';
+export { SignalingRelayCoordinator } from './cloudflare/coordinator';
+export type { RelayLimits } from './cloudflare/limits';
+export { DEFAULT_RELAY_LIMITS } from './cloudflare/limits';
+export { applyStatePatch, clone, createStatePatch, encodeSnapshot } from './codec';
+export type {
+  NetDiagnostics,
+  RelayProofDiagnostics,
+  RelayQuota,
+  TransportName,
+} from './diagnostics';
+export { createLoopbackPair } from './loopback';
+export type { UniversalNodeServer } from './node-websocket';
+export { NodeWebSocketPacketChannel, startUniversalNodeServer } from './node-websocket';
+export type { RoomCache, SeatReservation, ServerOptions, Type } from './platform';
+export {
+  __globalEndpoints,
+  accept,
+  addRoomType,
+  auth,
+  buildSeatReservation,
+  ClientArray,
+  ClientState,
+  Clock,
+  CloseCode,
+  connectClientToRoom,
+  controller,
+  create,
+  createEndpoint,
+  createInternalContext,
+  createMiddleware,
+  createRoom,
+  createRouter,
+  Deferred,
+  Delayed,
+  debugAndPrintError,
+  debugConnection,
+  debugDriver,
+  debugError,
+  debugMatchMaking,
+  debugMessage,
+  debugPatch,
+  debugPresence,
+  defineRoom,
+  defineRoomType,
+  defineServer,
+  disconnectAll,
+  driver,
+  dynamicImport,
+  ErrorCode,
+  findOneRoomAvailable,
+  generateId,
+  getAllHandlers,
+  getBearerToken,
+  getHandler,
+  getLocalRoomById,
+  getMessageBytes,
+  getRoomById,
+  getRoomClass,
+  getTransport,
+  gracefullyShutdown,
+  Hash,
+  handleCreateRoom,
+  healthCheckAllProcesses,
+  healthCheckProcessId,
+  initializeRoomCache,
+  isDevMode,
+  JWT,
+  join,
+  joinById,
+  joinOrCreate,
+  LobbyRoom,
+  LocalDriver,
+  LocalPresence,
+  listen,
+  logger,
+  matchMaker,
+  monitor,
+  NoopTransport,
+  OnAuthException,
+  OnCreateException,
+  OnDisposeException,
+  OnJoinException,
+  OnLeaveException,
+  OnMessageException,
+  onReady,
+  Protocol,
+  playground,
+  presence,
+  processId,
+  publicAddress,
+  QueueRoom,
+  query,
+  RedisDriver,
+  RedisPresence,
+  RegisteredHandler,
+  RelayRoom,
+  RoomInternalState,
+  reconnect,
+  remoteRoomCall,
+  removeRoomType,
+  requestFromIPC,
+  reserveMultipleSeatsFor,
+  reserveSeatFor,
+  room,
+  SchemaSerializer,
+  Server,
+  ServerError,
+  SimulationIntervalException,
+  setHealthChecksEnabled,
+  setup,
+  spliceOne,
+  state,
+  stats,
+  subscribeIPC,
+  subscribeLobby,
+  TimedEventException,
+  Transport,
+  toNodeHandler,
+  updateLobby,
+  validate,
+  WebSocketClient,
+  WebSocketTransport,
+} from './platform';
+export type { Envelope, Snapshot, StatePatch, StatePatchOperation } from './protocol';
+export { isEnvelope, P2P_CLOSE_CODES } from './protocol';
+export { CloudflareRelayPacketChannel } from './relay';
+export type { CompatClient } from './room';
+export { Room } from './room';
+export type { RoomClass } from './runtime';
+export { UniversalRoomRuntime } from './runtime';
+export {
+  $changes,
+  $childType,
+  $decoder,
+  $deleteByIndex,
+  $encoder,
+  $filter,
+  $getByIndex,
+  $refId,
+  $track,
+  ArraySchema,
+  Callbacks as SchemaCallbacks,
+  ChangeTree,
+  CollectionSchema,
+  Decoder,
+  decode,
+  decodeKeyValueOperation,
+  decodeSchemaOperation,
+  defineCustomTypes,
+  defineTypes,
+  deprecated,
+  dumpChanges,
+  Encoder,
+  encode,
+  encodeArray,
+  encodeKeyValueOperation,
+  encodeSchemaOperation,
+  entity,
+  getDecoderStateCallbacks,
+  getRawChangesCallback,
+  MapSchema,
+  Metadata,
+  OPERATION,
+  Reflection,
+  ReflectionField,
+  ReflectionType,
+  registerType,
+  Schema,
+  SetSchema,
+  StateCallbackStrategy,
+  StateView,
+  schema,
+  TypeContext,
+  type,
+  view,
+} from './schema';
+export { createWebRTCDataChannelPacketChannel, WebRTCDataChannelPacketChannel } from './webrtc';
+export { createWebSocketPacketChannel, WebSocketPacketChannel } from './websocket';

package/src/loopback.ts

@@ -0,0 +1,65 @@
+import type { PacketChannel } from './channels';
+import type { Envelope } from './protocol';
+
+type EnvelopeHandler = (envelope: Envelope) => void;
+type CloseHandler = (reason?: string) => void;
+
+class LoopbackPacketChannel implements PacketChannel {
+  readonly mode = 'loopback' as const;
+  private peer: LoopbackPacketChannel | null = null;
+  private closed = false;
+  private readonly envelopeHandlers = new Set<EnvelopeHandler>();
+  private readonly closeHandlers = new Set<CloseHandler>();
+
+  constructor(readonly peerId: string) {}
+
+  link(peer: LoopbackPacketChannel): void {
+    this.peer = peer;
+  }
+
+  send(envelope: Envelope): void {
+    if (this.closed) throw new Error(`Loopback channel ${this.peerId} is closed`);
+    if (!this.peer || this.peer.closed)
+      throw new Error(`Loopback peer for ${this.peerId} is closed`);
+    queueMicrotask(() => this.peer?.emitEnvelope(envelope));
+  }
+
+  onEnvelope(handler: EnvelopeHandler): () => void {
+    this.envelopeHandlers.add(handler);
+    return () => this.envelopeHandlers.delete(handler);
+  }
+
+  onClose(handler: CloseHandler): () => void {
+    this.closeHandlers.add(handler);
+    return () => this.closeHandlers.delete(handler);
+  }
+
+  close(reason?: string): void {
+    if (this.closed) return;
+    this.closed = true;
+    this.emitClose(reason);
+    const peer = this.peer;
+    this.peer = null;
+    peer?.close(reason);
+  }
+
+  private emitEnvelope(envelope: Envelope): void {
+    if (this.closed) return;
+    for (const handler of this.envelopeHandlers) handler(envelope);
+  }
+
+  private emitClose(reason?: string): void {
+    for (const handler of this.closeHandlers) handler(reason);
+  }
+}
+
+export function createLoopbackPair(
+  aPeerId = 'loopback-a',
+  bPeerId = 'loopback-b',
+): readonly [PacketChannel, PacketChannel] {
+  const a = new LoopbackPacketChannel(aPeerId);
+  const b = new LoopbackPacketChannel(bPeerId);
+  a.link(b);
+  b.link(a);
+  return [a, b];
+}

package/src/node-websocket.ts

@@ -0,0 +1,77 @@
+import type { AddressInfo } from 'node:net';
+import { WebSocket, WebSocketServer } from 'ws';
+import type { PacketChannel } from './channels';
+import type { Envelope } from './protocol';
+import { type RoomClass, UniversalRoomRuntime } from './runtime';
+
+type EnvelopeHandler = (envelope: Envelope) => void;
+type CloseHandler = (reason?: string) => void;
+
+export class NodeWebSocketPacketChannel implements PacketChannel {
+  readonly mode = 'websocket' as const;
+  private readonly envelopeHandlers = new Set<EnvelopeHandler>();
+  private readonly closeHandlers = new Set<CloseHandler>();
+
+  constructor(
+    readonly peerId: string,
+    private readonly socket: WebSocket,
+  ) {
+    socket.on('message', (data) => {
+      const raw = typeof data === 'string' ? data : data.toString();
+      const envelope = JSON.parse(raw) as Envelope;
+      for (const handler of this.envelopeHandlers) handler(envelope);
+    });
+    socket.on('close', (_code, reason) => {
+      const text = reason.length > 0 ? reason.toString() : undefined;
+      for (const handler of this.closeHandlers) handler(text);
+    });
+  }
+
+  send(envelope: Envelope): void {
+    if (this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error(`Node WebSocket for ${this.peerId} is not open`);
+    }
+    this.socket.send(JSON.stringify(envelope));
+  }
+
+  onEnvelope(handler: EnvelopeHandler): () => void {
+    this.envelopeHandlers.add(handler);
+    return () => this.envelopeHandlers.delete(handler);
+  }
+
+  onClose(handler: CloseHandler): () => void {
+    this.closeHandlers.add(handler);
+    return () => this.closeHandlers.delete(handler);
+  }
+
+  close(reason?: string): void {
+    this.socket.close(1000, reason);
+  }
+}
+
+export interface UniversalNodeServer {
+  readonly url: string;
+  close(): Promise<void>;
+}
+
+export async function startUniversalNodeServer(
+  roomName: string,
+  roomClass: RoomClass,
+  port = 0,
+): Promise<UniversalNodeServer> {
+  const runtime = new UniversalRoomRuntime(roomClass, roomName);
+  const server = new WebSocketServer({ port });
+  let nextPeerId = 1;
+
+  server.on('connection', (socket) => {
+    runtime.attach(new NodeWebSocketPacketChannel(`client-${nextPeerId++}`, socket));
+  });
+
+  await new Promise<void>((resolve) => server.once('listening', resolve));
+  const address = server.address() as AddressInfo;
+  return {
+    url: `ws://127.0.0.1:${address.port}`,
+    close: () =>
+      new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve()))),
+  };
+}