@lesomnus/grpc-dgram 0.0.1

package/dist/wire-BR8KiyRg.mjs

@@ -0,0 +1,876 @@
+import { r as StatusError, s as toStatusError } from "./status-DZwMDWIn.mjs";
+//#region src/limits.ts
+let DropPolicy = /* @__PURE__ */ function(DropPolicy) {
+	DropPolicy[DropPolicy["Newest"] = 0] = "Newest";
+	DropPolicy[DropPolicy["Oldest"] = 1] = "Oldest";
+	return DropPolicy;
+}({});
+function resolveRxConfig(c = {}) {
+	return {
+		size: c.size !== void 0 && c.size > 0 ? c.size : 32,
+		policy: c.policy ?? 0
+	};
+}
+function resolveLimits(l = {}) {
+	const pos = (v, d) => v !== void 0 && v > 0 ? v : d;
+	return {
+		maxTombstones: pos(l.maxTombstones, 1024),
+		maxTombstoneBytes: pos(l.maxTombstoneBytes, 1 << 20),
+		maxDeadPeers: pos(l.maxDeadPeers, 4),
+		maxPendingResets: pos(l.maxPendingResets, 1024),
+		maxLiveCalls: pos(l.maxLiveCalls, 4096),
+		maxRepliesPerRTI: pos(l.maxRepliesPerRTI, 64)
+	};
+}
+//#endregion
+//#region src/metadata.ts
+const isBinaryKey = (key) => key.endsWith("-bin");
+function metadataJoin(a, b) {
+	if (a === void 0) return b === void 0 ? void 0 : cloneMetadata(b);
+	const out = cloneMetadata(a);
+	if (b !== void 0) for (const [k, vs] of Object.entries(b)) {
+		const cur = out[k];
+		out[k] = cur === void 0 ? [...vs] : [...cur, ...vs];
+	}
+	return out;
+}
+function cloneMetadata(md) {
+	const out = {};
+	for (const [k, vs] of Object.entries(md)) out[k] = [...vs];
+	return out;
+}
+const B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const B64_VALUES = (() => {
+	const t = (/* @__PURE__ */ new Int8Array(128)).fill(-1);
+	for (let i = 0; i < 64; i++) t[B64_CHARS.charCodeAt(i)] = i;
+	return t;
+})();
+function encodeBase64(bytes) {
+	const out = [];
+	let i = 0;
+	for (; i + 2 < bytes.length; i += 3) {
+		const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+		out.push(B64_CHARS[n >>> 18 & 63] + B64_CHARS[n >>> 12 & 63] + B64_CHARS[n >>> 6 & 63] + B64_CHARS[n & 63]);
+	}
+	const rem = bytes.length - i;
+	if (rem === 1) {
+		const n = bytes[i] << 16;
+		out.push(`${B64_CHARS[n >>> 18 & 63]}${B64_CHARS[n >>> 12 & 63]}==`);
+	} else if (rem === 2) {
+		const n = bytes[i] << 16 | bytes[i + 1] << 8;
+		out.push(`${B64_CHARS[n >>> 18 & 63]}${B64_CHARS[n >>> 12 & 63]}${B64_CHARS[n >>> 6 & 63]}=`);
+	}
+	return out.join("");
+}
+function decodeBase64(s) {
+	let end = s.length;
+	while (end > 0 && s.charCodeAt(end - 1) === 61) end--;
+	const pad = s.length - end;
+	if (pad > 2 || pad > 0 && s.length % 4 !== 0) throw new Error("drpc: invalid base64: bad padding");
+	const rem = end & 3;
+	if (rem === 1) throw new Error("drpc: invalid base64: truncated group");
+	const full = end >>> 2;
+	const out = new Uint8Array(full * 3 + (rem === 0 ? 0 : rem - 1));
+	let o = 0;
+	let i = 0;
+	const six = (p) => {
+		const c = s.charCodeAt(p);
+		const v = c < 128 ? B64_VALUES[c] : -1;
+		if (v < 0) throw new Error(`drpc: invalid base64: illegal character ${JSON.stringify(s[p] ?? "")}`);
+		return v;
+	};
+	for (let g = 0; g < full; g++, i += 4) {
+		const n = six(i) << 18 | six(i + 1) << 12 | six(i + 2) << 6 | six(i + 3);
+		out[o++] = n >>> 16 & 255;
+		out[o++] = n >>> 8 & 255;
+		out[o++] = n & 255;
+	}
+	if (rem === 2) out[o++] = (six(i) << 2 | six(i + 1) >>> 4) & 255;
+	else if (rem === 3) {
+		const n = six(i) << 12 | six(i + 1) << 6 | six(i + 2);
+		out[o++] = n >>> 10 & 255;
+		out[o++] = n >>> 2 & 255;
+	}
+	return out;
+}
+const textEncoder$1 = new TextEncoder();
+const textDecoder$1 = new TextDecoder();
+function encodeMetadataValue(key, value) {
+	if (!isBinaryKey(key)) return textEncoder$1.encode(value);
+	try {
+		return decodeBase64(value);
+	} catch (err) {
+		throw new StatusError(13, binaryValueMsg(key, err));
+	}
+}
+function decodeMetadataValue(key, bytes) {
+	return isBinaryKey(key) ? encodeBase64(bytes) : textDecoder$1.decode(bytes);
+}
+function validateMetadata(md) {
+	if (md === void 0) return;
+	for (const [k, vs] of Object.entries(md)) validateMetadataPair(k, vs);
+}
+function validateMetadataPair(key, values) {
+	if (key === "") throw new StatusError(13, "there is an empty key in the header");
+	for (let i = 0; i < key.length; i++) {
+		const c = key.charCodeAt(i);
+		if (!(c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 46 || c === 45 || c === 95)) throw new StatusError(13, `header key ${JSON.stringify(key)} contains illegal characters not in [0-9a-z-_.]`);
+	}
+	if (isBinaryKey(key)) {
+		for (const v of values) try {
+			decodeBase64(v);
+		} catch (err) {
+			throw new StatusError(13, binaryValueMsg(key, err));
+		}
+		return;
+	}
+	for (const v of values) for (let i = 0; i < v.length; i++) {
+		const c = v.charCodeAt(i);
+		if (c < 32 || c > 126) throw new StatusError(13, `header key ${JSON.stringify(key)} contains value with non-printable ASCII characters`);
+	}
+}
+function binaryValueMsg(key, err) {
+	const why = err instanceof Error ? err.message : String(err);
+	return `header key ${JSON.stringify(key)} carries a binary value that is not base64 (${why})`;
+}
+//#endregion
+//#region src/seam.ts
+function hasTransportInfo(tx) {
+	return typeof tx.reliable === "function";
+}
+function hasConnAttacher(tx) {
+	return typeof tx.attachConn === "function";
+}
+async function unpack(frames, h, ctx) {
+	for (const f of frames) try {
+		await h.handle(f, ctx);
+	} catch {}
+}
+//#endregion
+//#region src/util.ts
+const noop = () => {};
+function nowMs() {
+	return Date.now();
+}
+function nonzeroEpoch() {
+	const buf = /* @__PURE__ */ new Uint32Array(1);
+	for (;;) {
+		globalThis.crypto.getRandomValues(buf);
+		if (buf[0] !== 0) return buf[0];
+	}
+}
+function unrefTimer(t) {
+	t.unref?.();
+}
+var Latch = class {
+	tripped = false;
+	promise;
+	resolve;
+	constructor() {
+		this.promise = new Promise((res) => {
+			this.resolve = res;
+		});
+	}
+	trip() {
+		if (this.tripped) return;
+		this.tripped = true;
+		this.resolve();
+	}
+	wait() {
+		return this.promise;
+	}
+};
+function abortListener(signal, fn) {
+	signal.addEventListener("abort", fn, { once: true });
+	return () => signal.removeEventListener("abort", fn);
+}
+var FrameQueue = class {
+	cap;
+	dropped = 0;
+	buf = [];
+	readWaiters = [];
+	spaceWaiters = [];
+	putTail = Promise.resolve();
+	constructor(cap) {
+		this.cap = cap;
+	}
+	get size() {
+		return this.buf.length;
+	}
+	tryTake() {
+		const f = this.buf.shift();
+		if (f !== void 0) wake(this.spaceWaiters);
+		return f;
+	}
+	tryPut(f) {
+		if (this.buf.length >= this.cap) return false;
+		this.buf.push(f);
+		wake(this.readWaiters);
+		return true;
+	}
+	putDrop(f, policy) {
+		if (this.tryPut(f)) return;
+		if (policy === 1) {
+			if (this.buf.shift() !== void 0) this.dropped++;
+			if (this.tryPut(f)) return;
+		}
+		this.dropped++;
+	}
+	async putBlocking(f, done, signal) {
+		const prev = this.putTail;
+		let release = noop;
+		this.putTail = new Promise((r) => {
+			release = r;
+		});
+		try {
+			await prev;
+			for (;;) {
+				if (this.tryPut(f)) return true;
+				if (done.tripped) return true;
+				if (signal?.aborted) return false;
+				let dispose = noop;
+				const waits = [this.space(), done.wait()];
+				if (signal !== void 0) waits.push(new Promise((res) => {
+					dispose = abortListener(signal, res);
+				}));
+				try {
+					await Promise.race(waits);
+				} finally {
+					dispose();
+				}
+			}
+		} finally {
+			release();
+		}
+	}
+	readable() {
+		if (this.buf.length > 0) return Promise.resolve();
+		return new Promise((res) => this.readWaiters.push(res));
+	}
+	space() {
+		return new Promise((res) => this.spaceWaiters.push(res));
+	}
+};
+function wake(waiters) {
+	if (waiters.length === 0) return;
+	const ws = waiters.splice(0);
+	for (const w of ws) w();
+}
+var Sweeper = class {
+	timer;
+	stopped = false;
+	kick(intervalMs, sweep, hasWork) {
+		if (this.stopped || this.timer !== void 0) return;
+		const t = setInterval(() => {
+			sweep();
+			if (this.timer === t && !hasWork()) {
+				clearInterval(t);
+				this.timer = void 0;
+			}
+		}, intervalMs);
+		unrefTimer(t);
+		this.timer = t;
+	}
+	stop() {
+		this.stopped = true;
+		if (this.timer !== void 0) {
+			clearInterval(this.timer);
+			this.timer = void 0;
+		}
+	}
+};
+const W_INIT = 32;
+const DEFAULT_STALL_MS = 3e4;
+function reliableRxSize(size, reliable) {
+	return reliable && size < 32 ? 32 : size;
+}
+var FlowSender = class {
+	on = false;
+	observed = false;
+	granted = 0;
+	sent = 0;
+	waiters = [];
+	assume(window) {
+		if (window <= 0 || this.observed || this.on) return;
+		this.on = true;
+		this.granted = window;
+	}
+	observe(window) {
+		if (this.observed) return;
+		this.observed = true;
+		if (window <= 0) this.on = false;
+		else {
+			this.on = true;
+			this.granted = window;
+		}
+		wake(this.waiters);
+	}
+	grant(n) {
+		if (n <= 0 || !this.on) return;
+		this.granted = Math.min(this.granted + n, Number.MAX_SAFE_INTEGER);
+		wake(this.waiters);
+	}
+	undo() {
+		if (this.sent > 0) this.sent--;
+		wake(this.waiters);
+	}
+	release() {
+		this.on = false;
+		wake(this.waiters);
+	}
+	tryAcquire() {
+		if (this.on && this.sent >= this.granted) return false;
+		this.sent++;
+		return true;
+	}
+	async acquire(done, stallMs, signal) {
+		let timer;
+		let dispose = noop;
+		let expired = false;
+		let bounds;
+		try {
+			for (;;) {
+				if (this.tryAcquire()) return "ok";
+				if (done.tripped) return "ended";
+				if (signal?.aborted) return "aborted";
+				if (expired) return "stalled";
+				if (bounds === void 0) {
+					bounds = [done.wait()];
+					if (stallMs > 0) bounds.push(new Promise((res) => {
+						const t = setTimeout(() => {
+							expired = true;
+							res();
+						}, stallMs);
+						unrefTimer(t);
+						timer = t;
+					}));
+					if (signal !== void 0) bounds.push(new Promise((res) => {
+						dispose = abortListener(signal, res);
+					}));
+				}
+				await Promise.race([this.parked(), ...bounds]);
+			}
+		} finally {
+			if (timer !== void 0) clearTimeout(timer);
+			dispose();
+		}
+	}
+	parked() {
+		return new Promise((res) => this.waiters.push(res));
+	}
+};
+var FlowReceiver = class {
+	on = false;
+	window = 0;
+	pending = 0;
+	enable(window) {
+		this.on = window > 0;
+		this.window = window;
+	}
+	get active() {
+		return this.on;
+	}
+	consumed(n) {
+		if (!this.on || n <= 0) return 0;
+		this.pending += n;
+		if (this.pending * 2 < this.window) return 0;
+		const grant = this.pending;
+		this.pending = 0;
+		return grant;
+	}
+};
+const DEFAULT_MAX_RECV_MSG_SIZE = 4 * 1024 * 1024;
+const DEFAULT_MAX_SEND_MSG_SIZE = 2147483647;
+function sizeOr(v, def) {
+	return v === void 0 ? def : v;
+}
+function checkSendSize(n, limit) {
+	if (n > limit) throw new StatusError(8, `drpc: trying to send message larger than max (${n} vs. ${limit})`);
+}
+function checkRecvSize(n, limit) {
+	if (n > limit) throw new StatusError(8, `drpc: received message larger than max (${n} vs. ${limit})`);
+}
+const rawPayload = (bytes) => ({
+	bytes,
+	compressed: false
+});
+const FORMATS = {
+	gzip: "gzip",
+	deflate: "deflate"
+};
+const compressorCache = /* @__PURE__ */ new Map();
+function getCompressor(name) {
+	if (name === "") return void 0;
+	const hit = compressorCache.get(name);
+	if (hit !== void 0 || compressorCache.has(name)) return hit;
+	const c = makeCompressor(name);
+	compressorCache.set(name, c);
+	return c;
+}
+function makeCompressor(name) {
+	const format = FORMATS[name];
+	if (format === void 0) return void 0;
+	if (typeof CompressionStream === "undefined" || typeof DecompressionStream === "undefined") return void 0;
+	try {
+		new CompressionStream(format);
+		new DecompressionStream(format);
+	} catch {
+		return;
+	}
+	return new StreamCompressor(format);
+}
+var StreamCompressor = class {
+	format;
+	constructor(format) {
+		this.format = format;
+	}
+	async compress(data) {
+		try {
+			return await runTransform(new CompressionStream(this.format), data, Number.MAX_SAFE_INTEGER);
+		} catch (err) {
+			if (err instanceof StatusError) throw err;
+			throw new StatusError(13, `drpc: compressor: ${errMsg(err)}`);
+		}
+	}
+	async decompress(data, maxRecv) {
+		const limit = maxRecv > 0 ? maxRecv : DEFAULT_MAX_RECV_MSG_SIZE;
+		try {
+			return await runTransform(new DecompressionStream(this.format), data, limit);
+		} catch (err) {
+			if (err instanceof StatusError) throw err;
+			throw new StatusError(13, `drpc: decompress: ${errMsg(err)}`);
+		}
+	}
+};
+async function runTransform(ts, data, limit) {
+	const writer = ts.writable.getWriter();
+	const reader = ts.readable.getReader();
+	let writeErr;
+	const written = (async () => {
+		await writer.write(data);
+		await writer.close();
+	})().catch((err) => {
+		writeErr = err;
+	});
+	const chunks = [];
+	let total = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value === void 0) continue;
+			total += value.length;
+			if (total > limit) throw new StatusError(8, `drpc: received message after decompression larger than max (> ${limit})`);
+			chunks.push(value);
+		}
+	} catch (err) {
+		reader.cancel().catch(noop);
+		throw err;
+	}
+	await written;
+	if (writeErr !== void 0) throw writeErr;
+	if (chunks.length === 1) return chunks[0];
+	const out = new Uint8Array(total);
+	let at = 0;
+	for (const c of chunks) {
+		out.set(c, at);
+		at += c.length;
+	}
+	return out;
+}
+async function compressPayload(comp, payload) {
+	if (payload.length === 0) return rawPayload(payload);
+	const out = await comp.compress(payload);
+	if (out.length >= payload.length) return rawPayload(payload);
+	return {
+		bytes: out,
+		compressed: true
+	};
+}
+async function decompressPayload(comp, payload, maxRecv) {
+	if (comp === void 0) throw new StatusError(13, "drpc: frame is compressed but the call has no compressor");
+	return comp.decompress(payload, maxRecv);
+}
+function errMsg(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/wire.ts
+const FlagOpen = 1;
+const FlagClose = 2;
+const FlagReset = 4;
+const FlagPing = 8;
+const FlagWindow = 16;
+const FlagCompressed = 32;
+const SHAPE_MASK = 31;
+function frame(init) {
+	return {
+		epoch: 0,
+		sid: 0,
+		seq: 0,
+		flags: 0,
+		method: "",
+		codec: "",
+		desc: "",
+		peerEpoch: 0,
+		window: 0,
+		compressor: "",
+		...init
+	};
+}
+const isOpen = (f) => (f.flags & 1) !== 0;
+const isClose = (f) => (f.flags & 2) !== 0;
+const isReset = (f) => (f.flags & 4) !== 0;
+const isPing = (f) => (f.flags & 8) !== 0;
+const isWindow = (f) => (f.flags & 16) !== 0;
+const isCompressed = (f) => (f.flags & 32) !== 0;
+const shapeOf = (f) => f.flags & 31;
+const hasUnknownFlags = (f) => (f.flags & -64) !== 0;
+function legalShape(shape) {
+	switch (shape) {
+		case 0:
+		case 1:
+		case 2:
+		case 3:
+		case 4:
+		case 8:
+		case 16: return true;
+		default: return false;
+	}
+}
+const isTerminal = (f) => shapeOf(f) === 2 && f.code !== void 0;
+const isHalfClose = (f) => shapeOf(f) === 2 && f.code === void 0;
+const isData = (f) => shapeOf(f) === 0 && f.payload !== void 0;
+const isHeaderFrame = (f) => shapeOf(f) === 0 && f.payload === void 0;
+function frameStatus(f) {
+	return new StatusError(f.code ?? 0, f.desc);
+}
+function setFrameError(f, err) {
+	const st = toStatusError(err);
+	f.code = st.code;
+	f.desc = st.desc;
+}
+function resetFor(f) {
+	return frame({
+		flags: 4,
+		epoch: f.epoch,
+		sid: f.sid,
+		peerEpoch: f.peerEpoch
+	});
+}
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+var Writer = class {
+	buf = [];
+	byte(b) {
+		this.buf.push(b & 255);
+	}
+	varint(v) {
+		let n = v >>> 0;
+		while (n > 127) {
+			this.buf.push(n & 127 | 128);
+			n >>>= 7;
+		}
+		this.buf.push(n);
+	}
+	varint64(v) {
+		let n = BigInt.asUintN(64, v);
+		while (n > 127n) {
+			this.buf.push(Number(n & 127n) | 128);
+			n >>= 7n;
+		}
+		this.buf.push(Number(n));
+	}
+	tag(field, wire) {
+		this.varint(field << 3 | wire);
+	}
+	fixed32(field, v) {
+		this.tag(field, 5);
+		const n = v >>> 0;
+		this.buf.push(n & 255, n >>> 8 & 255, n >>> 16 & 255, n >>> 24 & 255);
+	}
+	bytes(field, v) {
+		this.tag(field, 2);
+		this.varint(v.length);
+		for (let i = 0; i < v.length; i++) this.buf.push(v[i]);
+	}
+	string(field, v) {
+		this.bytes(field, textEncoder.encode(v));
+	}
+	finish() {
+		return Uint8Array.from(this.buf);
+	}
+};
+var Reader = class {
+	buf;
+	pos = 0;
+	constructor(buf) {
+		this.buf = buf;
+	}
+	get eof() {
+		return this.pos >= this.buf.length;
+	}
+	next() {
+		if (this.pos >= this.buf.length) throw new Error("drpc: malformed frame: truncated");
+		return this.buf[this.pos++];
+	}
+	varint() {
+		let out = 0n;
+		for (let shift = 0n; shift < 70n; shift += 7n) {
+			const b = this.next();
+			out |= BigInt(b & 127) << shift;
+			if ((b & 128) === 0) return BigInt.asUintN(64, out);
+		}
+		throw new Error("drpc: malformed frame: varint too long");
+	}
+	varint32() {
+		return Number(this.varint() & 4294967295n);
+	}
+	fixed32() {
+		if (this.pos + 4 > this.buf.length) throw new Error("drpc: malformed frame: truncated");
+		const b = this.buf;
+		const p = this.pos;
+		this.pos += 4;
+		return (b[p] | b[p + 1] << 8 | b[p + 2] << 16 | b[p + 3] << 24) >>> 0;
+	}
+	bytes() {
+		const n = this.varint32();
+		if (this.pos + n > this.buf.length) throw new Error("drpc: malformed frame: truncated");
+		const out = this.buf.subarray(this.pos, this.pos + n);
+		this.pos += n;
+		return out;
+	}
+	string() {
+		return textDecoder.decode(this.bytes());
+	}
+	skip(wire) {
+		switch (wire) {
+			case 0:
+				this.varint();
+				return;
+			case 1:
+				if (this.pos + 8 > this.buf.length) throw new Error("drpc: malformed frame: truncated");
+				this.pos += 8;
+				return;
+			case 2:
+				this.bytes();
+				return;
+			case 5:
+				this.fixed32();
+				return;
+			default: throw new Error(`drpc: malformed frame: unsupported wire type ${wire}`);
+		}
+	}
+};
+function encodeDuration(ms) {
+	const w = new Writer();
+	const totalNs = BigInt(Math.round(ms * 1e6));
+	const seconds = totalNs / 1000000000n;
+	const nanos = totalNs % 1000000000n;
+	if (seconds !== 0n) {
+		w.tag(1, 0);
+		w.varint64(seconds);
+	}
+	if (nanos !== 0n) {
+		w.tag(2, 0);
+		w.varint64(nanos);
+	}
+	return w.finish();
+}
+function decodeDuration(data) {
+	const r = new Reader(data);
+	let seconds = 0n;
+	let nanos = 0n;
+	while (!r.eof) {
+		const tag = r.varint32();
+		const field = tag >>> 3;
+		const wire = tag & 7;
+		if (field === 1 && wire === 0) seconds = BigInt.asIntN(64, r.varint());
+		else if (field === 2 && wire === 0) nanos = BigInt.asIntN(32, r.varint());
+		else r.skip(wire);
+	}
+	return Number(seconds) * 1e3 + Number(nanos) / 1e6;
+}
+function encodeAny(a) {
+	const w = new Writer();
+	if (a.typeUrl !== "") w.string(1, a.typeUrl);
+	if (a.value.length > 0) w.bytes(2, a.value);
+	return w.finish();
+}
+function decodeAny(data) {
+	const r = new Reader(data);
+	const a = {
+		typeUrl: "",
+		value: /* @__PURE__ */ new Uint8Array(0)
+	};
+	while (!r.eof) {
+		const tag = r.varint32();
+		const field = tag >>> 3;
+		const wire = tag & 7;
+		if (field === 1 && wire === 2) a.typeUrl = r.string();
+		else if (field === 2 && wire === 2) a.value = r.bytes().slice();
+		else r.skip(wire);
+	}
+	return a;
+}
+function encodeMetadata(md) {
+	const w = new Writer();
+	for (const key of Object.keys(md).sort()) {
+		const entry = new Writer();
+		for (const v of md[key]) entry.bytes(1, encodeMetadataValue(key, v));
+		const kv = new Writer();
+		kv.string(1, key);
+		kv.bytes(2, entry.finish());
+		w.bytes(1, kv.finish());
+	}
+	return w.finish();
+}
+function decodeMetadata(data) {
+	const md = {};
+	const r = new Reader(data);
+	while (!r.eof) {
+		const tag = r.varint32();
+		if (tag >>> 3 === 1 && (tag & 7) === 2) {
+			const kv = new Reader(r.bytes());
+			let key = "";
+			const raw = [];
+			while (!kv.eof) {
+				const t = kv.varint32();
+				if (t >>> 3 === 1 && (t & 7) === 2) key = kv.string();
+				else if (t >>> 3 === 2 && (t & 7) === 2) {
+					const entry = new Reader(kv.bytes());
+					while (!entry.eof) {
+						const et = entry.varint32();
+						if (et >>> 3 === 1 && (et & 7) === 2) raw.push(entry.bytes());
+						else entry.skip(et & 7);
+					}
+				} else kv.skip(t & 7);
+			}
+			md[key] = raw.map((b) => decodeMetadataValue(key, b));
+		} else r.skip(tag & 7);
+	}
+	return md;
+}
+function encodeFrame(f) {
+	const w = new Writer();
+	if (f.epoch !== 0) w.fixed32(1, f.epoch);
+	if (f.sid !== 0) w.fixed32(2, f.sid);
+	if (f.seq !== 0) w.fixed32(3, f.seq);
+	if (f.flags !== 0) {
+		w.tag(4, 0);
+		w.varint(f.flags);
+	}
+	if (f.method !== "") w.string(5, f.method);
+	if (f.codec !== "") w.string(7, f.codec);
+	if (f.timeoutMs !== void 0) w.bytes(8, encodeDuration(f.timeoutMs));
+	if (f.payload !== void 0) w.bytes(9, f.payload);
+	if (f.code !== void 0) {
+		w.tag(10, 0);
+		w.varint(f.code);
+	}
+	if (f.desc !== "") w.string(11, f.desc);
+	if (f.header !== void 0) w.bytes(12, encodeMetadata(f.header));
+	if (f.trailer !== void 0) w.bytes(13, encodeMetadata(f.trailer));
+	if (f.peerEpoch !== 0) w.fixed32(14, f.peerEpoch);
+	if (f.window) {
+		w.tag(15, 0);
+		w.varint(f.window);
+	}
+	if (f.compressor) w.string(16, f.compressor);
+	if (f.details !== void 0) for (const d of f.details) w.bytes(17, encodeAny(d));
+	return w.finish();
+}
+function decodeFrame(data) {
+	const f = frame();
+	const r = new Reader(data);
+	while (!r.eof) {
+		const tag = r.varint32();
+		const field = tag >>> 3;
+		const wire = tag & 7;
+		switch (field) {
+			case 1:
+				if (wire !== 5) r.skip(wire);
+				else f.epoch = r.fixed32();
+				break;
+			case 2:
+				if (wire !== 5) r.skip(wire);
+				else f.sid = r.fixed32();
+				break;
+			case 3:
+				if (wire !== 5) r.skip(wire);
+				else f.seq = r.fixed32();
+				break;
+			case 4:
+				if (wire !== 0) r.skip(wire);
+				else f.flags = r.varint32();
+				break;
+			case 5:
+				if (wire !== 2) r.skip(wire);
+				else f.method = r.string();
+				break;
+			case 7:
+				if (wire !== 2) r.skip(wire);
+				else f.codec = r.string();
+				break;
+			case 8:
+				if (wire !== 2) r.skip(wire);
+				else f.timeoutMs = decodeDuration(r.bytes());
+				break;
+			case 9:
+				if (wire !== 2) r.skip(wire);
+				else f.payload = r.bytes().slice();
+				break;
+			case 10:
+				if (wire !== 0) r.skip(wire);
+				else f.code = r.varint32();
+				break;
+			case 11:
+				if (wire !== 2) r.skip(wire);
+				else f.desc = r.string();
+				break;
+			case 12:
+				if (wire !== 2) r.skip(wire);
+				else f.header = decodeMetadata(r.bytes());
+				break;
+			case 13:
+				if (wire !== 2) r.skip(wire);
+				else f.trailer = decodeMetadata(r.bytes());
+				break;
+			case 14:
+				if (wire !== 5) r.skip(wire);
+				else f.peerEpoch = r.fixed32();
+				break;
+			case 15:
+				if (wire !== 0) r.skip(wire);
+				else f.window = r.varint32();
+				break;
+			case 16:
+				if (wire !== 2) r.skip(wire);
+				else f.compressor = r.string();
+				break;
+			case 17:
+				if (wire !== 2) r.skip(wire);
+				else (f.details ??= []).push(decodeAny(r.bytes()));
+				break;
+			default: r.skip(wire);
+		}
+	}
+	return f;
+}
+function encodeEnvelop(frames) {
+	const w = new Writer();
+	for (const f of frames) w.bytes(1, encodeFrame(f));
+	return w.finish();
+}
+function decodeEnvelop(data) {
+	const frames = [];
+	const r = new Reader(data);
+	while (!r.eof) {
+		const tag = r.varint32();
+		if (tag >>> 3 === 1 && (tag & 7) === 2) frames.push(decodeFrame(r.bytes()));
+		else r.skip(tag & 7);
+	}
+	return frames;
+}
+//#endregion
+export { unpack as $, DEFAULT_MAX_SEND_MSG_SIZE as A, checkSendSize as B, isTerminal as C, setFrameError as D, resetFor as E, Latch as F, noop as G, decompressPayload as H, Sweeper as I, reliableRxSize as J, nowMs as K, W_INIT as L, FlowReceiver as M, FlowSender as N, shapeOf as O, FrameQueue as P, hasTransportInfo as Q, abortListener as R, isReset as S, legalShape as T, getCompressor as U, compressPayload as V, nonzeroEpoch as W, unrefTimer as X, sizeOr as Y, hasConnAttacher as Z, isData as _, FlagReset as a, validateMetadata as at, isOpen as b, decodeEnvelop as c, resolveLimits as ct, encodeFrame as d, cloneMetadata as et, frame as f, isCompressed as g, isClose as h, FlagPing as i, metadataJoin as it, DEFAULT_STALL_MS as j, DEFAULT_MAX_RECV_MSG_SIZE as k, decodeFrame as l, resolveRxConfig as lt, hasUnknownFlags as m, FlagCompressed as n, encodeBase64 as nt, FlagWindow as o, validateMetadataPair as ot, frameStatus as p, rawPayload as q, FlagOpen as r, isBinaryKey as rt, SHAPE_MASK as s, DropPolicy as st, FlagClose as t, decodeBase64 as tt, encodeEnvelop as u, isHalfClose as v, isWindow as w, isPing as x, isHeaderFrame as y, checkRecvSize as z };