crossws 0.2.3 → 0.3.0

package/README.md

@@ -1,4 +1,4 @@
-# ⛨ CrossWS
+# crossws
 
 <!-- automd:badges -->
 
@@ -7,24 +7,23 @@
 
 <!-- /automd -->
 
-Elegant, typed, and simple interface to implement platform-agnostic WebSocket servers.
+Elegant, typed, and simple toolkit to implement cross-platform WebSocket servers.
 
 👉 [📖 documentation](https://crossws.unjs.io)
 
 ## Features
 
-🧩 Seamlessly integrates with, [Bun](https://bun.sh/), [Deno](https://deno.com/), [Cloudflare Workers](https://workers.cloudflare.com/) and [Node.js](https://nodejs.org/en) ([ws](https://github.com/websockets/ws) || [uWebSockets](https://github.com/uNetworking/uWebSockets.js)).
+🧩 Seamlessly integrates with [Bun](https://crossws.unjs.io/adapters/bun), [Cloudflare Workers](https://crossws.unjs.io/adapters/cloudflare), [Deno](https://crossws.unjs.io/adapters/deno) and [Node.js](https://crossws.unjs.io/adapters/node) and any compatible web framework.
 
-🚀 High-performance server hooks, avoiding heavy per-connection events API ([why](https://bun.sh/docs/api/websockets#lcYFjkFYJC-summary))
+✅ Prebundled with [ws](https://github.com/websockets/ws) for Node.js support with alternative/much faster [uWebSockets](https://crossws.unjs.io/adapters/node#uwebsockets) adapter.
 
-📦 No external dependencies, includes [ws](https://github.com/websockets/ws) for Node.js support
+📦 Extremely lightweight and tree-shakable conditional ESM exports.
 
-💡 Extremely lightweight and tree-shakable packaging with ESM and CJS support
+🚀 High-performance and simple hooks API, without per-connection callback creation.
 
-🔍 Developer-friendly object logging
+🌟 Typed hooks API and developer-friendly object inspection.
 
-> [!IMPORTANT]
-> This project and API are under development.
+[^1]: crossws supports Node.js via [npm:ws](https://github.com/websockets/ws) (prebundled) or [uWebSockets.js](https://github.com/uNetworking/uWebSockets.js).
 
 ## Contribution
 

package/adapters/cloudflare-durable.d.ts

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

package/adapters/sse.d.ts

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

package/dist/adapters/bun.d.mts

@@ -1,17 +1,36 @@
-import { A as AdapterOptions, P as Peer, b as Adapter } from '../shared/crossws.a2e5c71e.mjs';
-import { WebSocketHandler, Server } from 'bun';
+import { AdapterInstance, AdapterOptions, Adapter, Peer } from '../index.mjs';
+import { WebSocketHandler, Server, ServerWebSocket } from 'bun';
+import '../shared/crossws.ChIJSJVK.mjs';
 
-interface BunAdapter {
+interface BunAdapter extends AdapterInstance {
     websocket: WebSocketHandler<ContextData>;
-    handleUpgrade(req: Request, server: Server): Promise<boolean>;
+    handleUpgrade(req: Request, server: Server): Promise<Response | undefined>;
 }
 interface BunOptions extends AdapterOptions {
 }
 type ContextData = {
-    _peer?: Peer;
-    req?: Request;
+    peer?: BunPeer;
+    request: Request;
     server?: Server;
 };
 declare const _default: Adapter<BunAdapter, BunOptions>;
 
+declare class BunPeer extends Peer<{
+    ws: ServerWebSocket<ContextData>;
+    request: Request;
+    peers: Set<BunPeer>;
+}> {
+    get remoteAddress(): string;
+    send(data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    publish(topic: string, data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    close(code?: number, reason?: string): void;
+    terminate(): void;
+}
+
 export { type BunAdapter, type BunOptions, _default as default };

package/dist/adapters/bun.d.ts

@@ -1,17 +1,36 @@
-import { A as AdapterOptions, P as Peer, b as Adapter } from '../shared/crossws.a2e5c71e.js';
-import { WebSocketHandler, Server } from 'bun';
+import { AdapterInstance, AdapterOptions, Adapter, Peer } from '../index.js';
+import { WebSocketHandler, Server, ServerWebSocket } from 'bun';
+import '../shared/crossws.ChIJSJVK.js';
 
-interface BunAdapter {
+interface BunAdapter extends AdapterInstance {
     websocket: WebSocketHandler<ContextData>;
-    handleUpgrade(req: Request, server: Server): Promise<boolean>;
+    handleUpgrade(req: Request, server: Server): Promise<Response | undefined>;
 }
 interface BunOptions extends AdapterOptions {
 }
 type ContextData = {
-    _peer?: Peer;
-    req?: Request;
+    peer?: BunPeer;
+    request: Request;
     server?: Server;
 };
 declare const _default: Adapter<BunAdapter, BunOptions>;
 
+declare class BunPeer extends Peer<{
+    ws: ServerWebSocket<ContextData>;
+    request: Request;
+    peers: Set<BunPeer>;
+}> {
+    get remoteAddress(): string;
+    send(data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    publish(topic: string, data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    close(code?: number, reason?: string): void;
+    terminate(): void;
+}
+
 export { type BunAdapter, type BunOptions, _default as default };

package/dist/adapters/bun.mjs

@@ -1,92 +1,84 @@
-import { d as defineWebSocketAdapter, M as Message, c as createCrossWS, P as Peer, t as toBufferLike } from '../shared/crossws.34cfc8d0.mjs';
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DTY7a69w.mjs';
+import { d as defineWebSocketAdapter, a as adapterUtils, A as AdapterHookable } from '../shared/crossws.B4sHId41.mjs';
+import 'uncrypto';
 
 const bun = defineWebSocketAdapter(
   (options = {}) => {
-    const crossws = createCrossWS(options);
-    const getPeer = (ws) => {
-      if (ws.data?._peer) {
-        return ws.data._peer;
-      }
-      const peer = new BunPeer({ bun: { ws } });
-      ws.data = ws.data || {};
-      ws.data._peer = peer;
-      return peer;
-    };
+    const hooks = new AdapterHookable(options);
+    const peers = /* @__PURE__ */ new Set();
     return {
-      async handleUpgrade(req, server) {
-        const { headers } = await crossws.upgrade({
-          url: req.url,
-          headers: req.headers
-        });
-        return server.upgrade(req, {
-          data: { req, server },
-          headers
+      ...adapterUtils(peers),
+      async handleUpgrade(request, server) {
+        const res = await hooks.callHook("upgrade", request);
+        if (res instanceof Response) {
+          return res;
+        }
+        const upgradeOK = server.upgrade(request, {
+          data: {
+            server,
+            request
+          },
+          headers: res?.headers
         });
+        if (!upgradeOK) {
+          return new Response("Upgrade failed", { status: 500 });
+        }
       },
       websocket: {
         message: (ws, message) => {
-          const peer = getPeer(ws);
-          crossws.$callHook("bun:message", peer, ws, message);
-          crossws.callHook("message", peer, new Message(message));
+          const peer = getPeer(ws, peers);
+          hooks.callHook("message", peer, new Message(message, peer));
         },
         open: (ws) => {
-          const peer = getPeer(ws);
-          crossws.$callHook("bun:open", peer, ws);
-          crossws.callHook("open", peer);
+          const peer = getPeer(ws, peers);
+          peers.add(peer);
+          hooks.callHook("open", peer);
         },
         close: (ws) => {
-          const peer = getPeer(ws);
-          crossws.$callHook("bun:close", peer, ws);
-          crossws.callHook("close", peer, {});
-        },
-        drain: (ws) => {
-          const peer = getPeer(ws);
-          crossws.$callHook("bun:drain", peer);
-        },
-        ping(ws, data) {
-          const peer = getPeer(ws);
-          crossws.$callHook("bun:ping", peer, ws, data);
-        },
-        pong(ws, data) {
-          const peer = getPeer(ws);
-          crossws.$callHook("bun:pong", peer, ws, data);
+          const peer = getPeer(ws, peers);
+          peers.delete(peer);
+          hooks.callHook("close", peer, {});
         }
       }
     };
   }
 );
-class BunPeer extends Peer {
-  get id() {
-    let addr = this.ctx.bun.ws.remoteAddress;
-    if (addr.includes(":")) {
-      addr = `[${addr}]`;
-    }
-    return addr;
-  }
-  get readyState() {
-    return this.ctx.bun.ws.readyState;
+function getPeer(ws, peers) {
+  if (ws.data?.peer) {
+    return ws.data.peer;
   }
-  get url() {
-    return this.ctx.bun.ws.data.req?.url || "/";
-  }
-  get headers() {
-    return this.ctx.bun.ws.data.req?.headers || new Headers();
+  const peer = new BunPeer({ ws, request: ws.data.request, peers });
+  ws.data = {
+    ...ws.data,
+    peer
+  };
+  return peer;
+}
+class BunPeer extends Peer {
+  get remoteAddress() {
+    return this._internal.ws.remoteAddress;
   }
-  send(message, options) {
-    return this.ctx.bun.ws.send(toBufferLike(message), options?.compress);
+  send(data, options) {
+    return this._internal.ws.send(toBufferLike(data), options?.compress);
   }
-  publish(topic, message, options) {
-    return this.ctx.bun.ws.publish(
+  publish(topic, data, options) {
+    return this._internal.ws.publish(
       topic,
-      toBufferLike(message),
+      toBufferLike(data),
       options?.compress
     );
   }
   subscribe(topic) {
-    this.ctx.bun.ws.subscribe(topic);
+    this._internal.ws.subscribe(topic);
   }
   unsubscribe(topic) {
-    this.ctx.bun.ws.unsubscribe(topic);
+    this._internal.ws.unsubscribe(topic);
+  }
+  close(code, reason) {
+    this._internal.ws.close(code, reason);
+  }
+  terminate() {
+    this._internal.ws.terminate();
   }
 }
 

package/dist/adapters/cloudflare-durable.d.mts

@@ -0,0 +1,20 @@
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.mjs';
+import { W as WebSocket$1 } from '../shared/crossws.ChIJSJVK.mjs';
+import * as CF from '@cloudflare/workers-types';
+import { DurableObject } from 'cloudflare:workers';
+
+declare const _default: 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>;
+    handleDurableClose(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, code: number, reason: string, wasClean: boolean): Promise<void>;
+}
+interface CloudflareOptions extends AdapterOptions {
+    bindingName?: string;
+    instanceName?: string;
+}
+
+export { type CloudflareDurableAdapter, type CloudflareOptions, _default as default };

package/dist/adapters/cloudflare-durable.d.ts

@@ -0,0 +1,20 @@
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.js';
+import { W as WebSocket$1 } from '../shared/crossws.ChIJSJVK.js';
+import * as CF from '@cloudflare/workers-types';
+import { DurableObject } from 'cloudflare:workers';
+
+declare const _default: 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>;
+    handleDurableClose(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, code: number, reason: string, wasClean: boolean): Promise<void>;
+}
+interface CloudflareOptions extends AdapterOptions {
+    bindingName?: string;
+    instanceName?: string;
+}
+
+export { type CloudflareDurableAdapter, type CloudflareOptions, _default as default };

package/dist/adapters/cloudflare-durable.mjs

@@ -0,0 +1,132 @@
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DTY7a69w.mjs';
+import { d as defineWebSocketAdapter, a as adapterUtils, A as AdapterHookable } from '../shared/crossws.B4sHId41.mjs';
+import 'uncrypto';
+
+const cloudflareDurable = defineWebSocketAdapter((opts) => {
+  const hooks = new AdapterHookable(opts);
+  const peers = /* @__PURE__ */ new Set();
+  return {
+    ...adapterUtils(peers),
+    handleUpgrade: async (req, env, _context) => {
+      const bindingName = opts?.bindingName ?? "$DurableObject";
+      const instanceName = opts?.instanceName ?? "crossws";
+      const binding = env[bindingName];
+      const id = binding.idFromName(instanceName);
+      const stub = binding.get(id);
+      return stub.fetch(req);
+    },
+    handleDurableInit: async (obj, state, env) => {
+    },
+    handleDurableUpgrade: async (obj, request) => {
+      const res = await hooks.callHook("upgrade", request);
+      if (res instanceof Response) {
+        return res;
+      }
+      const pair = new WebSocketPair();
+      const client = pair[0];
+      const server = pair[1];
+      const peer = CloudflareDurablePeer._restore(
+        obj,
+        server,
+        request
+      );
+      peers.add(peer);
+      obj.ctx.acceptWebSocket(server);
+      await hooks.callHook("open", peer);
+      return new Response(null, {
+        status: 101,
+        webSocket: client,
+        headers: res?.headers
+      });
+    },
+    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);
+      peers.delete(peer);
+      const details = { code, reason, wasClean };
+      await hooks.callHook("close", peer, details);
+    }
+  };
+});
+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) {
+    let peer = ws._crosswsPeer;
+    if (peer) {
+      return peer;
+    }
+    const state = ws.deserializeAttachment() || {};
+    peer = ws._crosswsPeer = new CloudflareDurablePeer({
+      ws,
+      request: request || { url: state.u },
+      durable
+    });
+    if (state.i) {
+      peer._id = state.i;
+    }
+    if (request?.url) {
+      state.u = request.url;
+    }
+    state.i = peer.id;
+    setAttachedState(ws, state);
+    return peer;
+  }
+}
+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 { cloudflareDurable as default };

package/dist/adapters/cloudflare.d.mts

@@ -1,9 +1,9 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.mjs';
-import * as _cf from '@cloudflare/workers-types';
+import { AdapterInstance, AdapterOptions, Adapter } from '../index.mjs';
+import * as CF from '@cloudflare/workers-types';
+import '../shared/crossws.ChIJSJVK.mjs';
 
-type Env = Record<string, any>;
-interface CloudflareAdapter {
-    handleUpgrade(req: _cf.Request, env: Env, context: _cf.ExecutionContext): Promise<_cf.Response>;
+interface CloudflareAdapter extends AdapterInstance {
+    handleUpgrade(req: CF.Request, env: unknown, context: CF.ExecutionContext): Promise<CF.Response>;
 }
 interface CloudflareOptions extends AdapterOptions {
 }

package/dist/adapters/cloudflare.d.ts

@@ -1,9 +1,9 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.js';
-import * as _cf from '@cloudflare/workers-types';
+import { AdapterInstance, AdapterOptions, Adapter } from '../index.js';
+import * as CF from '@cloudflare/workers-types';
+import '../shared/crossws.ChIJSJVK.js';
 
-type Env = Record<string, any>;
-interface CloudflareAdapter {
-    handleUpgrade(req: _cf.Request, env: Env, context: _cf.ExecutionContext): Promise<_cf.Response>;
+interface CloudflareAdapter extends AdapterInstance {
+    handleUpgrade(req: CF.Request, env: unknown, context: CF.ExecutionContext): Promise<CF.Response>;
 }
 interface CloudflareOptions extends AdapterOptions {
 }

package/dist/adapters/cloudflare.mjs

@@ -1,62 +1,69 @@
-import { d as defineWebSocketAdapter, M as Message, P as Peer, t as toBufferLike, c as createCrossWS } from '../shared/crossws.34cfc8d0.mjs';
-import { WSError } from '../index.mjs';
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DTY7a69w.mjs';
+import { d as defineWebSocketAdapter, a as adapterUtils, A as AdapterHookable } from '../shared/crossws.B4sHId41.mjs';
+import { W as WSError } from '../shared/crossws.By9qWDAI.mjs';
+import 'uncrypto';
 
 const cloudflare = defineWebSocketAdapter(
   (options = {}) => {
-    const crossws = createCrossWS(options);
-    const handleUpgrade = async (req, env, context) => {
-      const pair = new WebSocketPair();
-      const client = pair[0];
-      const server = pair[1];
-      const peer = new CloudflarePeer({
-        cloudflare: { client, server, req, env, context }
-      });
-      const { headers } = await crossws.upgrade(peer);
-      server.accept();
-      crossws.$callHook("cloudflare:accept", peer);
-      crossws.callHook("open", peer);
-      server.addEventListener("message", (event) => {
-        crossws.$callHook("cloudflare:message", peer, event);
-        crossws.callHook("message", peer, new Message(event.data));
-      });
-      server.addEventListener("error", (event) => {
-        crossws.$callHook("cloudflare:error", peer, event);
-        crossws.callHook("error", peer, new WSError(event.error));
-      });
-      server.addEventListener("close", (event) => {
-        crossws.$callHook("cloudflare:close", peer, event);
-        crossws.callHook("close", peer, {
-          code: event.code,
-          reason: event.reason
-        });
-      });
-      return new Response(null, {
-        status: 101,
-        webSocket: client,
-        headers
-      });
-    };
+    const hooks = new AdapterHookable(options);
+    const peers = /* @__PURE__ */ new Set();
     return {
-      handleUpgrade
+      ...adapterUtils(peers),
+      handleUpgrade: async (request, env, context) => {
+        const res = await hooks.callHook(
+          "upgrade",
+          request
+        );
+        if (res instanceof Response) {
+          return res;
+        }
+        const pair = new WebSocketPair();
+        const client = pair[0];
+        const server = pair[1];
+        const peer = new CloudflarePeer({
+          ws: client,
+          peers,
+          wsServer: server,
+          request,
+          cfEnv: env,
+          cfCtx: context
+        });
+        peers.add(peer);
+        server.accept();
+        hooks.callHook("open", peer);
+        server.addEventListener("message", (event) => {
+          hooks.callHook(
+            "message",
+            peer,
+            new Message(event.data, peer, event)
+          );
+        });
+        server.addEventListener("error", (event) => {
+          peers.delete(peer);
+          hooks.callHook("error", peer, new WSError(event.error));
+        });
+        server.addEventListener("close", (event) => {
+          peers.delete(peer);
+          hooks.callHook("close", peer, event);
+        });
+        return new Response(null, {
+          status: 101,
+          webSocket: client,
+          headers: res?.headers
+        });
+      }
     };
   }
 );
 class CloudflarePeer extends Peer {
-  get id() {
-    return void 0;
-  }
-  get url() {
-    return this.ctx.cloudflare.req.url;
-  }
-  get headers() {
-    return this.ctx.cloudflare.req.headers;
+  send(data) {
+    this._internal.wsServer.send(toBufferLike(data));
+    return 0;
   }
-  get readyState() {
-    return this.ctx.cloudflare.client.readyState;
+  publish(_topic, _message) {
   }
-  send(message) {
-    this.ctx.cloudflare.server.send(toBufferLike(message));
-    return 0;
+  close(code, reason) {
+    this._internal.ws.close(code, reason);
   }
 }
 

package/dist/adapters/deno.d.mts

@@ -1,7 +1,8 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.mjs';
+import { AdapterInstance, AdapterOptions, Adapter } from '../index.mjs';
 import * as _deno_types from '@deno/types';
+import '../shared/crossws.ChIJSJVK.mjs';
 
-interface DenoAdapter {
+interface DenoAdapter extends AdapterInstance {
     handleUpgrade(req: Request, info: ServeHandlerInfo): Promise<Response>;
 }
 interface DenoOptions extends AdapterOptions {
@@ -9,7 +10,13 @@ interface DenoOptions extends AdapterOptions {
 declare global {
     const Deno: typeof _deno_types.Deno;
 }
-type ServeHandlerInfo = any;
+type ServeHandlerInfo = {
+    remoteAddr?: {
+        transport: string;
+        hostname: string;
+        port: number;
+    };
+};
 declare const _default: Adapter<DenoAdapter, DenoOptions>;
 
 export { type DenoAdapter, type DenoOptions, _default as default };

package/dist/adapters/deno.d.ts

@@ -1,7 +1,8 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.js';
+import { AdapterInstance, AdapterOptions, Adapter } from '../index.js';
 import * as _deno_types from '@deno/types';
+import '../shared/crossws.ChIJSJVK.js';
 
-interface DenoAdapter {
+interface DenoAdapter extends AdapterInstance {
     handleUpgrade(req: Request, info: ServeHandlerInfo): Promise<Response>;
 }
 interface DenoOptions extends AdapterOptions {
@@ -9,7 +10,13 @@ interface DenoOptions extends AdapterOptions {
 declare global {
     const Deno: typeof _deno_types.Deno;
 }
-type ServeHandlerInfo = any;
+type ServeHandlerInfo = {
+    remoteAddr?: {
+        transport: string;
+        hostname: string;
+        port: number;
+    };
+};
 declare const _default: Adapter<DenoAdapter, DenoOptions>;
 
 export { type DenoAdapter, type DenoOptions, _default as default };