@lesomnus/grpc-dgram 0.0.1 → 0.1.0

package/dist/{protocol-K4Zy8MuQ.mjs → protocol-CTxSUZQF.mjs}

@@ -9,16 +9,17 @@ const DefaultWasmExec = "/wasm_exec.js";
 async function startInstance(app, opts = {}) {
 	const name = opts.entryPoint ?? "drpcServe";
 	const entry = claimEntryPoint(name);
+	const readyTimeoutMs = opts.readyTimeoutMs ?? 1e4;
 	try {
 		const go = opts.go ?? await newGo(String(opts.wasmExec ?? "/wasm_exec.js"));
 		const instance = await instantiate(app, go.importObject);
 		const run = go.run(instance);
-		return live(name, go, await awaitPublish(entry.published, run, name, opts.readyTimeoutMs ?? 1e4), run);
+		return live(name, go, await awaitPublish(entry.published, run, name, readyTimeoutMs), run, readyTimeoutMs);
 	} finally {
 		entry.release();
 	}
 }
-function live(name, go, serve, run) {
+function live(name, go, serve, run, timeoutMs) {
 	let dead;
 	let announce;
 	const exited = new Promise((res) => {
@@ -34,18 +35,29 @@ function live(name, go, serve, run) {
 	return {
 		entryPoint: name,
 		exited,
-		serve(port) {
+		serve(port, entryPoint, readyTimeoutMs) {
 			if (dead !== void 0) throw new Error(`wasm: the instance behind globalThis.${name} has exited${dead.cause instanceof Error ? `: ${dead.cause.message}` : ""}`);
-			serve(port);
+			if (entryPoint === void 0 || entryPoint === name) {
+				serve(port);
+				return Promise.resolve();
+			}
+			return entryPointNamed(entryPoint, readyTimeoutMs ?? timeoutMs, exited).then((fn) => {
+				if (dead !== void 0) throw new Error(`wasm: the instance behind globalThis.${name} exited while waiting for globalThis.${entryPoint}`);
+				fn(port);
+			});
 		}
 	};
 }
 function makeInert(go) {
 	const inner = go;
 	if (typeof inner._resume === "function") inner._resume = noop;
+	if (inner._scheduledTimeouts instanceof Map) {
+		for (const t of inner._scheduledTimeouts.values()) clearTimeout(t);
+		inner._scheduledTimeouts.clear();
+	}
 }
 const awaiting = /* @__PURE__ */ new Set();
-function claimEntryPoint(name) {
+function claimEntryPoint(name, after = "restore") {
 	if (awaiting.has(name)) throw new Error(`wasm: another instance is already waiting for globalThis.${name}; give one of them its own entryPoint`);
 	const g = globalThis;
 	const prev = Object.getOwnPropertyDescriptor(g, name);
@@ -70,11 +82,54 @@ function claimEntryPoint(name) {
 			if (released) return;
 			released = true;
 			awaiting.delete(name);
+			if (after === "keep" && value !== void 0) {
+				Object.defineProperty(g, name, {
+					configurable: true,
+					writable: true,
+					enumerable: true,
+					value
+				});
+				return;
+			}
 			if (prev === void 0) Reflect.deleteProperty(g, name);
 			else Object.defineProperty(g, name, prev);
 		}
 	};
 }
+const waits = /* @__PURE__ */ new Map();
+function entryPointNamed(name, timeoutMs, exited) {
+	const g = globalThis;
+	const v = Object.prototype.hasOwnProperty.call(g, name) ? g[name] : void 0;
+	if (typeof v === "function") return Promise.resolve(v);
+	if (v !== void 0) return Promise.reject(/* @__PURE__ */ new Error(`wasm: globalThis.${name} is a ${typeof v}, not a function taking one port`));
+	const pending = waits.get(name);
+	if (pending !== void 0) return pending;
+	if (awaiting.has(name)) return Promise.reject(/* @__PURE__ */ new Error(`wasm: an instance is starting on globalThis.${name}; it cannot be dialled as a second entry point at the same time`));
+	const w = watchEntryPoint(name, timeoutMs, exited);
+	waits.set(name, w);
+	w.catch(noop).then(() => {
+		if (waits.get(name) === w) waits.delete(name);
+	});
+	return w;
+}
+function watchEntryPoint(name, timeoutMs, exited) {
+	const entry = claimEntryPoint(name, "keep");
+	let timer;
+	const arms = [entry.published, exited.then((cause) => {
+		throw new Error(`wasm: the instance exited before publishing globalThis.${name}`, { cause });
+	})];
+	if (timeoutMs > 0) arms.push(new Promise((_, rej) => {
+		timer = setTimeout(() => rej(/* @__PURE__ */ new Error(`wasm: no globalThis.${name} after ${timeoutMs} ms — is that the name the second gateway serves under, and does it reach Serve?`)), timeoutMs);
+		unrefTimer(timer);
+	}));
+	return Promise.race(arms).then((fn) => {
+		if (typeof fn !== "function") throw new Error(`wasm: globalThis.${name} was set to a ${typeof fn}, not a function taking one port`);
+		return fn;
+	}).finally(() => {
+		if (timer !== void 0) clearTimeout(timer);
+		entry.release();
+	});
+}
 async function awaitPublish(published, run, name, timeoutMs) {
 	let timer;
 	const arms = [published, run.then(() => {

package/dist/transport/connect.d.mts

@@ -1,4 +1,4 @@
-import { n as Conn } from "../conn-DTWG9vIx.mjs";
+import { r as Conn } from "../conn-Dc57BC-h.mjs";
 import { Transport } from "@connectrpc/connect";
 //#region src/transport/connect/index.d.ts
 declare function createDrpcTransport(conn: Conn): Transport;

package/dist/transport/node-udp.d.mts

@@ -1,9 +1,8 @@
-import { O as Frame, _ as TransportInfo, g as FrameHandler, h as FrameContext, m as ConnAttacher, n as Conn, r as ConnOptions } from "../conn-DTWG9vIx.mjs";
-import { r as Server } from "../server-xIr1mwqq.mjs";
+import { F as EnvelopeSender, I as FrameContext, L as FrameHandler, P as ConnAttacher, R as TransportInfo, Y as Frame, b as Server, i as ConnOptions, r as Conn } from "../conn-Dc57BC-h.mjs";
 import { Socket } from "node:dgram";
 //#region src/transport/node-udp/index.d.ts
 declare const DefaultMaxMessageSize = 1200;
-declare class UdpTransport implements FrameHandler, TransportInfo, ConnAttacher {
+declare class UdpTransport implements FrameHandler, TransportInfo, ConnAttacher, EnvelopeSender {
   private readonly socket;
   private readonly max;
   private conn;
@@ -13,10 +12,11 @@ declare class UdpTransport implements FrameHandler, TransportInfo, ConnAttacher
   });
   reliable(): boolean;
   attachConn(conn: Conn): void;
+  sendFrames(frames: readonly Frame[]): Promise<void>;
   handle(f: Frame): Promise<void>;
   close(err?: unknown): void;
 }
-declare class UdpGateway implements FrameHandler {
+declare class UdpGateway implements FrameHandler, EnvelopeSender {
   private readonly socket;
   private readonly max;
   private readonly peers;
@@ -26,6 +26,7 @@ declare class UdpGateway implements FrameHandler {
     maxMessageSize?: number;
   });
   serve(server: Server): Promise<void>;
+  sendFrames(frames: readonly Frame[], ctx?: FrameContext): Promise<void>;
   handle(f: Frame, ctx?: FrameContext): Promise<void>;
   close(): void;
 }

package/dist/transport/node-udp.mjs

@@ -1,6 +1,6 @@
-import { $ as unpack, c as decodeEnvelop, u as encodeEnvelop } from "../wire-BR8KiyRg.mjs";
+import { n as Conn } from "../conn-CmYPHTPR.mjs";
+import { c as decodeEnvelope, it as unpack, u as encodeEnvelope } from "../wire-DqHx0oUs.mjs";
 import { n as MessageTooLargeError } from "../status-DZwMDWIn.mjs";
-import { n as Conn } from "../conn-DOmx4nbt.mjs";
 import { createSocket } from "node:dgram";
 //#region src/transport/node-udp/index.ts
 const DefaultMaxMessageSize = 1200;
@@ -36,7 +36,7 @@ var UdpTransport = class {
 		this.socket.on("message", (data) => {
 			let frames;
 			try {
-				frames = decodeEnvelop(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+				frames = decodeEnvelope(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
 			} catch {
 				return;
 			}
@@ -48,11 +48,14 @@ var UdpTransport = class {
 		});
 		this.socket.on("close", () => this.conn?.close());
 	}
-	handle(f) {
-		const data = encodeEnvelop([f]);
-		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`node-udp: ${data.length}-byte envelop over the ${this.max}-byte limit`);
+	sendFrames(frames) {
+		const data = encodeEnvelope(frames);
+		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`node-udp: ${data.length}-byte envelope over the ${this.max}-byte limit`);
 		return sendDatagram(this.socket, data);
 	}
+	handle(f) {
+		return this.sendFrames([f]);
+	}
 	close(err) {
 		if (this.closed) return;
 		this.closed = true;
@@ -87,7 +90,7 @@ var UdpGateway = class {
 				});
 				let frames;
 				try {
-					frames = decodeEnvelop(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+					frames = decodeEnvelope(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
 				} catch {
 					return;
 				}
@@ -100,15 +103,18 @@ var UdpGateway = class {
 			this.socket.on("error", () => this.close());
 		});
 	}
-	handle(f, ctx = {}) {
+	sendFrames(frames, ctx = {}) {
 		const key = ctx.peer;
 		if (typeof key !== "string") return Promise.reject(/* @__PURE__ */ new Error(`node-udp: no gateway peer in context (got ${String(key)})`));
 		const target = this.peers.get(key);
 		if (target === void 0) return Promise.reject(/* @__PURE__ */ new Error(`node-udp: peer ${key} is unknown`));
-		const data = encodeEnvelop([f]);
-		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`node-udp: ${data.length}-byte envelop over the ${this.max}-byte limit`);
+		const data = encodeEnvelope(frames);
+		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`node-udp: ${data.length}-byte envelope over the ${this.max}-byte limit`);
 		return sendDatagram(this.socket, data, target);
 	}
+	handle(f, ctx = {}) {
+		return this.sendFrames([f], ctx);
+	}
 	close() {
 		if (this.closed) return;
 		this.closed = true;

package/dist/transport/port.d.mts

@@ -1,5 +1,4 @@
-import { O as Frame, _ as TransportInfo, g as FrameHandler, h as FrameContext, m as ConnAttacher, n as Conn, r as ConnOptions } from "../conn-DTWG9vIx.mjs";
-import { r as Server } from "../server-xIr1mwqq.mjs";
+import { F as EnvelopeSender, I as FrameContext, L as FrameHandler, P as ConnAttacher, R as TransportInfo, Y as Frame, b as Server, i as ConnOptions, r as Conn } from "../conn-Dc57BC-h.mjs";
 //#region src/transport/port/index.d.ts
 declare const DefaultMaxMessageSize = 0;
 interface PortLike {
@@ -16,12 +15,13 @@ interface PortOptions {
   maxMessageSize?: number;
   transfer?: boolean;
 }
-declare class PortTransport implements FrameHandler, TransportInfo, ConnAttacher {
+declare class PortTransport implements FrameHandler, TransportInfo, ConnAttacher, EnvelopeSender {
   private readonly pt;
   private attached;
   constructor(port: PortLike, opts?: PortOptions);
   reliable(): boolean;
   attachConn(conn: Conn): void;
+  sendFrames(frames: readonly Frame[]): Promise<void>;
   handle(f: Frame): Promise<void>;
   close(cause?: unknown): void;
 }
@@ -32,7 +32,7 @@ interface WorkerDialOptions extends PortOptions {
   message?: unknown;
 }
 declare function dialWorker(worker: WorkerLike, opts?: ConnOptions & WorkerDialOptions): Conn;
-declare class PortGateway implements FrameHandler, TransportInfo {
+declare class PortGateway implements FrameHandler, TransportInfo, EnvelopeSender {
   private readonly o;
   private next;
   private readonly ports;
@@ -45,6 +45,7 @@ declare class PortGateway implements FrameHandler, TransportInfo {
   servePeer(server: Server, port: PortLike, opts?: {
     signal?: AbortSignal;
   }): Promise<unknown>;
+  sendFrames(frames: readonly Frame[], ctx?: FrameContext): Promise<void>;
   handle(f: Frame, ctx?: FrameContext): Promise<void>;
   close(): void;
 }

package/dist/transport/port.mjs

@@ -1,6 +1,6 @@
-import { $ as unpack, F as Latch, G as noop, R as abortListener, c as decodeEnvelop, u as encodeEnvelop } from "../wire-BR8KiyRg.mjs";
+import { n as Conn } from "../conn-CmYPHTPR.mjs";
+import { F as Latch, V as abortListener, Y as noop, c as decodeEnvelope, it as unpack, u as encodeEnvelope } from "../wire-DqHx0oUs.mjs";
 import { n as MessageTooLargeError, r as StatusError } from "../status-DZwMDWIn.mjs";
-import { n as Conn } from "../conn-DOmx4nbt.mjs";
 //#region src/transport/port/index.ts
 const DefaultMaxMessageSize = 0;
 const GOODBYE = /* @__PURE__ */ new Uint8Array(0);
@@ -66,8 +66,9 @@ var Port = class {
 		wakeAll(this.rxWaiters);
 	}
 	async send(frames) {
-		const data = encodeEnvelop(frames);
-		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`port: ${data.length}-byte envelop over the ${this.max}-byte limit`);
+		if (frames.length === 0) return;
+		const data = encodeEnvelope(frames);
+		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`port: ${data.length}-byte envelope over the ${this.max}-byte limit`);
 		if (this.dead.tripped) throw this.closedErr();
 		try {
 			this.post(data);
@@ -101,7 +102,7 @@ var Port = class {
 				}
 				let frames;
 				try {
-					frames = decodeEnvelop(data);
+					frames = decodeEnvelope(data);
 				} catch {
 					continue;
 				}
@@ -152,8 +153,11 @@ var PortTransport = class {
 			this.close();
 		})();
 	}
+	sendFrames(frames) {
+		return this.pt.send(frames);
+	}
 	handle(f) {
-		return this.pt.send([f]);
+		return this.sendFrames([f]);
 	}
 	close(cause) {
 		this.pt.close(cause);
@@ -225,12 +229,15 @@ var PortGateway = class {
 			this.drop(port, b);
 		}
 	}
-	handle(f, ctx = {}) {
+	sendFrames(frames, ctx = {}) {
 		const key = ctx.peer;
 		if (typeof key !== "number") return Promise.reject(/* @__PURE__ */ new Error(`port: no gateway peer in context (got ${String(key)})`));
 		const pt = this.peers.get(key);
 		if (pt === void 0) return Promise.reject(/* @__PURE__ */ new Error(`port: peer ${key} is disconnected`));
-		return pt.send([f]);
+		return pt.send(frames);
+	}
+	handle(f, ctx = {}) {
+		return this.sendFrames([f], ctx);
 	}
 	close() {
 		for (const b of [...this.ports.values()]) b.pt.close();

package/dist/transport/webrtc.d.mts

@@ -1,5 +1,4 @@
-import { O as Frame, h as FrameContext, n as Conn } from "../conn-DTWG9vIx.mjs";
-import { r as Server } from "../server-xIr1mwqq.mjs";
+import { F as EnvelopeSender, I as FrameContext, L as FrameHandler, Y as Frame, b as Server, r as Conn } from "../conn-Dc57BC-h.mjs";
 //#region src/transport/webrtc/index.d.ts
 declare const DefaultMaxMessageSizeUnreliable = 1200;
 declare const DefaultMaxMessageSizeReliable: number;
@@ -28,17 +27,18 @@ interface DataChannelOptions {
   sendStallTimeoutMs?: number;
 }
 declare function channelReliable(dc: DataChannelLike): boolean;
-declare class DataChannelTransport {
+declare class DataChannelTransport implements FrameHandler, EnvelopeSender {
   private readonly ch;
   private attached;
   private closed;
   constructor(dc: DataChannelLike, opts?: DataChannelOptions);
   reliable(): boolean;
   attachConn(conn: Conn): void;
+  sendFrames(frames: readonly Frame[], ctx?: FrameContext): Promise<void>;
   handle(f: Frame, ctx?: FrameContext): Promise<void>;
   close(): void;
 }
-declare class DataChannelGateway {
+declare class DataChannelGateway implements FrameHandler, EnvelopeSender {
   private readonly o;
   private next;
   private readonly chans;
@@ -50,6 +50,7 @@ declare class DataChannelGateway {
   servePeer(server: Server, dc: DataChannelLike, opts?: {
     signal?: AbortSignal;
   }): Promise<unknown>;
+  sendFrames(frames: readonly Frame[], ctx?: FrameContext): Promise<void>;
   handle(f: Frame, ctx?: FrameContext): Promise<void>;
 }
 //#endregion

package/dist/transport/webrtc.mjs

@@ -1,4 +1,4 @@
-import { $ as unpack, F as Latch, G as noop, R as abortListener, X as unrefTimer, c as decodeEnvelop, u as encodeEnvelop } from "../wire-BR8KiyRg.mjs";
+import { F as Latch, V as abortListener, Y as noop, c as decodeEnvelope, it as unpack, tt as unrefTimer, u as encodeEnvelope } from "../wire-DqHx0oUs.mjs";
 import { n as MessageTooLargeError } from "../status-DZwMDWIn.mjs";
 //#region src/transport/webrtc/index.ts
 const DefaultMaxMessageSizeUnreliable = 1200;
@@ -64,8 +64,8 @@ var Channel = class {
 		wakeAll(this.rxWaiters);
 	}
 	async send(frames, signal) {
-		const data = encodeEnvelop(frames);
-		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`webrtc: ${data.length}-byte envelop over the ${this.max}-byte limit`);
+		const data = encodeEnvelope(frames);
+		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`webrtc: ${data.length}-byte envelope over the ${this.max}-byte limit`);
 		const stalled = new Latch();
 		let stallTimer;
 		if (this.stallMs > 0) {
@@ -129,7 +129,7 @@ var Channel = class {
 			if (data !== void 0) {
 				let frames;
 				try {
-					frames = decodeEnvelop(data);
+					frames = decodeEnvelope(data);
 				} catch {
 					continue;
 				}
@@ -168,8 +168,11 @@ var DataChannelTransport = class {
 			conn.close(err);
 		})();
 	}
+	sendFrames(frames, ctx = {}) {
+		return this.ch.send(frames, ctx.signal);
+	}
 	handle(f, ctx = {}) {
-		return this.ch.send([f], ctx.signal);
+		return this.sendFrames([f], ctx);
 	}
 	close() {
 		if (this.closed) return;
@@ -228,12 +231,15 @@ var DataChannelGateway = class {
 			this.drop(dc, b);
 		}
 	}
-	handle(f, ctx = {}) {
+	sendFrames(frames, ctx = {}) {
 		const key = ctx.peer;
 		if (typeof key !== "number") return Promise.reject(/* @__PURE__ */ new Error(`webrtc: no gateway peer in context (got ${String(key)})`));
 		const ch = this.peers.get(key);
 		if (ch === void 0) return Promise.reject(/* @__PURE__ */ new Error(`webrtc: peer ${key} is gone`));
-		return ch.send([f], ctx.signal);
+		return ch.send(frames, ctx.signal);
+	}
+	handle(f, ctx = {}) {
+		return this.sendFrames([f], ctx);
 	}
 };
 //#endregion

package/dist/transport/websocket.d.mts

@@ -1,5 +1,4 @@
-import { O as Frame, _ as TransportInfo, g as FrameHandler, h as FrameContext, m as ConnAttacher, n as Conn, r as ConnOptions } from "../conn-DTWG9vIx.mjs";
-import { r as Server } from "../server-xIr1mwqq.mjs";
+import { F as EnvelopeSender, I as FrameContext, L as FrameHandler, P as ConnAttacher, R as TransportInfo, Y as Frame, b as Server, i as ConnOptions, r as Conn } from "../conn-Dc57BC-h.mjs";
 //#region src/transport/websocket/index.d.ts
 declare const DefaultMaxMessageSize = 0;
 declare const DefaultMaxBufferedAmount: number;
@@ -26,17 +25,18 @@ interface WebSocketOptions {
   keepaliveIntervalMs?: number;
   keepaliveTimeoutMs?: number;
 }
-declare class WebSocketTransport implements FrameHandler, TransportInfo, ConnAttacher {
+declare class WebSocketTransport implements FrameHandler, TransportInfo, ConnAttacher, EnvelopeSender {
   private readonly sock;
   private attached;
   private closed;
   constructor(ws: WebSocketLike, opts?: WebSocketOptions);
   reliable(): boolean;
   attachConn(conn: Conn): void;
+  sendFrames(frames: readonly Frame[], ctx?: FrameContext): Promise<void>;
   handle(f: Frame, ctx?: FrameContext): Promise<void>;
   close(): void;
 }
-declare class WebSocketGateway implements FrameHandler, TransportInfo {
+declare class WebSocketGateway implements FrameHandler, TransportInfo, EnvelopeSender {
   private readonly o;
   private next;
   private readonly socks;
@@ -49,6 +49,7 @@ declare class WebSocketGateway implements FrameHandler, TransportInfo {
   servePeer(server: Server, ws: WebSocketLike, opts?: {
     signal?: AbortSignal;
   }): Promise<unknown>;
+  sendFrames(frames: readonly Frame[], ctx?: FrameContext): Promise<void>;
   handle(f: Frame, ctx?: FrameContext): Promise<void>;
   close(): void;
 }

package/dist/transport/websocket.mjs

@@ -1,6 +1,6 @@
-import { $ as unpack, F as Latch, G as noop, R as abortListener, X as unrefTimer, c as decodeEnvelop, u as encodeEnvelop } from "../wire-BR8KiyRg.mjs";
+import { n as Conn } from "../conn-CmYPHTPR.mjs";
+import { F as Latch, V as abortListener, Y as noop, c as decodeEnvelope, it as unpack, tt as unrefTimer, u as encodeEnvelope } from "../wire-DqHx0oUs.mjs";
 import { n as MessageTooLargeError, r as StatusError } from "../status-DZwMDWIn.mjs";
-import { n as Conn } from "../conn-DOmx4nbt.mjs";
 //#region src/transport/websocket/index.ts
 const CONNECTING = 0;
 const OPEN = 1;
@@ -129,8 +129,8 @@ var Socket = class {
 		wakeAll(this.rxWaiters);
 	}
 	async send(frames, signal) {
-		const data = encodeEnvelop(frames);
-		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`websocket: ${data.length}-byte envelop over the ${this.max}-byte limit`);
+		const data = encodeEnvelope(frames);
+		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`websocket: ${data.length}-byte envelope over the ${this.max}-byte limit`);
 		const stalled = new Latch();
 		let stallTimer;
 		if (this.stallMs > 0) {
@@ -198,7 +198,7 @@ var Socket = class {
 			if (data !== void 0) {
 				let frames;
 				try {
-					frames = decodeEnvelop(data);
+					frames = decodeEnvelope(data);
 				} catch {
 					continue;
 				}
@@ -244,8 +244,11 @@ var WebSocketTransport = class {
 			this.close();
 		})();
 	}
+	sendFrames(frames, ctx = {}) {
+		return this.sock.send(frames, ctx.signal);
+	}
 	handle(f, ctx = {}) {
-		return this.sock.send([f], ctx.signal);
+		return this.sendFrames([f], ctx);
 	}
 	close() {
 		if (this.closed) return;
@@ -304,12 +307,15 @@ var WebSocketGateway = class {
 			this.drop(ws, b);
 		}
 	}
-	handle(f, ctx = {}) {
+	sendFrames(frames, ctx = {}) {
 		const key = ctx.peer;
 		if (typeof key !== "number") return Promise.reject(/* @__PURE__ */ new Error(`websocket: no gateway peer in context (got ${String(key)})`));
 		const sock = this.peers.get(key);
 		if (sock === void 0) return Promise.reject(/* @__PURE__ */ new Error(`websocket: peer ${key} is disconnected`));
-		return sock.send([f], ctx.signal);
+		return sock.send(frames, ctx.signal);
+	}
+	handle(f, ctx = {}) {
+		return this.sendFrames([f], ctx);
 	}
 	close() {
 		for (const b of [...this.socks.values()]) b.sock.close();

package/dist/transport/webtransport.d.mts

@@ -0,0 +1,53 @@
+import { F as EnvelopeSender, L as FrameHandler, P as ConnAttacher, R as TransportInfo, Y as Frame, i as ConnOptions, r as Conn } from "../conn-Dc57BC-h.mjs";
+//#region src/transport/webtransport/index.d.ts
+declare const DefaultMaxMessageSize = 1200;
+interface WebTransportLike {
+  readonly ready: Promise<void>;
+  readonly closed: Promise<unknown>;
+  readonly datagrams: {
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable?: WritableStream<Uint8Array>;
+    createWritable?(): WritableStream<Uint8Array>;
+    readonly maxDatagramSize?: number;
+  };
+  close(info?: unknown): void;
+}
+interface WebTransportDatagramOptions {
+  maxMessageSize?: number;
+}
+interface WebTransportDialOptions {
+  allowPooling?: boolean;
+  congestionControl?: 'default' | 'throughput' | 'low-latency';
+  protocols?: string[];
+  requireUnreliable?: boolean;
+  serverCertificateHashes?: {
+    algorithm: string;
+    value: ArrayBuffer | ArrayBufferView<ArrayBuffer>;
+  }[];
+}
+declare class WebTransportDatagramTransport implements FrameHandler, TransportInfo, ConnAttacher, EnvelopeSender {
+  private readonly wt;
+  private readonly max;
+  private readonly writer;
+  private reader;
+  private readonly opened;
+  private readonly dead;
+  private err;
+  private attached;
+  private closed;
+  constructor(wt: WebTransportLike, opts?: WebTransportDatagramOptions);
+  reliable(): boolean;
+  attachConn(conn: Conn): void;
+  private pump;
+  private limit;
+  private check;
+  sendFrames(frames: readonly Frame[]): Promise<void>;
+  handle(f: Frame): Promise<void>;
+  private send;
+  private fail;
+  private closedErr;
+  close(): void;
+}
+declare function dialWebTransport(url: string, opts?: ConnOptions & WebTransportDatagramOptions & WebTransportDialOptions): Conn;
+//#endregion
+export { DefaultMaxMessageSize, WebTransportDatagramOptions, WebTransportDatagramTransport, WebTransportDialOptions, WebTransportLike, dialWebTransport };