@lesomnus/grpc-dgram 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1079 @@
+import { $ as unpack, A as DEFAULT_MAX_SEND_MSG_SIZE, B as checkSendSize, C as isTerminal, D as setFrameError, E as resetFor, F as Latch, G as noop, H as decompressPayload, I as Sweeper, J as reliableRxSize, K as nowMs, L as W_INIT, M as FlowReceiver, N as FlowSender, O as shapeOf, P as FrameQueue, Q as hasTransportInfo, S as isReset, T as legalShape, U as getCompressor, V as compressPayload, W as nonzeroEpoch, X as unrefTimer, Y as sizeOr, Z as hasConnAttacher, _ as isData, a as FlagReset, at as validateMetadata, b as isOpen, c as decodeEnvelop, ct as resolveLimits, d as encodeFrame, et as cloneMetadata, f as frame, g as isCompressed, h as isClose, i as FlagPing, it as metadataJoin, j as DEFAULT_STALL_MS, k as DEFAULT_MAX_RECV_MSG_SIZE, l as decodeFrame, lt as resolveRxConfig, m as hasUnknownFlags, n as FlagCompressed, nt as encodeBase64, o as FlagWindow, ot as validateMetadataPair, p as frameStatus, q as rawPayload, r as FlagOpen, rt as isBinaryKey, s as SHAPE_MASK, st as DropPolicy, t as FlagClose, tt as decodeBase64, u as encodeEnvelop, v as isHalfClose, w as isWindow, x as isPing, y as isHeaderFrame, z as checkRecvSize } from "./wire-BR8KiyRg.mjs";
+import { a as isMessageTooLarge, i as abortCause, n as MessageTooLargeError, o as statusError, r as StatusError, s as toStatusError, t as Code } from "./status-DZwMDWIn.mjs";
+import { a as resolveTiming, c as RxWindow, i as statusDetails, l as TxSeq, n as Conn, o as K_LOUD, r as EndOfStreamError, s as RxVerdict, t as ClientStream, u as W_FWD } from "./conn-DOmx4nbt.mjs";
+//#region src/desc.ts
+function unaryMethod(path, init) {
+	return {
+		path,
+		clientStreams: false,
+		serverStreams: false,
+		...init
+	};
+}
+function serverStreamingMethod(path, init) {
+	return {
+		path,
+		clientStreams: false,
+		serverStreams: true,
+		...init
+	};
+}
+function clientStreamingMethod(path, init) {
+	return {
+		path,
+		clientStreams: true,
+		serverStreams: false,
+		...init
+	};
+}
+function bidiMethod(path, init) {
+	return {
+		path,
+		clientStreams: true,
+		serverStreams: true,
+		...init
+	};
+}
+function isUnary(desc) {
+	return !desc.clientStreams && !desc.serverStreams;
+}
+//#endregion
+//#region src/server.ts
+const EMPTY = /* @__PURE__ */ new Uint8Array(0);
+function detailsOf(err) {
+	if (!(err instanceof StatusError)) return void 0;
+	const d = err.details;
+	if (!Array.isArray(d) || d.length === 0) return void 0;
+	const out = [];
+	for (const e of d) {
+		if (e === null || typeof e !== "object") continue;
+		const a = e;
+		if (typeof a.typeUrl === "string" && a.value instanceof Uint8Array) out.push({
+			typeUrl: a.typeUrl,
+			value: a.value
+		});
+	}
+	return out.length > 0 ? out : void 0;
+}
+const errText = (e) => e instanceof Error ? e.message : String(e);
+function windowOf(f) {
+	const w = f.window;
+	return typeof w === "number" && Number.isFinite(w) && w > 0 ? Math.floor(w) : 0;
+}
+var PeerState = class {
+	peer;
+	epoch;
+	reliable;
+	createdAt;
+	maxTombs;
+	maxTombBytes;
+	hwm = 0;
+	cps = [];
+	dead = false;
+	tombs = /* @__PURE__ */ new Map();
+	tombOrder = [];
+	tombBytes = 0;
+	tombFloor = 0;
+	calls = /* @__PURE__ */ new Map();
+	liveCalls = 0;
+	lastRx;
+	lastTx;
+	lastPing = 0;
+	constructor(peer, epoch, reliable, createdAt, maxTombs, maxTombBytes) {
+		this.peer = peer;
+		this.epoch = epoch;
+		this.reliable = reliable;
+		this.createdAt = createdAt;
+		this.maxTombs = maxTombs;
+		this.maxTombBytes = maxTombBytes;
+		this.lastRx = createdAt;
+		this.lastTx = createdAt;
+	}
+	hwmAged(now, ttlMs) {
+		if (this.reliable) return this.hwm;
+		let aged = 0;
+		for (const cp of this.cps) if (now - cp.at >= ttlMs) aged = cp.hwm;
+		return aged;
+	}
+	addTomb(sid, term, expireAt) {
+		if (sid <= this.tombFloor) return;
+		const size = term?.payload?.length ?? 0;
+		const old = this.tombs.get(sid);
+		if (old !== void 0) {
+			this.tombBytes += size - old.size;
+			old.term = term;
+			old.size = size;
+			if (expireAt > old.expireAt) old.expireAt = expireAt;
+			return;
+		}
+		this.tombs.set(sid, {
+			sid,
+			term,
+			size,
+			expireAt,
+			lastReplay: 0
+		});
+		this.tombOrder.push(sid);
+		this.tombBytes += size;
+		for (let i = 0; this.tombBytes > this.maxTombBytes && i < this.tombOrder.length; i++) {
+			const tb = this.tombs.get(this.tombOrder[i]);
+			if (tb !== void 0 && tb.term !== void 0) {
+				this.tombBytes -= tb.size;
+				tb.term = void 0;
+				tb.size = 0;
+			}
+		}
+		while (this.tombs.size > this.maxTombs) {
+			let lowest = 0;
+			for (const tsid of this.tombs.keys()) if (lowest === 0 || tsid < lowest) lowest = tsid;
+			const tb = this.tombs.get(lowest);
+			if (tb !== void 0) this.tombBytes -= tb.size;
+			this.tombs.delete(lowest);
+			if (this.tombFloor < lowest) this.tombFloor = lowest;
+		}
+	}
+	removeTomb(sid) {
+		const tb = this.tombs.get(sid);
+		if (tb !== void 0) {
+			this.tombBytes -= tb.size;
+			this.tombs.delete(sid);
+		}
+	}
+	replayDue(tb, now, rtiMs) {
+		return tb.term !== void 0 && now - tb.lastReplay >= rtiMs;
+	}
+	replayTomb(tb, now, rtiMs) {
+		if (tb.term === void 0 || now - tb.lastReplay < rtiMs) return void 0;
+		tb.lastReplay = now;
+		this.lastTx = now;
+		return tb.term;
+	}
+};
+var PeerSlot = class {
+	peer;
+	epochs = /* @__PURE__ */ new Map();
+	liveCalls = 0;
+	replyBudget;
+	resetAt = /* @__PURE__ */ new Map();
+	pendingResets = /* @__PURE__ */ new Map();
+	constructor(peer) {
+		this.peer = peer;
+	}
+};
+const eksid = (epoch, sid) => `${epoch}:${sid}`;
+var Server = class {
+	epoch;
+	tx;
+	mode;
+	maxHandlerTimeoutMs;
+	rxCfg;
+	methodRx;
+	limits;
+	codecs;
+	compressors;
+	maxRecv;
+	maxSend;
+	stallMs;
+	services = /* @__PURE__ */ new Map();
+	serving = false;
+	slots = /* @__PURE__ */ new Map();
+	pendingResetTotal = 0;
+	resetAtTotal = 0;
+	replyBudgetTotal = 0;
+	drain = false;
+	closed = false;
+	liveTasks = 0;
+	idleWaiters = [];
+	sawUnreliable = false;
+	sw = new Sweeper();
+	constructor(tx, opts = {}) {
+		this.epoch = nonzeroEpoch();
+		this.tx = tx;
+		this.mode = {
+			reliable: opts.reliable ?? (hasTransportInfo(tx) ? tx.reliable() : false),
+			timing: resolveTiming(opts.timing)
+		};
+		this.maxHandlerTimeoutMs = opts.maxHandlerTimeoutMs ?? 0;
+		this.rxCfg = resolveRxConfig(opts.rxBuffer);
+		this.methodRx = new Map(Object.entries(opts.methodRxBuffer ?? {}).map(([k, v]) => [k, resolveRxConfig(v)]));
+		this.limits = resolveLimits(opts.limits);
+		this.codecs = new Map(Object.entries(opts.codecs ?? {}));
+		this.compressors = new Map(Object.entries(opts.compressors ?? {}));
+		this.maxRecv = sizeOr(opts.maxRecvMsgSize, DEFAULT_MAX_RECV_MSG_SIZE);
+		this.maxSend = sizeOr(opts.maxSendMsgSize, DEFAULT_MAX_SEND_MSG_SIZE);
+		this.stallMs = opts.timing?.stallMs ?? 3e4;
+	}
+	register(desc, handler) {
+		if (this.serving) throw new Error("drpc: register called after the server started serving");
+		this.services.set(desc.path, {
+			desc,
+			handler
+		});
+	}
+	rxReliable(ctx) {
+		return ctx.reliable ?? this.mode.reliable;
+	}
+	async handle(f, ctx = {}) {
+		this.serving = true;
+		if (isReset(f)) {
+			if (f.epoch !== this.epoch) return;
+			this.resetByPeerSid(ctx.peer, f.sid, f.peerEpoch);
+			return;
+		}
+		const peer = ctx.peer;
+		const sid = f.sid;
+		const slot = this.slots.get(peer);
+		const ps = slot?.epochs.get(f.epoch);
+		const now = nowMs();
+		if (isPing(f)) {
+			if (ps !== void 0) ps.lastRx = now;
+			if (sid === 0) return;
+			if (ps?.calls.has(sid)) return;
+			const tb = ps?.tombs.get(sid);
+			if (ps !== void 0 && tb !== void 0) {
+				const rti = this.mode.timing.retransmitMs;
+				if (ps.replayDue(tb, now, rti) && this.allowReply(slot, now)) {
+					const replay = ps.replayTomb(tb, now, rti);
+					if (replay !== void 0) {
+						await this.send(replay, ctx);
+						return;
+					}
+				}
+				if (tb.term !== void 0) return;
+				return this.sendReset(slot, f, ctx);
+			}
+			return this.sendReset(slot, f, ctx);
+		}
+		const st = ps?.calls.get(sid);
+		if (st !== void 0) {
+			await st.handleRx(f, ctx);
+			return;
+		}
+		if (shapeOf(f) === 16) return;
+		if (ps !== void 0) {
+			const tb = ps.tombs.get(sid);
+			if (tb !== void 0) {
+				ps.lastRx = now;
+				const rti = this.mode.timing.retransmitMs;
+				if (ps.replayDue(tb, now, rti) && this.allowReply(slot, now)) {
+					const replay = ps.replayTomb(tb, now, rti);
+					if (replay !== void 0) await this.send(replay, ctx);
+				}
+				return;
+			}
+			if (sid <= ps.tombFloor) {
+				ps.lastRx = now;
+				return;
+			}
+		}
+		if (isOpen(f) && f.seq === 1) {
+			if (ps !== void 0) {
+				if (sid <= ps.hwmAged(now, this.mode.timing.tombstoneMs)) return this.sendReset(slot, f, ctx);
+			}
+			return this.open(ctx, f);
+		}
+		if (this.rxReliable(ctx)) return this.sendReset(slot, f, ctx);
+		const s = this.ensureSlot(peer);
+		const k = eksid(f.epoch, sid);
+		if (!s.pendingResets.has(k) && this.pendingResetTotal < this.limits.maxPendingResets) {
+			s.pendingResets.set(k, {
+				due: now + this.mode.timing.holdMs,
+				echo: f.epoch,
+				peerEcho: f.peerEpoch,
+				epoch: f.epoch,
+				sid
+			});
+			this.pendingResetTotal++;
+			this.sawUnreliable = true;
+		}
+		this.kickSweep();
+	}
+	async open(ctx, f) {
+		if (this.drain || this.closed) return this.sendReset(this.slots.get(ctx.peer), f, ctx);
+		const rel = this.rxReliable(ctx);
+		const reg = this.services.get(f.method);
+		if (reg === void 0) return this.rejectOpen(ctx, f, 12, "method not found");
+		let codec;
+		if (f.codec === "") codec = {
+			request: reg.desc.request,
+			response: reg.desc.response
+		};
+		else {
+			const named = this.codecs.get(f.codec);
+			if (named === void 0) return this.rejectOpen(ctx, f, 12, `unsupported codec: ${f.codec}`);
+			codec = named.resolve(reg.desc);
+		}
+		let comp;
+		if (f.compressor) {
+			comp = this.compressors.get(f.compressor);
+			if (comp === void 0) return this.rejectOpen(ctx, f, 12, `unsupported compressor: ${f.compressor}`);
+		}
+		const now = nowMs();
+		const slot = this.ensureSlot(ctx.peer);
+		const ps = this.ensurePeer(slot, f.epoch, now, rel);
+		if (slot.liveCalls >= this.limits.maxLiveCalls) return this.rejectOpen(ctx, f, 8, "too many concurrent calls");
+		const cfg = this.methodRx.get(reg.desc.path) ?? this.rxCfg;
+		const rxCfg = {
+			size: reliableRxSize(cfg.size, rel),
+			policy: cfg.policy
+		};
+		const st = new ServerStream(this, ctx.peer, f.epoch, f.sid, reg, codec, rxCfg, rel, comp, this.maxRecv, this.maxSend, this.stallMs);
+		st.ps = ps;
+		st.slot = slot;
+		if (rel) st.flowTx.observe(windowOf(f));
+		if (f.timeoutMs !== void 0) {
+			let d = f.timeoutMs;
+			if (this.maxHandlerTimeoutMs > 0 && d > this.maxHandlerTimeoutMs) d = this.maxHandlerTimeoutMs;
+			st.deadlineAt = now + d;
+			if (d <= 0) st.cancel(statusError(4, "call timeout"));
+			else {
+				const t = setTimeout(() => st.cancel(statusError(4, "call timeout")), d);
+				unrefTimer(t);
+				st.deadlineTimer = t;
+			}
+		}
+		st.metadata = f.header;
+		ps.calls.set(f.sid, st);
+		slot.liveCalls++;
+		ps.liveCalls++;
+		if (ps.hwm < f.sid) ps.hwm = f.sid;
+		ps.dead = false;
+		ps.lastRx = now;
+		if (slot.pendingResets.delete(eksid(f.epoch, f.sid))) this.pendingResetTotal--;
+		this.liveTasks++;
+		this.kickSweep();
+		const desc = reg.desc;
+		if (isUnary(desc)) this.runUnary(st, f);
+		else if (!desc.clientStreams) {
+			if (f.payload !== void 0) st.rxq.tryPut(f);
+			if (isClose(f)) st.rxEOF.trip();
+			st.sendH();
+			this.runStream(st);
+		} else {
+			if (f.payload !== void 0 || isClose(f)) st.rxDropped++;
+			st.sendH();
+			this.runStream(st);
+		}
+	}
+	async rejectOpen(ctx, f, code, msg) {
+		const t = frame({
+			epoch: this.epoch,
+			sid: f.sid,
+			seq: 1,
+			flags: 2,
+			desc: msg,
+			peerEpoch: f.epoch
+		});
+		t.code = code;
+		if (!this.rxReliable(ctx)) {
+			const now = nowMs();
+			const slot = this.ensureSlot(ctx.peer);
+			const ps = this.ensurePeer(slot, f.epoch, now, false);
+			ps.lastRx = now;
+			if (ps.hwm < f.sid) ps.hwm = f.sid;
+			ps.addTomb(f.sid, t, now + this.mode.timing.tombstoneMs);
+			this.kickSweep();
+		}
+		await this.send(t, ctx);
+	}
+	async runUnary(st, open) {
+		let term;
+		try {
+			let err;
+			let resp;
+			try {
+				const req = await st.decodeMessage(open);
+				resp = await st.reg.handler(req, st.context);
+			} catch (e) {
+				err = toStatusError(e);
+			}
+			if (err === void 0 && st.signal.aborted) err = abortCause(st.signal);
+			if (err === void 0) try {
+				st.setResponse(resp);
+			} catch (e) {
+				err = statusError(13, `marshal response: ${errText(e)}`);
+			}
+			const t = await st.terminalFrame(err);
+			if (st.suppressTerm) return;
+			term = t;
+			st.transmitTerminal(t).catch(noop);
+		} finally {
+			this.finish(st, term);
+			this.taskDone();
+		}
+	}
+	async runStream(st) {
+		let term;
+		try {
+			const desc = st.reg.desc;
+			let err;
+			try {
+				if (!desc.clientStreams) {
+					const req = await st.recv();
+					if (req === void 0) throw statusError(2, "missing request message");
+					await st.reg.handler(req, st, st.context);
+				} else if (!desc.serverStreams) {
+					const resp = await st.reg.handler(st, st.context);
+					st.setResponse(resp);
+				} else await st.reg.handler(st, st.context);
+			} catch (e) {
+				err = toStatusError(e);
+			}
+			if (err === void 0 && st.signal.aborted) err = abortCause(st.signal);
+			const t = await st.terminalFrame(err);
+			if (st.suppressTerm) return;
+			term = t;
+			st.transmitTerminal(t).catch(noop);
+		} finally {
+			this.finish(st, term);
+			this.taskDone();
+		}
+	}
+	finish(st, term) {
+		const now = nowMs();
+		const slot = st.slot;
+		const ps = st.ps;
+		if (ps !== void 0) {
+			ps.calls.delete(st.sid);
+			ps.liveCalls--;
+			if (!st.reliable) {
+				let ttl = this.mode.timing.tombstoneMs;
+				if (st.deadlineAt !== void 0) ttl = Math.max(ttl, st.deadlineAt - now);
+				if (ps.dead) term = void 0;
+				ps.addTomb(st.sid, term, now + ttl);
+			}
+		}
+		if (slot !== void 0 && slot.liveCalls > 0) slot.liveCalls--;
+		st.flowTx.release();
+		st.cancel(statusError(1, "call finished"));
+		if (st.deadlineTimer !== void 0) {
+			clearTimeout(st.deadlineTimer);
+			st.deadlineTimer = void 0;
+		}
+		this.kickSweep();
+	}
+	resetByPeerSid(peer, sid, peerEpoch) {
+		const slot = this.slots.get(peer);
+		if (slot === void 0) return;
+		const targets = [];
+		for (const [epoch, ps] of slot.epochs) {
+			if (peerEpoch !== 0 && epoch !== peerEpoch) continue;
+			const st = ps.calls.get(sid);
+			if (st !== void 0) targets.push(st);
+		}
+		const cause = statusError(14, "call reset by peer");
+		for (const st of targets) {
+			st.suppressTerm = true;
+			st.cancel(cause);
+		}
+	}
+	async sendReset(slot, f, ctx) {
+		if (!this.rxReliable(ctx)) {
+			const n = nowMs();
+			const s = slot ?? this.ensureSlot(ctx.peer);
+			const k = eksid(f.epoch, f.sid);
+			const last = s.resetAt.get(k);
+			if (last !== void 0) {
+				if (n - last < this.mode.timing.retransmitMs) return;
+			} else if (this.resetAtTotal >= this.limits.maxPendingResets) return;
+			if (!this.allowReply(s, n)) return;
+			if (!s.resetAt.has(k)) this.resetAtTotal++;
+			s.resetAt.set(k, n);
+			this.sawUnreliable = true;
+			this.kickSweep();
+		}
+		await this.send(resetFor(f), ctx);
+	}
+	allowReply(slot, now) {
+		let b = slot.replyBudget;
+		if (b === void 0) {
+			if (this.replyBudgetTotal >= this.limits.maxPendingResets) return false;
+			b = {
+				windowStart: now,
+				n: 0
+			};
+			slot.replyBudget = b;
+			this.replyBudgetTotal++;
+		}
+		if (now - b.windowStart >= this.mode.timing.retransmitMs) {
+			b.windowStart = now;
+			b.n = 0;
+		}
+		if (b.n >= this.limits.maxRepliesPerRTI) return false;
+		b.n++;
+		return true;
+	}
+	async gracefulStop() {
+		this.drain = true;
+		await this.waitIdle();
+		this.closed = true;
+		this.sw.stop();
+	}
+	async stop() {
+		this.drain = true;
+		this.closed = true;
+		const targets = [];
+		for (const slot of this.slots.values()) for (const ps of slot.epochs.values()) for (const st of ps.calls.values()) targets.push(st);
+		const cause = statusError(14, "server stopped");
+		for (const st of targets) st.cancel(cause);
+		await this.waitIdle();
+		this.sw.stop();
+	}
+	disconnectPeer(peer, err) {
+		const slot = this.slots.get(peer);
+		if (slot === void 0) return;
+		const targets = [];
+		for (const ps of slot.epochs.values()) for (const st of ps.calls.values()) targets.push(st);
+		this.pendingResetTotal -= slot.pendingResets.size;
+		this.resetAtTotal -= slot.resetAt.size;
+		if (slot.replyBudget !== void 0) this.replyBudgetTotal--;
+		this.slots.delete(peer);
+		const cause = err === void 0 || err === null ? statusError(14, "transport closed") : statusError(14, `transport closed: ${err instanceof Error ? err.message : String(err)}`);
+		for (const st of targets) st.cancel(cause);
+	}
+	waitIdle() {
+		if (this.liveTasks === 0) return Promise.resolve();
+		return new Promise((res) => this.idleWaiters.push(res));
+	}
+	taskDone() {
+		this.liveTasks--;
+		if (this.liveTasks === 0) {
+			const ws = this.idleWaiters.splice(0);
+			for (const w of ws) w();
+		}
+	}
+	/** @internal */
+	get timing() {
+		return this.mode.timing;
+	}
+	/** @internal */
+	send(f, ctx) {
+		return Promise.resolve(this.tx.handle(f, ctx)).catch(noop);
+	}
+	/** @internal */
+	sendOrThrow(f, ctx) {
+		return Promise.resolve(this.tx.handle(f, ctx));
+	}
+	/** @internal */
+	txFor(peer) {
+		return peer === void 0 ? {} : { peer };
+	}
+	/** @internal */
+	allowReplyFor(peer, now) {
+		const slot = this.slots.get(peer);
+		if (slot === void 0) return false;
+		return this.allowReply(slot, now);
+	}
+	ensureSlot(peer) {
+		let slot = this.slots.get(peer);
+		if (slot === void 0) {
+			slot = new PeerSlot(peer);
+			this.slots.set(peer, slot);
+		}
+		return slot;
+	}
+	ensurePeer(slot, epoch, now, reliable) {
+		let ps = slot.epochs.get(epoch);
+		if (ps !== void 0) return ps;
+		const dead = [];
+		for (const p of slot.epochs.values()) if (p.liveCalls === 0) dead.push(p);
+		if (dead.length >= this.limits.maxDeadPeers) {
+			let oldest = dead[0];
+			for (const p of dead) if (p.createdAt < oldest.createdAt) oldest = p;
+			slot.epochs.delete(oldest.epoch);
+		}
+		ps = new PeerState(slot.peer, epoch, reliable, now, this.limits.maxTombstones, this.limits.maxTombstoneBytes);
+		slot.epochs.set(epoch, ps);
+		if (!reliable) this.sawUnreliable = true;
+		return ps;
+	}
+	/** @internal */
+	kickSweep() {
+		if (!this.sawUnreliable) return;
+		this.sw.kick(this.mode.timing.tickMs, () => this.sweep(nowMs()), () => this.hasWork());
+	}
+	hasWork() {
+		if (this.pendingResetTotal > 0 || this.resetAtTotal > 0 || this.replyBudgetTotal > 0) return true;
+		for (const slot of this.slots.values()) for (const ps of slot.epochs.values()) if (!ps.reliable) return true;
+		return false;
+	}
+	sweep(now) {
+		const t = this.mode.timing;
+		const jobs = [];
+		const lost = [];
+		for (const [peerKey, slot] of this.slots) {
+			for (const [k, pr] of slot.pendingResets) {
+				if (now < pr.due) continue;
+				const ps = slot.epochs.get(pr.epoch);
+				if (ps !== void 0 && (ps.calls.has(pr.sid) || ps.tombs.has(pr.sid))) {
+					slot.pendingResets.delete(k);
+					this.pendingResetTotal--;
+					continue;
+				}
+				if (!this.allowReply(slot, now)) continue;
+				slot.pendingResets.delete(k);
+				this.pendingResetTotal--;
+				jobs.push({
+					f: frame({
+						flags: 4,
+						epoch: pr.echo,
+						peerEpoch: pr.peerEcho,
+						sid: pr.sid
+					}),
+					ctx: this.txFor(slot.peer)
+				});
+			}
+			for (const [k, at] of slot.resetAt) if (now - at > t.tombstoneMs) {
+				slot.resetAt.delete(k);
+				this.resetAtTotal--;
+			}
+			if (slot.replyBudget !== void 0 && now - slot.replyBudget.windowStart > t.tombstoneMs) {
+				slot.replyBudget = void 0;
+				this.replyBudgetTotal--;
+			}
+			for (const [epoch, ps] of slot.epochs) {
+				if (ps.reliable) continue;
+				ps.cps.push({
+					at: now,
+					hwm: ps.hwm
+				});
+				while (ps.cps.length > 1 && now - ps.cps[1].at >= t.tombstoneMs) ps.cps.shift();
+				const aged = ps.hwmAged(now, t.tombstoneMs);
+				for (const [sid, tb] of ps.tombs) if (now > tb.expireAt && sid <= aged) ps.removeTomb(sid);
+				if (ps.tombOrder.length > 2 * ps.tombs.size + 16) ps.tombOrder = ps.tombOrder.filter((sid) => ps.tombs.has(sid));
+				if (ps.liveCalls > 0 && !ps.dead) {
+					if (now - ps.lastRx >= t.livenessMs) {
+						ps.dead = true;
+						for (const st of ps.calls.values()) {
+							st.suppressTerm = true;
+							lost.push(st);
+						}
+						for (const tb of ps.tombs.values()) {
+							ps.tombBytes -= tb.size;
+							tb.term = void 0;
+							tb.size = 0;
+						}
+					} else if (now - ps.lastTx >= t.probeMs && now - ps.lastPing >= t.probeMs) {
+						ps.lastPing = now;
+						ps.lastTx = now;
+						jobs.push({
+							f: frame({
+								epoch: this.epoch,
+								flags: 8,
+								peerEpoch: epoch
+							}),
+							ctx: this.txFor(slot.peer)
+						});
+					}
+				}
+				if (ps.liveCalls === 0 && ps.tombs.size === 0 && now - ps.lastRx > 2 * t.tombstoneMs) slot.epochs.delete(epoch);
+			}
+			for (const ps of slot.epochs.values()) {
+				if (ps.reliable) continue;
+				for (const st of ps.calls.values()) {
+					const f = st.probeDue(now, t.probeMs, this.epoch);
+					if (f !== void 0) {
+						ps.lastTx = now;
+						jobs.push({
+							f,
+							ctx: this.txFor(slot.peer)
+						});
+					}
+				}
+			}
+			if (slot.epochs.size === 0 && slot.liveCalls === 0 && slot.pendingResets.size === 0 && slot.resetAt.size === 0 && slot.replyBudget === void 0) this.slots.delete(peerKey);
+		}
+		const cause = statusError(14, "peer lost");
+		for (const st of lost) st.cancel(cause);
+		for (const j of jobs) this.send(j.f, j.ctx);
+	}
+};
+var ServerStream = class {
+	server;
+	peer;
+	clientEpoch;
+	sid;
+	reg;
+	reliable;
+	comp;
+	maxRecv;
+	maxSend;
+	stallMs;
+	context;
+	/** @internal */ ps;
+	/** @internal */ slot;
+	/** @internal */ deadlineAt;
+	/** @internal */ deadlineTimer;
+	/** @internal */ metadata;
+	/** @internal */ suppressTerm = false;
+	/** @internal */ flowTx = new FlowSender();
+	flowRx = new FlowReceiver();
+	txSeq = new TxSeq();
+	/** @internal */ txHeader;
+	hdrSent = false;
+	hdrFlushed = false;
+	hdrFrame;
+	/** @internal */ trailerMd;
+	resp;
+	respSet = false;
+	lastRx;
+	lastTx;
+	lastProbe = 0;
+	hReplayAt = 0;
+	rxWin = new RxWindow();
+	/** @internal */ rxq;
+	rxCfg;
+	/** @internal */ rxDropped = 0;
+	/** @internal */ rxEOF = new Latch();
+	ctrl = new AbortController();
+	endLatch = new Latch();
+	/** @internal */
+	constructor(server, peer, clientEpoch, sid, reg, codec, rxCfg, reliable, comp, maxRecv, maxSend, stallMs) {
+		this.server = server;
+		this.peer = peer;
+		this.clientEpoch = clientEpoch;
+		this.sid = sid;
+		this.reg = reg;
+		this.reliable = reliable;
+		this.comp = comp;
+		this.maxRecv = maxRecv;
+		this.maxSend = maxSend;
+		this.stallMs = stallMs;
+		this.reqCodec = codec.request;
+		this.resCodec = codec.response;
+		this.rxCfg = rxCfg;
+		this.rxq = new FrameQueue(rxCfg.size);
+		this.rxWin.l = 1;
+		this.rxWin.strict = reliable;
+		if (reliable) this.flowRx.enable(rxCfg.size);
+		const n = nowMs();
+		this.lastRx = n;
+		this.lastTx = n;
+		const self = this;
+		this.context = {
+			signal: this.ctrl.signal,
+			get metadata() {
+				return self.metadata;
+			},
+			peer,
+			method: reg.desc.path,
+			get deadline() {
+				return self.deadlineAt;
+			},
+			setHeader: (md) => this.setHeader(md),
+			sendHeader: (md) => this.sendHeader(md),
+			setTrailer: (md) => {
+				if (Object.keys(md).length === 0) return;
+				try {
+					validateMetadata(md);
+				} catch {
+					return;
+				}
+				this.trailerMd = metadataJoin(this.trailerMd, md);
+			}
+		};
+	}
+	/** @internal */ reqCodec;
+	/** @internal */ resCodec;
+	get signal() {
+		return this.ctrl.signal;
+	}
+	/** @internal */
+	cancel(cause) {
+		this.ctrl.abort(cause);
+		this.endLatch.trip();
+	}
+	/** @internal */
+	async handleRx(f, ctx) {
+		if (hasUnknownFlags(f) || !legalShape(shapeOf(f))) {
+			this.cancel(statusError(13, `drpc: frame carries unsupported flags 0x${f.flags.toString(16)}`));
+			return;
+		}
+		if (shapeOf(f) === 16) {
+			if (this.reliable) this.flowTx.grant(windowOf(f));
+			return;
+		}
+		if (isOpen(f)) {
+			if (f.seq !== 1) {
+				this.rxDropped++;
+				return;
+			}
+			if (this.reliable) {
+				this.cancel(statusError(13, "reliable transport lost or reordered a frame"));
+				return;
+			}
+			this.noteValidatedRx();
+			if (!isUnary(this.reg.desc) || this.hdrFrame !== void 0) this.replayH();
+			return;
+		}
+		switch (this.rxWin.check(f.seq)) {
+			case 1:
+				this.noteValidatedRx();
+				return;
+			case 2: return;
+			case 3:
+				this.cancel(statusError(15, "seq window overrun: >W_fwd consecutive frames lost"));
+				return;
+			case 4:
+				this.cancel(statusError(13, "reliable transport lost or reordered a frame"));
+				return;
+			case 0: break;
+		}
+		this.noteValidatedRx();
+		if (isTerminal(f)) this.cancel(frameStatus(f));
+		else if (isHalfClose(f)) this.rxEOF.trip();
+		else if (isData(f)) {
+			if (isUnary(this.reg.desc) || !this.reg.desc.clientStreams) {
+				this.rxDropped++;
+				return;
+			}
+			if (this.reliable) {
+				if (this.flowRx.active) {
+					if (!this.rxq.tryPut(f)) this.cancel(statusError(13, "drpc: peer exceeded the advertised flow-control window"));
+				} else if (!await this.rxq.putBlocking(f, this.endLatch, ctx.signal)) {
+					this.rxDropped++;
+					this.cancel(statusError(14, "transport closed during delivery"));
+				}
+			} else this.rxq.putDrop(f, this.rxCfg.policy);
+		} else this.rxDropped++;
+	}
+	noteValidatedRx() {
+		const n = nowMs();
+		this.lastRx = n;
+		if (this.ps !== void 0) this.ps.lastRx = n;
+	}
+	async recv() {
+		for (;;) {
+			const f = this.rxq.tryTake();
+			if (f !== void 0) {
+				const msg = await this.decodeMessage(f);
+				this.grantWindow(1);
+				return msg;
+			}
+			if (this.rxEOF.tripped) return void 0;
+			if (this.ctrl.signal.aborted) throw abortCause(this.ctrl.signal);
+			await Promise.race([
+				this.rxq.readable(),
+				this.rxEOF.wait(),
+				this.endLatch.wait()
+			]);
+		}
+	}
+	async *[Symbol.asyncIterator]() {
+		for (;;) {
+			const m = await this.recv();
+			if (m === void 0) return;
+			yield m;
+		}
+	}
+	/** @internal */
+	transmit(f) {
+		const n = nowMs();
+		this.lastTx = n;
+		if (this.ps !== void 0) this.ps.lastTx = n;
+		return this.server.send(f, this.server.txFor(this.peer));
+	}
+	nextFrame() {
+		const f = frame({
+			epoch: this.server.epoch,
+			sid: this.sid,
+			seq: this.txSeq.next()
+		});
+		f.peerEpoch = this.clientEpoch;
+		return f;
+	}
+	attachHeader(f, force) {
+		if (this.hdrSent) return;
+		if (this.txHeader !== void 0) {
+			f.header = this.txHeader;
+			this.hdrSent = true;
+			return;
+		}
+		if (force) {
+			f.header = {};
+			this.hdrSent = true;
+		}
+	}
+	/** @internal */
+	sendH() {
+		const f = this.nextFrame();
+		if (this.reliable) f.window = this.rxCfg.size;
+		this.attachHeader(f, false);
+		if (this.hdrFrame === void 0) this.hdrFrame = f;
+		this.transmit(f).catch(noop);
+	}
+	grantWindow(n) {
+		if (this.ctrl.signal.aborted) return;
+		const g = this.flowRx.consumed(n);
+		if (g === 0) return;
+		const f = frame({
+			epoch: this.server.epoch,
+			sid: this.sid,
+			peerEpoch: this.clientEpoch,
+			flags: 16,
+			window: g
+		});
+		this.transmit(f).catch(noop);
+	}
+	replayH() {
+		const n = nowMs();
+		if (n - this.hReplayAt < this.server.timing.retransmitMs) return;
+		this.hReplayAt = n;
+		if (!this.server.allowReplyFor(this.peer, n)) return;
+		let f = this.hdrFrame;
+		if (f === void 0) {
+			f = this.nextFrame();
+			if (this.reliable) f.window = this.rxCfg.size;
+			this.attachHeader(f, false);
+		}
+		this.transmit(f).catch(noop);
+	}
+	/** @internal */
+	probeDue(now, probeMs, epoch) {
+		if (now - this.lastRx < probeMs || now - this.lastTx < probeMs || now - this.lastProbe < probeMs) return;
+		this.lastProbe = now;
+		return frame({
+			epoch,
+			sid: this.sid,
+			flags: 8,
+			peerEpoch: this.clientEpoch
+		});
+	}
+	/** @internal */
+	setHeader(md) {
+		if (Object.keys(md).length === 0) return;
+		validateMetadata(md);
+		if (this.hdrFlushed || this.hdrSent) throw illegalHeaderWrite();
+		this.txHeader = metadataJoin(this.txHeader, md);
+	}
+	/** @internal */
+	async sendHeader(md) {
+		if (md !== void 0) validateMetadata(md);
+		if (this.hdrFlushed || this.hdrSent) throw illegalHeaderWrite();
+		this.hdrFlushed = true;
+		if (md !== void 0) this.txHeader = metadataJoin(this.txHeader, md);
+		const f = this.nextFrame();
+		this.attachHeader(f, true);
+		if (this.hdrFrame === void 0) this.hdrFrame = f;
+		try {
+			await this.transmitOrThrow(f);
+		} catch (e) {
+			this.undoRefused(f, e);
+			throw toStatusError(e);
+		}
+	}
+	async send(msg) {
+		const raw = this.resCodec.marshal(msg);
+		if (!this.reg.desc.serverStreams) throw statusError(13, "send on a non-server-streaming call");
+		if (!this.flowTx.tryAcquire()) switch (await this.flowTx.acquire(this.endLatch, this.stallMs)) {
+			case "ok": break;
+			case "stalled": throw statusError(14, `drpc: flow-control stall: the peer granted no credit for ${this.stallMs}ms`);
+			default: throw abortCause(this.ctrl.signal);
+		}
+		let enc;
+		try {
+			enc = await this.encodePayload(raw);
+		} catch (e) {
+			this.flowTx.undo();
+			throw e;
+		}
+		if (this.ctrl.signal.aborted) throw abortCause(this.ctrl.signal);
+		const f = this.nextFrame();
+		f.payload = enc.bytes;
+		if (enc.compressed) f.flags |= 32;
+		this.attachHeader(f, false);
+		try {
+			await this.transmitOrThrow(f);
+		} catch (e) {
+			this.undoRefused(f, e);
+			throw e;
+		}
+	}
+	transmitOrThrow(f) {
+		const n = nowMs();
+		this.lastTx = n;
+		if (this.ps !== void 0) this.ps.lastTx = n;
+		return this.server.sendOrThrow(f, this.server.txFor(this.peer));
+	}
+	undoRefused(f, err) {
+		if (!isMessageTooLarge(err)) return;
+		this.txSeq.undo(f.seq);
+		if (isData(f)) this.flowTx.undo();
+	}
+	async encodePayload(payload) {
+		const enc = this.comp === void 0 ? rawPayload(payload) : await compressPayload(this.comp, payload);
+		checkSendSize(enc.bytes.length, this.maxSend);
+		return enc;
+	}
+	/** @internal */
+	async decodeMessage(f) {
+		const raw = f.payload ?? EMPTY;
+		const payload = isCompressed(f) ? await decompressPayload(this.comp, raw, this.maxRecv) : raw;
+		checkRecvSize(payload.length, this.maxRecv);
+		return this.reqCodec.unmarshal(payload);
+	}
+	/** @internal */
+	setResponse(resp) {
+		if (this.respSet) throw statusError(13, "response already set");
+		this.resp = this.resCodec.marshal(resp);
+		this.respSet = true;
+	}
+	/** @internal */
+	async terminalFrame(err) {
+		let enc;
+		let st = err;
+		if (st === void 0 && this.respSet) try {
+			enc = await this.encodePayload(this.resp ?? EMPTY);
+		} catch (e) {
+			st = toStatusError(e);
+		}
+		const f = this.nextFrame();
+		f.flags = 2;
+		if (this.txHeader !== void 0) {
+			f.header = this.txHeader;
+			this.hdrSent = true;
+		}
+		if (this.trailerMd !== void 0) f.trailer = this.trailerMd;
+		if (st !== void 0) {
+			setFrameError(f, st);
+			f.details = detailsOf(st);
+			return f;
+		}
+		if (enc !== void 0) {
+			f.payload = enc.bytes;
+			if (enc.compressed) f.flags |= 32;
+		}
+		f.code = 0;
+		return f;
+	}
+	/** @internal */
+	async transmitTerminal(f) {
+		let err = await this.tryTransmit(f);
+		if (err === void 0) return;
+		if (f.details !== void 0 && f.details.length > 0) {
+			f.details = void 0;
+			const e2 = await this.tryTransmit(f);
+			if (e2 === void 0) return;
+			err = e2;
+		}
+		if (f.payload === void 0 && f.code === 8) return;
+		f.payload = void 0;
+		f.flags &= -33;
+		f.details = void 0;
+		setFrameError(f, statusError(8, `drpc: the terminal frame does not fit the transport: ${errText(err)}`));
+		await this.tryTransmit(f);
+	}
+	async tryTransmit(f) {
+		try {
+			await this.transmitOrThrow(f);
+			return;
+		} catch (e) {
+			return isMessageTooLarge(e) ? e : void 0;
+		}
+	}
+};
+function illegalHeaderWrite() {
+	return statusError(13, "drpc: sendHeader called multiple times");
+}
+//#endregion
+export { ClientStream, Code, Conn, DEFAULT_MAX_RECV_MSG_SIZE, DEFAULT_MAX_SEND_MSG_SIZE, DEFAULT_STALL_MS, DropPolicy, EndOfStreamError, FlagClose, FlagCompressed, FlagOpen, FlagPing, FlagReset, FlagWindow, K_LOUD, MessageTooLargeError, RxVerdict, RxWindow, SHAPE_MASK, Server, StatusError, TxSeq, W_FWD, W_INIT, abortCause, bidiMethod, clientStreamingMethod, cloneMetadata, decodeBase64, decodeEnvelop, decodeFrame, encodeBase64, encodeEnvelop, encodeFrame, frame, frameStatus, getCompressor, hasConnAttacher, hasTransportInfo, hasUnknownFlags, isBinaryKey, isClose, isCompressed, isData, isHalfClose, isHeaderFrame, isMessageTooLarge, isOpen, isPing, isReset, isTerminal, isUnary, isWindow, legalShape, metadataJoin, resetFor, serverStreamingMethod, setFrameError, shapeOf, statusDetails, statusError, toStatusError, unaryMethod, unpack, validateMetadata, validateMetadataPair };