@lesomnus/grpc-dgram 0.0.1

package/dist/conn-DOmx4nbt.mjs

@@ -0,0 +1,849 @@
+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 { a as isMessageTooLarge, i as abortCause, o as statusError, r as StatusError, s as toStatusError } from "./status-DZwMDWIn.mjs";
+//#region src/seq.ts
+const W_FWD = 4096;
+const K_LOUD = 3;
+var TxSeq = class {
+	v = 0;
+	next() {
+		this.v = this.v + 1 >>> 0;
+		return this.v;
+	}
+	undo(seq) {
+		if (seq !== 0 && this.v === seq) this.v = this.v - 1 >>> 0;
+	}
+};
+let RxVerdict = /* @__PURE__ */ function(RxVerdict) {
+	RxVerdict[RxVerdict["Accept"] = 0] = "Accept";
+	RxVerdict[RxVerdict["Dup"] = 1] = "Dup";
+	RxVerdict[RxVerdict["Beyond"] = 2] = "Beyond";
+	RxVerdict[RxVerdict["DataLoss"] = 3] = "DataLoss";
+	RxVerdict[RxVerdict["ProtocolError"] = 4] = "ProtocolError";
+	return RxVerdict;
+}({});
+var RxWindow = class {
+	l = 0;
+	strict = false;
+	beyondN = 0;
+	beyondLast = 0;
+	check(seq) {
+		if (seq === 0) return 2;
+		if (this.strict) {
+			if (seq === this.l + 1 >>> 0) {
+				this.l = seq;
+				return 0;
+			}
+			return 4;
+		}
+		const d = seq - this.l >>> 0;
+		if (d === 0 || d >= 2147483648) return 1;
+		if (d <= 4096) {
+			this.l = seq;
+			this.beyondN = 0;
+			return 0;
+		}
+		if (this.beyondN > 0 && seq - this.beyondLast >>> 0 <= 4096) this.beyondN++;
+		else this.beyondN = 1;
+		this.beyondLast = seq;
+		if (this.beyondN >= 3) return 3;
+		return 2;
+	}
+};
+//#endregion
+//#region src/timing.ts
+function resolveTiming(t = {}) {
+	const callMs = t.callMs ?? 5e3;
+	const livenessMs = t.livenessMs ?? 15e3;
+	const retransmitMs = t.retransmitMs ?? 1e3;
+	let tombstoneMs = t.tombstoneMs ?? 3e4;
+	if (tombstoneMs < 2 * livenessMs) tombstoneMs = 2 * livenessMs;
+	const holdMs = t.holdMs ?? retransmitMs;
+	const tickMs = Math.max(1, Math.min(Math.min(retransmitMs, holdMs) / 2, 500));
+	return {
+		callMs,
+		livenessMs,
+		retransmitMs,
+		tombstoneMs,
+		holdMs,
+		probeMs: livenessMs / 3,
+		tickMs
+	};
+}
+//#endregion
+//#region src/conn.ts
+var EndOfStreamError = class extends Error {
+	constructor() {
+		super("stream ended");
+		this.name = "EndOfStreamError";
+	}
+};
+function statusDetails(err) {
+	return err instanceof StatusError ? err.details : void 0;
+}
+const EMPTY = /* @__PURE__ */ new Uint8Array(0);
+function terminalStatus(f) {
+	const st = frameStatus(f);
+	if (f.details !== void 0 && f.details.length > 0) st.details = f.details;
+	return st;
+}
+var Conn = class {
+	epoch;
+	tx;
+	mode;
+	rxCfg;
+	limits;
+	defaults;
+	compressor;
+	compressors;
+	maxRecv;
+	maxSend;
+	stallMs;
+	ss = /* @__PURE__ */ new Map();
+	tombs = /* @__PURE__ */ new Map();
+	resetAt = /* @__PURE__ */ new Map();
+	sidNext = 0;
+	exhausted = false;
+	closed = false;
+	lastRx = 0;
+	lastTx = 0;
+	lastPing = 0;
+	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)
+		};
+		const rx = resolveRxConfig(opts.rxBuffer);
+		this.rxCfg = {
+			size: reliableRxSize(rx.size, this.mode.reliable),
+			policy: rx.policy
+		};
+		this.limits = resolveLimits(opts.limits);
+		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;
+		if (hasConnAttacher(tx)) tx.attachConn(this);
+	}
+	get reliable() {
+		return this.mode.reliable;
+	}
+	async handle(f, ctx = {}) {
+		const sid = f.sid;
+		if (isReset(f)) {
+			if (f.epoch !== this.epoch) return;
+			const s = this.ss.get(sid);
+			if (s !== void 0) {
+				s.finishReset();
+				return;
+			}
+			this.clearTombAbort(sid);
+			return;
+		}
+		if (f.peerEpoch !== this.epoch) {
+			if (isPing(f) && sid === 0) return;
+			await this.sendReset(f);
+			return;
+		}
+		if (shapeOf(f) === 16) {
+			const s = this.ss.get(sid);
+			if (s !== void 0) await s.handleRx(f, ctx);
+			return;
+		}
+		if (isPing(f)) {
+			this.lastRx = nowMs();
+			if (sid === 0) return;
+			if (this.ss.has(sid)) return;
+			await this.sendReset(f);
+			return;
+		}
+		const s = this.ss.get(sid);
+		if (s !== void 0) {
+			await s.handleRx(f, ctx);
+			return;
+		}
+		if (this.tombs.get(sid) !== void 0) {
+			this.lastRx = nowMs();
+			if (isTerminal(f)) this.clearTombAbort(sid);
+			return;
+		}
+		await this.sendReset(f);
+	}
+	close(err) {
+		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.sw.stop();
+		const cl = this.tx.close;
+		if (typeof cl === "function") cl.call(this.tx);
+	}
+	async invoke(desc, req, opts = {}) {
+		const merged = {
+			...this.defaults,
+			...opts
+		};
+		let timeoutCause;
+		if (!this.mode.reliable && merged.timeoutMs === void 0) {
+			merged.timeoutMs = this.mode.timing.callMs;
+			timeoutCause = statusError(4, "drpc: default call timeout");
+		}
+		const s = this.createStream(desc, merged, timeoutCause);
+		let err;
+		let out;
+		try {
+			try {
+				await s.sendRaw(req);
+			} catch (e) {
+				if (!(e instanceof EndOfStreamError)) err = toStatusError(e);
+			}
+			if (err === void 0) try {
+				out = await s.recv();
+				if (out === void 0) err = statusError(13, "unary call ended without a response");
+			} catch (e) {
+				err = toStatusError(e);
+			}
+		} finally {
+			s.abandon();
+		}
+		if (merged.onHeader !== void 0) merged.onHeader(await s.header());
+		if (merged.onTrailer !== void 0) merged.onTrailer(s.trailer());
+		if (err !== void 0) throw err;
+		return out;
+	}
+	newStream(desc, opts = {}) {
+		const merged = {
+			...this.defaults,
+			...opts
+		};
+		const s = this.createStream(desc, merged, void 0);
+		if (desc.clientStreams) s.sendOpen();
+		return s;
+	}
+	resolveCall(opts) {
+		const name = opts.compressor ?? this.compressor;
+		let compressor;
+		if (name !== "") {
+			compressor = this.compressors.get(name) ?? getCompressor(name);
+			if (compressor === void 0) throw statusError(13, `drpc: no compressor registered for ${JSON.stringify(name)}`);
+		}
+		return {
+			compressorName: name,
+			compressor,
+			maxRecv: sizeOr(opts.maxRecvMsgSize, this.maxRecv),
+			maxSend: sizeOr(opts.maxSendMsgSize, this.maxSend),
+			stallMs: this.stallMs
+		};
+	}
+	createStream(desc, opts, timeoutCause) {
+		const ci = this.resolveCall(opts);
+		validateMetadata(opts.metadata);
+		if (this.closed) throw statusError(14, "drpc: the connection is closed");
+		if (this.exhausted) throw statusError(8, "sid space exhausted; create a new Conn");
+		this.sidNext = this.sidNext + 1 >>> 0;
+		if (this.sidNext === 0) {
+			this.exhausted = true;
+			throw statusError(8, "sid space exhausted; create a new Conn");
+		}
+		if (!this.mode.reliable && this.ss.size === 0) {
+			const n = nowMs();
+			this.lastRx = n;
+			this.lastTx = n;
+		}
+		const s = new ClientStream(this, desc, this.sidNext, opts, ci, timeoutCause);
+		this.ss.set(s.sid, s);
+		s.arm(opts);
+		this.kickSweep();
+		return s;
+	}
+	/** @internal */
+	get timing() {
+		return this.mode.timing;
+	}
+	/** @internal */
+	get isReliable() {
+		return this.mode.reliable;
+	}
+	/** @internal */
+	get streamRxCfg() {
+		return this.rxCfg;
+	}
+	/** @internal */
+	transmit(f) {
+		this.lastTx = nowMs();
+		return Promise.resolve(this.tx.handle(f));
+	}
+	/** @internal */
+	noteRx() {
+		this.lastRx = nowMs();
+	}
+	/** @internal */
+	retire(s) {
+		this.ss.delete(s.sid);
+		if (!this.mode.reliable) {
+			const now = nowMs();
+			let ttl = this.mode.timing.tombstoneMs;
+			if (s.deadlineAt !== void 0) ttl = Math.max(ttl, s.deadlineAt - now);
+			const tb = {
+				expireAt: now + ttl,
+				abort: s.abortFrame,
+				retxAt: 0,
+				ivalMs: 0
+			};
+			if (tb.abort !== void 0) {
+				tb.ivalMs = this.mode.timing.retransmitMs;
+				tb.retxAt = now + tb.ivalMs;
+			}
+			this.tombs.set(s.sid, tb);
+		}
+		this.kickSweep();
+	}
+	clearTombAbort(sid) {
+		const tb = this.tombs.get(sid);
+		if (tb !== void 0) {
+			tb.abort = void 0;
+			tb.retxAt = 0;
+		}
+	}
+	async sendReset(f) {
+		if (!this.mode.reliable) {
+			const sid = f.sid;
+			const n = nowMs();
+			const last = this.resetAt.get(sid);
+			if (last !== void 0) {
+				if (n - last < this.mode.timing.retransmitMs) return;
+			} else if (this.resetAt.size >= this.limits.maxPendingResets) return;
+			this.resetAt.set(sid, n);
+			this.kickSweep();
+		}
+		try {
+			await this.tx.handle(resetFor(f));
+		} catch {}
+	}
+	failAll(err) {
+		const ss = [...this.ss.values()];
+		for (const tb of this.tombs.values()) {
+			tb.abort = void 0;
+			tb.retxAt = 0;
+		}
+		for (const s of ss) s.finishLocal(err);
+	}
+	/** @internal */
+	kickSweep() {
+		if (this.mode.reliable) return;
+		this.sw.kick(this.mode.timing.tickMs, () => this.sweep(nowMs()), () => this.hasWork());
+	}
+	hasWork() {
+		return this.ss.size > 0 || this.tombs.size > 0 || this.resetAt.size > 0;
+	}
+	sweep(now) {
+		const t = this.mode.timing;
+		const streams = [...this.ss.values()];
+		const tombRetx = [];
+		for (const [sid, tb] of this.tombs) {
+			if (now > tb.expireAt) {
+				this.tombs.delete(sid);
+				continue;
+			}
+			if (tb.abort !== void 0 && tb.retxAt !== 0 && now > tb.retxAt) {
+				tombRetx.push(tb.abort);
+				tb.ivalMs = Math.min(tb.ivalMs * 2, t.probeMs);
+				tb.retxAt = now + tb.ivalMs;
+			}
+		}
+		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.failAll(statusError(14, "peer lost"));
+				return;
+			}
+			if (now - this.lastTx >= t.probeMs && now - this.lastPing >= t.probeMs) {
+				this.lastPing = now;
+				this.lastTx = now;
+				Promise.resolve(this.tx.handle(frame({
+					epoch: this.epoch,
+					flags: 8
+				}))).catch(noop);
+			}
+		}
+		for (const s of streams) {
+			for (const f of s.sweepRetx(now, t.probeMs)) s.transmit(f).catch(noop);
+			const p = s.probeDue(now, t.probeMs);
+			if (p !== void 0) {
+				this.lastTx = now;
+				Promise.resolve(this.tx.handle(p)).catch(noop);
+			}
+		}
+		for (const f of tombRetx) {
+			this.lastTx = now;
+			Promise.resolve(this.tx.handle(f)).catch(noop);
+		}
+	}
+};
+var ClientStream = class {
+	sid;
+	conn;
+	desc;
+	reqCodec;
+	resCodec;
+	codecName;
+	openHdr;
+	ci;
+	flowTx = new FlowSender();
+	flowRx = new FlowReceiver();
+	rxSize;
+	callerSignal;
+	signalDispose = noop;
+	deadlineTimer;
+	deadlineFired = false;
+	timeoutCause;
+	/** @internal */
+	deadlineAt;
+	txSeq = new TxSeq();
+	txOpened = false;
+	txClosed = false;
+	/** @internal */
+	abortFrame;
+	retxOpen;
+	retxClose;
+	retxAt = 0;
+	retxIval = 0;
+	lastRx;
+	lastTx;
+	lastProbe = 0;
+	rxWin = new RxWindow();
+	srvEpoch = 0;
+	srvEpochSet = false;
+	rxq;
+	rxPolicy;
+	rxDropped = 0;
+	rxHeader;
+	trailerMd;
+	hdrLatch = new Latch();
+	done = new Latch();
+	term;
+	termErr;
+	termPayloadDelivered = false;
+	/** @internal */
+	constructor(conn, desc, sid, opts, ci, timeoutCause) {
+		this.conn = conn;
+		this.desc = desc;
+		this.sid = sid;
+		this.ci = ci;
+		const forced = opts.codec;
+		this.reqCodec = forced?.request ?? desc.request;
+		this.resCodec = forced?.response ?? desc.response;
+		this.codecName = forced?.name ?? "";
+		this.openHdr = opts.metadata;
+		this.callerSignal = opts.signal;
+		this.timeoutCause = timeoutCause;
+		if (opts.timeoutMs !== void 0) this.deadlineAt = nowMs() + opts.timeoutMs;
+		const cfg = conn.streamRxCfg;
+		this.rxSize = cfg.size;
+		this.rxq = new FrameQueue(cfg.size);
+		this.rxPolicy = cfg.policy;
+		this.rxWin.strict = conn.isReliable;
+		if (conn.isReliable) {
+			this.flowRx.enable(cfg.size);
+			this.flowTx.assume(32);
+		}
+		const n = nowMs();
+		this.lastRx = n;
+		this.lastTx = n;
+	}
+	/** @internal */
+	arm(opts) {
+		if (opts.timeoutMs !== void 0) {
+			if (opts.timeoutMs <= 0) {
+				this.deadlineFired = true;
+				this.abortFromCtx();
+				return;
+			}
+			const t = setTimeout(() => {
+				this.deadlineFired = true;
+				this.abortFromCtx();
+			}, opts.timeoutMs);
+			unrefTimer(t);
+			this.deadlineTimer = t;
+		}
+		if (this.callerSignal !== void 0) {
+			if (this.callerSignal.aborted) {
+				this.abortFromCtx();
+				return;
+			}
+			this.signalDispose = abortListener(this.callerSignal, () => this.abortFromCtx());
+		}
+	}
+	/** @internal */
+	async handleRx(f, ctx) {
+		if (this.done.tripped) 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);
+			return;
+		}
+		if (this.srvEpochSet && f.epoch !== this.srvEpoch) {
+			this.rxDropped++;
+			return;
+		}
+		if (shapeOf(f) === 16) {
+			if (this.conn.isReliable) this.flowTx.grant(f.window);
+			return;
+		}
+		const v = this.rxWin.check(f.seq);
+		if (v === 0 && !this.srvEpochSet) {
+			this.srvEpoch = f.epoch;
+			this.srvEpochSet = true;
+		}
+		switch (v) {
+			case 1:
+				this.noteValidatedRx();
+				return;
+			case 2: return;
+			case 3: {
+				const err = statusError(15, "seq window overrun: >W_fwd consecutive frames lost");
+				this.sendAbort(15);
+				this.finishLocal(err);
+				return;
+			}
+			case 4: {
+				const err = statusError(13, "reliable transport lost or reordered a frame");
+				this.sendAbort(13);
+				this.finishLocal(err);
+				return;
+			}
+			case 0: break;
+		}
+		this.noteValidatedRx();
+		if (this.conn.isReliable) this.flowTx.observe(f.window);
+		if (isTerminal(f)) {
+			this.latchHeader(f);
+			if (f.trailer !== void 0) this.trailerMd = f.trailer;
+			this.finishTerm(f);
+		} else if (isHeaderFrame(f)) this.latchHeader(f);
+		else if (isData(f)) {
+			if (!this.desc.serverStreams) {
+				this.rxDropped++;
+				return;
+			}
+			this.latchHeader(f);
+			if (this.conn.isReliable) {
+				if (this.flowRx.active) {
+					if (!this.rxq.tryPut(f)) {
+						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)) {
+					this.rxDropped++;
+					this.finishLocal(statusError(14, "transport closed during delivery"));
+				}
+			} else this.rxq.putDrop(f, this.rxPolicy);
+		} else this.rxDropped++;
+	}
+	grantWindow(n) {
+		if (this.done.tripped) return;
+		const g = this.flowRx.consumed(n);
+		if (g === 0) return;
+		const f = frame({
+			epoch: this.conn.epoch,
+			sid: this.sid,
+			flags: 16,
+			window: g
+		});
+		this.transmit(f).catch(noop);
+	}
+	async recvInto(f) {
+		let payload;
+		try {
+			payload = f.payload ?? EMPTY;
+			if (isCompressed(f)) payload = await decompressPayload(this.ci.compressor, payload, this.ci.maxRecv);
+			checkRecvSize(payload.length, this.ci.maxRecv);
+		} catch (e) {
+			const err = toStatusError(e);
+			this.sendAbort(8);
+			this.finishLocal(err);
+			throw err;
+		}
+		return this.resCodec.unmarshal(payload);
+	}
+	latchHeader(f) {
+		if (f.header === void 0) return;
+		if (this.rxHeader === void 0) this.rxHeader = f.header;
+		this.hdrLatch.trip();
+	}
+	noteValidatedRx() {
+		this.lastRx = nowMs();
+		this.conn.noteRx();
+		this.retxOpen = void 0;
+	}
+	openFrame() {
+		this.txOpened = true;
+		const f = frame({
+			epoch: this.conn.epoch,
+			sid: this.sid,
+			seq: this.txSeq.next(),
+			flags: 1,
+			method: this.desc.path
+		});
+		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.openHdr !== void 0) f.header = this.openHdr;
+		if (this.deadlineAt !== void 0) f.timeoutMs = this.deadlineAt - nowMs();
+		if (!this.conn.isReliable) {
+			this.retxOpen = f;
+			this.scheduleRetx();
+		}
+		return f;
+	}
+	nextFrame() {
+		return frame({
+			epoch: this.conn.epoch,
+			sid: this.sid,
+			seq: this.txSeq.next()
+		});
+	}
+	/** @internal */
+	async sendOpen() {
+		if (this.txOpened || this.txClosed) return;
+		const f = this.openFrame();
+		try {
+			await this.transmit(f);
+		} catch (e) {
+			this.finishLocal(toStatusError(e));
+		}
+	}
+	/** @internal */
+	async sendRaw(m) {
+		if (this.done.tripped) throw new EndOfStreamError();
+		if (this.txClosed) {
+			if (this.abortFrame !== void 0) throw new EndOfStreamError();
+			throw statusError(13, "send called after closeSend");
+		}
+		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`);
+		}
+		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();
+			throw e;
+		}
+		try {
+			checkSendSize(enc.bytes.length, this.ci.maxSend);
+		} catch (e) {
+			if (!opening) this.flowTx.undo();
+			throw e;
+		}
+		if (this.done.tripped) throw new EndOfStreamError();
+		if (!opening && this.txClosed) throw new EndOfStreamError();
+		let f;
+		if (!this.txOpened) {
+			f = this.openFrame();
+			if (!this.desc.clientStreams) {
+				f.flags |= 2;
+				this.txClosed = true;
+			}
+		} else f = this.nextFrame();
+		f.payload = enc.bytes;
+		if (enc.compressed) f.flags |= 32;
+		try {
+			await this.transmit(f);
+		} catch (e) {
+			this.undoRefused(f, e);
+			throw e;
+		}
+	}
+	undoRefused(f, err) {
+		if (!isMessageTooLarge(err)) return;
+		this.txSeq.undo(f.seq);
+		if ((f.flags & 1) !== 0) {
+			this.txOpened = false;
+			this.txClosed = false;
+			this.retxOpen = void 0;
+			this.retxAt = 0;
+		}
+		if (isData(f)) this.flowTx.undo();
+	}
+	async send(m) {
+		let err;
+		try {
+			await this.sendRaw(m);
+		} catch (e) {
+			err = e;
+			if (!(e instanceof EndOfStreamError)) {
+				err = toStatusError(e);
+				this.sendAbort(1);
+				this.finishLocal(err);
+			}
+		}
+		if (!this.desc.clientStreams) return;
+		if (err !== void 0) throw err;
+	}
+	closeSend() {
+		if (!this.desc.clientStreams) return;
+		if (this.txClosed || this.done.tripped) return;
+		this.txClosed = true;
+		const f = this.nextFrame();
+		f.flags = 2;
+		if (!this.conn.isReliable) {
+			this.retxClose = f;
+			this.scheduleRetx();
+		}
+		this.transmit(f).catch(noop);
+	}
+	async recv() {
+		for (;;) {
+			const f = this.rxq.tryTake();
+			if (f !== void 0) return this.recvBuffered(f);
+			if (this.done.tripped) return this.terminalRecv();
+			await Promise.race([this.rxq.readable(), this.done.wait()]);
+		}
+	}
+	async recvBuffered(f) {
+		const m = await this.recvInto(f);
+		this.grantWindow(1);
+		return m;
+	}
+	async terminalRecv() {
+		if (this.termErr !== void 0) throw this.termErr;
+		const f = this.term;
+		if ((f.code ?? 0) !== 0) throw terminalStatus(f);
+		if (f.payload !== void 0 && !this.termPayloadDelivered) {
+			this.termPayloadDelivered = true;
+			return this.recvInto(f);
+		}
+	}
+	async *[Symbol.asyncIterator]() {
+		for (;;) {
+			const m = await this.recv();
+			if (m === void 0) return;
+			yield m;
+		}
+	}
+	async header() {
+		await Promise.race([this.hdrLatch.wait(), this.done.wait()]);
+		return this.rxHeader;
+	}
+	trailer() {
+		return this.trailerMd;
+	}
+	latchedHeader() {
+		return this.rxHeader;
+	}
+	cancel() {
+		if (this.done.tripped) return;
+		this.sendAbort(1);
+		this.finishLocal(statusError(1, "call cancelled"));
+	}
+	abortFromCtx() {
+		if (this.done.tripped) return;
+		let cause;
+		if (this.deadlineFired) cause = this.timeoutCause ?? statusError(4, "deadline exceeded");
+		else if (this.callerSignal !== void 0 && this.callerSignal.aborted) cause = abortCause(this.callerSignal);
+		else cause = statusError(1, "call cancelled");
+		const code = cause.code === 4 ? 4 : 1;
+		this.sendAbort(code);
+		this.finishLocal(cause);
+	}
+	sendAbort(code) {
+		if (!this.txOpened) {
+			this.txClosed = true;
+			return;
+		}
+		if (this.abortFrame !== void 0) return;
+		this.txClosed = true;
+		const f = this.nextFrame();
+		f.flags = 2;
+		f.code = code;
+		this.abortFrame = f;
+		this.transmit(f).catch(noop);
+	}
+	finishTerm(f) {
+		if (this.done.tripped) return;
+		this.term = f;
+		this.done.trip();
+		this.release();
+	}
+	/** @internal */
+	finishLocal(err) {
+		if (this.done.tripped) return;
+		this.termErr = err;
+		this.done.trip();
+		this.release();
+	}
+	/** @internal */
+	abandon() {
+		if (this.done.tripped) return;
+		if (this.deadlineFired || this.callerSignal !== void 0 && this.callerSignal.aborted) {
+			this.abortFromCtx();
+			return;
+		}
+		this.sendAbort(1);
+		this.finishLocal(statusError(1, "call abandoned"));
+	}
+	/** @internal */
+	finishReset() {
+		if (this.done.tripped) return;
+		this.sendAbort(1);
+		this.finishLocal(statusError(14, "call reset by peer"));
+	}
+	release() {
+		this.flowTx.release();
+		if (this.deadlineTimer !== void 0) {
+			clearTimeout(this.deadlineTimer);
+			this.deadlineTimer = void 0;
+		}
+		this.signalDispose();
+		this.conn.retire(this);
+		this.hdrLatch.trip();
+	}
+	/** @internal */
+	transmit(f) {
+		this.lastTx = nowMs();
+		return this.conn.transmit(f);
+	}
+	scheduleRetx() {
+		if (this.conn.isReliable) return;
+		this.retxIval = this.conn.timing.retransmitMs;
+		this.retxAt = nowMs() + this.retxIval;
+		this.conn.kickSweep();
+	}
+	/** @internal */
+	sweepRetx(now, capMs) {
+		if (this.retxAt === 0 || now < this.retxAt) return [];
+		const out = [];
+		if (this.retxOpen !== void 0) out.push(this.retxOpen);
+		if (this.retxClose !== void 0) out.push(this.retxClose);
+		if (out.length === 0) {
+			this.retxAt = 0;
+			return [];
+		}
+		this.retxIval = Math.min(this.retxIval * 2, capMs);
+		this.retxAt = now + this.retxIval;
+		return out;
+	}
+	/** @internal */
+	probeDue(now, probeMs) {
+		if (now - this.lastRx < probeMs || now - this.lastTx < probeMs || now - this.lastProbe < probeMs) return;
+		this.lastProbe = now;
+		return frame({
+			epoch: this.conn.epoch,
+			sid: this.sid,
+			flags: 8
+		});
+	}
+};
+//#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 };