@vgai/p2p-colyseus 0.1.0

package/src/runtime.ts

@@ -0,0 +1,371 @@
+import type { PacketChannel } from './channels';
+import { clone, createStatePatch, encodeSnapshot } from './codec';
+import type { Envelope, Snapshot } from './protocol';
+import { P2P_CLOSE_CODES } from './protocol';
+import type { BroadcastOptions, CompatClient, Room } from './room';
+
+export type RoomClass<T extends Room = Room> = new () => T;
+
+interface RuntimeClient extends CompatClient {
+  readonly channel: PacketChannel;
+  lastState: unknown;
+}
+
+interface PendingReconnection {
+  readonly previousClient: RuntimeClient;
+  readonly deferred: ReconnectionDeferred;
+  readonly timer?: ReturnType<typeof setTimeout>;
+}
+
+export class UniversalRoomRuntime<T extends Room = Room> {
+  readonly room: T;
+  private clock = 0;
+  private readonly clients = new Map<string, RuntimeClient>();
+  private readonly reconnections = new Map<string, PendingReconnection>();
+
+  constructor(
+    roomClass: RoomClass<T>,
+    private readonly roomName: string,
+    options?: unknown,
+  ) {
+    this.room = new roomClass();
+    this.room._attachRuntime({
+      broadcastMessage: (type, payload, options) => this.broadcastMessage(type, payload, options),
+      broadcastState: () => this.broadcastState(),
+      disconnect: (code) => this.disconnect(code),
+      send: (client, type, payload) => this.sendToClient(client, type, payload),
+      removeClient: (client, code, reason) =>
+        this.removeClient(client as RuntimeClient, true, code, reason),
+      allowReconnection: (client, seconds) =>
+        this.allowReconnection(client as RuntimeClient, seconds),
+    });
+    this.room.onCreate?.(options);
+  }
+
+  attach(channel: PacketChannel): void {
+    channel.onEnvelope((envelope) => this.handleEnvelope(channel, envelope));
+    channel.onClose(() => this.removeByChannel(channel, true));
+  }
+
+  private handleEnvelope(channel: PacketChannel, envelope: Envelope): void {
+    if (envelope.kind === 'ping') {
+      channel.send({ kind: 'pong', t: envelope.t });
+      return;
+    }
+
+    if (envelope.kind === 'join') {
+      if (envelope.room !== this.roomName) {
+        channel.send({
+          kind: 'join-error',
+          requestId: envelope.requestId,
+          message: `Room not found: ${envelope.room}`,
+        });
+        closeAfterSend(channel, String(P2P_CLOSE_CODES.roomNotFound));
+        return;
+      }
+      void this.join(channel, envelope.requestId, envelope.options);
+      return;
+    }
+
+    const client = this.findByChannel(channel);
+    if (!client) return;
+
+    if (envelope.kind === 'message') {
+      try {
+        this.room._dispatchMessage(client, envelope.type, envelope.payload);
+      } catch (error) {
+        channel.send({
+          kind: 'message',
+          type: 'error',
+          payload: {
+            code: P2P_CLOSE_CODES.internalError,
+            message: error instanceof Error ? error.message : 'server error',
+          },
+        });
+      }
+    } else if (envelope.kind === 'leave') {
+      this.removeClient(client, true);
+    } else if (envelope.kind === 'state-resync') {
+      this.sendSnapshot(client);
+    }
+  }
+
+  private async join(channel: PacketChannel, requestId: string, options?: unknown): Promise<void> {
+    if (this.room.locked) {
+      channel.send({
+        kind: 'join-error',
+        requestId,
+        message: String(P2P_CLOSE_CODES.roomFull),
+      });
+      closeAfterSend(channel, String(P2P_CLOSE_CODES.roomFull));
+      return;
+    }
+
+    const reconnectionToken = getReconnectionToken(options);
+    const pendingReconnection = reconnectionToken
+      ? this.reconnections.get(reconnectionToken)
+      : undefined;
+
+    const sessionId = pendingReconnection?.previousClient.sessionId ?? channel.peerId;
+    const events = new MiniEmitter();
+    const client: RuntimeClient = {
+      id: sessionId,
+      sessionId,
+      state: 1,
+      reconnectionToken: pendingReconnection?.previousClient.reconnectionToken ?? sessionId,
+      ref: events,
+      channel,
+      lastState: undefined,
+      raw: (data, _options, cb) => {
+        channel.send({ kind: 'message', type: 'raw', payload: data });
+        cb?.();
+      },
+      enqueueRaw: (data) => channel.send({ kind: 'message', type: 'raw', payload: data }),
+      send: (type, payload) => channel.send({ kind: 'message', type: String(type), payload }),
+      sendBytes: (type, bytes) =>
+        channel.send({ kind: 'message', type: String(type), payload: bytes }),
+      leave: (code, data) => this.removeClient(client, true, code, data),
+      close: (code, data) => this.removeClient(client, true, code, data),
+      error: (code, message) =>
+        channel.send({ kind: 'message', type: 'error', payload: { code, message } }),
+    };
+    try {
+      const authResult = await this.room.onAuth?.(client, options);
+      if (authResult === false) {
+        channel.send({
+          kind: 'join-error',
+          requestId,
+          message: String(P2P_CLOSE_CODES.unauthorized),
+        });
+        closeAfterSend(channel, String(P2P_CLOSE_CODES.unauthorized));
+        return;
+      }
+      client.auth = authResult;
+    } catch (error) {
+      channel.send({
+        kind: 'join-error',
+        requestId,
+        message: error instanceof Error ? error.message : String(P2P_CLOSE_CODES.unauthorized),
+      });
+      closeAfterSend(channel, String(P2P_CLOSE_CODES.unauthorized));
+      return;
+    }
+    if (pendingReconnection) {
+      if (pendingReconnection.timer) clearTimeout(pendingReconnection.timer);
+      this.reconnections.delete(reconnectionToken!);
+    }
+    if (!pendingReconnection && this.room.locked) {
+      channel.send({
+        kind: 'join-error',
+        requestId,
+        message: String(P2P_CLOSE_CODES.roomFull),
+      });
+      closeAfterSend(channel, String(P2P_CLOSE_CODES.roomFull));
+      return;
+    }
+    this.clients.set(sessionId, client);
+    this.room.clients.push(client);
+    if (pendingReconnection) {
+      this.room.onReconnect?.(client);
+      pendingReconnection.deferred.resolve(client);
+    } else {
+      this.room.onJoin?.(client, options);
+    }
+    const snapshot = this.createSnapshot();
+    client.lastState = clone(snapshot.state);
+    channel.send({
+      kind: 'join-ok',
+      requestId,
+      sessionId,
+      snapshot,
+      clock: ++this.clock,
+    });
+    this.broadcastState();
+  }
+
+  private removeByChannel(channel: PacketChannel, consented: boolean): void {
+    const client = this.findByChannel(channel);
+    if (client) this.removeClient(client, consented);
+  }
+
+  private removeClient(
+    client: RuntimeClient,
+    consented: boolean,
+    code = 1000,
+    reason?: string,
+  ): void {
+    if (!this.clients.delete(client.sessionId)) return;
+    client.state = 5;
+    this.room.clients.delete(client);
+    if (!consented) this.room.onDrop?.(client, code);
+    this.room.onLeave?.(client, code);
+    client.channel.send(
+      reason === undefined ? { kind: 'leave', code } : { kind: 'leave', code, reason },
+    );
+    closeAfterSend(client.channel, reason ?? 'left');
+    this.broadcastState();
+    this.disposeIfIdle();
+  }
+
+  private findByChannel(channel: PacketChannel): RuntimeClient | undefined {
+    for (const client of this.clients.values()) {
+      if (client.channel === channel) return client;
+    }
+    return undefined;
+  }
+
+  private sendToClient(client: CompatClient, type: string | number, payload?: unknown): void {
+    const runtimeClient = this.clients.get(client.sessionId);
+    runtimeClient?.channel.send({ kind: 'message', type: String(type), payload });
+  }
+
+  private broadcastMessage(
+    type: string | number,
+    payload?: unknown,
+    options?: BroadcastOptions,
+  ): void {
+    const except = new Set(
+      Array.isArray(options?.except)
+        ? options.except.map((client) => client.sessionId)
+        : options?.except
+          ? [options.except.sessionId]
+          : [],
+    );
+    for (const client of this.clients.values()) {
+      if (!except.has(client.sessionId))
+        client.channel.send({ kind: 'message', type: String(type), payload });
+    }
+  }
+
+  broadcastState(): boolean {
+    const snapshot = this.createSnapshot();
+    let clock: number | undefined;
+    let sent = false;
+    for (const client of this.clients.values()) {
+      const patch = createStatePatch(client.lastState, snapshot.state);
+      if (patch.operations.length === 0) continue;
+      clock ??= ++this.clock;
+      client.lastState = clone(snapshot.state);
+      client.channel.send({ kind: 'state-patch', patch, clock });
+      sent = true;
+    }
+    return sent;
+  }
+
+  private async disconnect(code = 4000): Promise<void> {
+    for (const client of [...this.clients.values()])
+      this.removeClient(client, true, code, 'disconnect');
+  }
+
+  private allowReconnection(
+    client: RuntimeClient,
+    seconds: number | 'manual',
+  ): ReconnectionDeferred {
+    const token = client.reconnectionToken;
+    const existing = this.reconnections.get(token);
+    if (existing?.timer) clearTimeout(existing.timer);
+    const deferred = new ReconnectionDeferred();
+    const timer =
+      seconds === 'manual'
+        ? undefined
+        : setTimeout(
+            () => {
+              this.reconnections.delete(token);
+              deferred.reject(new Error('reconnection timeout'));
+              this.disposeIfIdle();
+            },
+            Math.max(0, seconds * 1000),
+          );
+    if (timer) (timer as unknown as { unref?: () => void }).unref?.();
+    this.reconnections.set(token, {
+      previousClient: client,
+      deferred,
+      ...(timer ? { timer } : {}),
+    });
+    return deferred;
+  }
+
+  private disposeIfIdle(): void {
+    if (this.clients.size === 0 && this.reconnections.size === 0 && this.room.autoDispose) {
+      this.room.onDispose?.();
+      this.room._disposeRuntime();
+    }
+  }
+
+  private sendSnapshot(client: RuntimeClient): void {
+    const snapshot = this.createSnapshot();
+    client.lastState = clone(snapshot.state);
+    client.channel.send({ kind: 'state-snapshot', snapshot, clock: ++this.clock });
+  }
+
+  private createSnapshot(): Snapshot {
+    return { type: 'snapshot', state: encodeSnapshot(this.room._snapshot()) };
+  }
+}
+
+class MiniEmitter {
+  private readonly handlers = new Map<string, Set<(...args: unknown[]) => void>>();
+
+  on(event: string, handler: (...args: unknown[]) => void): void {
+    let eventHandlers = this.handlers.get(event);
+    if (!eventHandlers) {
+      eventHandlers = new Set();
+      this.handlers.set(event, eventHandlers);
+    }
+    eventHandlers.add(handler);
+  }
+
+  off(event: string, handler: (...args: unknown[]) => void): void {
+    this.handlers.get(event)?.delete(handler);
+  }
+
+  emit(event: string, ...args: unknown[]): void {
+    for (const handler of this.handlers.get(event) ?? []) handler(...args);
+  }
+}
+
+class ReconnectionDeferred implements Promise<CompatClient> {
+  readonly [Symbol.toStringTag] = 'Promise';
+  private resolvePromise!: (client: CompatClient) => void;
+  private rejectPromise!: (reason?: unknown) => void;
+  private readonly promise = new Promise<CompatClient>((resolve, reject) => {
+    this.resolvePromise = resolve;
+    this.rejectPromise = reject;
+  });
+
+  resolve(client: CompatClient): void {
+    this.resolvePromise(client);
+  }
+
+  reject(reason?: unknown): void {
+    this.rejectPromise(reason);
+  }
+
+  // biome-ignore lint/suspicious/noThenProperty: allowReconnection returns a Promise-compatible thenable in Colyseus.
+  then<TResult1 = CompatClient, TResult2 = never>(
+    onfulfilled?: ((value: CompatClient) => 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<CompatClient | TResult> {
+    return this.promise.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null): Promise<CompatClient> {
+    return this.promise.finally(onfinally);
+  }
+}
+
+function getReconnectionToken(options: unknown): string | undefined {
+  if (typeof options !== 'object' || options === null) return undefined;
+  const token = (options as { reconnectionToken?: unknown }).reconnectionToken;
+  return typeof token === 'string' ? token : undefined;
+}
+
+function closeAfterSend(channel: PacketChannel, reason: string): void {
+  queueMicrotask(() => channel.close(reason));
+}

package/src/schema.ts

@@ -0,0 +1,287 @@
+const SCHEMA_TYPES = Symbol('p2pColyseusSchemaTypes');
+
+export const $refId = '~refId';
+export const $track = '~track';
+export const $encoder = '~encoder';
+export const $decoder = '~decoder';
+export const $filter = '~filter';
+export const $getByIndex = '~getByIndex';
+export const $deleteByIndex = '~deleteByIndex';
+export const $changes = '~changes';
+export const $childType = '~childType';
+
+export const OPERATION = {
+  ADD: 128,
+  REPLACE: 0,
+  DELETE: 64,
+  DELETE_AND_MOVE: 96,
+  MOVE_AND_ADD: 160,
+  DELETE_AND_ADD: 192,
+  CLEAR: 10,
+  REVERSE: 15,
+  MOVE: 32,
+  DELETE_BY_REFID: 33,
+  ADD_BY_REFID: 129,
+} as const;
+
+export class Schema {
+  constructor(props?: Record<string, unknown>) {
+    if (props) this.assign(props as Partial<this>);
+  }
+
+  static getSchemaTypes(): ReadonlyMap<string, unknown> {
+    const combined = new Map<string, unknown>();
+    // biome-ignore lint/complexity/noThisInStatic: schema metadata must be read from the concrete subclass.
+    const parent = Object.getPrototypeOf(this) as {
+      getSchemaTypes?: () => ReadonlyMap<string, unknown>;
+    } | null;
+    if (parent && parent !== Schema && parent.getSchemaTypes) {
+      for (const [key, value] of parent.getSchemaTypes()) combined.set(key, value);
+    }
+    // biome-ignore lint/complexity/noThisInStatic: schema metadata must be read from the concrete subclass.
+    const own = (this as unknown as { [SCHEMA_TYPES]?: Map<string, unknown> })[SCHEMA_TYPES];
+    for (const [key, value] of own ?? []) combined.set(key, value);
+    return combined;
+  }
+
+  static is(type: unknown): boolean {
+    return typeof type === 'function' && (type === Schema || type.prototype instanceof Schema);
+  }
+
+  static isSchema(obj: unknown): obj is Schema {
+    return obj instanceof Schema;
+  }
+
+  assign<T extends Partial<this>>(props: T): this {
+    Object.assign(this, props);
+    return this;
+  }
+
+  restore(jsonData: Record<string, unknown>): this {
+    Object.assign(this, jsonData);
+    return this;
+  }
+
+  setDirty(_property?: string | number | symbol, _operation?: unknown): void {
+    // This shim snapshots mutable state each tick, so explicit dirty marking is unnecessary.
+  }
+
+  clone(): this {
+    const cloned = new (this.constructor as new () => this)();
+    return cloned.restore(deepClone(this.toJSON() as Record<string, unknown>));
+  }
+
+  toJSON(): unknown {
+    return encodeSnapshotState(this);
+  }
+
+  discardAllChanges(): void {
+    // Compatibility no-op. Change tracking is handled by snapshot diffing.
+  }
+}
+
+export class MapSchema<T> extends Map<string, T> {
+  constructor(entries?: Iterable<readonly [string, T]> | null) {
+    super(entries);
+  }
+}
+
+export class ArraySchema<T> extends Array<T> {
+  constructor(...items: T[]) {
+    super(...items);
+  }
+}
+
+export class CollectionSchema<T> extends Set<T> {
+  constructor(values?: Iterable<T> | null) {
+    super(values);
+  }
+}
+
+export class SetSchema<T> extends Set<T> {
+  constructor(values?: Iterable<T> | null) {
+    super(values);
+  }
+}
+
+export function type(_kind: unknown): PropertyDecorator {
+  return (target, propertyKey) => {
+    const ctor = target.constructor as unknown as { [SCHEMA_TYPES]?: Map<string, unknown> };
+    ctor[SCHEMA_TYPES] ??= new Map();
+    ctor[SCHEMA_TYPES].set(String(propertyKey), _kind);
+  };
+}
+
+export const schema = type;
+export const view = type;
+export const entity = type;
+export const deprecated = type;
+
+export function defineTypes<T extends typeof Schema>(
+  target: T,
+  fields: Record<string, unknown>,
+): T {
+  const ctor = target as unknown as { [SCHEMA_TYPES]?: Map<string, unknown> };
+  ctor[SCHEMA_TYPES] ??= new Map();
+  for (const [key, value] of Object.entries(fields)) ctor[SCHEMA_TYPES].set(key, value);
+  return target;
+}
+
+export function defineCustomTypes<T extends Record<string, unknown>>(types: T): T {
+  return types;
+}
+
+export function registerType(): void {
+  // Custom binary type registration is not needed by the JSON snapshot codec.
+}
+
+export function dumpChanges(value: unknown): unknown {
+  return encodeSnapshotState(value);
+}
+
+export const encode = {
+  number(value: number): number {
+    return value;
+  },
+  string(value: string): string {
+    return value;
+  },
+  boolean(value: boolean): boolean {
+    return value;
+  },
+};
+
+export const decode = {
+  number(value: number): number {
+    return value;
+  },
+  string(value: string): string {
+    return value;
+  },
+  boolean(value: boolean): boolean {
+    return value;
+  },
+};
+
+export class Encoder<T = unknown> {
+  constructor(public state?: T) {}
+
+  encode(): Uint8Array {
+    return new TextEncoder().encode(JSON.stringify(encodeSnapshotState(this.state)));
+  }
+
+  encodeAll(): Uint8Array {
+    return this.encode();
+  }
+
+  discardChanges(): void {}
+}
+
+export class Decoder<T = unknown> {
+  state: T | undefined;
+
+  decode(bytes: Uint8Array): T | undefined {
+    const text = new TextDecoder().decode(bytes);
+    this.state = text ? (JSON.parse(text) as T) : undefined;
+    return this.state;
+  }
+}
+
+export class StateView {
+  readonly items = new Set<unknown>();
+
+  add(item: unknown): void {
+    this.items.add(item);
+  }
+
+  remove(item: unknown): void {
+    this.items.delete(item);
+  }
+
+  has(item: unknown): boolean {
+    return this.items.has(item);
+  }
+}
+
+export class Reflection {}
+export class ReflectionType extends Schema {}
+export class ReflectionField extends Schema {}
+export class Metadata {}
+export class TypeContext {}
+export class ChangeTree {}
+
+export class Callbacks {
+  static get(state: unknown): unknown {
+    return state;
+  }
+}
+
+export const StateCallbackStrategy = {};
+
+export function getDecoderStateCallbacks(state: unknown): unknown {
+  return state;
+}
+
+export function getRawChangesCallback(
+  callback: (...args: unknown[]) => void,
+): (...args: unknown[]) => void {
+  return callback;
+}
+
+export function encodeSchemaOperation(value: unknown): unknown {
+  return value;
+}
+
+export function encodeArray(value: unknown): unknown {
+  return value;
+}
+
+export function encodeKeyValueOperation(value: unknown): unknown {
+  return value;
+}
+
+export function decodeSchemaOperation(value: unknown): unknown {
+  return value;
+}
+
+export function decodeKeyValueOperation(value: unknown): unknown {
+  return value;
+}
+
+export function encodeSnapshotState(value: unknown): unknown {
+  if (value instanceof ArraySchema || Array.isArray(value)) {
+    return value.map((item) => encodeSnapshotState(item));
+  }
+
+  if (value instanceof CollectionSchema || value instanceof SetSchema || value instanceof Set) {
+    return [...value.values()].map((item) => encodeSnapshotState(item));
+  }
+
+  if (value instanceof MapSchema || value instanceof Map) {
+    const out: Record<string, unknown> = {};
+    for (const [key, item] of value.entries()) out[String(key)] = encodeSnapshotState(item);
+    return out;
+  }
+
+  if (value instanceof Schema || isPlainObject(value)) {
+    const out: Record<string, unknown> = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (typeof item === 'function') continue;
+      out[key] = encodeSnapshotState(item);
+    }
+    return out;
+  }
+
+  return value;
+}
+
+function deepClone<T>(value: T): T {
+  if (typeof structuredClone === 'function') return structuredClone(value);
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return (
+    typeof value === 'object' && value !== null && Object.getPrototypeOf(value) === Object.prototype
+  );
+}