crossws 0.3.4 → 0.4.0

package/dist/adapters/node.mjs

@@ -1,9 +1,9 @@
-import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.BS81iGZK.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 { 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 { S as StubRequest } from '../shared/crossws.B31KJMcF.mjs';
 import 'stream';
-import { _ as _WebSocketServer } from '../shared/crossws.DelSCW9g.mjs';
-import 'uncrypto';
 import 'events';
 import 'http';
 import 'crypto';
@@ -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,23 +66,28 @@ 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);
       });
     },
-    closeAll: (code, data) => {
+    closeAll: (code, data, force) => {
       for (const client of wss.clients) {
-        client.close(code, data);
+        if (force) {
+          client.terminate();
+        } else {
+          client.close(code, data);
+        }
       }
     }
   };
@@ -112,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) {
@@ -149,7 +152,10 @@ async function sendResponse(socket, res) {
     }
   }
   return new Promise((resolve) => {
-    socket.end(resolve);
+    socket.end(() => {
+      socket.destroy();
+      resolve();
+    });
   });
 }
 

package/dist/adapters/sse.d.mts

@@ -1,5 +1,5 @@
-import { AdapterInstance, AdapterOptions, Adapter } from '../index.mjs';
-import '../shared/crossws.ChIJSJVK.mjs';
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
 
 interface SSEAdapter extends AdapterInstance {
     fetch(req: Request): Promise<Response>;
@@ -9,4 +9,5 @@ interface SSEOptions extends AdapterOptions {
 }
 declare const sseAdapter: Adapter<SSEAdapter, SSEOptions>;
 
-export { type SSEAdapter, type SSEOptions, sseAdapter as default };
+export { sseAdapter as default };
+export type { SSEAdapter, SSEOptions };

package/dist/adapters/sse.mjs

@@ -1,15 +1,14 @@
-import { M as Message, P as Peer, a as toString } from '../shared/crossws.BS81iGZK.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 peersMap = opts.bidir ? /* @__PURE__ */ new Map() : undefined;
+  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 { AdapterInstance, AdapterOptions, Adapter, Peer } from '../index.mjs';
-import { W as WebSocket } from '../shared/crossws.ChIJSJVK.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;
@@ -55,4 +58,5 @@ declare class UwsWebSocketProxy implements Partial<WebSocket> {
     get extensions(): string;
 }
 
-export { type UWSAdapter, type UWSOptions, uwsAdapter as default };
+export { uwsAdapter as default };
+export type { UWSAdapter, UWSOptions };

package/dist/adapters/uws.mjs

@@ -1,15 +1,16 @@
-import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.BS81iGZK.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, A as AdapterHookable, g as getPeers } from '../shared/crossws.CPlNx7g8.mjs';
+import { S as StubRequest } from '../shared/crossws.B31KJMcF.mjs';
 
 const uwsAdapter = (options = {}) => {
   const hooks = new AdapterHookable(options);
-  const peers = /* @__PURE__ */ new Set();
+  const globalPeers = /* @__PURE__ */ new Map();
   return {
-    ...adapterUtils(peers),
+    ...adapterUtils(globalPeers),
     websocket: {
       ...options.uws,
       close(ws, code, message) {
+        const peers = getPeers(globalPeers, ws.getUserData().namespace);
         const peer = getPeer(ws, peers);
         peer._internal.ws.readyState = 2;
         peers.delete(peer);
@@ -20,10 +21,12 @@ const uwsAdapter = (options = {}) => {
         peer._internal.ws.readyState = 3;
       },
       message(ws, message, isBinary) {
+        const peers = getPeers(globalPeers, ws.getUserData().namespace);
         const peer = getPeer(ws, peers);
         hooks.callHook("message", peer, new Message(message, peer));
       },
       open(ws) {
+        const peers = getPeers(globalPeers, ws.getUserData().namespace);
         const peer = getPeer(ws, peers);
         peers.add(peer);
         hooks.callHook("open", peer);
@@ -33,9 +36,8 @@ const uwsAdapter = (options = {}) => {
         res.onAborted(() => {
           aborted = true;
         });
-        const { upgradeHeaders, endResponse, context } = await hooks.upgrade(
-          new UWSReqProxy(req)
-        );
+        const webReq = new UWSReqProxy(req);
+        const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(webReq);
         if (endResponse) {
           res.writeStatus(`${endResponse.status} ${endResponse.statusText}`);
           for (const [key, value] of endResponse.headers) {
@@ -70,12 +72,14 @@ const uwsAdapter = (options = {}) => {
             {
               req,
               res,
+              webReq,
               protocol,
               extensions,
-              context
+              context,
+              namespace
             },
             key,
-            protocol,
+            "",
             extensions,
             uwsContext
           );
@@ -93,7 +97,8 @@ function getPeer(uws, peers) {
     peers,
     uws,
     ws: new UwsWebSocketProxy(uws),
-    request: new UWSReqProxy(uwsData.req),
+    request: uwsData.webReq,
+    namespace: uwsData.namespace,
     uwsData
   });
   uwsData.peer = peer;
@@ -138,30 +143,23 @@ class UWSPeer extends Peer {
     this._internal.uws.close();
   }
 }
-class UWSReqProxy {
-  _headers;
-  _rawHeaders = [];
-  url;
-  constructor(_req) {
+class UWSReqProxy extends StubRequest {
+  constructor(req) {
+    const rawHeaders = [];
     let host = "localhost";
     let proto = "http";
-    _req.forEach((key, value) => {
+    req.forEach((key, value) => {
       if (key === "host") {
         host = value;
       } else if (key === "x-forwarded-proto" && value === "https") {
         proto = "https";
       }
-      this._rawHeaders.push([key, value]);
+      rawHeaders.push([key, value]);
     });
-    const query = _req.getQuery();
-    const pathname = _req.getUrl();
-    this.url = `${proto}://${host}${pathname}${query ? `?${query}` : ""}`;
-  }
-  get headers() {
-    if (!this._headers) {
-      this._headers = new Headers(this._rawHeaders);
-    }
-    return this._headers;
+    const query = req.getQuery();
+    const pathname = req.getUrl();
+    const url = `${proto}://${host}${pathname}${query ? `?${query}` : ""}`;
+    super(url, { headers: rawHeaders });
   }
 }
 class UwsWebSocketProxy {

package/dist/index.d.mts

@@ -1,12 +1,15 @@
-import { W as WebSocket } from './shared/crossws.ChIJSJVK.mjs';
+import { W as WebSocket } from './shared/crossws.BQXMA5bH.mjs';
 
 declare const kNodeInspect: unique symbol;
 
+interface PeerContext extends Record<string, unknown> {
+}
 interface AdapterInternal {
     ws: unknown;
-    request: UpgradeRequest;
+    request: Request;
+    namespace: string;
     peers?: Set<Peer>;
-    context?: Peer["context"];
+    context?: PeerContext;
 }
 declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal> {
     #private;
@@ -14,7 +17,8 @@ declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal>
     protected _topics: Set<string>;
     protected _id?: string;
     constructor(internal: Internal);
-    get context(): Record<string, unknown>;
+    get context(): PeerContext;
+    get namespace(): string;
     /**
      * Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the peer.
      */
@@ -22,7 +26,7 @@ declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal>
     /** IP address of the peer */
     get remoteAddress(): string | undefined;
     /** upgrade request */
-    get request(): UpgradeRequest;
+    get request(): Request;
     /**
      * Get the [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) instance.
      *
@@ -54,15 +58,19 @@ declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal>
     toString(): string;
     [Symbol.toPrimitive](): string;
     [Symbol.toStringTag](): "WebSocket";
-    [kNodeInspect](): Record<string, unknown>;
+    [kNodeInspect](): unknown;
 }
 
 interface AdapterInstance {
-    readonly peers: Set<Peer>;
-    readonly publish: Peer["publish"];
+    readonly peers: Map<string, Set<Peer>>;
+    readonly publish: (topic: string, data: unknown, options?: {
+        compress?: boolean;
+        namespace?: string;
+    }) => void;
 }
 interface AdapterOptions {
     resolve?: ResolveHooks;
+    getNamespace?: (request: Request) => string;
     hooks?: Partial<Hooks>;
 }
 type Adapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions> = (options?: Options) => AdapterT;
@@ -118,28 +126,33 @@ declare class Message implements Partial<MessageEvent> {
     get data(): unknown;
     toString(): string;
     [Symbol.toPrimitive](): string;
-    [kNodeInspect](): {
-        data: unknown;
-    };
+    [kNodeInspect](): unknown;
 }
 
 declare function defineHooks<T extends Partial<Hooks> = Partial<Hooks>>(hooks: T): T;
-type ResolveHooks = (info: RequestInit | Peer) => Partial<Hooks> | Promise<Partial<Hooks>>;
+type ResolveHooks = (request: Request & {
+    readonly context?: PeerContext;
+}) => Partial<Hooks> | Promise<Partial<Hooks>>;
 type MaybePromise<T> = T | Promise<T>;
-type UpgradeRequest = Request | {
-    url: string;
-    headers: Headers;
-};
 interface Hooks {
-    /** Upgrading */
     /**
+     * Upgrading a request to a WebSocket connection.
+     *
+     * - You can throw a Response to abort the upgrade.
+     * - You can return { headers } to modify the response.
+     * - You can return { namespace } to change the pub/sub namespace.
+     * - You can return { context } to provide a custom peer context.
      *
      * @param request
      * @throws {Response}
      */
-    upgrade: (request: UpgradeRequest & {
-        context: Peer["context"];
-    }) => MaybePromise<Response | ResponseInit | void>;
+    upgrade: (request: Request & {
+        readonly context?: Record<string, unknown>;
+    }) => MaybePromise<{
+        headers?: HeadersInit;
+        namespace?: string;
+        context?: PeerContext;
+    } | Response | void>;
     /** A message is received */
     message: (peer: Peer, message: Message) => MaybePromise<void>;
     /** A socket is opened */
@@ -153,4 +166,5 @@ interface Hooks {
     error: (peer: Peer, error: WSError) => MaybePromise<void>;
 }
 
-export { type Adapter, type AdapterInstance, type AdapterOptions, type Hooks, Message, Peer, type ResolveHooks, WSError, defineHooks, defineWebSocketAdapter };
+export { Message, Peer, WSError, defineHooks, defineWebSocketAdapter };
+export type { Adapter, AdapterInstance, AdapterInternal, AdapterOptions, Hooks, PeerContext, ResolveHooks };

package/dist/index.mjs

@@ -1 +1 @@
-export { d as defineHooks, b as defineWebSocketAdapter } from './shared/crossws.D9ehKjSh.mjs';
+export { d as defineHooks, b as defineWebSocketAdapter } from './shared/crossws.CPlNx7g8.mjs';

package/dist/server/bun.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };

package/dist/server/bun.mjs

@@ -0,0 +1,37 @@
+import { serve as serve$1 } from 'srvx/bun';
+import bunAdapter from '../adapters/bun.mjs';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+
+function plugin(wsOpts) {
+  return (server) => {
+    const ws = bunAdapter({
+      hooks: wsOpts,
+      resolve: wsOpts.resolve,
+      ...wsOpts.options?.bun
+    });
+    server.options.middleware.unshift((req, next) => {
+      if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        return ws.handleUpgrade(
+          req,
+          req.runtime.bun.server
+        );
+      }
+      return next();
+    });
+    server.options.bun ??= {};
+    if (server.options.bun.websocket) {
+      throw new Error("websocket handlers for bun already set!");
+    }
+    server.options.bun.websocket = ws.websocket;
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/server/cloudflare.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };

package/dist/server/cloudflare.mjs

@@ -0,0 +1,36 @@
+import { serve as serve$1 } from 'srvx/cloudflare';
+import cloudflareAdapter from '../adapters/cloudflare.mjs';
+import 'cloudflare:workers';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+import '../shared/crossws.B31KJMcF.mjs';
+import '../shared/crossws.By9qWDAI.mjs';
+
+function plugin(wsOpts) {
+  return (server) => {
+    const ws = cloudflareAdapter({
+      hooks: wsOpts,
+      resolve: wsOpts.resolve,
+      ...wsOpts.options?.cloudflare
+    });
+    server.options.middleware.unshift((req, next) => {
+      if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        return ws.handleUpgrade(
+          req,
+          req.runtime.cloudflare.env,
+          req.runtime.cloudflare.context
+        );
+      }
+      return next();
+    });
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/server/default.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };

package/dist/server/default.mjs

@@ -0,0 +1,32 @@
+import { serve as serve$1 } from 'srvx';
+import sseAdapter from '../adapters/sse.mjs';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+
+function plugin(wsOpts) {
+  const ws = sseAdapter({
+    hooks: wsOpts,
+    resolve: wsOpts.resolve,
+    ...wsOpts.options?.sse
+  });
+  console.warn(
+    "[crossws] Using SSE adapter for WebSocket support. This requires a custom WebSocket client (https://crossws.h3.dev/adapters/sse)."
+  );
+  return (server) => {
+    server.options.middleware.unshift((req, next) => {
+      if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        return ws.fetch(req);
+      }
+      return next();
+    });
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/server/deno.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };