@lesomnus/grpc-dgram 0.0.1 → 0.1.0

package/dist/{conn-DOmx4nbt.mjs → conn-CmYPHTPR.mjs}

@@ -1,5 +1,19 @@
-import { A as DEFAULT_MAX_SEND_MSG_SIZE, B as checkSendSize, C as isTerminal, E as resetFor, F as Latch, G as noop, H as decompressPayload, I as Sweeper, J as reliableRxSize, K as nowMs, M as FlowReceiver, N as FlowSender, O as shapeOf, P as FrameQueue, Q as hasTransportInfo, R as abortListener, 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, at as validateMetadata, ct as resolveLimits, f as frame, g as isCompressed, k as DEFAULT_MAX_RECV_MSG_SIZE, lt as resolveRxConfig, m as hasUnknownFlags, p as frameStatus, q as rawPayload, x as isPing, y as isHeaderFrame, z as checkRecvSize } from "./wire-BR8KiyRg.mjs";
+import { $ as sizeOr, A as DEFAULT_MAX_SEND_MSG_SIZE, C as isTerminal, 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, S as isReset, T as legalShape, U as checkRecvSize, V as abortListener, W as checkSendSize, X as nowMs, Y as noop, Z as rawPayload, _ as isData, et as tryAcquireBoth, f as frame, g as isCompressed, k as DEFAULT_MAX_RECV_MSG_SIZE, m as hasUnknownFlags, mt as resolveRxConfig, nt as hasConnAttacher, p as frameStatus, pt as resolveLimits, q as getCompressor, rt as hasTransportInfo, tt as unrefTimer, ut as validateMetadata, x as isPing, y as isHeaderFrame, z as W_CONN } from "./wire-DqHx0oUs.mjs";
 import { a as isMessageTooLarge, i as abortCause, o as statusError, r as StatusError, s as toStatusError } from "./status-DZwMDWIn.mjs";
+//#region src/interceptor.ts
+/** @internal */
+function chain1(is) {
+	if (is === void 0 || is.length === 0) return void 0;
+	const snapshot = [...is];
+	return (x, last) => snapshot.reduceRight((next, h) => (x2) => h(x2, next), last)(x);
+}
+/** @internal */
+function chain2(is) {
+	if (is === void 0 || is.length === 0) return void 0;
+	const snapshot = [...is];
+	return (x, y, last) => snapshot.reduceRight((next, h) => (x2, y2) => h(x2, y2, next), last)(x, y);
+}
+//#endregion
 //#region src/seq.ts
 const W_FWD = 4096;
 const K_LOUD = 3;
@@ -26,6 +40,12 @@ var RxWindow = class {
 	strict = false;
 	beyondN = 0;
 	beyondLast = 0;
+	gap = 0;
+	takeGap() {
+		const g = this.gap;
+		this.gap = 0;
+		return g;
+	}
 	check(seq) {
 		if (seq === 0) return 2;
 		if (this.strict) {
@@ -38,6 +58,7 @@ var RxWindow = class {
 		const d = seq - this.l >>> 0;
 		if (d === 0 || d >= 2147483648) return 1;
 		if (d <= 4096) {
+			this.gap = d - 1;
 			this.l = seq;
 			this.beyondN = 0;
 			return 0;
@@ -50,6 +71,89 @@ var RxWindow = class {
 	}
 };
 //#endregion
+//#region src/stats.ts
+var Counters = class {
+	n = {
+		skipped: 0,
+		dropped: 0,
+		offShape: 0,
+		resetSent: 0,
+		resetReceived: 0,
+		retransmit: 0,
+		probeSent: 0,
+		keepaliveSent: 0,
+		livenessExpired: 0,
+		tombstoneReplay: 0,
+		dataLoss: 0,
+		flowStall: 0,
+		flowResume: 0,
+		peerFlowStall: 0,
+		peerFlowResume: 0
+	};
+	observe = (ev) => {
+		const n = Math.max(ev.count, 1);
+		switch (ev.kind) {
+			case "skipped":
+				this.n.skipped += n;
+				break;
+			case "dropped":
+				this.n.dropped += n;
+				break;
+			case "off-shape":
+				this.n.offShape += n;
+				break;
+			case "reset-sent":
+				this.n.resetSent++;
+				break;
+			case "reset-received":
+				this.n.resetReceived++;
+				break;
+			case "retransmit":
+				this.n.retransmit++;
+				break;
+			case "probe-sent":
+				this.n.probeSent++;
+				break;
+			case "keepalive-sent":
+				this.n.keepaliveSent++;
+				break;
+			case "liveness-expired":
+				this.n.livenessExpired++;
+				break;
+			case "tombstone-replay":
+				this.n.tombstoneReplay++;
+				break;
+			case "data-loss":
+				this.n.dataLoss++;
+				break;
+			case "flow-stall":
+				this.n.flowStall++;
+				break;
+			case "flow-resume":
+				this.n.flowResume++;
+				break;
+			case "peer-flow-stall":
+				this.n.peerFlowStall++;
+				break;
+			case "peer-flow-resume":
+				this.n.peerFlowResume++;
+				break;
+		}
+	};
+	snapshot() {
+		return { ...this.n };
+	}
+};
+function statsSink(opt) {
+	if (opt === void 0) return [];
+	return typeof opt === "function" ? [opt] : [...opt];
+}
+function emit(sink, ev) {
+	for (const h of sink) try {
+		h(ev);
+	} catch {}
+}
+//#endregion
 //#region src/timing.ts
 function resolveTiming(t = {}) {
 	const callMs = t.callMs ?? 5e3;
@@ -98,16 +202,23 @@ var Conn = class {
 	maxRecv;
 	maxSend;
 	stallMs;
+	/** @internal */ pstats;
 	ss = /* @__PURE__ */ new Map();
 	tombs = /* @__PURE__ */ new Map();
 	resetAt = /* @__PURE__ */ new Map();
 	sidNext = 0;
 	exhausted = false;
 	closed = false;
+	/** @internal */ connTx = new FlowSender();
+	/** @internal */ connRx = new PeerFlowRx();
+	srvEpoch = 0;
+	srvEpochSet = false;
 	lastRx = 0;
 	lastTx = 0;
 	lastPing = 0;
 	sw = new Sweeper();
+	unaryInt;
+	streamInt;
 	constructor(tx, opts = {}) {
 		this.epoch = nonzeroEpoch();
 		this.tx = tx;
@@ -121,21 +232,38 @@ var Conn = class {
 			policy: rx.policy
 		};
 		this.limits = resolveLimits(opts.limits);
+		if (this.mode.reliable) {
+			this.connTx.assume(W_CONN);
+			this.connRx.enable(this.limits.maxPeerWindow, 0);
+		}
 		this.defaults = opts.defaultCallOptions ?? {};
 		this.compressor = opts.compressor ?? "";
 		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;
+		this.pstats = statsSink(opts.protocolStats);
+		this.unaryInt = chain2(opts.unaryInterceptors);
+		this.streamInt = chain1(opts.streamInterceptors);
 		if (hasConnAttacher(tx)) tx.attachConn(this);
 	}
 	get reliable() {
 		return this.mode.reliable;
 	}
+	protoEvent(kind, sid = 0) {
+		if (this.pstats.length === 0) return;
+		emit(this.pstats, {
+			kind,
+			sid,
+			method: "",
+			count: 0
+		});
+	}
 	async handle(f, ctx = {}) {
 		const sid = f.sid;
 		if (isReset(f)) {
 			if (f.epoch !== this.epoch) return;
+			this.protoEvent("reset-received", sid);
 			const s = this.ss.get(sid);
 			if (s !== void 0) {
 				s.finishReset();
@@ -145,10 +273,14 @@ var Conn = class {
 			return;
 		}
 		if (f.peerEpoch !== this.epoch) {
-			if (isPing(f) && sid === 0) return;
+			if (sid === 0 && (isPing(f) || shapeOf(f) === 16)) return;
 			await this.sendReset(f);
 			return;
 		}
+		if (sid === 0 && shapeOf(f) === 16) {
+			if (this.mode.reliable && this.serverEpochIs(f.epoch)) this.connTx.grant(f.window);
+			return;
+		}
 		if (shapeOf(f) === 16) {
 			const s = this.ss.get(sid);
 			if (s !== void 0) await s.handleRx(f, ctx);
@@ -166,6 +298,9 @@ var Conn = class {
 			await s.handleRx(f, ctx);
 			return;
 		}
+		this.lockServerEpoch(f.epoch);
+		this.observeAdvertisement(f);
+		this.creditUnbuffered(f);
 		if (this.tombs.get(sid) !== void 0) {
 			this.lastRx = nowMs();
 			if (isTerminal(f)) this.clearTombAbort(sid);
@@ -177,6 +312,7 @@ var Conn = class {
 		const st = err === void 0 || err === null ? statusError(14, "transport closed") : statusError(14, `transport closed: ${err instanceof Error ? err.message : String(err)}`);
 		this.closed = true;
 		this.failAll(st);
+		this.connTx.release();
 		this.sw.stop();
 		const cl = this.tx.close;
 		if (typeof cl === "function") cl.call(this.tx);
@@ -191,6 +327,28 @@ var Conn = class {
 			merged.timeoutMs = this.mode.timing.callMs;
 			timeoutCause = statusError(4, "drpc: default call timeout");
 		}
+		const call = {
+			desc,
+			opts: merged
+		};
+		const budget = merged.timeoutMs;
+		const deadlineAt = budget === void 0 ? void 0 : nowMs() + budget;
+		const last = (r, c) => {
+			if (deadlineAt === void 0 || c.opts.timeoutMs !== budget) return this.doInvoke(r, c, void 0);
+			return this.doInvoke(r, {
+				desc: c.desc,
+				opts: {
+					...c.opts,
+					timeoutMs: deadlineAt - nowMs()
+				}
+			}, timeoutCause);
+		};
+		const out = this.unaryInt === void 0 ? await last(req, call) : await this.unaryInt(req, call, last);
+		if (out === void 0) throw statusError(13, "drpc: the interceptor chain resolved to no response");
+		return out;
+	}
+	async doInvoke(req, call, timeoutCause) {
+		const { desc, opts: merged } = call;
 		const s = this.createStream(desc, merged, timeoutCause);
 		let err;
 		let out;
@@ -215,12 +373,18 @@ var Conn = class {
 		return out;
 	}
 	newStream(desc, opts = {}) {
-		const merged = {
-			...this.defaults,
-			...opts
+		const call = {
+			desc,
+			opts: {
+				...this.defaults,
+				...opts
+			}
 		};
-		const s = this.createStream(desc, merged, void 0);
-		if (desc.clientStreams) s.sendOpen();
+		return this.streamInt === void 0 ? this.doNewStream(call) : this.streamInt(call, (c) => this.doNewStream(c));
+	}
+	doNewStream(call) {
+		const s = this.createStream(call.desc, call.opts, void 0);
+		if (call.desc.clientStreams) s.sendOpen();
 		return s;
 	}
 	resolveCall(opts) {
@@ -281,6 +445,55 @@ var Conn = class {
 		this.lastRx = nowMs();
 	}
 	/** @internal */
+	lockServerEpoch(epoch) {
+		const changed = this.srvEpochSet && this.srvEpoch !== epoch;
+		this.srvEpoch = epoch;
+		this.srvEpochSet = true;
+		if (!changed || !this.mode.reliable) return;
+		this.connTx.reassume(W_CONN);
+		this.connRx.renew();
+	}
+	/** @internal */
+	observeAdvertisement(f) {
+		if (!this.mode.reliable || !(isHeaderFrame(f) || isTerminal(f))) return;
+		this.connTx.observe(f.connWindow);
+	}
+	/** @internal */
+	get locked() {
+		return this.srvEpochSet;
+	}
+	serverEpochIs(epoch) {
+		return this.srvEpochSet && this.srvEpoch === epoch;
+	}
+	serverCurrent(epoch) {
+		return !this.srvEpochSet || this.srvEpoch === epoch;
+	}
+	/** @internal */
+	creditUnbuffered(f) {
+		if (!this.mode.reliable || !isData(f) || !this.serverCurrent(f.epoch)) return;
+		const g = this.connRx.unadmitted(f.epoch, 1);
+		if (g > 0) this.grantPeer(g);
+	}
+	/** @internal */
+	retirePeer(n, epoch) {
+		if (n === 0) return;
+		const g = this.connRx.retire(epoch, n, this.serverCurrent(epoch));
+		if (g > 0) this.grantPeer(g);
+	}
+	/** @internal */
+	get peerWindow() {
+		return this.limits.maxPeerWindow;
+	}
+	grantPeer(n) {
+		if (this.closed) return;
+		const f = frame({
+			epoch: this.epoch,
+			flags: 16,
+			window: n
+		});
+		Promise.resolve(this.tx.handle(f)).catch(noop);
+	}
+	/** @internal */
 	retire(s) {
 		this.ss.delete(s.sid);
 		if (!this.mode.reliable) {
@@ -298,6 +511,7 @@ var Conn = class {
 				tb.retxAt = now + tb.ivalMs;
 			}
 			this.tombs.set(s.sid, tb);
+			s.dropRetx();
 		}
 		this.kickSweep();
 	}
@@ -319,6 +533,7 @@ var Conn = class {
 			this.resetAt.set(sid, n);
 			this.kickSweep();
 		}
+		this.protoEvent("reset-sent", f.sid);
 		try {
 			await this.tx.handle(resetFor(f));
 		} catch {}
@@ -357,12 +572,14 @@ var Conn = class {
 		for (const [sid, at] of this.resetAt) if (now - at > t.tombstoneMs) this.resetAt.delete(sid);
 		if (this.ss.size > 0) {
 			if (now - this.lastRx >= t.livenessMs) {
+				this.protoEvent("liveness-expired");
 				this.failAll(statusError(14, "peer lost"));
 				return;
 			}
 			if (now - this.lastTx >= t.probeMs && now - this.lastPing >= t.probeMs) {
 				this.lastPing = now;
 				this.lastTx = now;
+				this.protoEvent("keepalive-sent");
 				Promise.resolve(this.tx.handle(frame({
 					epoch: this.epoch,
 					flags: 8
@@ -370,14 +587,19 @@ var Conn = class {
 			}
 		}
 		for (const s of streams) {
-			for (const f of s.sweepRetx(now, t.probeMs)) s.transmit(f).catch(noop);
+			for (const f of s.sweepRetx(now, t.probeMs)) {
+				s.protoEvent("retransmit");
+				s.transmit(f).catch(noop);
+			}
 			const p = s.probeDue(now, t.probeMs);
 			if (p !== void 0) {
+				s.protoEvent("probe-sent");
 				this.lastTx = now;
 				Promise.resolve(this.tx.handle(p)).catch(noop);
 			}
 		}
 		for (const f of tombRetx) {
+			this.protoEvent("retransmit", f.sid);
 			this.lastTx = now;
 			Promise.resolve(this.tx.handle(f)).catch(noop);
 		}
@@ -417,6 +639,8 @@ var ClientStream = class {
 	rxWin = new RxWindow();
 	srvEpoch = 0;
 	srvEpochSet = false;
+	pinned = 0;
+	rxReleased = false;
 	rxq;
 	rxPolicy;
 	rxDropped = 0;
@@ -477,13 +701,43 @@ var ClientStream = class {
 			this.signalDispose = abortListener(this.callerSignal, () => this.abortFromCtx());
 		}
 	}
+	pin() {
+		if (this.rxReleased) return false;
+		this.pinned++;
+		return true;
+	}
+	unpin() {
+		if (this.pinned === 0) return false;
+		this.pinned--;
+		return true;
+	}
+	undoCredit() {
+		if (this.flowTx.undo() && this.conn.isReliable) this.conn.connTx.undo();
+	}
+	/** @internal */
+	protoEvent(kind, count = 0) {
+		const sink = this.conn.pstats;
+		if (sink.length === 0) return;
+		emit(sink, {
+			kind,
+			sid: this.sid,
+			method: this.desc.path,
+			count
+		});
+	}
 	/** @internal */
 	async handleRx(f, ctx) {
-		if (this.done.tripped) return;
+		if (this.done.tripped) {
+			this.conn.lockServerEpoch(f.epoch);
+			this.conn.observeAdvertisement(f);
+			this.conn.creditUnbuffered(f);
+			return;
+		}
 		if (hasUnknownFlags(f) || !legalShape(shapeOf(f))) {
 			const err = statusError(13, `drpc: frame carries unsupported flags 0x${(f.flags >>> 0).toString(16)}`);
 			this.sendAbort(13);
 			this.finishLocal(err);
+			this.conn.creditUnbuffered(f);
 			return;
 		}
 		if (this.srvEpochSet && f.epoch !== this.srvEpoch) {
@@ -498,13 +752,16 @@ var ClientStream = class {
 		if (v === 0 && !this.srvEpochSet) {
 			this.srvEpoch = f.epoch;
 			this.srvEpochSet = true;
+			this.conn.lockServerEpoch(f.epoch);
 		}
+		if (v !== 0) this.conn.creditUnbuffered(f);
 		switch (v) {
 			case 1:
 				this.noteValidatedRx();
 				return;
 			case 2: return;
 			case 3: {
+				this.protoEvent("data-loss");
 				const err = statusError(15, "seq window overrun: >W_fwd consecutive frames lost");
 				this.sendAbort(15);
 				this.finishLocal(err);
@@ -518,8 +775,13 @@ var ClientStream = class {
 			}
 			case 0: break;
 		}
+		const gap = this.rxWin.takeGap();
+		if (gap > 0) this.protoEvent("skipped", gap);
 		this.noteValidatedRx();
-		if (this.conn.isReliable) this.flowTx.observe(f.window);
+		if (this.conn.isReliable) {
+			this.flowTx.observe(f.window);
+			this.conn.observeAdvertisement(f);
+		}
 		if (isTerminal(f)) {
 			this.latchHeader(f);
 			if (f.trailer !== void 0) this.trailerMd = f.trailer;
@@ -528,21 +790,36 @@ var ClientStream = class {
 		else if (isData(f)) {
 			if (!this.desc.serverStreams) {
 				this.rxDropped++;
+				this.protoEvent("off-shape", 1);
+				this.conn.creditUnbuffered(f);
 				return;
 			}
 			this.latchHeader(f);
 			if (this.conn.isReliable) {
+				if (!this.conn.connRx.admit()) {
+					const err = statusError(13, "drpc: peer exceeded the connection flow-control window");
+					this.sendAbort(13);
+					this.finishLocal(err);
+					this.conn.creditUnbuffered(f);
+					return;
+				}
+				if (!this.pin()) {
+					this.conn.retirePeer(1, f.epoch);
+					return;
+				}
 				if (this.flowRx.active) {
 					if (!this.rxq.tryPut(f)) {
+						if (this.unpin()) this.conn.retirePeer(1, f.epoch);
 						const err = statusError(13, "drpc: peer exceeded the advertised flow-control window");
 						this.sendAbort(13);
 						this.finishLocal(err);
 					}
 				} else if (!await this.rxq.putBlocking(f, this.done, ctx.signal)) {
+					if (this.unpin()) this.conn.retirePeer(1, f.epoch);
 					this.rxDropped++;
 					this.finishLocal(statusError(14, "transport closed during delivery"));
 				}
-			} else this.rxq.putDrop(f, this.rxPolicy);
+			} else if (this.rxq.putDrop(f, this.rxPolicy) > 0) this.protoEvent("dropped", 1);
 		} else this.rxDropped++;
 	}
 	grantWindow(n) {
@@ -592,7 +869,10 @@ var ClientStream = class {
 		});
 		if (this.codecName !== "") f.codec = this.codecName;
 		if (this.ci.compressorName !== "") f.compressor = this.ci.compressorName;
-		if (this.conn.isReliable) f.window = this.rxSize;
+		if (this.conn.isReliable) {
+			f.window = this.rxSize;
+			f.connWindow = this.conn.peerWindow;
+		}
 		if (this.openHdr !== void 0) f.header = this.openHdr;
 		if (this.deadlineAt !== void 0) f.timeoutMs = this.deadlineAt - nowMs();
 		if (!this.conn.isReliable) {
@@ -627,27 +907,39 @@ var ClientStream = class {
 		}
 		const raw = this.reqCodec.marshal(m);
 		const opening = !this.txOpened;
-		if (!opening && !this.flowTx.tryAcquire()) switch (await this.flowTx.acquire(this.done, this.ci.stallMs, this.callerSignal)) {
-			case "ok": break;
-			case "ended": throw new EndOfStreamError();
-			case "aborted": throw this.callerSignal === void 0 ? statusError(1, "call cancelled") : abortCause(this.callerSignal);
-			case "stalled": throw statusError(14, `drpc: flow-control stall: the peer granted no credit for ${this.ci.stallMs}ms`);
+		const connTx = this.conn.isReliable ? this.conn.connTx : void 0;
+		if (!opening && !tryAcquireBoth(this.flowTx, connTx)) {
+			let peer = false;
+			switch (await acquireBoth(this.flowTx, connTx, this.done, this.ci.stallMs, this.callerSignal, (p) => {
+				peer = p;
+				this.protoEvent(p ? "peer-flow-stall" : "flow-stall");
+			})) {
+				case "ok":
+					this.protoEvent(peer ? "peer-flow-resume" : "flow-resume");
+					break;
+				case "ended": throw new EndOfStreamError();
+				case "aborted": throw this.callerSignal === void 0 ? statusError(1, "call cancelled") : abortCause(this.callerSignal);
+				case "stalled": throw statusError(14, `drpc: flow-control stall: the peer granted no credit for ${this.ci.stallMs}ms`);
+				case "peer-stalled": throw statusError(14, `drpc: flow-control stall: the peer granted no connection credit for ${this.ci.stallMs}ms`);
+			}
 		}
 		let enc = rawPayload(raw);
 		if (this.ci.compressor !== void 0) try {
 			enc = await compressPayload(this.ci.compressor, raw);
 		} catch (e) {
-			if (!opening) this.flowTx.undo();
+			if (!opening) this.undoCredit();
 			throw e;
 		}
 		try {
 			checkSendSize(enc.bytes.length, this.ci.maxSend);
 		} catch (e) {
-			if (!opening) this.flowTx.undo();
+			if (!opening) this.undoCredit();
 			throw e;
 		}
-		if (this.done.tripped) throw new EndOfStreamError();
-		if (!opening && this.txClosed) throw new EndOfStreamError();
+		if (this.done.tripped || !opening && this.txClosed) {
+			if (!opening) this.undoCredit();
+			throw new EndOfStreamError();
+		}
 		let f;
 		if (!this.txOpened) {
 			f = this.openFrame();
@@ -674,7 +966,7 @@ var ClientStream = class {
 			this.retxOpen = void 0;
 			this.retxAt = 0;
 		}
-		if (isData(f)) this.flowTx.undo();
+		if (isData(f)) this.undoCredit();
 	}
 	async send(m) {
 		let err;
@@ -712,6 +1004,7 @@ var ClientStream = class {
 		}
 	}
 	async recvBuffered(f) {
+		if (this.unpin()) this.conn.retirePeer(1, f.epoch);
 		const m = await this.recvInto(f);
 		this.grantWindow(1);
 		return m;
@@ -798,6 +1091,7 @@ var ClientStream = class {
 		if (this.done.tripped) return;
 		this.sendAbort(1);
 		this.finishLocal(statusError(14, "call reset by peer"));
+		if (this.conn.isReliable && !this.conn.locked) this.conn.connTx.refund(this.flowTx.drain());
 	}
 	release() {
 		this.flowTx.release();
@@ -807,6 +1101,10 @@ var ClientStream = class {
 		}
 		this.signalDispose();
 		this.conn.retire(this);
+		const pinned = this.pinned;
+		this.pinned = 0;
+		this.rxReleased = true;
+		this.conn.retirePeer(pinned, this.srvEpoch);
 		this.hdrLatch.trip();
 	}
 	/** @internal */
@@ -821,6 +1119,12 @@ var ClientStream = class {
 		this.conn.kickSweep();
 	}
 	/** @internal */
+	dropRetx() {
+		this.retxOpen = void 0;
+		this.retxClose = void 0;
+		this.retxAt = 0;
+	}
+	/** @internal */
 	sweepRetx(now, capMs) {
 		if (this.retxAt === 0 || now < this.retxAt) return [];
 		const out = [];
@@ -846,4 +1150,4 @@ var ClientStream = class {
 	}
 };
 //#endregion
-export { resolveTiming as a, RxWindow as c, statusDetails as i, TxSeq as l, Conn as n, K_LOUD as o, EndOfStreamError as r, RxVerdict as s, ClientStream as t, W_FWD as u };
+export { resolveTiming as a, statsSink as c, RxWindow as d, TxSeq as f, statusDetails as i, K_LOUD as l, chain2 as m, Conn as n, Counters as o, W_FWD as p, EndOfStreamError as r, emit as s, ClientStream as t, RxVerdict as u };