@lesomnus/grpc-dgram 0.0.1 → 0.1.0

package/dist/transport/webtransport.mjs

@@ -0,0 +1,144 @@
+import { n as Conn } from "../conn-CmYPHTPR.mjs";
+import { F as Latch, 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";
+//#region src/transport/webtransport/index.ts
+const DefaultMaxMessageSize = 1200;
+function closeCauseOf(info) {
+	const i = info;
+	const code = typeof i?.closeCode === "number" ? i.closeCode : 0;
+	const reason = typeof i?.reason === "string" && i.reason !== "" ? `: ${i.reason}` : "";
+	if (code === 0 && reason === "") return void 0;
+	return /* @__PURE__ */ new Error(`webtransport: session closed with code ${code}${reason}`);
+}
+function bytesOf(v) {
+	if (v instanceof Uint8Array) return v;
+	if (ArrayBuffer.isView(v)) return new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
+	if (v instanceof ArrayBuffer) return new Uint8Array(v);
+}
+var WebTransportDatagramTransport = class {
+	wt;
+	max;
+	writer;
+	reader;
+	opened = new Latch();
+	dead = new Latch();
+	err;
+	attached = false;
+	closed = false;
+	constructor(wt, opts = {}) {
+		this.wt = wt;
+		this.max = opts.maxMessageSize;
+		const ds = wt.datagrams;
+		let sink;
+		if (typeof ds.createWritable === "function") try {
+			sink = ds.createWritable();
+		} catch (e) {
+			this.fail(e);
+		}
+		else {
+			sink = ds.writable;
+			if (sink === void 0) throw new Error("webtransport: session exposes neither datagrams.createWritable() nor datagrams.writable");
+		}
+		this.writer = sink?.getWriter();
+		this.writer?.closed.catch(noop);
+		wt.ready.then(() => this.opened.trip(), (e) => this.fail(e));
+		wt.closed.then((info) => this.fail(closeCauseOf(info)), (e) => this.fail(e));
+	}
+	reliable() {
+		return false;
+	}
+	attachConn(conn) {
+		if (this.attached) throw new Error("webtransport: transport already attached to a Conn");
+		this.attached = true;
+		const reader = this.wt.datagrams.readable.getReader();
+		this.reader = reader;
+		this.pump(conn, reader);
+		this.dead.wait().then(() => {
+			conn.close(this.err);
+			this.close();
+		});
+	}
+	async pump(conn, reader) {
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) return;
+				if (this.dead.tripped) return;
+				const data = bytesOf(value);
+				if (data === void 0) continue;
+				let frames;
+				try {
+					frames = decodeEnvelope(data);
+				} catch {
+					continue;
+				}
+				unpack(frames, conn, {});
+			}
+		} catch {}
+	}
+	limit() {
+		if (this.max !== void 0) return this.max;
+		if (!this.opened.tripped) return DefaultMaxMessageSize;
+		const m = this.wt.datagrams.maxDatagramSize;
+		return typeof m === "number" && m > 0 ? m : DefaultMaxMessageSize;
+	}
+	check(data) {
+		const max = this.limit();
+		if (max > 0 && data.length > max) throw new MessageTooLargeError(`webtransport: ${data.length}-byte envelope over the ${max}-byte limit`);
+	}
+	sendFrames(frames) {
+		const data = encodeEnvelope(frames);
+		this.check(data);
+		return this.send(data);
+	}
+	handle(f) {
+		return this.sendFrames([f]);
+	}
+	async send(data) {
+		if (!this.opened.tripped) {
+			await Promise.race([this.opened.wait(), this.dead.wait()]);
+			if (this.dead.tripped) throw this.closedErr();
+			this.check(data);
+		}
+		const writer = this.writer;
+		if (writer === void 0 || this.dead.tripped) throw this.closedErr();
+		try {
+			await writer.write(data);
+		} catch (e) {
+			this.fail(e);
+			throw this.closedErr();
+		}
+	}
+	fail(err) {
+		if (!this.dead.tripped && this.err === void 0) this.err = err;
+		this.dead.trip();
+	}
+	closedErr() {
+		const e = new StatusError(14, `webtransport: session closed${this.err instanceof Error ? `: ${this.err.message}` : ""}`);
+		if (this.err !== void 0) e.cause = this.err;
+		return e;
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.fail(void 0);
+		try {
+			this.wt.close();
+		} catch {}
+		this.reader?.cancel().catch(noop);
+	}
+};
+function dialWebTransport(url, opts = {}) {
+	const ctor = globalThis.WebTransport;
+	if (ctor === void 0) throw new Error("webtransport: this runtime has no global WebTransport; construct one and pass it to new WebTransportDatagramTransport()");
+	const { allowPooling, congestionControl, protocols, requireUnreliable = true, serverCertificateHashes } = opts;
+	return new Conn(new WebTransportDatagramTransport(new ctor(url, {
+		allowPooling,
+		congestionControl,
+		protocols,
+		requireUnreliable,
+		serverCertificateHashes
+	}), opts), opts);
+}
+//#endregion
+export { DefaultMaxMessageSize, WebTransportDatagramTransport, dialWebTransport };

package/dist/wasm/worker.mjs

@@ -1,10 +1,11 @@
-import { o as startInstance, t as isPageMessage } from "../protocol-K4Zy8MuQ.mjs";
+import { o as startInstance, t as isPageMessage } from "../protocol-CTxSUZQF.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;
+	let answered = false;
 	const bury = () => {
 		gone = true;
 		for (const port of ports) farewell(port);
@@ -14,13 +15,20 @@ function serveIn(scope) {
 		const msg = ev.data;
 		if (!isPageMessage(msg)) return;
 		if (msg.drpc === "start") {
-			if (instance !== void 0) return;
+			if (instance !== void 0) {
+				if (answered) scope.postMessage({
+					drpc: "error",
+					message: "this worker already runs an instance — a second server in it is a second entry point, dialled with sock.dial({ entryPoint }), not a second open()"
+				});
+				return;
+			}
 			instance = startInstance(msg.app, {
 				entryPoint: msg.entryPoint,
 				readyTimeoutMs: msg.readyTimeoutMs,
 				wasmExec: msg.wasmExec
 			});
 			instance.then((inst) => {
+				answered = true;
 				scope.postMessage({ drpc: "ready" });
 				inst.exited.then((cause) => {
 					bury();
@@ -30,6 +38,7 @@ function serveIn(scope) {
 					});
 				});
 			}, (e) => {
+				answered = true;
 				bury();
 				scope.postMessage({
 					drpc: "error",
@@ -46,14 +55,20 @@ function serveIn(scope) {
 		}
 		ports.add(port);
 		instance.then((inst) => {
+			let served;
 			try {
-				inst.serve(port);
+				served = inst.serve(port, msg.entryPoint, msg.readyTimeoutMs);
 			} catch {
-				ports.delete(port);
-				farewell(port);
+				abandon(port);
+				return;
 			}
+			served.catch(() => abandon(port));
 		}, () => {});
 	});
+	function abandon(port) {
+		ports.delete(port);
+		farewell(port);
+	}
 }
 function farewell(port) {
 	try {

package/dist/wasm.d.mts

@@ -1,4 +1,4 @@
-import { n as Conn, r as ConnOptions } from "./conn-DTWG9vIx.mjs";
+import { i as ConnOptions, r as Conn } from "./conn-Dc57BC-h.mjs";
 import { PortOptions } from "./transport/port.mjs";
 //#region src/wasm/instance.d.ts
 declare const DefaultEntryPoint = "drpcServe";
@@ -25,12 +25,16 @@ interface OpenOptions extends PortOptions {
   readyTimeoutMs?: number;
   go?: GoLike;
 }
+interface DialOptions extends ConnOptions {
+  entryPoint?: string;
+  readyTimeoutMs?: number;
+}
 interface WasmSock {
   readonly worker?: WasmWorker;
   readonly exited: Promise<unknown>;
-  dial(opts?: ConnOptions): Conn;
+  dial(opts?: DialOptions): 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 };
+export { DefaultEntryPoint, DefaultReadyTimeoutMs, DefaultWasmExec, DialOptions, type GoLike, OpenOptions, type WasmApp, WasmSock, WasmWorker, open };

package/dist/wasm.mjs

@@ -1,6 +1,6 @@
-import { n as Conn } from "./conn-DOmx4nbt.mjs";
+import { n as Conn } from "./conn-CmYPHTPR.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";
+import { a as DefaultWasmExec, i as DefaultReadyTimeoutMs, n as isWorkerMessage, o as startInstance, r as DefaultEntryPoint } from "./protocol-CTxSUZQF.mjs";
 //#region src/wasm/index.ts
 async function open(app, opts = {}) {
 	if (opts.worker === false) return new HereSock(await startInstance(app, opts), opts);
@@ -38,9 +38,10 @@ var Sock = class {
 			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();
+		const { entryPoint, readyTimeoutMs, ...connOpts } = opts;
+		const tx = this.connect(entryPoint, readyTimeoutMs);
 		this.txs.add(tx);
-		return new Conn(tx, opts);
+		return new Conn(tx, connOpts);
 	}
 	close() {
 		if (this.closed) return;
@@ -53,7 +54,14 @@ var Sock = class {
 		let tx;
 		try {
 			tx = new PortTransport(ch.port1, this.o);
-			handover(ch.port2);
+			const handed = handover(ch.port2);
+			if (handed !== void 0) {
+				const t = tx;
+				handed.catch((e) => {
+					this.txs.delete(t);
+					t.close(e);
+				});
+			}
 			return tx;
 		} catch (e) {
 			tx?.close(e);
@@ -105,8 +113,12 @@ var WorkerSock = class extends Sock {
 		this.worker.postMessage(start);
 		return this.readiness;
 	}
-	connect() {
-		const serve = { drpc: "serve" };
+	connect(entryPoint, readyTimeoutMs) {
+		const serve = {
+			drpc: "serve",
+			...entryPoint === void 0 ? {} : { entryPoint },
+			...readyTimeoutMs === void 0 ? {} : { readyTimeoutMs }
+		};
 		return this.channelTo((port) => this.worker.postMessage(serve, [port]));
 	}
 	stop() {
@@ -147,8 +159,8 @@ var HereSock = class extends Sock {
 		this.inst = inst;
 		inst.exited.then((cause) => this.bury(cause));
 	}
-	connect() {
-		return this.channelTo((port) => this.inst.serve(port));
+	connect(entryPoint, readyTimeoutMs) {
+		return this.channelTo((port) => this.inst.serve(port, entryPoint, readyTimeoutMs));
 	}
 	stop() {}
 };