@lesomnus/grpc-dgram 0.0.1

package/dist/transport/websocket.mjs

@@ -0,0 +1,324 @@
+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 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;
+const CLOSING = 2;
+const CLOSED = 3;
+const DefaultMaxMessageSize = 0;
+const DefaultMaxBufferedAmount = 1 << 20;
+const DefaultKeepaliveIntervalMs = 2e4;
+const DefaultKeepaliveTimeoutMs = 3e4;
+const bufferedPollMs = 25;
+const closeCodesClean = /* @__PURE__ */ new Set([
+	1e3,
+	1001,
+	1005
+]);
+function wire(ws, type, fn) {
+	if (typeof ws.addEventListener === "function") ws.addEventListener(type, fn);
+	else ws[`on${type}`] = fn;
+}
+function errorOf(ev) {
+	const e = ev;
+	if (e?.error !== void 0 && e.error !== null) return e.error;
+	if (typeof e?.message === "string") return /* @__PURE__ */ new Error(`websocket: ${e.message}`);
+	return /* @__PURE__ */ new Error("websocket: transport error");
+}
+function closeCauseOf(ev) {
+	const e = ev;
+	const code = typeof e?.code === "number" ? e.code : 1005;
+	if (closeCodesClean.has(code)) return void 0;
+	const reason = typeof e?.reason === "string" && e.reason !== "" ? `: ${e.reason}` : "";
+	return /* @__PURE__ */ new Error(`websocket: closed with code ${code}${reason}`);
+}
+function wakeAll(waiters) {
+	if (waiters.length === 0) return;
+	const ws = waiters.splice(0);
+	for (const w of ws) w();
+}
+var Socket = class {
+	ws;
+	max;
+	high;
+	stallMs;
+	kaIntervalMs;
+	kaTimeoutMs;
+	opened = new Latch();
+	dead = new Latch();
+	err;
+	rx = [];
+	rxWaiters = [];
+	kaTimer;
+	kaDeadline;
+	constructor(ws, o) {
+		this.ws = ws;
+		this.max = o.maxMessageSize ?? 0;
+		this.high = o.maxBufferedAmount ?? 1048576;
+		this.kaIntervalMs = o.keepaliveIntervalMs ?? 2e4;
+		this.kaTimeoutMs = o.keepaliveTimeoutMs ?? 3e4;
+		this.stallMs = o.sendStallTimeoutMs ?? this.kaTimeoutMs;
+		try {
+			ws.binaryType = "arraybuffer";
+		} catch {}
+		wire(ws, "open", () => this.onOpen());
+		wire(ws, "error", (ev) => this.fail(errorOf(ev)));
+		wire(ws, "close", (ev) => this.fail(closeCauseOf(ev)));
+		wire(ws, "message", (ev) => this.onMessage(ev));
+		if (ws.readyState === OPEN) this.onOpen();
+		else if (ws.readyState === CLOSING || ws.readyState === CLOSED) this.fail(void 0);
+	}
+	fail(err) {
+		if (!this.dead.tripped && this.err === void 0) this.err = err;
+		this.dead.trip();
+		this.stopKeepalive();
+		wakeAll(this.rxWaiters);
+	}
+	deathErr() {
+		return this.err;
+	}
+	closedErr() {
+		const e = new StatusError(14, `websocket: socket closed${this.err instanceof Error ? `: ${this.err.message}` : ""}`);
+		if (this.err !== void 0) e.cause = this.err;
+		return e;
+	}
+	onOpen() {
+		if (this.dead.tripped) return;
+		this.opened.trip();
+		this.startKeepalive();
+	}
+	startKeepalive() {
+		if (this.kaTimer !== void 0 || this.dead.tripped) return;
+		if (this.kaIntervalMs <= 0 || this.kaTimeoutMs <= 0) return;
+		const ws = this.ws;
+		if (typeof ws.ping !== "function" || typeof ws.on !== "function") return;
+		ws.on("pong", () => this.progress());
+		const t = setInterval(() => {
+			try {
+				ws.ping?.();
+			} catch (e) {
+				this.fail(new Error(`websocket: keepalive ping: ${e instanceof Error ? e.message : String(e)}`, { cause: e }));
+			}
+		}, this.kaIntervalMs);
+		unrefTimer(t);
+		this.kaTimer = t;
+		this.progress();
+	}
+	progress() {
+		if (this.kaDeadline !== void 0) clearTimeout(this.kaDeadline);
+		this.kaDeadline = void 0;
+		if (this.kaTimer === void 0 || this.dead.tripped) return;
+		const t = setTimeout(() => this.fail(/* @__PURE__ */ new Error(`websocket: no read progress within ${this.kaTimeoutMs}ms`)), this.kaTimeoutMs);
+		unrefTimer(t);
+		this.kaDeadline = t;
+	}
+	stopKeepalive() {
+		if (this.kaTimer !== void 0) clearInterval(this.kaTimer);
+		if (this.kaDeadline !== void 0) clearTimeout(this.kaDeadline);
+		this.kaTimer = void 0;
+		this.kaDeadline = void 0;
+	}
+	onMessage(ev) {
+		if (this.dead.tripped) return;
+		this.progress();
+		const data = ev.data;
+		if (data instanceof ArrayBuffer) this.rx.push(new Uint8Array(data));
+		else if (ArrayBuffer.isView(data)) this.rx.push(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+		else return;
+		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 stalled = new Latch();
+		let stallTimer;
+		if (this.stallMs > 0) {
+			stallTimer = setTimeout(() => stalled.trip(), this.stallMs);
+			unrefTimer(stallTimer);
+		}
+		let disposeAbort = noop;
+		const signalAborted = new Latch();
+		if (signal !== void 0) if (signal.aborted) signalAborted.trip();
+		else disposeAbort = abortListener(signal, () => signalAborted.trip());
+		try {
+			while (!this.opened.tripped) {
+				await Promise.race([
+					this.opened.wait(),
+					stalled.wait(),
+					this.dead.wait(),
+					signalAborted.wait()
+				]);
+				if (this.opened.tripped) break;
+				if (this.dead.tripped) throw this.closedErr();
+				if (stalled.tripped) {
+					const err = /* @__PURE__ */ new Error(`websocket: send stalled: socket not open within ${this.stallMs}ms`);
+					this.fail(err);
+					throw err;
+				}
+				if (signalAborted.tripped) throw new Error("websocket: send aborted");
+			}
+			while (this.high > 0 && this.ws.bufferedAmount >= this.high) {
+				if (this.dead.tripped) throw this.closedErr();
+				await Promise.race([
+					poll(),
+					stalled.wait(),
+					this.dead.wait(),
+					signalAborted.wait()
+				]);
+				if (this.dead.tripped) throw this.closedErr();
+				if (stalled.tripped) {
+					const err = /* @__PURE__ */ new Error(`websocket: send stalled at the buffered-amount mark for ${this.stallMs}ms`);
+					this.fail(err);
+					throw err;
+				}
+				if (signalAborted.tripped) throw new Error("websocket: send aborted");
+			}
+			if (this.dead.tripped) throw this.closedErr();
+			try {
+				this.ws.send(data);
+			} catch (e) {
+				this.fail(e);
+				throw this.closedErr();
+			}
+		} finally {
+			if (stallTimer !== void 0) clearTimeout(stallTimer);
+			disposeAbort();
+		}
+	}
+	async pump(h, ctx) {
+		const dctl = new AbortController();
+		this.dead.wait().then(() => dctl.abort(this.closedErr()));
+		const dctx = {
+			...ctx,
+			signal: dctl.signal
+		};
+		for (;;) {
+			const data = this.rx.shift();
+			if (data !== void 0) {
+				let frames;
+				try {
+					frames = decodeEnvelop(data);
+				} catch {
+					continue;
+				}
+				await unpack(frames, h, dctx);
+				continue;
+			}
+			if (this.dead.tripped) return this.err;
+			await Promise.race([this.rxReadable(), this.dead.wait()]);
+		}
+	}
+	rxReadable() {
+		if (this.rx.length > 0) return Promise.resolve();
+		return new Promise((res) => this.rxWaiters.push(res));
+	}
+	close() {
+		this.fail(void 0);
+		try {
+			if (this.ws.readyState === CONNECTING || this.ws.readyState === OPEN) this.ws.close(1e3, "");
+		} catch {}
+	}
+};
+function poll() {
+	return new Promise((res) => {
+		unrefTimer(setTimeout(res, bufferedPollMs));
+	});
+}
+var WebSocketTransport = class {
+	sock;
+	attached = false;
+	closed = false;
+	constructor(ws, opts = {}) {
+		this.sock = new Socket(ws, opts);
+	}
+	reliable() {
+		return true;
+	}
+	attachConn(conn) {
+		if (this.attached) throw new Error("websocket: transport already attached to a Conn");
+		this.attached = true;
+		(async () => {
+			const err = await this.sock.pump(conn, {});
+			conn.close(err);
+			this.close();
+		})();
+	}
+	handle(f, ctx = {}) {
+		return this.sock.send([f], ctx.signal);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.sock.close();
+	}
+};
+var WebSocketGateway = class {
+	o;
+	next = 0;
+	socks = /* @__PURE__ */ new Map();
+	peers = /* @__PURE__ */ new Map();
+	constructor(opts = {}) {
+		this.o = opts;
+	}
+	reliable() {
+		return true;
+	}
+	bind(ws) {
+		this.bindSocket(ws);
+	}
+	bindSocket(ws) {
+		let b = this.socks.get(ws);
+		if (b === void 0) {
+			b = {
+				sock: new Socket(ws, this.o),
+				key: ++this.next,
+				served: false
+			};
+			this.socks.set(ws, b);
+			this.peers.set(b.key, b.sock);
+		}
+		return b;
+	}
+	drop(ws, b) {
+		b.sock.fail(void 0);
+		this.socks.delete(ws);
+		this.peers.delete(b.key);
+	}
+	async servePeer(server, ws, opts = {}) {
+		const b = this.bindSocket(ws);
+		if (b.served) throw new Error("websocket: socket already served");
+		b.served = true;
+		let disposeAbort = noop;
+		if (opts.signal !== void 0) if (opts.signal.aborted) b.sock.close();
+		else disposeAbort = abortListener(opts.signal, () => b.sock.close());
+		try {
+			const err = await b.sock.pump(server, {
+				peer: b.key,
+				reliable: true
+			});
+			server.disconnectPeer(b.key, err);
+			return err;
+		} finally {
+			disposeAbort();
+			this.drop(ws, b);
+		}
+	}
+	handle(f, 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);
+	}
+	close() {
+		for (const b of [...this.socks.values()]) b.sock.close();
+	}
+};
+function dialWebSocket(url, opts = {}) {
+	const ctor = globalThis.WebSocket;
+	if (ctor === void 0) throw new Error("websocket: this runtime has no global WebSocket; construct one (e.g. from the 'ws' package) and pass it to new WebSocketTransport()");
+	return new Conn(new WebSocketTransport(new ctor(url, opts.protocols), opts), opts);
+}
+//#endregion
+export { DefaultKeepaliveIntervalMs, DefaultKeepaliveTimeoutMs, DefaultMaxBufferedAmount, DefaultMaxMessageSize, WebSocketGateway, WebSocketTransport, dialWebSocket };

package/dist/wasm/worker.d.mts

@@ -0,0 +1,8 @@
+//#region src/wasm/worker.d.ts
+interface WorkerScope {
+  addEventListener(type: string, fn: (ev: unknown) => void): void;
+  postMessage(message: unknown): void;
+}
+declare function serveIn(scope: WorkerScope): void;
+//#endregion
+export { WorkerScope, serveIn };

package/dist/wasm/worker.mjs

@@ -0,0 +1,73 @@
+import { o as startInstance, t as isPageMessage } from "../protocol-K4Zy8MuQ.mjs";
+//#region src/wasm/worker.ts
+const GOODBYE = /* @__PURE__ */ new Uint8Array(0);
+function serveIn(scope) {
+	const ports = /* @__PURE__ */ new Set();
+	let instance;
+	let gone = false;
+	const bury = () => {
+		gone = true;
+		for (const port of ports) farewell(port);
+		ports.clear();
+	};
+	scope.addEventListener("message", (ev) => {
+		const msg = ev.data;
+		if (!isPageMessage(msg)) return;
+		if (msg.drpc === "start") {
+			if (instance !== void 0) return;
+			instance = startInstance(msg.app, {
+				entryPoint: msg.entryPoint,
+				readyTimeoutMs: msg.readyTimeoutMs,
+				wasmExec: msg.wasmExec
+			});
+			instance.then((inst) => {
+				scope.postMessage({ drpc: "ready" });
+				inst.exited.then((cause) => {
+					bury();
+					scope.postMessage({
+						drpc: "exited",
+						message: reason(cause)
+					});
+				});
+			}, (e) => {
+				bury();
+				scope.postMessage({
+					drpc: "error",
+					message: reason(e)
+				});
+			});
+			return;
+		}
+		const port = ev.ports?.[0];
+		if (port === void 0) return;
+		if (gone || instance === void 0) {
+			farewell(port);
+			return;
+		}
+		ports.add(port);
+		instance.then((inst) => {
+			try {
+				inst.serve(port);
+			} catch {
+				ports.delete(port);
+				farewell(port);
+			}
+		}, () => {});
+	});
+}
+function farewell(port) {
+	try {
+		port.postMessage(GOODBYE);
+	} catch {}
+	try {
+		port.close();
+	} catch {}
+}
+function reason(cause) {
+	if (cause instanceof Error && cause.message !== "") return cause.message;
+	return String(cause);
+}
+const g = globalThis;
+if (g.self === g && g.document === void 0 && typeof g.postMessage === "function") serveIn(g);
+//#endregion
+export { serveIn };

package/dist/wasm.d.mts

@@ -0,0 +1,36 @@
+import { n as Conn, r as ConnOptions } from "./conn-DTWG9vIx.mjs";
+import { PortOptions } from "./transport/port.mjs";
+//#region src/wasm/instance.d.ts
+declare const DefaultEntryPoint = "drpcServe";
+declare const DefaultReadyTimeoutMs = 10000;
+declare const DefaultWasmExec = "/wasm_exec.js";
+interface GoLike {
+  readonly importObject: WebAssembly.Imports;
+  run(instance: WebAssembly.Instance): Promise<void>;
+}
+type WasmApp = string | URL | BufferSource | WebAssembly.Module;
+//#endregion
+//#region src/wasm/index.d.ts
+interface WasmWorker {
+  postMessage(message: unknown, transfer?: unknown[]): void;
+  addEventListener(type: string, fn: (ev: unknown) => void): void;
+  removeEventListener(type: string, fn: (ev: unknown) => void): void;
+  terminate(): void;
+}
+interface OpenOptions extends PortOptions {
+  worker?: boolean | WasmWorker;
+  workerUrl?: string | URL;
+  wasmExec?: string | URL;
+  entryPoint?: string;
+  readyTimeoutMs?: number;
+  go?: GoLike;
+}
+interface WasmSock {
+  readonly worker?: WasmWorker;
+  readonly exited: Promise<unknown>;
+  dial(opts?: ConnOptions): Conn;
+  close(): void;
+}
+declare function open(app: WasmApp, opts?: OpenOptions): Promise<WasmSock>;
+//#endregion
+export { DefaultEntryPoint, DefaultReadyTimeoutMs, DefaultWasmExec, type GoLike, OpenOptions, type WasmApp, WasmSock, WasmWorker, open };

package/dist/wasm.mjs

@@ -0,0 +1,156 @@
+import { n as Conn } from "./conn-DOmx4nbt.mjs";
+import { PortTransport } from "./transport/port.mjs";
+import { a as DefaultWasmExec, i as DefaultReadyTimeoutMs, n as isWorkerMessage, o as startInstance, r as DefaultEntryPoint } from "./protocol-K4Zy8MuQ.mjs";
+//#region src/wasm/index.ts
+async function open(app, opts = {}) {
+	if (opts.worker === false) return new HereSock(await startInstance(app, opts), opts);
+	if (opts.go !== void 0) throw new Error("wasm: opts.go builds the Go instance in this realm, and it cannot be posted to a worker — pass { worker: false } with it, or drop it");
+	const given = typeof opts.worker === "object" && opts.worker !== null ? opts.worker : void 0;
+	const sock = new WorkerSock(given ?? spawn(opts.workerUrl), given === void 0, opts);
+	try {
+		await sock.start(app, opts);
+	} catch (e) {
+		sock.close();
+		throw e;
+	}
+	return sock;
+}
+function spawn(url) {
+	const ctor = globalThis.Worker;
+	if (typeof ctor !== "function") throw new Error("wasm: this realm has no Worker — pass { worker: false } to run the instance here (node, tests), or a worker you made yourself");
+	return new ctor(url ?? new URL("./wasm/worker.mjs", import.meta.url), { type: "module" });
+}
+var Sock = class {
+	o;
+	exited;
+	txs = /* @__PURE__ */ new Set();
+	dead;
+	closed = false;
+	announce;
+	constructor(o) {
+		this.o = o;
+		this.exited = new Promise((res) => {
+			this.announce = res;
+		});
+	}
+	dial(opts = {}) {
+		if (this.dead !== void 0) {
+			const what = this.closed ? "this sock is closed" : "the wasm instance has exited";
+			throw new Error(`wasm: ${what}${this.dead.cause instanceof Error ? `: ${this.dead.cause.message}` : ""}`);
+		}
+		const tx = this.connect();
+		this.txs.add(tx);
+		return new Conn(tx, opts);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.bury(/* @__PURE__ */ new Error("the wasm sock was closed"));
+		this.stop();
+	}
+	channelTo(handover) {
+		const ch = new MessageChannel();
+		let tx;
+		try {
+			tx = new PortTransport(ch.port1, this.o);
+			handover(ch.port2);
+			return tx;
+		} catch (e) {
+			tx?.close(e);
+			ch.port1.close();
+			ch.port2.close();
+			throw e;
+		}
+	}
+	bury(cause) {
+		if (this.dead !== void 0) return;
+		this.dead = { cause };
+		for (const tx of this.txs) tx.close(cause);
+		this.txs.clear();
+		this.announce(cause);
+	}
+};
+var WorkerSock = class extends Sock {
+	worker;
+	own;
+	readiness;
+	ready;
+	failed;
+	detach = [];
+	serving = false;
+	constructor(worker, own, o) {
+		super(o);
+		this.worker = worker;
+		this.own = own;
+		this.readiness = new Promise((res, rej) => {
+			this.ready = res;
+			this.failed = rej;
+		});
+		this.listen("message", (ev) => this.onMessage(ev));
+		this.listen("error", (ev) => {
+			if (this.serving) return;
+			const detail = ev.message;
+			this.die(/* @__PURE__ */ new Error(`wasm: the worker itself failed${typeof detail === "string" && detail !== "" ? `: ${detail}` : ""} — is workerUrl the module this package ships?`));
+		});
+		this.listen("messageerror", () => {});
+	}
+	start(app, opts) {
+		const start = {
+			drpc: "start",
+			app,
+			wasmExec: String(opts.wasmExec ?? "/wasm_exec.js"),
+			entryPoint: opts.entryPoint ?? "drpcServe",
+			readyTimeoutMs: opts.readyTimeoutMs ?? 1e4
+		};
+		this.worker.postMessage(start);
+		return this.readiness;
+	}
+	connect() {
+		const serve = { drpc: "serve" };
+		return this.channelTo((port) => this.worker.postMessage(serve, [port]));
+	}
+	stop() {
+		if (this.own) this.worker.terminate();
+		for (const off of this.detach.splice(0)) off();
+	}
+	listen(type, fn) {
+		this.worker.addEventListener(type, fn);
+		this.detach.push(() => this.worker.removeEventListener(type, fn));
+	}
+	onMessage(ev) {
+		const msg = ev.data;
+		if (!isWorkerMessage(msg)) return;
+		switch (msg.drpc) {
+			case "ready":
+				this.serving = true;
+				this.ready();
+				break;
+			case "error":
+				this.failed(/* @__PURE__ */ new Error(`wasm: ${msg.message}`));
+				break;
+			case "exited":
+				this.die(new Error(msg.message));
+				break;
+		}
+	}
+	die(cause) {
+		this.failed(cause);
+		this.bury(cause);
+		for (const off of this.detach.splice(0)) off();
+	}
+};
+var HereSock = class extends Sock {
+	inst;
+	worker = void 0;
+	constructor(inst, o) {
+		super(o);
+		this.inst = inst;
+		inst.exited.then((cause) => this.bury(cause));
+	}
+	connect() {
+		return this.channelTo((port) => this.inst.serve(port));
+	}
+	stop() {}
+};
+//#endregion
+export { DefaultEntryPoint, DefaultReadyTimeoutMs, DefaultWasmExec, open };