crossws 0.3.5 → 0.4.1

package/adapters/bun.d.ts

@@ -1,2 +1,2 @@
-export * from "../dist/adapters/bun";
-export { default } from "../dist/adapters/bun";
+export * from "../dist/adapters/bun.mjs";
+export { default } from "../dist/adapters/bun.mjs";

package/adapters/cloudflare.d.ts

@@ -1,2 +1,2 @@
-export * from "../dist/adapters/cloudflare";
-export { default } from "../dist/adapters/cloudflare";
+export * from "../dist/adapters/cloudflare.mjs";
+export { default } from "../dist/adapters/cloudflare.mjs";

package/adapters/deno.d.ts

@@ -1,2 +1,2 @@
-export * from "../dist/adapters/deno";
-export { default } from "../dist/adapters/deno";
+export * from "../dist/adapters/deno.mjs";
+export { default } from "../dist/adapters/deno.mjs";

package/adapters/node.d.ts

@@ -1,2 +1,2 @@
-export * from "../dist/adapters/node";
-export { default } from "../dist/adapters/node";
+export * from "../dist/adapters/node.mjs";
+export { default } from "../dist/adapters/node.mjs";

package/adapters/sse.d.ts

@@ -1,2 +1,2 @@
-export * from "../dist/adapters/sse";
-export { default } from "../dist/adapters/sse";
+export * from "../dist/adapters/sse.mjs";
+export { default } from "../dist/adapters/sse.mjs";

package/adapters/uws.d.ts

@@ -1,2 +1,2 @@
-export * from "../dist/adapters/uws";
-export { default } from "../dist/adapters/uws";
+export * from "../dist/adapters/uws.mjs";
+export { default } from "../dist/adapters/uws.mjs";

package/dist/adapters/bun.d.mts

@@ -1,5 +1,5 @@
 import { WebSocketHandler, ServerWebSocket, Server } from 'bun';
-import { Adapter, AdapterInstance, Peer, AdapterOptions } from '../index.mjs';
+import { Adapter, AdapterInstance, Peer, PeerContext, AdapterOptions } from '../index.mjs';
 import '../shared/crossws.BQXMA5bH.mjs';
 
 interface BunAdapter extends AdapterInstance {
@@ -10,19 +10,21 @@ interface BunOptions extends AdapterOptions {
 }
 type ContextData = {
     peer?: BunPeer;
+    namespace: string;
     request: Request;
     server?: Server;
-    context: Peer["context"];
+    context: PeerContext;
 };
 declare const bunAdapter: Adapter<BunAdapter, BunOptions>;
 
 declare class BunPeer extends Peer<{
     ws: ServerWebSocket<ContextData>;
+    namespace: string;
     request: Request;
     peers: Set<BunPeer>;
 }> {
     get remoteAddress(): string;
-    get context(): Peer["context"];
+    get context(): PeerContext;
     send(data: unknown, options?: {
         compress?: boolean;
     }): number;

package/dist/adapters/bun.mjs

@@ -1,14 +1,18 @@
-import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
-import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
-import 'uncrypto';
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.WpyOHUXc.mjs';
+import { a as adapterUtils, g as getPeers, A as AdapterHookable } from '../shared/crossws.CPlNx7g8.mjs';
 
 const bunAdapter = (options = {}) => {
+  if (typeof Bun === "undefined") {
+    throw new Error(
+      "[crossws] Using Bun adapter in an incompatible environment."
+    );
+  }
   const hooks = new AdapterHookable(options);
-  const peers = /* @__PURE__ */ new Set();
+  const globalPeers = /* @__PURE__ */ new Map();
   return {
-    ...adapterUtils(peers),
+    ...adapterUtils(globalPeers),
     async handleUpgrade(request, server) {
-      const { upgradeHeaders, endResponse, context } = await hooks.upgrade(request);
+      const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
       if (endResponse) {
         return endResponse;
       }
@@ -16,7 +20,8 @@ const bunAdapter = (options = {}) => {
         data: {
           server,
           request,
-          context
+          context,
+          namespace
         },
         headers: upgradeHeaders
       });
@@ -26,15 +31,18 @@ const bunAdapter = (options = {}) => {
     },
     websocket: {
       message: (ws, message) => {
+        const peers = getPeers(globalPeers, ws.data.namespace);
         const peer = getPeer(ws, peers);
         hooks.callHook("message", peer, new Message(message, peer));
       },
       open: (ws) => {
+        const peers = getPeers(globalPeers, ws.data.namespace);
         const peer = getPeer(ws, peers);
         peers.add(peer);
         hooks.callHook("open", peer);
       },
       close: (ws, code, reason) => {
+        const peers = getPeers(globalPeers, ws.data.namespace);
         const peer = getPeer(ws, peers);
         peers.delete(peer);
         hooks.callHook("close", peer, { code, reason });
@@ -43,14 +51,16 @@ const bunAdapter = (options = {}) => {
   };
 };
 function getPeer(ws, peers) {
-  if (ws.data?.peer) {
+  if (ws.data.peer) {
     return ws.data.peer;
   }
-  const peer = new BunPeer({ ws, request: ws.data.request, peers });
-  ws.data = {
-    ...ws.data,
-    peer
-  };
+  const peer = new BunPeer({
+    ws,
+    request: ws.data.request,
+    peers,
+    namespace: ws.data.namespace
+  });
+  ws.data.peer = peer;
   return peer;
 }
 class BunPeer extends Peer {

package/dist/adapters/cloudflare.d.mts

@@ -1,13 +1,46 @@
-import { Adapter, AdapterInstance, AdapterOptions } from '../index.mjs';
 import * as CF from '@cloudflare/workers-types';
-import '../shared/crossws.BQXMA5bH.mjs';
+import { DurableObject } from 'cloudflare:workers';
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.mjs';
+import { W as WebSocket$1 } from '../shared/crossws.BQXMA5bH.mjs';
 
-interface CloudflareAdapter extends AdapterInstance {
-    handleUpgrade(req: CF.Request, env: unknown, context: CF.ExecutionContext): Promise<CF.Response>;
-}
+type WSDurableObjectStub = CF.DurableObjectStub & {
+    webSocketPublish?: (topic: string, data: unknown, opts: any) => Promise<void>;
+};
+type ResolveDurableStub = (req: CF.Request | undefined, env: unknown, context: CF.ExecutionContext | undefined) => WSDurableObjectStub | undefined | Promise<WSDurableObjectStub | undefined>;
 interface CloudflareOptions extends AdapterOptions {
+    /**
+     * Durable Object binding name from environment.
+     *
+     * **Note:** This option will be ignored if `resolveDurableStub` is provided.
+     *
+     * @default "$DurableObject"
+     */
+    bindingName?: string;
+    /**
+     * Durable Object instance name.
+     *
+     * **Note:** This option will be ignored if `resolveDurableStub` is provided.
+     *
+     * @default "crossws"
+     */
+    instanceName?: string;
+    /**
+     * Custom function that resolves Durable Object binding to handle the WebSocket upgrade.
+     *
+     * **Note:** This option will override `bindingName` and `instanceName`.
+     */
+    resolveDurableStub?: ResolveDurableStub;
+}
+declare const cloudflareAdapter: Adapter<CloudflareDurableAdapter, CloudflareOptions>;
+
+interface CloudflareDurableAdapter extends AdapterInstance {
+    handleUpgrade(req: Request | CF.Request, env: unknown, context: CF.ExecutionContext): Promise<Response>;
+    handleDurableInit(obj: DurableObject, state: DurableObjectState, env: unknown): void;
+    handleDurableUpgrade(obj: DurableObject, req: Request | CF.Request): Promise<Response>;
+    handleDurableMessage(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, message: ArrayBuffer | string): Promise<void>;
+    handleDurablePublish: (obj: DurableObject, topic: string, data: unknown, opts: any) => Promise<void>;
+    handleDurableClose(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, code: number, reason: string, wasClean: boolean): Promise<void>;
 }
-declare const cloudflareAdapter: Adapter<CloudflareAdapter, CloudflareOptions>;
 
 export { cloudflareAdapter as default };
-export type { CloudflareAdapter, CloudflareOptions };
+export type { CloudflareDurableAdapter, CloudflareOptions };

package/dist/adapters/cloudflare.mjs

@@ -1,31 +1,54 @@
-import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
-import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
+import { env } from 'cloudflare:workers';
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.WpyOHUXc.mjs';
+import { a as adapterUtils, g as getPeers, A as AdapterHookable } from '../shared/crossws.CPlNx7g8.mjs';
+import { S as StubRequest } from '../shared/crossws.B31KJMcF.mjs';
 import { W as WSError } from '../shared/crossws.By9qWDAI.mjs';
-import 'uncrypto';
 
-const cloudflareAdapter = (options = {}) => {
-  const hooks = new AdapterHookable(options);
-  const peers = /* @__PURE__ */ new Set();
+const cloudflareAdapter = (opts = {}) => {
+  const hooks = new AdapterHookable(opts);
+  const globalPeers = /* @__PURE__ */ new Map();
+  const resolveDurableStub = opts.resolveDurableStub || ((_req, env$1, _context) => {
+    const bindingName = opts.bindingName || "$DurableObject";
+    const binding = (env$1 || env)[bindingName];
+    if (binding) {
+      const instanceId = binding.idFromName(opts.instanceName || "crossws");
+      return binding.get(instanceId);
+    }
+  });
+  const { publish: durablePublish, ...utils } = adapterUtils(globalPeers);
   return {
-    ...adapterUtils(peers),
-    handleUpgrade: async (request, env, cfCtx) => {
-      const { upgradeHeaders, endResponse, context } = await hooks.upgrade(
-        request
+    ...utils,
+    handleUpgrade: async (request, cfEnv, cfCtx) => {
+      const stub = await resolveDurableStub(
+        request,
+        cfEnv,
+        cfCtx
       );
+      if (stub) {
+        return stub.fetch(
+          request
+        );
+      }
+      const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
       if (endResponse) {
         return endResponse;
       }
+      const peers = getPeers(
+        globalPeers,
+        namespace
+      );
       const pair = new WebSocketPair();
       const client = pair[0];
       const server = pair[1];
-      const peer = new CloudflarePeer({
+      const peer = new CloudflareFallbackPeer({
         ws: client,
         peers,
         wsServer: server,
         request,
-        cfEnv: env,
+        cfEnv,
         cfCtx,
-        context
+        context,
+        namespace
       });
       peers.add(peer);
       server.accept();
@@ -50,19 +73,154 @@ const cloudflareAdapter = (options = {}) => {
         webSocket: client,
         headers: upgradeHeaders
       });
+    },
+    handleDurableInit: async (obj, state, env) => {
+    },
+    handleDurableUpgrade: async (obj, request) => {
+      const { upgradeHeaders, endResponse, namespace } = await hooks.upgrade(
+        request
+      );
+      if (endResponse) {
+        return endResponse;
+      }
+      const peers = getPeers(globalPeers, namespace);
+      const pair = new WebSocketPair();
+      const client = pair[0];
+      const server = pair[1];
+      const peer = CloudflareDurablePeer._restore(
+        obj,
+        server,
+        request,
+        namespace
+      );
+      peers.add(peer);
+      obj.ctx.acceptWebSocket(server);
+      await hooks.callHook("open", peer);
+      return new Response(null, {
+        status: 101,
+        webSocket: client,
+        headers: upgradeHeaders
+      });
+    },
+    handleDurableMessage: async (obj, ws, message) => {
+      const peer = CloudflareDurablePeer._restore(obj, ws);
+      await hooks.callHook("message", peer, new Message(message, peer));
+    },
+    handleDurableClose: async (obj, ws, code, reason, wasClean) => {
+      const peer = CloudflareDurablePeer._restore(obj, ws);
+      const peers = getPeers(globalPeers, peer.namespace);
+      peers.delete(peer);
+      const details = { code, reason, wasClean };
+      await hooks.callHook("close", peer, details);
+    },
+    handleDurablePublish: async (_obj, topic, data, opts2) => {
+      return durablePublish(topic, data, opts2);
+    },
+    publish: async (topic, data, opts2) => {
+      const stub = await resolveDurableStub(void 0, env, void 0);
+      if (!stub) {
+        throw new Error("[crossws] Durable Object binding cannot be resolved.");
+      }
+      try {
+        return await stub.webSocketPublish(topic, data, opts2);
+      } catch (error) {
+        console.error(error);
+        throw error;
+      }
     }
   };
 };
-class CloudflarePeer extends Peer {
+class CloudflareDurablePeer extends Peer {
+  get peers() {
+    return new Set(
+      this.#getwebsockets().map(
+        (ws) => CloudflareDurablePeer._restore(this._internal.durable, ws)
+      )
+    );
+  }
+  #getwebsockets() {
+    return this._internal.durable.ctx.getWebSockets();
+  }
+  send(data) {
+    return this._internal.ws.send(toBufferLike(data));
+  }
+  subscribe(topic) {
+    super.subscribe(topic);
+    const state = getAttachedState(this._internal.ws);
+    if (!state.t) {
+      state.t = /* @__PURE__ */ new Set();
+    }
+    state.t.add(topic);
+    setAttachedState(this._internal.ws, state);
+  }
+  publish(topic, data) {
+    const websockets = this.#getwebsockets();
+    if (websockets.length < 2) {
+      return;
+    }
+    const dataBuff = toBufferLike(data);
+    for (const ws of websockets) {
+      if (ws === this._internal.ws) {
+        continue;
+      }
+      const state = getAttachedState(ws);
+      if (state.t?.has(topic)) {
+        ws.send(dataBuff);
+      }
+    }
+  }
+  close(code, reason) {
+    this._internal.ws.close(code, reason);
+  }
+  static _restore(durable, ws, request, namespace) {
+    let peer = ws._crosswsPeer;
+    if (peer) {
+      return peer;
+    }
+    const state = ws.deserializeAttachment() || {};
+    peer = ws._crosswsPeer = new CloudflareDurablePeer({
+      ws,
+      request: request || new StubRequest(state.u || ""),
+      namespace: namespace || state.n || "",
+      durable
+    });
+    if (state.i) {
+      peer._id = state.i;
+    }
+    if (request?.url) {
+      state.u = request.url;
+    }
+    state.i = peer.id;
+    setAttachedState(ws, state);
+    return peer;
+  }
+}
+class CloudflareFallbackPeer extends Peer {
   send(data) {
     this._internal.wsServer.send(toBufferLike(data));
     return 0;
   }
   publish(_topic, _message) {
+    console.warn(
+      "[crossws] [cloudflare] pub/sub support requires Durable Objects."
+    );
   }
   close(code, reason) {
     this._internal.ws.close(code, reason);
   }
 }
+function getAttachedState(ws) {
+  let state = ws._crosswsState;
+  if (state) {
+    return state;
+  }
+  state = ws.deserializeAttachment() || {};
+  ws._crosswsState = state;
+  return state;
+}
+function setAttachedState(ws, state) {
+  ws._crosswsState = state;
+  ws.serializeAttachment(state);
+}
 
 export { cloudflareAdapter as default };

package/dist/adapters/deno.mjs

@@ -1,28 +1,37 @@
-import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
-import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.WpyOHUXc.mjs';
+import { a as adapterUtils, A as AdapterHookable, g as getPeers } from '../shared/crossws.CPlNx7g8.mjs';
 import { W as WSError } from '../shared/crossws.By9qWDAI.mjs';
-import 'uncrypto';
 
 const denoAdapter = (options = {}) => {
+  if (typeof Deno === "undefined") {
+    throw new Error(
+      "[crossws] Using Deno adapter in an incompatible environment."
+    );
+  }
   const hooks = new AdapterHookable(options);
-  const peers = /* @__PURE__ */ new Set();
+  const globalPeers = /* @__PURE__ */ new Map();
   return {
-    ...adapterUtils(peers),
+    ...adapterUtils(globalPeers),
     handleUpgrade: async (request, info) => {
-      const { upgradeHeaders, endResponse, context } = await hooks.upgrade(request);
+      const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
       if (endResponse) {
         return endResponse;
       }
+      const headers = upgradeHeaders instanceof Headers ? upgradeHeaders : new Headers(upgradeHeaders);
       const upgrade = Deno.upgradeWebSocket(request, {
-        // @ts-expect-error https://github.com/denoland/deno/pull/22242
-        headers: upgradeHeaders
+        // @ts-expect-error Setting headers is currently not supported in Deno
+        // https://github.com/denoland/deno/issues/19277
+        headers,
+        protocol: headers.get("sec-websocket-protocol") ?? ""
       });
+      const peers = getPeers(globalPeers, namespace);
       const peer = new DenoPeer({
         ws: upgrade.socket,
         request,
         peers,
         denoInfo: info,
-        context
+        context,
+        namespace
       });
       peers.add(peer);
       upgrade.socket.addEventListener("open", () => {

package/dist/adapters/node.d.mts

@@ -286,7 +286,7 @@ type WebSocketServer = Server;
 declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
 
 interface NodeAdapter extends AdapterInstance {
-    handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): Promise<void>;
+    handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer, webRequest?: Request): Promise<void>;
     closeAll: (code?: number, data?: string | Buffer, force?: boolean) => void;
 }
 interface NodeOptions extends AdapterOptions {

package/dist/adapters/node.mjs

@@ -1,8 +1,8 @@
-import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
-import { A as AdapterHookable, a as adapterUtils } from '../shared/crossws.D9ehKjSh.mjs';
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.WpyOHUXc.mjs';
+import { g as getPeers, A as AdapterHookable, a as adapterUtils } from '../shared/crossws.CPlNx7g8.mjs';
 import { W as WSError } from '../shared/crossws.By9qWDAI.mjs';
 import { _ as _WebSocketServer } from '../shared/crossws.CipVM6lf.mjs';
-import 'uncrypto';
+import { S as StubRequest } from '../shared/crossws.B31KJMcF.mjs';
 import 'stream';
 import 'events';
 import 'http';
@@ -15,15 +15,28 @@ import 'tls';
 import 'url';
 
 const nodeAdapter = (options = {}) => {
+  if ("Deno" in globalThis || "Bun" in globalThis) {
+    throw new Error(
+      "[crossws] Using Node.js adapter in an incompatible environment."
+    );
+  }
   const hooks = new AdapterHookable(options);
-  const peers = /* @__PURE__ */ new Set();
+  const globalPeers = /* @__PURE__ */ new Map();
   const wss = options.wss || new _WebSocketServer({
     noServer: true,
+    handleProtocols: () => false,
     ...options.serverOptions
   });
   wss.on("connection", (ws, nodeReq) => {
     const request = new NodeReqProxy(nodeReq);
-    const peer = new NodePeer({ ws, request, peers, nodeReq });
+    const peers = getPeers(globalPeers, nodeReq._namespace);
+    const peer = new NodePeer({
+      ws,
+      request,
+      peers,
+      nodeReq,
+      namespace: nodeReq._namespace
+    });
     peers.add(peer);
     hooks.callHook("open", peer);
     ws.on("message", (data) => {
@@ -53,16 +66,17 @@ const nodeAdapter = (options = {}) => {
     }
   });
   return {
-    ...adapterUtils(peers),
-    handleUpgrade: async (nodeReq, socket, head) => {
-      const request = new NodeReqProxy(nodeReq);
-      const { upgradeHeaders, endResponse, context } = await hooks.upgrade(request);
+    ...adapterUtils(globalPeers),
+    handleUpgrade: async (nodeReq, socket, head, webRequest) => {
+      const request = webRequest || new NodeReqProxy(nodeReq);
+      const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
       if (endResponse) {
         return sendResponse(socket, endResponse);
       }
       nodeReq._request = request;
       nodeReq._upgradeHeaders = upgradeHeaders;
       nodeReq._context = context;
+      nodeReq._namespace = namespace;
       wss.handleUpgrade(nodeReq, socket, head, (ws) => {
         wss.emit("connection", ws, nodeReq);
       });
@@ -116,27 +130,12 @@ class NodePeer extends Peer {
     this._internal.ws.terminate();
   }
 }
-class NodeReqProxy {
-  _req;
-  _headers;
-  _url;
+class NodeReqProxy extends StubRequest {
   constructor(req) {
-    this._req = req;
-  }
-  get url() {
-    if (!this._url) {
-      const req = this._req;
-      const host = req.headers["host"] || "localhost";
-      const isSecure = req.socket?.encrypted ?? req.headers["x-forwarded-proto"] === "https";
-      this._url = `${isSecure ? "https" : "http"}://${host}${req.url}`;
-    }
-    return this._url;
-  }
-  get headers() {
-    if (!this._headers) {
-      this._headers = new Headers(this._req.headers);
-    }
-    return this._headers;
+    const host = req.headers["host"] || "localhost";
+    const isSecure = req.socket?.encrypted ?? req.headers["x-forwarded-proto"] === "https";
+    const url = `${isSecure ? "https" : "http"}://${host}${req.url}`;
+    super(url, { headers: req.headers });
   }
 }
 async function sendResponse(socket, res) {

package/dist/adapters/sse.mjs

@@ -1,15 +1,14 @@
-import { M as Message, P as Peer, a as toString } from '../shared/crossws.DfCzGthR.mjs';
-import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
-import 'uncrypto';
+import { M as Message, P as Peer, a as toString } from '../shared/crossws.WpyOHUXc.mjs';
+import { a as adapterUtils, A as AdapterHookable, g as getPeers } from '../shared/crossws.CPlNx7g8.mjs';
 
 const sseAdapter = (opts = {}) => {
   const hooks = new AdapterHookable(opts);
-  const peers = /* @__PURE__ */ new Set();
+  const globalPeers = /* @__PURE__ */ new Map();
   const peersMap = opts.bidir ? /* @__PURE__ */ new Map() : void 0;
   return {
-    ...adapterUtils(peers),
+    ...adapterUtils(globalPeers),
     fetch: async (request) => {
-      const { upgradeHeaders, endResponse, context } = await hooks.upgrade(request);
+      const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
       if (endResponse) {
         return endResponse;
       }
@@ -32,13 +31,15 @@ const sseAdapter = (opts = {}) => {
         return new Response(null, {});
       } else {
         const ws = new SSEWebSocketStub();
+        const peers = getPeers(globalPeers, namespace);
         peer = new SSEPeer({
           peers,
           peersMap,
           request,
           hooks,
           ws,
-          context
+          context,
+          namespace
         });
         peers.add(peer);
         if (opts.bidir) {

package/dist/adapters/uws.d.mts

@@ -1,14 +1,20 @@
-import { Adapter, AdapterInstance, Peer, AdapterOptions } from '../index.mjs';
+import { Adapter, AdapterInstance, Peer, PeerContext, AdapterOptions } from '../index.mjs';
 import { W as WebSocket } from '../shared/crossws.BQXMA5bH.mjs';
 import uws from 'uWebSockets.js';
 
+declare const StubRequest: {
+    new (url: string, init?: RequestInit): Request;
+};
+
 type UserData = {
     peer?: UWSPeer;
     req: uws.HttpRequest;
     res: uws.HttpResponse;
+    webReq: UWSReqProxy;
     protocol: string;
     extensions: string;
-    context: Peer["context"];
+    context: PeerContext;
+    namespace: string;
 };
 type WebSocketHandler = uws.WebSocketBehavior<UserData>;
 interface UWSAdapter extends AdapterInstance {
@@ -22,12 +28,13 @@ declare const uwsAdapter: Adapter<UWSAdapter, UWSOptions>;
 declare class UWSPeer extends Peer<{
     peers: Set<UWSPeer>;
     request: UWSReqProxy;
+    namespace: string;
     uws: uws.WebSocket<UserData>;
     ws: UwsWebSocketProxy;
     uwsData: UserData;
 }> {
     get remoteAddress(): string | undefined;
-    get context(): Record<string, unknown>;
+    get context(): PeerContext;
     send(data: unknown, options?: {
         compress?: boolean;
     }): number;
@@ -39,12 +46,8 @@ declare class UWSPeer extends Peer<{
     close(code?: number, reason?: uws.RecognizedString): void;
     terminate(): void;
 }
-declare class UWSReqProxy {
-    private _headers?;
-    private _rawHeaders;
-    url: string;
-    constructor(_req: uws.HttpRequest);
-    get headers(): Headers;
+declare class UWSReqProxy extends StubRequest {
+    constructor(req: uws.HttpRequest);
 }
 declare class UwsWebSocketProxy implements Partial<WebSocket> {
     private _uws;