@lesomnus/grpc-dgram 0.0.1 → 0.1.0

package/dist/index.d.mts

@@ -1,6 +1,5 @@
-import { $ as StatusError, A as decodeEnvelop, B as isHalfClose, C as FlagCompressed, D as FlagWindow, E as FlagReset, F as frameStatus, G as isTerminal, H as isOpen, I as hasUnknownFlags, J as resetFor, K as isWindow, L as isClose, M as encodeEnvelop, N as encodeFrame, O as Frame, P as frame, Q as MessageTooLargeError, R as isCompressed, S as FlagClose, T as FlagPing, U as isPing, V as isHeaderFrame, W as isReset, X as shapeOf, Y as setFrameError, Z as Code, _ as TransportInfo, a as EndOfStreamError, at as Limits, b as unpack, c as Compressor, ct as Timing, d as DEFAULT_STALL_MS, et as abortCause, f as W_INIT, g as FrameHandler, h as FrameContext, i as DetailedStatusError, it as DropPolicy, j as decodeFrame, k as SHAPE_MASK, l as DEFAULT_MAX_RECV_MSG_SIZE, m as ConnAttacher, n as Conn, nt as statusError, o as FlowTiming, ot as RxBufferConfig, p as getCompressor, q as legalShape, r as ConnOptions, rt as toStatusError, s as statusDetails, t as ClientStream, tt as isMessageTooLarge, u as DEFAULT_MAX_SEND_MSG_SIZE, v as hasConnAttacher, w as FlagOpen, x as Any, y as hasTransportInfo, z as isData } from "./conn-DTWG9vIx.mjs";
+import { $ as encodeEnvelope, A as DEFAULT_STALL_MS, At as DropPolicy, B as hasTransportInfo, C as ServerReader, Ct as statusError, D as Compressor, Dt as ProtocolEvent, E as UnaryHandler, Et as Counters, F as EnvelopeSender, G as FlagOpen, H as Any, I as FrameContext, J as FlagWindow, K as FlagPing, L as FrameHandler, M as W_INIT, Mt as RxBufferConfig, N as getCompressor, Nt as Timing, O as DEFAULT_MAX_RECV_MSG_SIZE, Ot as ProtocolEventKind, P as ConnAttacher, Q as decodeFrame, R as TransportInfo, S as ServerOptions, St as isMessageTooLarge, T as ServerWriter, Tt as CounterSnapshot, U as FlagClose, V as unpack, W as FlagCompressed, X as SHAPE_MASK, Y as Frame, Z as decodeEnvelope, _ as UnaryServerInterceptor, _t as shapeOf, a as DetailedStatusError, at as isCompressed, b as Server, bt as StatusError, c as statusDetails, ct as isHeaderFrame, d as StreamServerHandler, dt as isReset, et as encodeFrame, f as StreamServerInterceptor, ft as isTerminal, g as UnaryServerHandler, gt as setFrameError, h as UnaryInvoker, ht as resetFor, i as ConnOptions, it as isClose, j as W_CONN, jt as Limits, k as DEFAULT_MAX_SEND_MSG_SIZE, kt as ProtocolStats, l as ClientCall, lt as isOpen, m as UnaryClientInterceptor, mt as legalShape, n as ClientStream, nt as frameStatus, o as EndOfStreamError, ot as isData, p as Streamer, pt as isWindow, q as FlagReset, r as Conn, rt as hasUnknownFlags, s as FlowTiming, st as isHalfClose, t as CallConfig, tt as frame, u as StreamClientInterceptor, ut as isPing, v as BidiHandler, vt as Code, w as ServerStreamingHandler, wt as toStatusError, x as ServerContext, xt as abortCause, y as ClientStreamingHandler, yt as MessageTooLargeError, z as hasConnAttacher } from "./conn-Dc57BC-h.mjs";
 import { S as validateMetadataPair, _ as decodeBase64, a as MethodDesc, b as metadataJoin, c as ServerStreamingDesc, d as clientStreamingMethod, f as isUnary, g as cloneMetadata, h as Metadata, i as ForcedCodec, l as UnaryDesc, m as unaryMethod, n as CallOptions, o as NamedCodec, p as serverStreamingMethod, r as ClientStreamingDesc, s as PayloadCodec, t as BidiDesc, u as bidiMethod, v as encodeBase64, x as validateMetadata, y as isBinaryKey } from "./desc-BMF2FBqk.mjs";
-import { a as ServerOptions, c as ServerWriter, i as ServerContext, l as UnaryHandler, n as ClientStreamingHandler, o as ServerReader, r as Server, s as ServerStreamingHandler, t as BidiHandler } from "./server-xIr1mwqq.mjs";
 //#region src/seq.d.ts
 declare const W_FWD = 4096;
 declare const K_LOUD = 3;
@@ -21,7 +20,9 @@ declare class RxWindow {
   strict: boolean;
   private beyondN;
   private beyondLast;
+  private gap;
+  takeGap(): number;
   check(seq: number): RxVerdict;
 }
 //#endregion
-export { type Any, type BidiDesc, type BidiHandler, type CallOptions, ClientStream, type ClientStreamingDesc, type ClientStreamingHandler, Code, type Compressor, Conn, type ConnAttacher, type ConnOptions, DEFAULT_MAX_RECV_MSG_SIZE, DEFAULT_MAX_SEND_MSG_SIZE, DEFAULT_STALL_MS, type DetailedStatusError, DropPolicy, EndOfStreamError, FlagClose, FlagCompressed, FlagOpen, FlagPing, FlagReset, FlagWindow, type FlowTiming, type ForcedCodec, type Frame, type FrameContext, type FrameHandler, K_LOUD, type Limits, MessageTooLargeError, type Metadata, type MethodDesc, type NamedCodec, type PayloadCodec, type RxBufferConfig, RxVerdict, RxWindow, SHAPE_MASK, Server, type ServerContext, type ServerOptions, type ServerReader, type ServerStreamingDesc, type ServerStreamingHandler, type ServerWriter, StatusError, type Timing, type TransportInfo, TxSeq, type UnaryDesc, type UnaryHandler, 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 };
+export { type Any, type BidiDesc, type BidiHandler, type CallConfig, type CallOptions, type ClientCall, ClientStream, type ClientStreamingDesc, type ClientStreamingHandler, Code, type Compressor, Conn, type ConnAttacher, type ConnOptions, type CounterSnapshot, Counters, DEFAULT_MAX_RECV_MSG_SIZE, DEFAULT_MAX_SEND_MSG_SIZE, DEFAULT_STALL_MS, type DetailedStatusError, DropPolicy, EndOfStreamError, type EnvelopeSender, FlagClose, FlagCompressed, FlagOpen, FlagPing, FlagReset, FlagWindow, type FlowTiming, type ForcedCodec, type Frame, type FrameContext, type FrameHandler, K_LOUD, type Limits, MessageTooLargeError, type Metadata, type MethodDesc, type NamedCodec, type PayloadCodec, type ProtocolEvent, type ProtocolEventKind, type ProtocolStats, type RxBufferConfig, RxVerdict, RxWindow, SHAPE_MASK, Server, type ServerContext, type ServerOptions, type ServerReader, type ServerStreamingDesc, type ServerStreamingHandler, type ServerWriter, StatusError, type StreamClientInterceptor, type StreamServerHandler, type StreamServerInterceptor, type Streamer, type Timing, type TransportInfo, TxSeq, type UnaryClientInterceptor, type UnaryDesc, type UnaryHandler, type UnaryInvoker, type UnaryServerHandler, type UnaryServerInterceptor, W_CONN, W_FWD, W_INIT, abortCause, bidiMethod, clientStreamingMethod, cloneMetadata, decodeBase64, decodeEnvelope, decodeFrame, encodeBase64, encodeEnvelope, 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 };

package/dist/index.mjs

@@ -1,6 +1,6 @@
-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 resolveTiming, c as statsSink, d as RxWindow, f as TxSeq, i as statusDetails, l as K_LOUD, m as chain2, n as Conn, o as Counters, p as W_FWD, r as EndOfStreamError, s as emit, t as ClientStream, u as RxVerdict } from "./conn-CmYPHTPR.mjs";
+import { $ as sizeOr, A as DEFAULT_MAX_SEND_MSG_SIZE, B as W_INIT, C as isTerminal, D as setFrameError, E as resetFor, F as Latch, G as compressPayload, H as acquireBoth, I as PeerFlowRx, J as nonzeroEpoch, K as decompressPayload, L as Sweeper, M as FlowReceiver, N as FlowSender, O as shapeOf, P as FrameQueue, Q as reliableRxSize, R as U32_MAX, S as isReset, T as legalShape, U as checkRecvSize, W as checkSendSize, X as nowMs, Y as noop, Z as rawPayload, _ as isData, a as FlagReset, at as cloneMetadata, b as isOpen, c as decodeEnvelope, ct as isBinaryKey, d as encodeFrame, dt as validateMetadataPair, et as tryAcquireBoth, f as frame, ft as DropPolicy, g as isCompressed, h as isClose, i as FlagPing, it as unpack, j as DEFAULT_STALL_MS, k as DEFAULT_MAX_RECV_MSG_SIZE, l as decodeFrame, lt as metadataJoin, m as hasUnknownFlags, mt as resolveRxConfig, n as FlagCompressed, nt as hasConnAttacher, o as FlagWindow, ot as decodeBase64, p as frameStatus, pt as resolveLimits, q as getCompressor, r as FlagOpen, rt as hasTransportInfo, s as SHAPE_MASK, st as encodeBase64, t as FlagClose, tt as unrefTimer, u as encodeEnvelope, ut as validateMetadata, v as isHalfClose, w as isWindow, x as isPing, y as isHeaderFrame, z as W_CONN } from "./wire-DqHx0oUs.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 {
@@ -60,6 +60,10 @@ function windowOf(f) {
 	const w = f.window;
 	return typeof w === "number" && Number.isFinite(w) && w > 0 ? Math.floor(w) : 0;
 }
+function connWindowOf(f) {
+	const w = f.connWindow;
+	return typeof w === "number" && Number.isFinite(w) && w > 0 ? Math.min(Math.floor(w), U32_MAX) : 0;
+}
 var PeerState = class {
 	peer;
 	epoch;
@@ -76,6 +80,7 @@ var PeerState = class {
 	tombFloor = 0;
 	calls = /* @__PURE__ */ new Map();
 	liveCalls = 0;
+	connTx = new FlowSender();
 	lastRx;
 	lastTx;
 	lastPing = 0;
@@ -156,6 +161,7 @@ var PeerSlot = class {
 	replyBudget;
 	resetAt = /* @__PURE__ */ new Map();
 	pendingResets = /* @__PURE__ */ new Map();
+	flow;
 	constructor(peer) {
 		this.peer = peer;
 	}
@@ -174,6 +180,7 @@ var Server = class {
 	maxRecv;
 	maxSend;
 	stallMs;
+	/** @internal */ pstats;
 	services = /* @__PURE__ */ new Map();
 	serving = false;
 	slots = /* @__PURE__ */ new Map();
@@ -186,6 +193,8 @@ var Server = class {
 	idleWaiters = [];
 	sawUnreliable = false;
 	sw = new Sweeper();
+	unaryInt;
+	streamInt;
 	constructor(tx, opts = {}) {
 		this.epoch = nonzeroEpoch();
 		this.tx = tx;
@@ -202,6 +211,19 @@ var Server = class {
 		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;
+		this.pstats = statsSink(opts.protocolStats);
+		this.unaryInt = chain2(opts.unaryInterceptors);
+		this.streamInt = chain2(opts.streamInterceptors);
+	}
+	protoEvent(kind, peer, sid = 0) {
+		if (this.pstats.length === 0) return;
+		emit(this.pstats, {
+			kind,
+			peer,
+			sid,
+			method: "",
+			count: 0
+		});
 	}
 	register(desc, handler) {
 		if (this.serving) throw new Error("drpc: register called after the server started serving");
@@ -217,6 +239,7 @@ var Server = class {
 		this.serving = true;
 		if (isReset(f)) {
 			if (f.epoch !== this.epoch) return;
+			this.protoEvent("reset-received", ctx.peer, f.sid);
 			this.resetByPeerSid(ctx.peer, f.sid, f.peerEpoch);
 			return;
 		}
@@ -235,6 +258,7 @@ var Server = class {
 				if (ps.replayDue(tb, now, rti) && this.allowReply(slot, now)) {
 					const replay = ps.replayTomb(tb, now, rti);
 					if (replay !== void 0) {
+						this.protoEvent("tombstone-replay", peer, sid);
 						await this.send(replay, ctx);
 						return;
 					}
@@ -244,6 +268,11 @@ var Server = class {
 			}
 			return this.sendReset(slot, f, ctx);
 		}
+		if (sid === 0 && shapeOf(f) === 16) {
+			if (this.rxReliable(ctx)) if (ps !== void 0) ps.connTx.grant(windowOf(f));
+			else slot?.flow?.creditEvicted(f.epoch, windowOf(f));
+			return;
+		}
 		const st = ps?.calls.get(sid);
 		if (st !== void 0) {
 			await st.handleRx(f, ctx);
@@ -257,7 +286,10 @@ var Server = class {
 				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);
+					if (replay !== void 0) {
+						this.protoEvent("tombstone-replay", peer, sid);
+						await this.send(replay, ctx);
+					}
 				}
 				return;
 			}
@@ -272,7 +304,17 @@ var Server = class {
 			}
 			return this.open(ctx, f);
 		}
-		if (this.rxReliable(ctx)) return this.sendReset(slot, f, ctx);
+		if (this.rxReliable(ctx)) {
+			const pf = slot?.flow;
+			if (pf !== void 0 && isData(f)) if (ps !== void 0) {
+				const g = pf.unadmitted(f.epoch, 1);
+				if (g > 0) this.grantPeer(ps, g);
+			} else {
+				const g = pf.unadmittedEvicted(f.epoch, 1);
+				if (g > 0) this.grantEpoch(peer, f.epoch, g);
+			}
+			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) {
@@ -311,6 +353,7 @@ var Server = class {
 		const now = nowMs();
 		const slot = this.ensureSlot(ctx.peer);
 		const ps = this.ensurePeer(slot, f.epoch, now, rel);
+		if (rel) this.observeAdvertisement(ps, f);
 		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 = {
@@ -339,6 +382,7 @@ var Server = class {
 		if (ps.hwm < f.sid) ps.hwm = f.sid;
 		ps.dead = false;
 		ps.lastRx = now;
+		if (rel) st.pf = this.ensurePeerFlow(slot);
 		if (slot.pendingResets.delete(eksid(f.epoch, f.sid))) this.pendingResetTotal--;
 		this.liveTasks++;
 		this.kickSweep();
@@ -356,6 +400,7 @@ var Server = class {
 		}
 	}
 	async rejectOpen(ctx, f, code, msg) {
+		const rel = this.rxReliable(ctx);
 		const t = frame({
 			epoch: this.epoch,
 			sid: f.sid,
@@ -365,15 +410,19 @@ var Server = class {
 			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;
+		this.advertise(t, rel);
+		const now = nowMs();
+		const slot = this.ensureSlot(ctx.peer);
+		const ps = this.ensurePeer(slot, f.epoch, now, rel);
+		ps.lastRx = now;
+		if (rel) {
+			this.observeAdvertisement(ps, f);
+			this.ensurePeerFlow(slot);
+		} else {
 			if (ps.hwm < f.sid) ps.hwm = f.sid;
 			ps.addTomb(f.sid, t, now + this.mode.timing.tombstoneMs);
-			this.kickSweep();
 		}
+		this.kickSweep();
 		await this.send(t, ctx);
 	}
 	async runUnary(st, open) {
@@ -383,7 +432,9 @@ var Server = class {
 			let resp;
 			try {
 				const req = await st.decodeMessage(open);
-				resp = await st.reg.handler(req, st.context);
+				const h = async (r, c) => await st.reg.handler(r, c);
+				resp = this.unaryInt === void 0 ? await h(req, st.context) : await this.unaryInt(req, st.context, h);
+				if (resp === void 0) throw statusError(13, "unary handler produced no response");
 			} catch (e) {
 				err = toStatusError(e);
 			}
@@ -408,14 +459,20 @@ var Server = class {
 			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);
+				const last = async (stream, ctx) => {
+					if (!desc.clientStreams) {
+						const req = await stream.recv();
+						if (req === void 0) throw statusError(2, "missing request message");
+						return st.reg.handler(req, stream, ctx);
+					}
+					if (!desc.serverStreams) return st.reg.handler(stream, ctx);
+					return st.reg.handler(stream, ctx);
+				};
+				const out = this.streamInt === void 0 ? await last(st, st.context) : await this.streamInt(st, st.context, last);
+				if (desc.clientStreams && !desc.serverStreams) {
+					if (out === void 0) throw statusError(13, "client-streaming handler produced no response");
+					st.setResponse(out);
+				}
 			} catch (e) {
 				err = toStatusError(e);
 			}
@@ -445,6 +502,7 @@ var Server = class {
 		}
 		if (slot !== void 0 && slot.liveCalls > 0) slot.liveCalls--;
 		st.flowTx.release();
+		st.releasePinned();
 		st.cancel(statusError(1, "call finished"));
 		if (st.deadlineTimer !== void 0) {
 			clearTimeout(st.deadlineTimer);
@@ -482,6 +540,7 @@ var Server = class {
 			this.sawUnreliable = true;
 			this.kickSweep();
 		}
+		this.protoEvent("reset-sent", ctx.peer, f.sid);
 		await this.send(resetFor(f), ctx);
 	}
 	allowReply(slot, now) {
@@ -523,13 +582,18 @@ var Server = class {
 		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);
+		const senders = [];
+		for (const ps of slot.epochs.values()) {
+			for (const st of ps.calls.values()) targets.push(st);
+			senders.push(ps.connTx);
+		}
 		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);
+		for (const tx of senders) tx.release();
 	}
 	waitIdle() {
 		if (this.liveTasks === 0) return Promise.resolve();
@@ -575,18 +639,54 @@ var Server = class {
 	ensurePeer(slot, epoch, now, reliable) {
 		let ps = slot.epochs.get(epoch);
 		if (ps !== void 0) return ps;
+		let held;
+		if (reliable) held = slot.flow?.unstash(epoch);
 		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;
+			if (oldest.reliable) this.ensurePeerFlow(slot).stash(oldest.epoch, oldest.connTx.state());
 			slot.epochs.delete(oldest.epoch);
 		}
 		ps = new PeerState(slot.peer, epoch, reliable, now, this.limits.maxTombstones, this.limits.maxTombstoneBytes);
+		if (held !== void 0) ps.connTx.restore(held);
 		slot.epochs.set(epoch, ps);
 		if (!reliable) this.sawUnreliable = true;
 		return ps;
 	}
+	observeAdvertisement(ps, f) {
+		ps.connTx.observe(connWindowOf(f));
+	}
+	/** @internal */
+	advertise(f, reliable) {
+		if (reliable) f.connWindow = this.limits.maxPeerWindow;
+	}
+	ensurePeerFlow(slot) {
+		let pf = slot.flow;
+		if (pf === void 0) {
+			pf = new PeerFlowRx();
+			pf.enable(this.limits.maxPeerWindow, this.limits.maxDeadPeers);
+			slot.flow = pf;
+		}
+		return pf;
+	}
+	/** @internal */
+	grantPeer(ps, n) {
+		this.grantOn(ps.peer, ps.epoch, n);
+	}
+	grantEpoch(peer, epoch, n) {
+		this.grantOn(peer, epoch, n);
+	}
+	grantOn(peer, epoch, n) {
+		if (this.closed) return;
+		this.send(frame({
+			epoch: this.epoch,
+			peerEpoch: epoch,
+			flags: 16,
+			window: n
+		}), this.txFor(peer));
+	}
 	/** @internal */
 	kickSweep() {
 		if (!this.sawUnreliable) return;
@@ -613,6 +713,7 @@ var Server = class {
 				if (!this.allowReply(slot, now)) continue;
 				slot.pendingResets.delete(k);
 				this.pendingResetTotal--;
+				this.protoEvent("reset-sent", slot.peer, pr.sid);
 				jobs.push({
 					f: frame({
 						flags: 4,
@@ -644,6 +745,7 @@ var Server = class {
 				if (ps.liveCalls > 0 && !ps.dead) {
 					if (now - ps.lastRx >= t.livenessMs) {
 						ps.dead = true;
+						this.protoEvent("liveness-expired", slot.peer);
 						for (const st of ps.calls.values()) {
 							st.suppressTerm = true;
 							lost.push(st);
@@ -656,6 +758,7 @@ var Server = class {
 					} else if (now - ps.lastTx >= t.probeMs && now - ps.lastPing >= t.probeMs) {
 						ps.lastPing = now;
 						ps.lastTx = now;
+						this.protoEvent("keepalive-sent", slot.peer);
 						jobs.push({
 							f: frame({
 								epoch: this.epoch,
@@ -668,20 +771,19 @@ var Server = class {
 				}
 				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)
-						});
-					}
+			for (const ps of slot.epochs.values()) for (const st of ps.calls.values()) {
+				if (st.reliable) continue;
+				const f = st.probeDue(now, t.probeMs, this.epoch);
+				if (f !== void 0) {
+					st.protoEvent("probe-sent");
+					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);
+			if (slot.epochs.size === 0 && slot.liveCalls === 0 && slot.pendingResets.size === 0 && slot.resetAt.size === 0 && slot.replyBudget === void 0 && slot.flow === void 0) this.slots.delete(peerKey);
 		}
 		const cause = statusError(14, "peer lost");
 		for (const st of lost) st.cancel(cause);
@@ -701,6 +803,7 @@ var ServerStream = class {
 	stallMs;
 	context;
 	/** @internal */ ps;
+	/** @internal */ pf;
 	/** @internal */ slot;
 	/** @internal */ deadlineAt;
 	/** @internal */ deadlineTimer;
@@ -721,6 +824,8 @@ var ServerStream = class {
 	lastProbe = 0;
 	hReplayAt = 0;
 	rxWin = new RxWindow();
+	pinned = 0;
+	rxReleased = false;
 	/** @internal */ rxq;
 	rxCfg;
 	/** @internal */ rxDropped = 0;
@@ -757,6 +862,7 @@ var ServerStream = class {
 			},
 			peer,
 			method: reg.desc.path,
+			desc: reg.desc,
 			get deadline() {
 				return self.deadlineAt;
 			},
@@ -767,6 +873,7 @@ var ServerStream = class {
 				try {
 					validateMetadata(md);
 				} catch {
+					this.protoEvent("off-shape", 1);
 					return;
 				}
 				this.trailerMd = metadataJoin(this.trailerMd, md);
@@ -784,9 +891,22 @@ var ServerStream = class {
 		this.endLatch.trip();
 	}
 	/** @internal */
+	protoEvent(kind, count = 0) {
+		const sink = this.server.pstats;
+		if (sink.length === 0) return;
+		emit(sink, {
+			kind,
+			peer: this.peer,
+			sid: this.sid,
+			method: this.reg.desc.path,
+			count
+		});
+	}
+	/** @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)}`));
+			this.creditUnbuffered(f);
 			return;
 		}
 		if (shapeOf(f) === 16) {
@@ -806,12 +926,15 @@ var ServerStream = class {
 			if (!isUnary(this.reg.desc) || this.hdrFrame !== void 0) this.replayH();
 			return;
 		}
-		switch (this.rxWin.check(f.seq)) {
+		const v = this.rxWin.check(f.seq);
+		if (v !== 0) this.creditUnbuffered(f);
+		switch (v) {
 			case 1:
 				this.noteValidatedRx();
 				return;
 			case 2: return;
 			case 3:
+				this.protoEvent("data-loss");
 				this.cancel(statusError(15, "seq window overrun: >W_fwd consecutive frames lost"));
 				return;
 			case 4:
@@ -819,22 +942,38 @@ var ServerStream = class {
 				return;
 			case 0: break;
 		}
+		const gap = this.rxWin.takeGap();
+		if (gap > 0) this.protoEvent("skipped", gap);
 		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++;
+				this.creditUnbuffered(f);
 				return;
 			}
 			if (this.reliable) {
+				if (this.pf !== void 0 && !this.pf.admit()) {
+					this.cancel(statusError(13, "drpc: peer exceeded the connection flow-control window"));
+					this.creditUnbuffered(f);
+					return;
+				}
+				if (!this.pin()) {
+					this.retirePeer(1);
+					return;
+				}
 				if (this.flowRx.active) {
-					if (!this.rxq.tryPut(f)) this.cancel(statusError(13, "drpc: peer exceeded the advertised flow-control window"));
+					if (!this.rxq.tryPut(f)) {
+						if (this.unpin()) this.retirePeer(1);
+						this.cancel(statusError(13, "drpc: peer exceeded the advertised flow-control window"));
+					}
 				} else if (!await this.rxq.putBlocking(f, this.endLatch, ctx.signal)) {
+					if (this.unpin()) this.retirePeer(1);
 					this.rxDropped++;
 					this.cancel(statusError(14, "transport closed during delivery"));
 				}
-			} else this.rxq.putDrop(f, this.rxCfg.policy);
+			} else if (this.rxq.putDrop(f, this.rxCfg.policy) > 0) this.protoEvent("dropped", 1);
 		} else this.rxDropped++;
 	}
 	noteValidatedRx() {
@@ -845,11 +984,7 @@ var ServerStream = class {
 	async recv() {
 		for (;;) {
 			const f = this.rxq.tryTake();
-			if (f !== void 0) {
-				const msg = await this.decodeMessage(f);
-				this.grantWindow(1);
-				return msg;
-			}
+			if (f !== void 0) return this.recvBuffered(f);
 			if (this.rxEOF.tripped) return void 0;
 			if (this.ctrl.signal.aborted) throw abortCause(this.ctrl.signal);
 			await Promise.race([
@@ -859,6 +994,39 @@ var ServerStream = class {
 			]);
 		}
 	}
+	async recvBuffered(f) {
+		if (!isOpen(f) && this.unpin()) this.retirePeer(1);
+		const msg = await this.decodeMessage(f);
+		this.grantWindow(1);
+		return msg;
+	}
+	pin() {
+		if (this.rxReleased) return false;
+		this.pinned++;
+		return true;
+	}
+	unpin() {
+		if (this.pinned === 0) return false;
+		this.pinned--;
+		return true;
+	}
+	/** @internal */
+	releasePinned() {
+		const pinned = this.pinned;
+		this.pinned = 0;
+		this.rxReleased = true;
+		this.retirePeer(pinned);
+	}
+	creditUnbuffered(f) {
+		if (!this.reliable || this.pf === void 0 || this.ps === void 0 || !isData(f)) return;
+		const g = this.pf.unadmitted(this.clientEpoch, 1);
+		if (g > 0) this.server.grantPeer(this.ps, g);
+	}
+	retirePeer(n) {
+		if (n === 0 || this.pf === void 0 || this.ps === void 0) return;
+		const g = this.pf.retire(this.clientEpoch, n, true);
+		if (g > 0) this.server.grantPeer(this.ps, g);
+	}
 	async *[Symbol.asyncIterator]() {
 		for (;;) {
 			const m = await this.recv();
@@ -898,6 +1066,7 @@ var ServerStream = class {
 	sendH() {
 		const f = this.nextFrame();
 		if (this.reliable) f.window = this.rxCfg.size;
+		this.server.advertise(f, this.reliable);
 		this.attachHeader(f, false);
 		if (this.hdrFrame === void 0) this.hdrFrame = f;
 		this.transmit(f).catch(noop);
@@ -924,6 +1093,7 @@ var ServerStream = class {
 		if (f === void 0) {
 			f = this.nextFrame();
 			if (this.reliable) f.window = this.rxCfg.size;
+			this.server.advertise(f, this.reliable);
 			this.attachHeader(f, false);
 		}
 		this.transmit(f).catch(noop);
@@ -953,6 +1123,7 @@ var ServerStream = class {
 		this.hdrFlushed = true;
 		if (md !== void 0) this.txHeader = metadataJoin(this.txHeader, md);
 		const f = this.nextFrame();
+		this.server.advertise(f, this.reliable);
 		this.attachHeader(f, true);
 		if (this.hdrFrame === void 0) this.hdrFrame = f;
 		try {
@@ -965,19 +1136,33 @@ var ServerStream = class {
 	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);
+		if (this.ctrl.signal.aborted) throw abortCause(this.ctrl.signal);
+		const connTx = this.reliable && this.ps !== void 0 ? this.ps.connTx : void 0;
+		if (!tryAcquireBoth(this.flowTx, connTx)) {
+			let peer = false;
+			switch (await acquireBoth(this.flowTx, connTx, this.endLatch, this.stallMs, void 0, (p) => {
+				peer = p;
+				this.protoEvent(p ? "peer-flow-stall" : "flow-stall");
+			})) {
+				case "ok":
+					this.protoEvent(peer ? "peer-flow-resume" : "flow-resume");
+					break;
+				case "stalled": throw statusError(14, `drpc: flow-control stall: the peer granted no credit for ${this.stallMs}ms`);
+				case "peer-stalled": throw statusError(14, `drpc: flow-control stall: the peer granted no connection credit for ${this.stallMs}ms`);
+				default: throw abortCause(this.ctrl.signal);
+			}
 		}
 		let enc;
 		try {
 			enc = await this.encodePayload(raw);
 		} catch (e) {
-			this.flowTx.undo();
+			this.undoCredit();
 			throw e;
 		}
-		if (this.ctrl.signal.aborted) throw abortCause(this.ctrl.signal);
+		if (this.ctrl.signal.aborted) {
+			this.undoCredit();
+			throw abortCause(this.ctrl.signal);
+		}
 		const f = this.nextFrame();
 		f.payload = enc.bytes;
 		if (enc.compressed) f.flags |= 32;
@@ -998,7 +1183,11 @@ var ServerStream = class {
 	undoRefused(f, err) {
 		if (!isMessageTooLarge(err)) return;
 		this.txSeq.undo(f.seq);
-		if (isData(f)) this.flowTx.undo();
+		if (isData(f)) this.undoCredit();
+	}
+	undoCredit() {
+		this.flowTx.undo();
+		if (this.reliable && this.ps !== void 0) this.ps.connTx.undo();
 	}
 	async encodePayload(payload) {
 		const enc = this.comp === void 0 ? rawPayload(payload) : await compressPayload(this.comp, payload);
@@ -1029,6 +1218,7 @@ var ServerStream = class {
 		}
 		const f = this.nextFrame();
 		f.flags = 2;
+		this.server.advertise(f, this.reliable);
 		if (this.txHeader !== void 0) {
 			f.header = this.txHeader;
 			this.hdrSent = true;
@@ -1076,4 +1266,4 @@ 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 };
+export { ClientStream, Code, Conn, Counters, 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_CONN, W_FWD, W_INIT, abortCause, bidiMethod, clientStreamingMethod, cloneMetadata, decodeBase64, decodeEnvelope, decodeFrame, encodeBase64, encodeEnvelope, 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 };