@lesomnus/grpc-dgram 0.0.1

package/dist/protocol-K4Zy8MuQ.mjs

@@ -0,0 +1,156 @@
+//#region src/wasm/instance.ts
+const noop = () => {};
+function unrefTimer(t) {
+	t.unref?.();
+}
+const DefaultEntryPoint = "drpcServe";
+const DefaultReadyTimeoutMs = 1e4;
+const DefaultWasmExec = "/wasm_exec.js";
+async function startInstance(app, opts = {}) {
+	const name = opts.entryPoint ?? "drpcServe";
+	const entry = claimEntryPoint(name);
+	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);
+	} finally {
+		entry.release();
+	}
+}
+function live(name, go, serve, run) {
+	let dead;
+	let announce;
+	const exited = new Promise((res) => {
+		announce = res;
+	});
+	const died = (cause) => {
+		if (dead !== void 0) return;
+		dead = { cause };
+		makeInert(go);
+		announce(cause);
+	};
+	run.then(() => died(/* @__PURE__ */ new Error("the wasm instance exited")), (e) => died(new Error(`the wasm instance failed: ${e instanceof Error ? e.message : String(e)}`, { cause: e })));
+	return {
+		entryPoint: name,
+		exited,
+		serve(port) {
+			if (dead !== void 0) throw new Error(`wasm: the instance behind globalThis.${name} has exited${dead.cause instanceof Error ? `: ${dead.cause.message}` : ""}`);
+			serve(port);
+		}
+	};
+}
+function makeInert(go) {
+	const inner = go;
+	if (typeof inner._resume === "function") inner._resume = noop;
+}
+const awaiting = /* @__PURE__ */ new Set();
+function claimEntryPoint(name) {
+	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);
+	let value;
+	let publish;
+	const published = new Promise((res) => {
+		publish = res;
+	});
+	Object.defineProperty(g, name, {
+		configurable: true,
+		get: () => value,
+		set: (v) => {
+			value = v;
+			publish(v);
+		}
+	});
+	awaiting.add(name);
+	let released = false;
+	return {
+		published,
+		release() {
+			if (released) return;
+			released = true;
+			awaiting.delete(name);
+			if (prev === void 0) Reflect.deleteProperty(g, name);
+			else Object.defineProperty(g, name, prev);
+		}
+	};
+}
+async function awaitPublish(published, run, name, timeoutMs) {
+	let timer;
+	const arms = [published, run.then(() => {
+		throw new Error(`wasm: the instance exited before publishing globalThis.${name} — see the console for what it printed`);
+	}, (e) => {
+		throw new Error(`wasm: the instance failed before publishing globalThis.${name}`, { cause: e });
+	})];
+	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 server serves under?`)), timeoutMs);
+		unrefTimer(timer);
+	}));
+	try {
+		const serve = await Promise.race(arms);
+		if (typeof serve !== "function") throw new Error(`wasm: globalThis.${name} was set to a ${typeof serve}, not a function taking one port`);
+		return serve;
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+async function newGo(wasmExec) {
+	let ctor = goCtor();
+	if (ctor === void 0) {
+		await loadWasmExec(wasmExec);
+		ctor = goCtor();
+		if (ctor === void 0) throw new Error(`wasm: ${wasmExec} loaded but defined no globalThis.Go — is that the toolchain's wasm_exec.js?`);
+	}
+	return new ctor();
+}
+function goCtor() {
+	const ctor = globalThis.Go;
+	return typeof ctor === "function" ? ctor : void 0;
+}
+async function loadWasmExec(url) {
+	let res;
+	try {
+		res = await fetch(url);
+	} catch (e) {
+		throw new Error(missingWasmExec(url, String(e)), { cause: e });
+	}
+	if (!res.ok) throw new Error(missingWasmExec(url, `${res.status} ${res.statusText}`));
+	new Function(await res.text())();
+}
+function missingWasmExec(url, why) {
+	return `wasm: GET ${url} failed (${why}) — wasm_exec.js is the JS half of the Go runtime, and this package does not ship it: it is version-coupled to the compiler that built your module, so a vendored copy would pin the wrong one. Serve your toolchain's:
+  cp "\$(go env GOROOT)/lib/wasm/wasm_exec.js" ./public/
+or load it yourself before starting — a realm that already has globalThis.Go fetches nothing.`;
+}
+async function instantiate(app, imports) {
+	if (app instanceof WebAssembly.Module) return WebAssembly.instantiate(app, imports);
+	if (typeof app === "string" || app instanceof URL) return fromResponse(fetch(String(app)), String(app), imports);
+	return (await WebAssembly.instantiate(app, imports)).instance;
+}
+async function fromResponse(src, url, imports) {
+	const res = await src;
+	if (!res.ok) {
+		const body = await res.text().catch(() => "");
+		throw new Error(`wasm: GET ${url} failed: ${res.status} ${res.statusText}${body === "" ? "" : `\n${body}`}`);
+	}
+	if (typeof WebAssembly.instantiateStreaming === "function" && mimeOf(res) === "application/wasm") return (await WebAssembly.instantiateStreaming(res, imports)).instance;
+	return (await WebAssembly.instantiate(await res.arrayBuffer(), imports)).instance;
+}
+function mimeOf(res) {
+	return ((res.headers.get("content-type") ?? "").split(";")[0] ?? "").trim().toLowerCase();
+}
+//#endregion
+//#region src/wasm/protocol.ts
+function isPageMessage(v) {
+	const tag = tagOf(v);
+	return tag === "start" || tag === "serve";
+}
+function isWorkerMessage(v) {
+	const tag = tagOf(v);
+	return tag === "ready" || tag === "error" || tag === "exited";
+}
+function tagOf(v) {
+	return typeof v === "object" && v !== null ? v.drpc : void 0;
+}
+//#endregion
+export { DefaultWasmExec as a, DefaultReadyTimeoutMs as i, isWorkerMessage as n, startInstance as o, DefaultEntryPoint as r, isPageMessage as t };

package/dist/server-xIr1mwqq.d.mts

@@ -0,0 +1,112 @@
+import { O as Frame, at as Limits, c as Compressor, g as FrameHandler, h as FrameContext, o as FlowTiming, ot as RxBufferConfig, st as ResolvedTiming } from "./conn-DTWG9vIx.mjs";
+import { a as MethodDesc, h as Metadata, o as NamedCodec } from "./desc-BMF2FBqk.mjs";
+//#region src/server.d.ts
+interface ServerOptions {
+  reliable?: boolean;
+  timing?: FlowTiming;
+  maxHandlerTimeoutMs?: number;
+  rxBuffer?: RxBufferConfig;
+  methodRxBuffer?: Record<string, RxBufferConfig>;
+  limits?: Limits;
+  codecs?: Record<string, NamedCodec>;
+  compressors?: Record<string, Compressor>;
+  maxRecvMsgSize?: number;
+  maxSendMsgSize?: number;
+}
+interface ServerContext {
+  readonly signal: AbortSignal;
+  readonly metadata: Metadata | undefined;
+  readonly peer: unknown;
+  readonly method: string;
+  readonly deadline: number | undefined;
+  setHeader(md: Metadata): void;
+  sendHeader(md?: Metadata): Promise<void>;
+  setTrailer(md: Metadata): void;
+}
+interface ServerReader<Req> {
+  recv(): Promise<Req | undefined>;
+  [Symbol.asyncIterator](): AsyncIterator<Req>;
+}
+interface ServerWriter<Res> {
+  send(msg: Res): Promise<void>;
+}
+type UnaryHandler<Req, Res> = (req: Req, ctx: ServerContext) => Res | Promise<Res>;
+type ServerStreamingHandler<Req, Res> = (req: Req, stream: ServerWriter<Res>, ctx: ServerContext) => void | Promise<void>;
+type ClientStreamingHandler<Req, Res> = (stream: ServerReader<Req>, ctx: ServerContext) => Res | Promise<Res>;
+type BidiHandler<Req, Res> = (stream: ServerReader<Req> & ServerWriter<Res>, ctx: ServerContext) => void | Promise<void>;
+declare class Server {
+  readonly epoch: number;
+  private readonly tx;
+  private readonly mode;
+  private readonly maxHandlerTimeoutMs;
+  private readonly rxCfg;
+  private readonly methodRx;
+  private readonly limits;
+  private readonly codecs;
+  private readonly compressors;
+  private readonly maxRecv;
+  private readonly maxSend;
+  private readonly stallMs;
+  private readonly services;
+  private serving;
+  private readonly slots;
+  private pendingResetTotal;
+  private resetAtTotal;
+  private replyBudgetTotal;
+  private drain;
+  private closed;
+  private liveTasks;
+  private idleWaiters;
+  private sawUnreliable;
+  private readonly sw;
+  constructor(tx: FrameHandler, opts?: ServerOptions);
+  register<Req, Res>(desc: MethodDesc<Req, Res> & {
+    clientStreams: false;
+    serverStreams: false;
+  }, handler: UnaryHandler<Req, Res>): void;
+  register<Req, Res>(desc: MethodDesc<Req, Res> & {
+    clientStreams: false;
+    serverStreams: true;
+  }, handler: ServerStreamingHandler<Req, Res>): void;
+  register<Req, Res>(desc: MethodDesc<Req, Res> & {
+    clientStreams: true;
+    serverStreams: false;
+  }, handler: ClientStreamingHandler<Req, Res>): void;
+  register<Req, Res>(desc: MethodDesc<Req, Res> & {
+    clientStreams: true;
+    serverStreams: true;
+  }, handler: BidiHandler<Req, Res>): void;
+  private rxReliable;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+  private open;
+  private rejectOpen;
+  private runUnary;
+  private runStream;
+  private finish;
+  private resetByPeerSid;
+  private sendReset;
+  private allowReply;
+  gracefulStop(): Promise<void>;
+  stop(): Promise<void>;
+  disconnectPeer(peer: unknown, err?: unknown): void;
+  private waitIdle;
+  private taskDone;
+  /** @internal */
+  get timing(): ResolvedTiming;
+  /** @internal */
+  send(f: Frame, ctx: FrameContext): Promise<void>;
+  /** @internal */
+  sendOrThrow(f: Frame, ctx: FrameContext): Promise<void>;
+  /** @internal */
+  txFor(peer: unknown): FrameContext;
+  /** @internal */
+  allowReplyFor(peer: unknown, now: number): boolean;
+  private ensureSlot;
+  private ensurePeer;
+  /** @internal */
+  kickSweep(): void;
+  private hasWork;
+  private sweep;
+}
+//#endregion
+export { ServerOptions as a, ServerWriter as c, ServerContext as i, UnaryHandler as l, ClientStreamingHandler as n, ServerReader as o, Server as r, ServerStreamingHandler as s, BidiHandler as t };

package/dist/status-DZwMDWIn.mjs

@@ -0,0 +1,63 @@
+//#region src/status.ts
+let Code = /* @__PURE__ */ function(Code) {
+	Code[Code["OK"] = 0] = "OK";
+	Code[Code["CANCELLED"] = 1] = "CANCELLED";
+	Code[Code["UNKNOWN"] = 2] = "UNKNOWN";
+	Code[Code["INVALID_ARGUMENT"] = 3] = "INVALID_ARGUMENT";
+	Code[Code["DEADLINE_EXCEEDED"] = 4] = "DEADLINE_EXCEEDED";
+	Code[Code["NOT_FOUND"] = 5] = "NOT_FOUND";
+	Code[Code["ALREADY_EXISTS"] = 6] = "ALREADY_EXISTS";
+	Code[Code["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
+	Code[Code["RESOURCE_EXHAUSTED"] = 8] = "RESOURCE_EXHAUSTED";
+	Code[Code["FAILED_PRECONDITION"] = 9] = "FAILED_PRECONDITION";
+	Code[Code["ABORTED"] = 10] = "ABORTED";
+	Code[Code["OUT_OF_RANGE"] = 11] = "OUT_OF_RANGE";
+	Code[Code["UNIMPLEMENTED"] = 12] = "UNIMPLEMENTED";
+	Code[Code["INTERNAL"] = 13] = "INTERNAL";
+	Code[Code["UNAVAILABLE"] = 14] = "UNAVAILABLE";
+	Code[Code["DATA_LOSS"] = 15] = "DATA_LOSS";
+	Code[Code["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
+	return Code;
+}({});
+var StatusError = class extends Error {
+	code;
+	desc;
+	constructor(code, desc) {
+		super(`${Code[code] ?? code}: ${desc}`);
+		this.name = "StatusError";
+		this.code = code;
+		this.desc = desc;
+	}
+};
+function statusError(code, desc) {
+	return new StatusError(code, desc);
+}
+var MessageTooLargeError = class extends Error {
+	constructor(message = "message too large for the transport") {
+		super(message);
+		this.name = "MessageTooLargeError";
+	}
+};
+function isMessageTooLarge(err) {
+	for (let e = err, i = 0; i < 8; i++) {
+		if (e instanceof MessageTooLargeError) return true;
+		if (e instanceof Error && e.cause !== void 0) e = e.cause;
+		else return false;
+	}
+	return false;
+}
+function toStatusError(err) {
+	if (err instanceof StatusError) return err;
+	if (isMessageTooLarge(err)) return new StatusError(8, err instanceof Error ? err.message : String(err));
+	if (err instanceof Error) {
+		if (err.name === "AbortError") return new StatusError(1, err.message || "aborted");
+		if (err.name === "TimeoutError") return new StatusError(4, err.message || "deadline exceeded");
+		return new StatusError(2, err.message);
+	}
+	return new StatusError(2, String(err));
+}
+function abortCause(signal) {
+	return toStatusError(signal.reason);
+}
+//#endregion
+export { isMessageTooLarge as a, abortCause as i, MessageTooLargeError as n, statusError as o, StatusError as r, toStatusError as s, Code as t };

package/dist/transport/connect.d.mts

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

package/dist/transport/connect.mjs

@@ -0,0 +1,122 @@
+import { r as StatusError } from "../status-DZwMDWIn.mjs";
+import { fromMethod } from "./protobuf-es.mjs";
+import { create } from "@bufbuild/protobuf";
+import { ConnectError } from "@connectrpc/connect";
+//#region src/transport/connect/index.ts
+function headersToMetadata(h) {
+	if (h === void 0) return void 0;
+	const headers = h instanceof Headers ? h : new Headers(h);
+	let md;
+	headers.forEach((value, key) => {
+		(md ??= {})[key] = [value];
+	});
+	return md;
+}
+function safeAppend(headers, key, value) {
+	try {
+		headers.append(key, value);
+	} catch {}
+}
+function appendMetadata(headers, md) {
+	if (md === void 0) return;
+	for (const [key, values] of Object.entries(md)) for (const v of values) safeAppend(headers, key, v);
+}
+function metadataToHeaders(md) {
+	const headers = new Headers();
+	appendMetadata(headers, md);
+	return headers;
+}
+function toConnectError(err, header, trailer) {
+	const meta = metadataToHeaders(header);
+	appendMetadata(meta, trailer);
+	if (err instanceof StatusError) return new ConnectError(err.desc, err.code, meta, void 0, err);
+	const ce = ConnectError.from(err);
+	meta.forEach((v, k) => safeAppend(ce.metadata, k, v));
+	return ce;
+}
+function callOptions(signal, timeoutMs, header) {
+	const opts = {};
+	if (signal !== void 0) opts.signal = signal;
+	if (timeoutMs !== void 0) opts.timeoutMs = timeoutMs;
+	const md = headersToMetadata(header);
+	if (md !== void 0) opts.metadata = md;
+	return opts;
+}
+function createDrpcTransport(conn) {
+	return {
+		async unary(method, signal, timeoutMs, header, input) {
+			const desc = fromMethod(method);
+			const opts = callOptions(signal, timeoutMs, header);
+			let respHeader;
+			let respTrailer;
+			opts.onHeader = (md) => {
+				respHeader = md;
+			};
+			opts.onTrailer = (md) => {
+				respTrailer = md;
+			};
+			try {
+				const message = await conn.invoke(desc, create(method.input, input), opts);
+				return {
+					stream: false,
+					service: method.parent,
+					method,
+					header: metadataToHeaders(respHeader),
+					message,
+					trailer: metadataToHeaders(respTrailer)
+				};
+			} catch (err) {
+				throw toConnectError(err, respHeader, respTrailer);
+			}
+		},
+		async stream(method, signal, timeoutMs, header, input) {
+			const desc = fromMethod(method);
+			const s = conn.newStream(desc, callOptions(signal, timeoutMs, header));
+			(async () => {
+				try {
+					for await (const raw of input) await s.send(create(method.input, raw));
+				} catch {
+					s.cancel();
+					return;
+				}
+				s.closeSend();
+			})().catch(() => {});
+			let first;
+			let firstIsEnd = false;
+			try {
+				const r = await s.recv();
+				if (r === void 0) firstIsEnd = true;
+				else first = r;
+			} catch (err) {
+				throw toConnectError(err, s.latchedHeader(), s.trailer());
+			}
+			const trailer = new Headers();
+			const message = (async function* () {
+				if (!firstIsEnd) {
+					yield first;
+					for (;;) {
+						let m;
+						try {
+							m = await s.recv();
+						} catch (err) {
+							throw toConnectError(err, s.latchedHeader(), s.trailer());
+						}
+						if (m === void 0) break;
+						yield m;
+					}
+				}
+				appendMetadata(trailer, s.trailer());
+			})();
+			return {
+				stream: true,
+				service: method.parent,
+				method,
+				header: metadataToHeaders(s.latchedHeader()),
+				message,
+				trailer
+			};
+		}
+	};
+}
+//#endregion
+export { createDrpcTransport };

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

@@ -0,0 +1,42 @@
+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 { Socket } from "node:dgram";
+//#region src/transport/node-udp/index.d.ts
+declare const DefaultMaxMessageSize = 1200;
+declare class UdpTransport implements FrameHandler, TransportInfo, ConnAttacher {
+  private readonly socket;
+  private readonly max;
+  private conn;
+  private closed;
+  constructor(socket: Socket, opts?: {
+    maxMessageSize?: number;
+  });
+  reliable(): boolean;
+  attachConn(conn: Conn): void;
+  handle(f: Frame): Promise<void>;
+  close(err?: unknown): void;
+}
+declare class UdpGateway implements FrameHandler {
+  private readonly socket;
+  private readonly max;
+  private readonly peers;
+  private server;
+  private closed;
+  constructor(socket: Socket, opts?: {
+    maxMessageSize?: number;
+  });
+  serve(server: Server): Promise<void>;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+  close(): void;
+}
+declare function dialUdp(port: number, host?: string, opts?: ConnOptions & {
+  maxMessageSize?: number;
+}): Promise<Conn>;
+declare function listenUdp(port?: number, host?: string, opts?: {
+  maxMessageSize?: number;
+}): Promise<{
+  gateway: UdpGateway;
+  port: number;
+}>;
+//#endregion
+export { DefaultMaxMessageSize, UdpGateway, UdpTransport, dialUdp, listenUdp };

package/dist/transport/node-udp.mjs

@@ -0,0 +1,144 @@
+import { $ as unpack, c as decodeEnvelop, u as encodeEnvelop } from "../wire-BR8KiyRg.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;
+function transient(err) {
+	const code = err?.code;
+	return code === "ECONNREFUSED" || code === "EHOSTUNREACH" || code === "ENETUNREACH";
+}
+function sendDatagram(socket, data, target) {
+	return new Promise((resolve, reject) => {
+		const cb = (err) => {
+			if (err && !transient(err)) reject(err);
+			else resolve();
+		};
+		if (target !== void 0) socket.send(data, target.port, target.address, cb);
+		else socket.send(data, cb);
+	});
+}
+var UdpTransport = class {
+	socket;
+	max;
+	conn;
+	closed = false;
+	constructor(socket, opts = {}) {
+		this.socket = socket;
+		this.max = opts.maxMessageSize ?? 1200;
+	}
+	reliable() {
+		return false;
+	}
+	attachConn(conn) {
+		if (this.conn !== void 0) throw new Error("node-udp: transport already attached to a Conn");
+		this.conn = conn;
+		this.socket.on("message", (data) => {
+			let frames;
+			try {
+				frames = decodeEnvelop(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+			} catch {
+				return;
+			}
+			unpack(frames, conn, {});
+		});
+		this.socket.on("error", (err) => {
+			if (transient(err)) return;
+			this.close(err);
+		});
+		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`);
+		return sendDatagram(this.socket, data);
+	}
+	close(err) {
+		if (this.closed) return;
+		this.closed = true;
+		try {
+			this.socket.close();
+		} catch {}
+		this.conn?.close(err);
+	}
+};
+function peerKey(rinfo) {
+	return `${rinfo.address}:${rinfo.port}`;
+}
+var UdpGateway = class {
+	socket;
+	max;
+	peers = /* @__PURE__ */ new Map();
+	server;
+	closed = false;
+	constructor(socket, opts = {}) {
+		this.socket = socket;
+		this.max = opts.maxMessageSize ?? 1200;
+	}
+	serve(server) {
+		if (this.server !== void 0) throw new Error("node-udp: gateway already serving");
+		this.server = server;
+		return new Promise((resolve) => {
+			this.socket.on("message", (data, rinfo) => {
+				const key = peerKey(rinfo);
+				this.peers.set(key, {
+					port: rinfo.port,
+					address: rinfo.address
+				});
+				let frames;
+				try {
+					frames = decodeEnvelop(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+				} catch {
+					return;
+				}
+				unpack(frames, server, {
+					peer: key,
+					reliable: false
+				});
+			});
+			this.socket.on("close", resolve);
+			this.socket.on("error", () => this.close());
+		});
+	}
+	handle(f, 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`);
+		return sendDatagram(this.socket, data, target);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		try {
+			this.socket.close();
+		} catch {}
+	}
+};
+function dialUdp(port, host = "127.0.0.1", opts = {}) {
+	const socket = createSocket("udp4");
+	return new Promise((resolve, reject) => {
+		socket.once("error", reject);
+		socket.connect(port, host, () => {
+			socket.off("error", reject);
+			resolve(new Conn(new UdpTransport(socket, opts), opts));
+		});
+	});
+}
+function listenUdp(port = 0, host = "127.0.0.1", opts) {
+	const socket = createSocket("udp4");
+	return new Promise((resolve, reject) => {
+		socket.once("error", reject);
+		socket.bind(port, host, () => {
+			socket.off("error", reject);
+			resolve({
+				gateway: new UdpGateway(socket, opts),
+				port: socket.address().port
+			});
+		});
+	});
+}
+//#endregion
+export { DefaultMaxMessageSize, UdpGateway, UdpTransport, dialUdp, listenUdp };

package/dist/transport/port.d.mts

@@ -0,0 +1,52 @@
+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";
+//#region src/transport/port/index.d.ts
+declare const DefaultMaxMessageSize = 0;
+interface PortLike {
+  postMessage(data: Uint8Array, transfer?: unknown[]): void;
+  addEventListener?(type: string, fn: (ev: unknown) => void): void;
+  removeEventListener?(type: string, fn: (ev: unknown) => void): void;
+  onmessage?: ((ev: never) => void) | null;
+  onmessageerror?: ((ev: never) => void) | null;
+  start?(): void;
+  close?(): void;
+  terminate?(): void;
+}
+interface PortOptions {
+  maxMessageSize?: number;
+  transfer?: boolean;
+}
+declare class PortTransport implements FrameHandler, TransportInfo, ConnAttacher {
+  private readonly pt;
+  private attached;
+  constructor(port: PortLike, opts?: PortOptions);
+  reliable(): boolean;
+  attachConn(conn: Conn): void;
+  handle(f: Frame): Promise<void>;
+  close(cause?: unknown): void;
+}
+interface WorkerLike {
+  postMessage(message: unknown, transfer?: unknown[]): void;
+}
+interface WorkerDialOptions extends PortOptions {
+  message?: unknown;
+}
+declare function dialWorker(worker: WorkerLike, opts?: ConnOptions & WorkerDialOptions): Conn;
+declare class PortGateway implements FrameHandler, TransportInfo {
+  private readonly o;
+  private next;
+  private readonly ports;
+  private readonly peers;
+  constructor(opts?: PortOptions);
+  reliable(): boolean;
+  bind(port: PortLike): void;
+  private bindPort;
+  private drop;
+  servePeer(server: Server, port: PortLike, opts?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+  close(): void;
+}
+//#endregion
+export { DefaultMaxMessageSize, PortGateway, PortLike, PortOptions, PortTransport, WorkerDialOptions, WorkerLike, dialWorker };