@vgai/p2p-colyseus 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Volter AI, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,125 @@
+# @vgai/p2p-colyseus
+
+Colyseus-compatible runtime pieces for running the same multiplayer room/client source in real Colyseus, loopback tests, universal Node WebSocket mode, browser-hosted P2P over WebRTC, and Cloudflare relay fallback.
+
+The core contract is strict: gameplay code should be authored like normal Colyseus code. Runtime selection belongs in config, build aliases, launch URLs, or test harnesses.
+
+## Authoring Contract
+
+Game code may use ordinary Colyseus-style imports:
+
+```ts
+import { Client, Callbacks } from '@colyseus/sdk';
+import { Schema, MapSchema, type } from '@colyseus/schema';
+import { Room } from 'colyseus';
+```
+
+Game code should not import WebRTC, Cloudflare signaling, relay fallback, `@vgai/p2p-colyseus`, or engine transport selection APIs. If the source has to branch for real Colyseus vs P2P, the compatibility package or launch layer is incomplete.
+
+## Runtime Modes
+
+- Real Colyseus: normal Colyseus packages and a real Colyseus server.
+- Loopback: `loopback://` client plus registered room classes for tests.
+- Universal Node WebSocket: no Colyseus server dependency, but WebSocket transport.
+- P2P host: browser creates the authoritative room and accepts clients.
+- P2P join: browser joins a host-created room by `roomId`.
+- Relay fallback: Cloudflare signaling/relay carries packets when direct WebRTC is unavailable or forced.
+
+## Browser Client Configuration
+
+Configure P2P outside gameplay code:
+
+```ts
+import { configureP2PColyseusClient } from '@vgai/p2p-colyseus/browser';
+import { TankRoom } from './server/rooms/tank-room';
+
+configureP2PColyseusClient({
+  mode: {
+    kind: 'p2p-host',
+    signalingUrl: 'https://vgai-p2p-colyseus.example.workers.dev',
+    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+  },
+  rooms: {
+    tank_room: TankRoom,
+  },
+});
+```
+
+Joining an existing host:
+
+```ts
+configureP2PColyseusClient({
+  mode: {
+    kind: 'p2p-join',
+    signalingUrl: 'https://vgai-p2p-colyseus.example.workers.dev',
+    roomId,
+    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+  },
+});
+```
+
+For proofing relay mode:
+
+```ts
+configureP2PColyseusClient({
+  mode: {
+    kind: 'p2p-join',
+    signalingUrl,
+    roomId,
+    iceServers: [],
+    forceRelay: true,
+  },
+});
+```
+
+## Cloudflare Worker
+
+The Worker entrypoint is exported at:
+
+```ts
+@vgai/p2p-colyseus/cloudflare/worker
+```
+
+Local commands:
+
+```bash
+npm --workspace @vgai/p2p-colyseus run typecheck
+npm --workspace @vgai/p2p-colyseus run test
+npm --workspace @vgai/p2p-colyseus run wrangler:dry-run
+npm --workspace @vgai/p2p-colyseus run wrangler:dev
+npm --workspace @vgai/p2p-colyseus run wrangler:deploy
+```
+
+Deployment config lives in `wrangler.toml`.
+
+## Cloudflare Env Vars
+
+- `P2P_COLYSEUS_RELAY_DISABLED`: set to `true` to reject relay service traffic.
+- `P2P_COLYSEUS_RELAY_DAILY_BUDGET_USD`: budget input used to derive the global relay byte cap.
+- `P2P_COLYSEUS_RELAY_ESTIMATED_USD_PER_GIB`: egress estimate used with the budget.
+- `P2P_COLYSEUS_RELAY_MAX_GLOBAL_BYTES_PER_DAY`: explicit byte cap override.
+- `P2P_COLYSEUS_MAX_REQUEST_BODY_BYTES`: maximum HTTP POST body size.
+- `P2P_COLYSEUS_MAX_GLOBAL_REQUESTS_PER_DAY`: global daily Worker request cap.
+- `P2P_COLYSEUS_MAX_GLOBAL_WEBSOCKET_MESSAGES_PER_DAY`: global daily WebSocket relay message cap.
+- `P2P_COLYSEUS_MAX_ACTIVE_RELAY_SOCKETS`: active relay WebSocket cap.
+- `P2P_COLYSEUS_ALLOWED_ORIGINS`: optional comma-separated CORS/origin allowlist. Unset means all origins are allowed.
+
+## Proof Command
+
+From the repo root:
+
+```bash
+npm run typecheck && npm run test:p2p-colyseus-proof
+```
+
+The proof deploys the Worker, runs package tests, executes live relay checks, records browser gameplay videos, summarizes artifacts, and validates all required proof rows. Artifact details are documented in `docs/P2P-COLYSEUS-PROOF-ARTIFACTS.md`.
+
+## Known Scope Boundaries
+
+- The workspace package is ESM-only (`"type": "module"`). CJS package output is not currently produced.
+- This is not a full Colyseus Cloud replacement.
+- Redis-backed presence/driver behavior is represented by local compatibility shims unless a proof explicitly covers distributed behavior.
+- Host migration is not implemented.
+- Direct WebRTC is proven in Chromium proof contexts; wider browser/NAT coverage is tracked in `docs/P2P-COLYSEUS-REMAINING-CHECKLIST.md`.
+
+Current product/security decisions are tracked in `docs/P2P-COLYSEUS-DECISIONS.md`.

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@vgai/p2p-colyseus",
+  "author": "Volter AI, Inc.",
+  "license": "Apache-2.0",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Colyseus-compatible transport for vgai — real Colyseus, loopback, WebRTC, or relay, chosen at runtime.",
+  "homepage": "https://github.com/volter-ai/vgai-engine#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/volter-ai/vgai-engine.git",
+    "directory": "packages/p2p-colyseus"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": ["src"],
+  "exports": {
+    ".": "./src/index.ts",
+    "./engine": "./src/engine.ts",
+    "./schema": "./src/schema.ts",
+    "./codec": "./src/codec.ts",
+    "./client": "./src/client.ts",
+    "./browser": "./src/browser.ts",
+    "./server": "./src/room.ts",
+    "./platform": "./src/platform.ts",
+    "./cloudflare/worker": "./src/cloudflare/worker.ts"
+  },
+  "scripts": {
+    "build": "cd ../.. && npx tsx scripts/check-p2p-package-build.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run test/**/*.test.ts",
+    "wrangler:dry-run": "wrangler deploy --dry-run --config wrangler.toml",
+    "wrangler:dev": "wrangler dev --config wrangler.toml",
+    "wrangler:deploy": "wrangler deploy --config wrangler.toml"
+  },
+  "dependencies": {
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@colyseus/sdk": "^0.17.34",
+    "@colyseus/schema": "^4.0.14",
+    "@colyseus/ws-transport": "^0.17.9",
+    "@types/node": "^25.3.0",
+    "@types/ws": "^8.5.13",
+    "colyseus": "^0.17.8",
+    "typescript": "^5.6.0",
+    "vitest": "^3.2.6",
+    "wrangler": "^4.106.0"
+  }
+}

package/src/access-token.ts

@@ -0,0 +1,74 @@
+export interface P2PAccessTokenClaims {
+  readonly roomName: string;
+  readonly peerId?: string | undefined;
+  readonly expiresAt: number;
+}
+
+export async function createP2PAccessToken(
+  secret: string,
+  claims: P2PAccessTokenClaims,
+): Promise<string> {
+  const payload = encodeBase64Url(JSON.stringify(claims));
+  const signature = await sign(secret, payload);
+  return `${payload}.${signature}`;
+}
+
+export async function verifyP2PAccessToken(
+  secret: string,
+  token: string,
+  expected: { roomName: string; peerId?: string | undefined },
+  now = Date.now(),
+): Promise<boolean> {
+  const [payload, signature, extra] = token.split('.');
+  if (!payload || !signature || extra !== undefined) return false;
+  const expectedSignature = await sign(secret, payload);
+  if (!constantTimeEqual(signature, expectedSignature)) return false;
+
+  let claims: P2PAccessTokenClaims;
+  try {
+    claims = JSON.parse(decodeBase64Url(payload)) as P2PAccessTokenClaims;
+  } catch {
+    return false;
+  }
+
+  if (claims.roomName !== expected.roomName) return false;
+  if (expected.peerId && claims.peerId && claims.peerId !== expected.peerId) return false;
+  return Number.isFinite(claims.expiresAt) && claims.expiresAt > now;
+}
+
+async function sign(secret: string, payload: string): Promise<string> {
+  const key = await crypto.subtle.importKey(
+    'raw',
+    new TextEncoder().encode(secret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign'],
+  );
+  const signature = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(payload));
+  return encodeBase64Url(new Uint8Array(signature));
+}
+
+function encodeBase64Url(value: string | Uint8Array): string {
+  const bytes = typeof value === 'string' ? new TextEncoder().encode(value) : value;
+  let binary = '';
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
+}
+
+function decodeBase64Url(value: string): string {
+  const padded = value
+    .replaceAll('-', '+')
+    .replaceAll('_', '/')
+    .padEnd(Math.ceil(value.length / 4) * 4, '=');
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return new TextDecoder().decode(bytes);
+}
+
+function constantTimeEqual(a: string, b: string): boolean {
+  if (a.length !== b.length) return false;
+  let result = 0;
+  for (let i = 0; i < a.length; i++) result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return result === 0;
+}

package/src/browser.ts

@@ -0,0 +1,202 @@
+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 type {
+  EngineNetBackend,
+  EngineNetConnectOptions,
+  EngineNetTransport,
+  EngineStateReplication,
+  P2PColyseusBackendOptions,
+  P2PColyseusMode,
+} from './engine';
+export { createP2PColyseusBackend } from './engine';
+export { createLoopbackPair } from './loopback';
+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';

package/src/callbacks.ts

@@ -0,0 +1,7 @@
+import type { CompatRoom } from './client';
+
+export const Callbacks = {
+  get(room: CompatRoom): CompatRoom['replication'] {
+    return room.replication;
+  },
+};

package/src/channels.ts

@@ -0,0 +1,12 @@
+import type { Envelope } from './protocol';
+
+export type PacketChannelMode = 'loopback' | 'websocket' | 'webrtc' | 'relay' | 'colyseus';
+
+export interface PacketChannel {
+  readonly peerId: string;
+  readonly mode: PacketChannelMode;
+  send(envelope: Envelope): void;
+  onEnvelope(handler: (envelope: Envelope) => void): () => void;
+  onClose(handler: (reason?: string) => void): () => void;
+  close(reason?: string): void;
+}