@arpabet/vrpc 0.2.0

package/dist/index.js

@@ -0,0 +1,2262 @@
+// src/value.ts
+var INT64_MIN = -9223372036854775808n;
+var INT64_MAX = 9223372036854775807n;
+var VrpcDouble = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return String(this.value);
+  }
+};
+function double(value) {
+  return new VrpcDouble(value);
+}
+var VrpcDecimal = class _VrpcDecimal {
+  constructor(coefficient, exponent) {
+    this.coefficient = coefficient;
+    this.exponent = exponent;
+    if (!Number.isInteger(exponent) || exponent < -2147483648 || exponent > 2147483647) {
+      throw new RangeError(`vrpc: decimal exponent out of int32 range: ${exponent}`);
+    }
+  }
+  coefficient;
+  exponent;
+  /** Parses "123", "-1.045", "1.2e-5" style decimal strings. */
+  static fromString(s) {
+    const m = /^([+-]?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(s.trim());
+    if (!m) throw new SyntaxError(`vrpc: invalid decimal string: ${JSON.stringify(s)}`);
+    const [, sign, int, frac = "", expStr] = m;
+    let exponent = (expStr ? parseInt(expStr, 10) : 0) - frac.length;
+    let digits = (int ?? "") + frac;
+    digits = digits.replace(/^0+(?=\d)/, "");
+    let coefficient = BigInt(digits);
+    if (sign === "-") coefficient = -coefficient;
+    return new _VrpcDecimal(coefficient, exponent);
+  }
+  toString() {
+    const neg = this.coefficient < 0n;
+    let digits = (neg ? -this.coefficient : this.coefficient).toString();
+    let out;
+    if (this.exponent >= 0) {
+      out = digits + "0".repeat(this.exponent);
+    } else {
+      const point = digits.length + this.exponent;
+      if (point > 0) {
+        out = digits.slice(0, point) + "." + digits.slice(point);
+      } else {
+        out = "0." + "0".repeat(-point) + digits;
+      }
+    }
+    return (neg ? "-" : "") + out;
+  }
+  toNumber() {
+    return Number(this.toString());
+  }
+  equals(other) {
+    return this.coefficient === other.coefficient && this.exponent === other.exponent;
+  }
+};
+function decimal(s) {
+  return VrpcDecimal.fromString(s);
+}
+var VrpcExt = class {
+  constructor(tag, data) {
+    this.tag = tag;
+    this.data = data;
+    if (!Number.isInteger(tag) || tag < 0 || tag > 255) {
+      throw new RangeError(`vrpc: ext tag out of byte range: ${tag}`);
+    }
+  }
+  tag;
+  data;
+  equals(other) {
+    return this.tag === other.tag && bytesEqual(this.data, other.data);
+  }
+};
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function isPlainObject(v) {
+  if (v === null || typeof v !== "object") return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder("utf-8", { fatal: false });
+function utf8Encode(s) {
+  return textEncoder.encode(s);
+}
+function utf8Decode(b) {
+  return textDecoder.decode(b);
+}
+function compareUtf8(a, b) {
+  if (a === b) return 0;
+  const ab = utf8Encode(a);
+  const bb = utf8Encode(b);
+  const n = Math.min(ab.length, bb.length);
+  for (let i = 0; i < n; i++) {
+    const d = ab[i] - bb[i];
+    if (d !== 0) return d;
+  }
+  return ab.length - bb.length;
+}
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var B64REV = new Int8Array(128).fill(-1);
+for (let i = 0; i < B64.length; i++) B64REV[B64.charCodeAt(i)] = i;
+function base64RawStdEncode(data) {
+  let out = "";
+  let i = 0;
+  for (; i + 2 < data.length; i += 3) {
+    const n = data[i] << 16 | data[i + 1] << 8 | data[i + 2];
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + B64[n >> 6 & 63] + B64[n & 63];
+  }
+  const rest = data.length - i;
+  if (rest === 1) {
+    const n = data[i] << 16;
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63];
+  } else if (rest === 2) {
+    const n = data[i] << 16 | data[i + 1] << 8;
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + B64[n >> 6 & 63];
+  }
+  return out;
+}
+function base64RawStdDecode(s) {
+  let end = s.length;
+  while (end > 0 && s[end - 1] === "=") end--;
+  const outLen = Math.floor(end * 3 / 4);
+  const out = new Uint8Array(outLen);
+  let acc = 0;
+  let bits = 0;
+  let o = 0;
+  for (let i = 0; i < end; i++) {
+    const c = s.charCodeAt(i);
+    const v = c < 128 ? B64REV[c] : -1;
+    if (v < 0) throw new SyntaxError(`vrpc: invalid base64 character at ${i}`);
+    acc = acc << 6 | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[o++] = acc >> bits & 255;
+    }
+  }
+  if (o !== outLen) throw new SyntaxError("vrpc: truncated base64 input");
+  return out;
+}
+function bytesToHex(data) {
+  let out = "";
+  for (const b of data) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+
+// src/msgpack.ts
+var BIGINT_EXT_TAG = 1;
+var DECIMAL_EXT_TAG = 2;
+var DEFAULT_LIMITS = {
+  maxDepth: 1e3,
+  maxCollectionLen: 16777216,
+  maxByteLen: 1073741824
+};
+var Writer = class {
+  buf = new Uint8Array(256);
+  len = 0;
+  ensure(n) {
+    if (this.len + n <= this.buf.length) return;
+    let cap = this.buf.length * 2;
+    while (cap < this.len + n) cap *= 2;
+    const next = new Uint8Array(cap);
+    next.set(this.buf.subarray(0, this.len));
+    this.buf = next;
+  }
+  byte(b) {
+    this.ensure(1);
+    this.buf[this.len++] = b;
+  }
+  bytes(data) {
+    this.ensure(data.length);
+    this.buf.set(data, this.len);
+    this.len += data.length;
+  }
+  u16(v) {
+    this.ensure(2);
+    this.buf[this.len++] = v >> 8 & 255;
+    this.buf[this.len++] = v & 255;
+  }
+  u32(v) {
+    this.ensure(4);
+    this.buf[this.len++] = v >>> 24 & 255;
+    this.buf[this.len++] = v >>> 16 & 255;
+    this.buf[this.len++] = v >>> 8 & 255;
+    this.buf[this.len++] = v & 255;
+  }
+  u64(v) {
+    this.ensure(8);
+    const dv = new DataView(this.buf.buffer, this.buf.byteOffset + this.len, 8);
+    dv.setBigUint64(0, BigInt.asUintN(64, v));
+    this.len += 8;
+  }
+  f64(v) {
+    this.ensure(8);
+    const dv = new DataView(this.buf.buffer, this.buf.byteOffset + this.len, 8);
+    dv.setFloat64(0, v);
+    this.len += 8;
+  }
+  result() {
+    return this.buf.slice(0, this.len);
+  }
+};
+function packLongNumber(w, v) {
+  if (v >= 0) {
+    if (v <= 127) w.byte(v);
+    else if (v <= 255) {
+      w.byte(204);
+      w.byte(v);
+    } else if (v <= 65535) {
+      w.byte(205);
+      w.u16(v);
+    } else if (v <= 4294967295) {
+      w.byte(206);
+      w.u32(v);
+    } else {
+      w.byte(207);
+      w.u64(BigInt(v));
+    }
+  } else {
+    if (v >= -32) w.byte(256 + v);
+    else if (v >= -128) {
+      w.byte(208);
+      w.byte(v & 255);
+    } else if (v >= -32768) {
+      w.byte(209);
+      w.u16(v & 65535);
+    } else if (v >= -2147483648) {
+      w.byte(210);
+      w.u32(v >>> 0);
+    } else {
+      w.byte(211);
+      w.u64(BigInt.asUintN(64, BigInt(v)));
+    }
+  }
+}
+function packLongBig(w, v) {
+  if (v >= 0n) {
+    if (v <= 0xffffffffn) {
+      packLongNumber(w, Number(v));
+    } else {
+      w.byte(207);
+      w.u64(v);
+    }
+  } else if (v >= -2147483648n) {
+    packLongNumber(w, Number(v));
+  } else {
+    w.byte(211);
+    w.u64(BigInt.asUintN(64, v));
+  }
+}
+function packDouble(w, v) {
+  w.byte(203);
+  w.f64(v);
+}
+function packStr(w, s) {
+  const b = utf8Encode(s);
+  if (b.length < 32) w.byte(160 | b.length);
+  else if (b.length <= 255) {
+    w.byte(217);
+    w.byte(b.length);
+  } else if (b.length <= 65535) {
+    w.byte(218);
+    w.u16(b.length);
+  } else {
+    w.byte(219);
+    w.u32(b.length);
+  }
+  w.bytes(b);
+}
+function packBin(w, b) {
+  if (b.length <= 255) {
+    w.byte(196);
+    w.byte(b.length);
+  } else if (b.length <= 65535) {
+    w.byte(197);
+    w.u16(b.length);
+  } else {
+    w.byte(198);
+    w.u32(b.length);
+  }
+  w.bytes(b);
+}
+function packExt(w, tag, data) {
+  const n = data.length;
+  if (n === 1) w.byte(212);
+  else if (n === 2) w.byte(213);
+  else if (n === 4) w.byte(214);
+  else if (n === 8) w.byte(215);
+  else if (n === 16) w.byte(216);
+  else if (n <= 255) {
+    w.byte(199);
+    w.byte(n);
+  } else if (n <= 65535) {
+    w.byte(200);
+    w.u16(n);
+  } else {
+    w.byte(201);
+    w.u32(n);
+  }
+  w.byte(tag);
+  w.bytes(data);
+}
+function bigIntGobEncode(v) {
+  const neg = v < 0n;
+  let abs = neg ? -v : v;
+  const mag = [];
+  while (abs > 0n) {
+    mag.unshift(Number(abs & 0xffn));
+    abs >>= 8n;
+  }
+  const out = new Uint8Array(1 + mag.length);
+  out[0] = 1 << 1 | (neg ? 1 : 0);
+  out.set(mag, 1);
+  return out;
+}
+function bigIntGobDecode(data) {
+  if (data.length === 0) throw new SyntaxError("vrpc: empty bigint payload");
+  const first = data[0];
+  if (first >> 1 !== 1) throw new SyntaxError(`vrpc: unsupported bigint gob version ${first >> 1}`);
+  const neg = (first & 1) === 1;
+  let v = 0n;
+  for (let i = 1; i < data.length; i++) v = v << 8n | BigInt(data[i]);
+  return neg ? -v : v;
+}
+function packBigInt(w, v) {
+  packExt(w, BIGINT_EXT_TAG, bigIntGobEncode(v));
+}
+function packDecimal(w, v) {
+  const coef = bigIntGobEncode(v.coefficient);
+  const payload = new Uint8Array(4 + coef.length);
+  const dv = new DataView(payload.buffer);
+  dv.setInt32(0, v.exponent);
+  payload.set(coef, 4);
+  packExt(w, DECIMAL_EXT_TAG, payload);
+}
+function packValue(w, v) {
+  if (v === null || v === void 0) {
+    w.byte(192);
+    return;
+  }
+  switch (typeof v) {
+    case "boolean":
+      w.byte(v ? 195 : 194);
+      return;
+    case "number":
+      if (Number.isSafeInteger(v)) packLongNumber(w, v === 0 ? 0 : v);
+      else if (Number.isInteger(v)) {
+        throw new RangeError(
+          `vrpc: integer ${v} exceeds \xB12^53; pass a bigint for exact int64 encoding`
+        );
+      } else packDouble(w, v);
+      return;
+    case "string":
+      packStr(w, v);
+      return;
+    case "bigint":
+      if (v >= INT64_MIN && v <= INT64_MAX) packLongBig(w, v);
+      else packBigInt(w, v);
+      return;
+    case "object":
+      break;
+    default:
+      throw new TypeError(`vrpc: cannot encode ${typeof v} as a value`);
+  }
+  if (v instanceof Uint8Array) {
+    packBin(w, v);
+  } else if (v instanceof VrpcDouble) {
+    packDouble(w, v.value);
+  } else if (v instanceof VrpcDecimal) {
+    packDecimal(w, v);
+  } else if (v instanceof VrpcExt) {
+    packExt(w, v.tag, v.data);
+  } else if (Array.isArray(v)) {
+    if (v.length < 16) w.byte(144 | v.length);
+    else if (v.length <= 65535) {
+      w.byte(220);
+      w.u16(v.length);
+    } else {
+      w.byte(221);
+      w.u32(v.length);
+    }
+    for (const item of v) packValue(w, item);
+  } else if (v instanceof Map) {
+    packMapEntries(
+      w,
+      [...v.keys()].map((k) => String(k)),
+      (k) => v.get(k)
+    );
+  } else if (isPlainObject(v)) {
+    packMapEntries(w, Object.keys(v), (k) => v[k]);
+  } else {
+    throw new TypeError(`vrpc: cannot encode ${v.constructor?.name ?? "object"} as a value`);
+  }
+}
+function packMapEntries(w, keys, get) {
+  const live = keys.filter((k) => get(k) !== void 0).sort(compareUtf8);
+  if (live.length < 16) w.byte(128 | live.length);
+  else if (live.length <= 65535) {
+    w.byte(222);
+    w.u16(live.length);
+  } else {
+    w.byte(223);
+    w.u32(live.length);
+  }
+  for (const k of live) {
+    packStr(w, k);
+    packValue(w, get(k));
+  }
+}
+function msgpackEncode(v) {
+  const w = new Writer();
+  packValue(w, v);
+  return w.result();
+}
+var Reader = class {
+  constructor(buf, limits) {
+    this.buf = buf;
+    this.limits = limits;
+    this.dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  buf;
+  limits;
+  pos = 0;
+  dv;
+  byte() {
+    if (this.pos >= this.buf.length) throw new SyntaxError("vrpc: truncated msgpack input");
+    return this.buf[this.pos++];
+  }
+  take(n) {
+    if (n > this.limits.maxByteLen) throw new RangeError(`vrpc: msgpack byte length ${n} exceeds limit`);
+    if (this.pos + n > this.buf.length) throw new SyntaxError("vrpc: truncated msgpack input");
+    const out = this.buf.slice(this.pos, this.pos + n);
+    this.pos += n;
+    return out;
+  }
+  u8() {
+    return this.byte();
+  }
+  u16() {
+    const v = this.dv.getUint16(this.need(2));
+    return v;
+  }
+  u32() {
+    return this.dv.getUint32(this.need(4));
+  }
+  i8() {
+    return this.dv.getInt8(this.need(1));
+  }
+  i16() {
+    return this.dv.getInt16(this.need(2));
+  }
+  i32() {
+    return this.dv.getInt32(this.need(4));
+  }
+  i64() {
+    return this.dv.getBigInt64(this.need(8));
+  }
+  u64() {
+    return this.dv.getBigUint64(this.need(8));
+  }
+  f32() {
+    return this.dv.getFloat32(this.need(4));
+  }
+  f64() {
+    return this.dv.getFloat64(this.need(8));
+  }
+  need(n) {
+    if (this.pos + n > this.buf.length) throw new SyntaxError("vrpc: truncated msgpack input");
+    const at = this.pos;
+    this.pos += n;
+    return at;
+  }
+};
+function normalizeInt(v) {
+  return v >= -9007199254740991n && v <= 9007199254740991n ? Number(v) : v;
+}
+function decodeExt(tag, data) {
+  if (tag === BIGINT_EXT_TAG) return bigIntGobDecode(data);
+  if (tag === DECIMAL_EXT_TAG) {
+    if (data.length < 5) throw new SyntaxError("vrpc: truncated decimal payload");
+    const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const exponent = dv.getInt32(0);
+    return new VrpcDecimal(bigIntGobDecode(data.subarray(4)), exponent);
+  }
+  return new VrpcExt(tag, data);
+}
+function readValue(r, depth) {
+  if (depth > r.limits.maxDepth) throw new RangeError("vrpc: msgpack nesting too deep");
+  const b = r.byte();
+  if (b <= 127) return b;
+  if (b >= 224) return b - 256;
+  if (b >= 160 && b <= 191) return utf8Decode(r.take(b & 31));
+  if (b >= 144 && b <= 159) return readList(r, b & 15, depth);
+  if (b >= 128 && b <= 143) return readMap(r, b & 15, depth);
+  switch (b) {
+    case 192:
+      return null;
+    case 194:
+      return false;
+    case 195:
+      return true;
+    case 196:
+      return r.take(r.u8());
+    case 197:
+      return r.take(r.u16());
+    case 198:
+      return r.take(r.u32());
+    case 199: {
+      const n = r.u8();
+      return decodeExt(r.byte(), r.take(n));
+    }
+    case 200: {
+      const n = r.u16();
+      return decodeExt(r.byte(), r.take(n));
+    }
+    case 201: {
+      const n = r.u32();
+      return decodeExt(r.byte(), r.take(n));
+    }
+    case 202:
+      return r.f32();
+    case 203:
+      return r.f64();
+    case 204:
+      return r.u8();
+    case 205:
+      return r.u16();
+    case 206:
+      return r.u32();
+    case 207:
+      return normalizeInt(r.u64());
+    case 208:
+      return r.i8();
+    case 209:
+      return r.i16();
+    case 210:
+      return r.i32();
+    case 211:
+      return normalizeInt(r.i64());
+    case 212:
+      return decodeExt(r.byte(), r.take(1));
+    case 213:
+      return decodeExt(r.byte(), r.take(2));
+    case 214:
+      return decodeExt(r.byte(), r.take(4));
+    case 215:
+      return decodeExt(r.byte(), r.take(8));
+    case 216:
+      return decodeExt(r.byte(), r.take(16));
+    case 217:
+      return utf8Decode(r.take(r.u8()));
+    case 218:
+      return utf8Decode(r.take(r.u16()));
+    case 219:
+      return utf8Decode(r.take(r.u32()));
+    case 220:
+      return readList(r, r.u16(), depth);
+    case 221:
+      return readList(r, r.u32(), depth);
+    case 222:
+      return readMap(r, r.u16(), depth);
+    case 223:
+      return readMap(r, r.u32(), depth);
+    default:
+      throw new SyntaxError(`vrpc: unsupported msgpack format 0x${b.toString(16)}`);
+  }
+}
+function readList(r, n, depth) {
+  if (n > r.limits.maxCollectionLen) throw new RangeError(`vrpc: msgpack list length ${n} exceeds limit`);
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) out[i] = readValue(r, depth + 1);
+  return out;
+}
+function readMap(r, n, depth) {
+  if (n > r.limits.maxCollectionLen) throw new RangeError(`vrpc: msgpack map length ${n} exceeds limit`);
+  const out = {};
+  for (let i = 0; i < n; i++) {
+    const key = readValue(r, depth + 1);
+    const val = readValue(r, depth + 1);
+    if (typeof key === "string") out[key] = val;
+    else if (typeof key === "number" || typeof key === "bigint") out[String(key)] = val;
+    else throw new SyntaxError("vrpc: unsupported msgpack map key type");
+  }
+  return out;
+}
+function msgpackDecode(data, limits = DEFAULT_LIMITS) {
+  const r = new Reader(data, limits);
+  const v = readValue(r, 0);
+  if (r.pos !== data.length) throw new SyntaxError("vrpc: trailing bytes after msgpack value");
+  return v;
+}
+
+// src/json.ts
+var BASE64_PREFIX = "base64,";
+var EXT_PREFIX = "data:application/x-msgpack-ext;";
+var MAX_SAFE = 9007199254740991;
+function writeValue(out, v, depth) {
+  if (depth > 512) throw new RangeError("vrpc: json nesting too deep");
+  if (v === null || v === void 0) {
+    out.push("null");
+    return;
+  }
+  switch (typeof v) {
+    case "boolean":
+      out.push(v ? "true" : "false");
+      return;
+    case "number":
+      writeNumber(out, v);
+      return;
+    case "bigint":
+      if (v > BigInt(MAX_SAFE) || v < -BigInt(MAX_SAFE)) {
+        throw new RangeError(
+          `vrpc: bigint ${v} exceeds \xB12^53 and cannot travel exactly in JSON; use the msgpack codec or model it as a string`
+        );
+      }
+      out.push(v.toString());
+      return;
+    case "string":
+      out.push(JSON.stringify(v));
+      return;
+    case "object":
+      break;
+    default:
+      throw new TypeError(`vrpc: cannot encode ${typeof v} as a value`);
+  }
+  if (v instanceof Uint8Array) {
+    out.push(JSON.stringify(BASE64_PREFIX + base64RawStdEncode(v)));
+  } else if (v instanceof VrpcDouble) {
+    writeNumber(out, v.value, true);
+  } else if (v instanceof VrpcExt) {
+    const payload = new Uint8Array(1 + v.data.length);
+    payload[0] = v.tag;
+    payload.set(v.data, 1);
+    out.push(JSON.stringify(EXT_PREFIX + BASE64_PREFIX + base64RawStdEncode(payload)));
+  } else if (v instanceof VrpcDecimal) {
+    throw new TypeError(
+      "vrpc: VrpcDecimal does not round-trip through the JSON codec; use msgpack or model it as a string"
+    );
+  } else if (Array.isArray(v)) {
+    out.push("[");
+    for (let i = 0; i < v.length; i++) {
+      if (i > 0) out.push(",");
+      writeValue(out, v[i], depth + 1);
+    }
+    out.push("]");
+  } else if (v instanceof Map || isPlainObject(v)) {
+    const get = v instanceof Map ? (k) => v.get(k) : (k) => v[k];
+    const keys = (v instanceof Map ? [...v.keys()].map(String) : Object.keys(v)).filter((k) => get(k) !== void 0).sort(compareUtf8);
+    out.push("{");
+    for (let i = 0; i < keys.length; i++) {
+      if (i > 0) out.push(",");
+      out.push(JSON.stringify(keys[i]), ":");
+      writeValue(out, get(keys[i]), depth + 1);
+    }
+    out.push("}");
+  } else {
+    throw new TypeError(`vrpc: cannot encode ${v.constructor?.name ?? "object"} as a value`);
+  }
+}
+function writeNumber(out, v, forceDouble = false) {
+  if (!Number.isFinite(v)) {
+    out.push("null");
+    return;
+  }
+  if (Number.isInteger(v) && !forceDouble && Math.abs(v) > MAX_SAFE) {
+    throw new RangeError(`vrpc: integer ${v} exceeds \xB12^53; use the msgpack codec with a bigint`);
+  }
+  out.push(Object.is(v, -0) ? "0" : String(v));
+}
+function jsonEncode(v) {
+  const out = [];
+  writeValue(out, v, 0);
+  return out.join("");
+}
+function reviveString(s) {
+  if (s.startsWith(EXT_PREFIX)) {
+    const rest = s.slice(EXT_PREFIX.length);
+    if (rest.startsWith(BASE64_PREFIX)) {
+      const payload = base64RawStdDecode(rest.slice(BASE64_PREFIX.length));
+      if (payload.length >= 1) {
+        return new VrpcExt(payload[0], payload.slice(1));
+      }
+    }
+    return s;
+  }
+  if (s.startsWith(BASE64_PREFIX)) {
+    try {
+      return base64RawStdDecode(s.slice(BASE64_PREFIX.length));
+    } catch {
+      return s;
+    }
+  }
+  return s;
+}
+function reviveValue(v, depth, limits) {
+  if (depth > limits.maxDepth) throw new RangeError("vrpc: json nesting too deep");
+  if (v === null) return null;
+  switch (typeof v) {
+    case "boolean":
+    case "number":
+      return v;
+    case "string":
+      return reviveString(v);
+    case "object":
+      break;
+    default:
+      throw new SyntaxError(`vrpc: unsupported json value of type ${typeof v}`);
+  }
+  if (Array.isArray(v)) {
+    if (v.length > limits.maxCollectionLen) throw new RangeError("vrpc: json list too long");
+    return v.map((item) => reviveValue(item, depth + 1, limits));
+  }
+  const out = {};
+  const entries = Object.entries(v);
+  if (entries.length > limits.maxCollectionLen) throw new RangeError("vrpc: json map too large");
+  for (const [k, val] of entries) out[k] = reviveValue(val, depth + 1, limits);
+  return out;
+}
+function jsonDecode(text, limits = DEFAULT_LIMITS) {
+  return reviveValue(JSON.parse(text), 0, limits);
+}
+
+// src/codec.ts
+function assertMap(v, codec) {
+  if (v === null || typeof v !== "object" || Array.isArray(v) || v instanceof Uint8Array) {
+    throw new SyntaxError(`vrpc: expected a ${codec} map envelope`);
+  }
+  return v;
+}
+function msgpackCodec(limits = DEFAULT_LIMITS) {
+  return {
+    name: "msgpack",
+    subprotocols: [],
+    textFrames: false,
+    encode: (msg) => msgpackEncode(msg),
+    decode: (data) => {
+      if (typeof data === "string") {
+        throw new SyntaxError(
+          "vrpc: received a text frame on a msgpack connection; JSON was not negotiated (offer subprotocol vrpc.json)"
+        );
+      }
+      return assertMap(msgpackDecode(data, limits), "msgpack");
+    }
+  };
+}
+function jsonCodec(limits = DEFAULT_LIMITS) {
+  return {
+    name: "json",
+    subprotocols: ["vrpc.json"],
+    textFrames: true,
+    encode: (msg) => jsonEncode(msg),
+    decode: (data) => {
+      if (typeof data !== "string") {
+        throw new SyntaxError("vrpc: received a binary frame on a JSON connection");
+      }
+      return assertMap(jsonDecode(data, limits), "json");
+    }
+  };
+}
+function codecByName(name, limits) {
+  return name === "json" ? jsonCodec(limits) : msgpackCodec(limits);
+}
+
+// src/errors.ts
+var Code = /* @__PURE__ */ ((Code2) => {
+  Code2[Code2["OK"] = 0] = "OK";
+  Code2[Code2["Unknown"] = 1] = "Unknown";
+  Code2[Code2["Canceled"] = 2] = "Canceled";
+  Code2[Code2["InvalidArgument"] = 3] = "InvalidArgument";
+  Code2[Code2["DeadlineExceeded"] = 4] = "DeadlineExceeded";
+  Code2[Code2["NotFound"] = 5] = "NotFound";
+  Code2[Code2["ResourceExhausted"] = 6] = "ResourceExhausted";
+  Code2[Code2["Unavailable"] = 7] = "Unavailable";
+  Code2[Code2["Unauthenticated"] = 8] = "Unauthenticated";
+  Code2[Code2["Internal"] = 9] = "Internal";
+  return Code2;
+})(Code || {});
+var CODE_NAMES = {
+  [0 /* OK */]: "OK",
+  [1 /* Unknown */]: "Unknown",
+  [2 /* Canceled */]: "Canceled",
+  [3 /* InvalidArgument */]: "InvalidArgument",
+  [4 /* DeadlineExceeded */]: "DeadlineExceeded",
+  [5 /* NotFound */]: "NotFound",
+  [6 /* ResourceExhausted */]: "ResourceExhausted",
+  [7 /* Unavailable */]: "Unavailable",
+  [8 /* Unauthenticated */]: "Unauthenticated",
+  [9 /* Internal */]: "Internal"
+};
+function codeName(code) {
+  return CODE_NAMES[code] ?? "Unknown";
+}
+var VrpcError = class extends Error {
+  constructor(code, message, options) {
+    super(`vrpc ${codeName(code)}: ${message}`, options);
+    this.code = code;
+  }
+  code;
+  name = "VrpcError";
+  /** The message without the "vrpc <Code>: " prefix. */
+  get detail() {
+    return this.message.replace(/^vrpc [A-Za-z]+: /, "");
+  }
+};
+function codeOf(err) {
+  if (err == null) return 0 /* OK */;
+  if (err instanceof VrpcError) return err.code;
+  return 1 /* Unknown */;
+}
+function errConnectionLost() {
+  return new VrpcError(7 /* Unavailable */, "connection lost");
+}
+function errClientClosed() {
+  return new VrpcError(7 /* Unavailable */, "client closed");
+}
+
+// src/hashchain.ts
+var HashChain = class _HashChain {
+  constructor(links, next) {
+    this.links = links;
+    this.next = next;
+  }
+  links;
+  next;
+  static DEFAULT_LENGTH = 1024;
+  static async create(n = _HashChain.DEFAULT_LENGTH) {
+    if (n <= 0) n = _HashChain.DEFAULT_LENGTH;
+    const links = new Array(n + 1);
+    const seed = new Uint8Array(32);
+    crypto.getRandomValues(seed);
+    links[0] = seed;
+    for (let i = 1; i <= n; i++) {
+      const digest = await crypto.subtle.digest("SHA-256", links[i - 1]);
+      links[i] = new Uint8Array(digest);
+    }
+    return new _HashChain(links, n - 1);
+  }
+  /** The public commitment h[N], hex-encoded. Resending it consumes nothing. */
+  anchor() {
+    return bytesToHex(this.links[this.links.length - 1]);
+  }
+  /**
+   * Reveals the next one-time resumption token and advances. Returns "" when
+   * the chain is exhausted and a fresh session is required.
+   */
+  nextToken() {
+    if (this.next < 0) return "";
+    const tok = bytesToHex(this.links[this.next]);
+    this.next--;
+    return tok;
+  }
+  remaining() {
+    return this.next + 1;
+  }
+};
+
+// src/protocol.ts
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2[MessageType2["HandshakeRequest"] = 0] = "HandshakeRequest";
+  MessageType2[MessageType2["HandshakeResponse"] = 1] = "HandshakeResponse";
+  MessageType2[MessageType2["FunctionRequest"] = 2] = "FunctionRequest";
+  MessageType2[MessageType2["FunctionResponse"] = 3] = "FunctionResponse";
+  MessageType2[MessageType2["GetStreamRequest"] = 4] = "GetStreamRequest";
+  MessageType2[MessageType2["PutStreamRequest"] = 5] = "PutStreamRequest";
+  MessageType2[MessageType2["ChatRequest"] = 6] = "ChatRequest";
+  MessageType2[MessageType2["ErrorResponse"] = 7] = "ErrorResponse";
+  MessageType2[MessageType2["StreamReady"] = 8] = "StreamReady";
+  MessageType2[MessageType2["StreamValue"] = 9] = "StreamValue";
+  MessageType2[MessageType2["StreamEnd"] = 10] = "StreamEnd";
+  MessageType2[MessageType2["CancelRequest"] = 11] = "CancelRequest";
+  MessageType2[MessageType2["StreamCredit"] = 14] = "StreamCredit";
+  return MessageType2;
+})(MessageType || {});
+function newDialect() {
+  return {
+    magic: "vRPC",
+    version: 1,
+    handshakeRequestId: 0,
+    messageTypeField: "t",
+    magicField: "m",
+    versionField: "v",
+    requestIdField: "rid",
+    timeoutField: "sla",
+    clientIdField: "cid",
+    sessionTokenField: "tok",
+    authField: "auth",
+    functionNameField: "fn",
+    argumentsField: "args",
+    resultField: "res",
+    errorField: "err",
+    codeField: "code",
+    creditField: "cr",
+    metadataField: "md",
+    valueField: "val"
+  };
+}
+var Protocol = class {
+  constructor(d) {
+    this.d = d;
+  }
+  d;
+  handshakeRequest(clientId, token, auth) {
+    const req = {
+      [this.d.magicField]: this.d.magic,
+      // Sent as a DOUBLE like the Go client (value.Double(1.0)); the server
+      // accepts any NUMBER <= its version.
+      [this.d.versionField]: new VrpcDouble(this.d.version),
+      [this.d.messageTypeField]: 0 /* HandshakeRequest */,
+      [this.d.requestIdField]: this.d.handshakeRequestId,
+      [this.d.clientIdField]: clientId
+    };
+    if (token !== "") req[this.d.sessionTokenField] = token;
+    if (auth !== void 0 && auth !== null) req[this.d.authField] = auth;
+    return req;
+  }
+  request(mt, requestId, name, args, timeoutMs, metadata) {
+    const req = {
+      [this.d.messageTypeField]: mt,
+      [this.d.requestIdField]: requestId,
+      [this.d.functionNameField]: name
+    };
+    if (args !== void 0) req[this.d.argumentsField] = args;
+    if (timeoutMs > 0) req[this.d.timeoutField] = Math.floor(timeoutMs);
+    if (metadata && Object.keys(metadata).length > 0) {
+      req[this.d.metadataField] = { ...metadata };
+    }
+    return req;
+  }
+  functionResult(requestId, result) {
+    const resp = {
+      [this.d.messageTypeField]: 3 /* FunctionResponse */,
+      [this.d.requestIdField]: requestId
+    };
+    if (result !== null && result !== void 0) resp[this.d.resultField] = result;
+    return resp;
+  }
+  errorResponse(requestId, code, message) {
+    return {
+      [this.d.messageTypeField]: 7 /* ErrorResponse */,
+      [this.d.requestIdField]: requestId,
+      [this.d.codeField]: code,
+      [this.d.errorField]: message
+    };
+  }
+  streamReady(requestId) {
+    return {
+      [this.d.messageTypeField]: 8 /* StreamReady */,
+      [this.d.requestIdField]: requestId
+    };
+  }
+  streamValue(requestId, value) {
+    return {
+      [this.d.messageTypeField]: 9 /* StreamValue */,
+      [this.d.requestIdField]: requestId,
+      [this.d.valueField]: value
+    };
+  }
+  streamEnd(requestId, value) {
+    const resp = {
+      [this.d.messageTypeField]: 10 /* StreamEnd */,
+      [this.d.requestIdField]: requestId
+    };
+    if (value !== void 0 && value !== null) resp[this.d.valueField] = value;
+    return resp;
+  }
+  streamCredit(requestId, credit) {
+    return {
+      [this.d.messageTypeField]: 14 /* StreamCredit */,
+      [this.d.requestIdField]: requestId,
+      [this.d.creditField]: credit
+    };
+  }
+  cancelRequest(requestId) {
+    return {
+      [this.d.messageTypeField]: 11 /* CancelRequest */,
+      [this.d.requestIdField]: requestId
+    };
+  }
+  // --- field accessors (absent or wrong-typed fields return undefined) ---
+  messageType(msg) {
+    return asIntField(msg[this.d.messageTypeField]);
+  }
+  requestId(msg) {
+    return asIntField(msg[this.d.requestIdField]);
+  }
+  functionName(msg) {
+    const v = msg[this.d.functionNameField];
+    return typeof v === "string" ? v : void 0;
+  }
+  args(msg) {
+    return msg[this.d.argumentsField] ?? null;
+  }
+  result(msg) {
+    return msg[this.d.resultField] ?? null;
+  }
+  streamVal(msg) {
+    return msg[this.d.valueField] ?? null;
+  }
+  credit(msg) {
+    return asIntField(msg[this.d.creditField]);
+  }
+  errorOf(msg) {
+    const code = asIntField(msg[this.d.codeField]) ?? 1 /* Unknown */;
+    const err = msg[this.d.errorField];
+    return { code, message: typeof err === "string" ? err : "" };
+  }
+  metadata(msg) {
+    const v = msg[this.d.metadataField];
+    if (v === null || v === void 0 || typeof v !== "object" || Array.isArray(v) || v instanceof Uint8Array) {
+      return void 0;
+    }
+    const out = {};
+    let any = false;
+    for (const [k, val] of Object.entries(v)) {
+      if (typeof val === "string") {
+        out[k] = val;
+        any = true;
+      }
+    }
+    return any ? out : void 0;
+  }
+};
+function asIntField(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "bigint") return Number(v);
+  return void 0;
+}
+
+// src/transport.ts
+var webSocketDialer = (opts) => {
+  return new Promise((resolve, reject) => {
+    const WS = opts.webSocket ?? globalThis.WebSocket;
+    if (typeof WS !== "function") {
+      reject(
+        new VrpcError(
+          9 /* Internal */,
+          "no WebSocket implementation available; pass one via the webSocket option"
+        )
+      );
+      return;
+    }
+    let ws;
+    try {
+      ws = opts.subprotocols.length > 0 ? new WS(opts.url, opts.subprotocols) : new WS(opts.url);
+    } catch (err) {
+      reject(new VrpcError(7 /* Unavailable */, `websocket dial failed: ${String(err)}`, { cause: err }));
+      return;
+    }
+    ws.binaryType = "arraybuffer";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      ws.close();
+      reject(new VrpcError(4 /* DeadlineExceeded */, `websocket dial timed out after ${opts.timeoutMs}ms`));
+    }, opts.timeoutMs);
+    ws.onopen = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (opts.subprotocols.length > 0 && !opts.subprotocols.includes(ws.protocol)) {
+        ws.close();
+        reject(
+          new VrpcError(
+            7 /* Unavailable */,
+            `server did not accept subprotocol ${opts.subprotocols.join("/")} (got ${JSON.stringify(
+              ws.protocol
+            )}); it likely predates JSON codec support \u2014 use codec: "msgpack"`
+          )
+        );
+        return;
+      }
+      resolve(wrap(ws));
+    };
+    ws.onerror = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new VrpcError(7 /* Unavailable */, `websocket dial failed: ${opts.url}`));
+    };
+    ws.onclose = (ev) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(
+        new VrpcError(
+          7 /* Unavailable */,
+          `websocket closed during dial (code ${ev.code}${ev.reason ? `, ${ev.reason}` : ""})`
+        )
+      );
+    };
+  });
+};
+function wrap(ws) {
+  let onMessageCb = null;
+  const early = [];
+  const deliver = (d) => {
+    if (onMessageCb) onMessageCb(d);
+    else early.push(d);
+  };
+  const t = {
+    send(data) {
+      ws.send(data);
+    },
+    close() {
+      ws.onclose = null;
+      ws.onerror = null;
+      ws.onmessage = null;
+      try {
+        ws.close(1e3);
+      } catch {
+      }
+    },
+    get onMessage() {
+      return onMessageCb;
+    },
+    set onMessage(cb) {
+      onMessageCb = cb;
+      if (cb && early.length > 0) {
+        const queued = early.splice(0, early.length);
+        for (const d of queued) cb(d);
+      }
+    },
+    onClose: null
+  };
+  let closed = false;
+  const fireClose = (err) => {
+    if (closed) return;
+    closed = true;
+    t.onClose?.(err);
+  };
+  ws.onmessage = (ev) => {
+    const data = ev.data;
+    if (typeof data === "string") deliver(data);
+    else if (data instanceof ArrayBuffer) deliver(new Uint8Array(data));
+    else if (ArrayBuffer.isView(data)) {
+      const view = data;
+      deliver(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+    }
+  };
+  ws.onclose = (ev) => {
+    fireClose(
+      ev.wasClean && ev.code === 1e3 ? void 0 : new VrpcError(7 /* Unavailable */, `websocket closed (code ${ev.code}${ev.reason ? `, ${ev.reason}` : ""})`)
+    );
+  };
+  ws.onerror = () => {
+    fireClose(new VrpcError(7 /* Unavailable */, "websocket error"));
+  };
+  return t;
+}
+
+// src/internal/async.ts
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+var CreditGate = class {
+  credit = 0;
+  closed = false;
+  waiters = [];
+  acquire() {
+    if (this.closed) return Promise.resolve(false);
+    if (this.credit > 0) {
+      this.credit--;
+      return Promise.resolve(true);
+    }
+    const d = deferred();
+    this.waiters.push(d);
+    return d.promise;
+  }
+  grant(n) {
+    if (n <= 0 || this.closed) return;
+    this.credit += n;
+    while (this.credit > 0 && this.waiters.length > 0) {
+      this.credit--;
+      this.waiters.shift().resolve(true);
+    }
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const w of this.waiters) w.resolve(false);
+    this.waiters = [];
+  }
+};
+var AsyncValueQueue = class {
+  constructor(maxPending, onConsume) {
+    this.maxPending = maxPending;
+    this.onConsume = onConsume;
+  }
+  maxPending;
+  onConsume;
+  buf = [];
+  waiter = null;
+  ended = false;
+  failure = null;
+  /** Queues a value; false means the queue is finished or overflowed. */
+  push(v) {
+    if (this.ended) return false;
+    if (this.waiter) {
+      const w = this.waiter;
+      this.waiter = null;
+      w.resolve({ value: v, done: false });
+      this.onConsume?.();
+      return true;
+    }
+    if (this.buf.length >= this.maxPending) return false;
+    this.buf.push(v);
+    return true;
+  }
+  /** Graceful end-of-stream: buffered values still drain to the consumer. */
+  end() {
+    if (this.ended) return;
+    this.ended = true;
+    if (this.waiter && this.buf.length === 0) {
+      const w = this.waiter;
+      this.waiter = null;
+      if (this.failure != null) w.reject(this.failure);
+      else w.resolve({ value: void 0, done: true });
+    }
+  }
+  /** Ends the stream with an error; buffered values still drain first. */
+  fail(err) {
+    if (this.ended) return;
+    this.failure = err;
+    this.end();
+  }
+  /** Hard stop: discards buffered values and ends immediately. */
+  abort(err) {
+    this.buf = [];
+    if (this.ended && !this.waiter) return;
+    this.ended = true;
+    if (err !== void 0) this.failure = err;
+    if (this.waiter) {
+      const w = this.waiter;
+      this.waiter = null;
+      if (this.failure != null) w.reject(this.failure);
+      else w.resolve({ value: void 0, done: true });
+    }
+  }
+  get isEnded() {
+    return this.ended;
+  }
+  next() {
+    if (this.buf.length > 0) {
+      const v = this.buf.shift();
+      this.onConsume?.();
+      return Promise.resolve({ value: v, done: false });
+    }
+    if (this.ended) {
+      return this.failure != null ? Promise.reject(this.failure) : Promise.resolve({ value: void 0, done: true });
+    }
+    if (this.waiter) {
+      return Promise.reject(new Error("vrpc: concurrent reads from a single stream consumer"));
+    }
+    this.waiter = deferred();
+    return this.waiter.promise;
+  }
+};
+function backoffDelay(attempt, opts) {
+  let delay = opts.initialDelayMs * 2 ** Math.max(0, attempt - 1);
+  if (delay > opts.maxDelayMs) delay = opts.maxDelayMs;
+  if (opts.jitter) delay = delay / 2 + Math.random() * (delay / 2);
+  return Math.round(delay);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve();
+    const t = setTimeout(done, ms);
+    function done() {
+      clearTimeout(t);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+function randomClientId() {
+  const a = new Uint32Array(2);
+  crypto.getRandomValues(a);
+  const id = a[0] % 2097152 * 4294967296 + a[1];
+  return id === 0 ? 1 : id;
+}
+
+// src/client.ts
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_PENDING = 4096;
+var PendingRequest = class {
+  constructor(requestId, kind, name, window2) {
+    this.requestId = requestId;
+    this.kind = kind;
+    this.name = name;
+    this.window = window2;
+    if (kind === "unary") this.unary = deferred();
+    if (kind === "get" || kind === "chat") this.queue = new AsyncValueQueue(window2, () => this.onConsume?.());
+    if (kind === "put" || kind === "chat") this.sendCredit = new CreditGate();
+    this.ready.promise.catch(() => {
+    });
+    this.unary?.promise.catch(() => {
+    });
+  }
+  requestId;
+  kind;
+  name;
+  window;
+  ready = deferred();
+  queue = null;
+  sendCredit = null;
+  unary = null;
+  timer = null;
+  error = null;
+  getClosed = false;
+  putClosed = false;
+  delivered = 0;
+  onConsume = null;
+  fail(err) {
+    this.error = err;
+    this.ready.reject(err);
+    this.unary?.reject(err);
+    this.queue?.fail(err);
+    this.sendCredit?.close();
+    this.getClosed = true;
+    this.putClosed = true;
+    if (this.timer) clearTimeout(this.timer);
+  }
+  /** Graceful teardown without an error (server cancel / normal close). */
+  finish() {
+    this.ready.reject(this.error ?? new VrpcError(2 /* Canceled */, `request ${this.requestId} closed`));
+    this.unary?.reject(this.error ?? new VrpcError(2 /* Canceled */, `request ${this.requestId} closed`));
+    this.queue?.end();
+    this.sendCredit?.close();
+    this.getClosed = true;
+    this.putClosed = true;
+    if (this.timer) clearTimeout(this.timer);
+  }
+};
+var ServingRequest = class {
+  constructor(requestId, kind, window2) {
+    this.requestId = requestId;
+    this.kind = kind;
+    this.window = window2;
+    if (kind === "in" || kind === "chat") {
+      this.inQueue = new AsyncValueQueue(window2, () => this.onConsume?.());
+    }
+    if (kind === "out" || kind === "chat") this.sendCredit = new CreditGate();
+  }
+  requestId;
+  kind;
+  window;
+  inQueue = null;
+  sendCredit = null;
+  abort = new AbortController();
+  delivered = 0;
+  closed = false;
+  onConsume = null;
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.abort.abort();
+    this.sendCredit?.close();
+    this.inQueue?.abort();
+  }
+};
+var VrpcClient = class {
+  protocol;
+  codec;
+  opts;
+  reconnect;
+  timeoutMs;
+  connectTimeoutMs;
+  maxPending;
+  dialer;
+  _status = "idle";
+  _clientId = randomClientId();
+  transport = null;
+  chain = null;
+  established = false;
+  nextRequestId = 0;
+  reconnects = 0;
+  pending = /* @__PURE__ */ new Map();
+  serving = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  connectPromise = null;
+  resumeAbort = null;
+  openWaiters = [];
+  handshakeWaiter = null;
+  handshakeTransport = null;
+  hintsInstalled = false;
+  constructor(options) {
+    this.opts = options;
+    this.codec = typeof options.codec === "object" ? options.codec : codecByName(options.codec ?? "msgpack");
+    this.protocol = new Protocol({ ...newDialect(), ...options.dialect });
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+    this.maxPending = options.maxPending ?? DEFAULT_MAX_PENDING;
+    this.dialer = options.dialer ?? webSocketDialer;
+    const rc = options.reconnect;
+    this.reconnect = {
+      enabled: rc === false ? false : (rc === true || rc === void 0 ? void 0 : rc.enabled) ?? true,
+      initialDelayMs: typeof rc === "object" && rc.initialDelayMs || 300,
+      maxDelayMs: typeof rc === "object" && rc.maxDelayMs || 1e4,
+      maxAttempts: typeof rc === "object" && rc.maxAttempts || Infinity,
+      jitter: typeof rc === "object" ? rc.jitter ?? true : true
+    };
+  }
+  get status() {
+    return this._status;
+  }
+  get connected() {
+    return this._status === "open";
+  }
+  get clientId() {
+    return this._clientId;
+  }
+  get codecName() {
+    return this.codec.name;
+  }
+  stats() {
+    return {
+      requests: this.nextRequestId,
+      reconnects: this.reconnects,
+      pending: this.pending.size,
+      serving: this.serving.size
+    };
+  }
+  // ------------------------------------------------------------------ events
+  on(event, fn) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(fn);
+    return () => set.delete(fn);
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const fn of [...set]) {
+      try {
+        fn(...args);
+      } catch {
+      }
+    }
+  }
+  setStatus(s) {
+    if (this._status === s) return;
+    this._status = s;
+    this.emit("status", s);
+    if (s === "open") {
+      const waiters = this.openWaiters;
+      this.openWaiters = [];
+      for (const w of waiters) w.resolve();
+    }
+    if (s === "closed") {
+      const waiters = this.openWaiters;
+      this.openWaiters = [];
+      for (const w of waiters) w.reject(errClientClosed());
+      this.emit("close");
+    }
+  }
+  // -------------------------------------------------------------- connection
+  /** Connects (idempotent). Calls also auto-connect on first use. */
+  async connect() {
+    if (this._status === "open") return;
+    if (this._status === "closed") throw errClientClosed();
+    if (!this.connectPromise) {
+      this.setStatus(this._status === "resuming" ? "resuming" : "connecting");
+      this.connectPromise = this.doConnect().finally(() => {
+        this.connectPromise = null;
+      });
+    }
+    return this.connectPromise;
+  }
+  async handshakeToken() {
+    if (this.opts.resume === false) {
+      if (this.established) this._clientId = randomClientId();
+      return "";
+    }
+    if (!this.chain) {
+      this.chain = await HashChain.create(this.opts.chainLength ?? HashChain.DEFAULT_LENGTH);
+    }
+    if (!this.established) return this.chain.anchor();
+    const tok = this.chain.nextToken();
+    if (tok !== "") return tok;
+    this._clientId = randomClientId();
+    this.chain = await HashChain.create(this.opts.chainLength ?? HashChain.DEFAULT_LENGTH);
+    this.established = false;
+    return this.chain.anchor();
+  }
+  async doConnect() {
+    const token = await this.handshakeToken();
+    const authOpt = this.opts.auth;
+    const auth = typeof authOpt === "function" ? await authOpt() : authOpt;
+    const dialOpts = {
+      url: this.opts.url,
+      subprotocols: this.codec.subprotocols,
+      timeoutMs: this.connectTimeoutMs
+    };
+    if (this.opts.webSocket) dialOpts.webSocket = this.opts.webSocket;
+    const transport = await this.dialer(dialOpts);
+    if (this._status === "closed") {
+      transport.close();
+      throw errClientClosed();
+    }
+    const hs = deferred();
+    this.handshakeWaiter = hs;
+    this.handshakeTransport = transport;
+    transport.onMessage = (data) => this.onFrame(transport, data);
+    transport.onClose = (err) => this.onTransportClose(transport, err);
+    try {
+      transport.send(this.codec.encode(this.protocol.handshakeRequest(this._clientId, token, auth ?? null)));
+      const timer = setTimeout(
+        () => hs.reject(new VrpcError(4 /* DeadlineExceeded */, `handshake timed out after ${this.connectTimeoutMs}ms`)),
+        this.connectTimeoutMs
+      );
+      let resp;
+      try {
+        resp = await hs.promise;
+      } finally {
+        clearTimeout(timer);
+        this.handshakeWaiter = null;
+        this.handshakeTransport = null;
+      }
+      this.transport = transport;
+      this.established = true;
+      this.setStatus("open");
+      this.installBrowserHints();
+      this.emit("open", resp);
+    } catch (err) {
+      this.handshakeWaiter = null;
+      this.handshakeTransport = null;
+      transport.onClose = null;
+      transport.close();
+      throw err instanceof VrpcError ? err : new VrpcError(7 /* Unavailable */, `handshake failed: ${String(err)}`, { cause: err });
+    }
+  }
+  /** Waits until the client is open, connecting if idle. */
+  async ensureOpen(signal) {
+    if (this._status === "open") return;
+    if (this._status === "closed") throw errClientClosed();
+    if (this._status === "idle") {
+      await this.connect();
+      return;
+    }
+    const d = deferred();
+    this.openWaiters.push(d);
+    if (signal) {
+      const onAbort = () => d.reject(new VrpcError(2 /* Canceled */, "aborted while waiting for connection"));
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+    await d.promise;
+  }
+  onTransportClose(transport, err) {
+    if (transport !== this.transport) {
+      if (transport === this.handshakeTransport) {
+        this.handshakeWaiter?.reject(err ?? errConnectionLost());
+      }
+      return;
+    }
+    this.transport = null;
+    this.failAllInFlight(errConnectionLost());
+    if (this._status === "closed") return;
+    if (!this.reconnect.enabled) {
+      this.setStatus("closed");
+      return;
+    }
+    void this.resumeLoop();
+  }
+  async resumeLoop() {
+    if (this.resumeAbort) return;
+    this.setStatus("resuming");
+    try {
+      for (let attempt = 1; attempt <= this.reconnect.maxAttempts; attempt++) {
+        const abort = new AbortController();
+        this.resumeAbort = abort;
+        await sleep(backoffDelay(attempt, this.reconnect), abort.signal);
+        this.resumeAbort = null;
+        if (this._status === "closed") return;
+        if (abort.signal.aborted) attempt = 0;
+        this.reconnects++;
+        try {
+          await this.connect();
+          return;
+        } catch {
+        }
+      }
+      this.setStatus("closed");
+    } finally {
+      this.resumeAbort = null;
+    }
+  }
+  /** Browser wake hints: retry immediately when connectivity likely returned. */
+  installBrowserHints() {
+    if (this.hintsInstalled || typeof window === "undefined" || typeof window.addEventListener !== "function") {
+      return;
+    }
+    this.hintsInstalled = true;
+    const hint = () => {
+      if (this._status === "resuming") this.resumeAbort?.abort();
+    };
+    window.addEventListener("online", hint);
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "visible") hint();
+      });
+    }
+  }
+  failAllInFlight(err) {
+    const pending = [...this.pending.values()];
+    this.pending.clear();
+    for (const p of pending) p.fail(err);
+    const serving = [...this.serving.values()];
+    this.serving.clear();
+    for (const s of serving) s.close();
+  }
+  /** Closes the client permanently. */
+  close() {
+    if (this._status === "closed") return;
+    this.resumeAbort?.abort();
+    this.handshakeWaiter?.reject(errClientClosed());
+    const t = this.transport;
+    this.transport = null;
+    this.setStatus("closed");
+    this.failAllInFlight(errClientClosed());
+    t?.close();
+  }
+  // ---------------------------------------------------------------- sending
+  sendFrame(env) {
+    const t = this.transport;
+    if (!t) throw errConnectionLost();
+    t.send(this.codec.encode(env));
+  }
+  trySendFrame(env) {
+    try {
+      this.sendFrame(env);
+    } catch {
+    }
+  }
+  cancelRequest(requestId) {
+    this.trySendFrame(this.protocol.cancelRequest(requestId));
+  }
+  buildMetadata(name, callMd) {
+    const base = typeof this.opts.metadata === "function" ? this.opts.metadata(name) : this.opts.metadata;
+    if (!base && !callMd) return void 0;
+    return { ...base, ...callMd };
+  }
+  // ------------------------------------------------------------------ unary
+  /** Calls a unary function on the server. */
+  async call(name, args, opts = {}) {
+    await this.ensureOpen(opts.signal);
+    const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
+    const rid = ++this.nextRequestId;
+    const p = new PendingRequest(rid, "unary", name, 1);
+    this.pending.set(rid, p);
+    const settle = () => {
+      if (p.timer) clearTimeout(p.timer);
+      this.pending.delete(rid);
+    };
+    if (timeoutMs > 0) {
+      p.timer = setTimeout(() => {
+        this.cancelRequest(rid);
+        p.fail(new VrpcError(4 /* DeadlineExceeded */, `call ${name} timed out after ${timeoutMs}ms`));
+        settle();
+      }, timeoutMs);
+    }
+    if (opts.signal) {
+      const onAbort = () => {
+        this.cancelRequest(rid);
+        p.fail(new VrpcError(2 /* Canceled */, `call ${name} aborted`));
+        settle();
+      };
+      if (opts.signal.aborted) onAbort();
+      else opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      this.sendFrame(
+        this.protocol.request(2 /* FunctionRequest */, rid, name, args, timeoutMs, this.buildMetadata(name, opts.metadata))
+      );
+    } catch (err) {
+      p.fail(err instanceof VrpcError ? err : errConnectionLost());
+      settle();
+    }
+    try {
+      return await p.unary.promise;
+    } finally {
+      settle();
+    }
+  }
+  // ---------------------------------------------------------------- streams
+  /**
+   * Opens a server->client stream. Consume with `for await`; breaking out of
+   * the loop cancels the stream. Credit is granted as values are consumed, so
+   * a slow consumer applies real backpressure to the server.
+   */
+  getStream(name, args, opts = {}) {
+    const rid = ++this.nextRequestId;
+    const p = new PendingRequest(rid, "get", name, this.maxPending);
+    return this.openConsumingStream(p, 4 /* GetStreamRequest */, name, args, opts);
+  }
+  openConsumingStream(p, mt, name, args, opts) {
+    const rid = p.requestId;
+    this.pending.set(rid, p);
+    p.onConsume = () => {
+      p.delivered++;
+      const batch = Math.max(1, Math.floor(p.window / 2));
+      if (p.delivered >= batch) {
+        const n = p.delivered;
+        p.delivered = 0;
+        this.trySendFrame(this.protocol.streamCredit(rid, n));
+      }
+    };
+    const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
+    void this.establishStream(p, mt, name, args, timeoutMs, opts);
+    const self = this;
+    const iterator = {
+      requestId: rid,
+      ready: p.ready.promise,
+      async next() {
+        const q = p.queue;
+        const res = await q.next();
+        if (res.done) self.retireGetSide(p);
+        return res;
+      },
+      async return(value) {
+        iterator.cancel();
+        return { value, done: true };
+      },
+      async throw(err) {
+        iterator.cancel();
+        throw err;
+      },
+      cancel() {
+        if (p.getClosed && p.putClosed) return;
+        self.cancelRequest(rid);
+        p.finish();
+        self.pending.delete(rid);
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+    return iterator;
+  }
+  async establishStream(p, mt, name, args, timeoutMs, opts) {
+    const rid = p.requestId;
+    try {
+      await this.ensureOpen(opts.signal);
+      const establishTimer = setTimeout(() => {
+        if (!p.getClosed) {
+          this.cancelRequest(rid);
+          p.fail(new VrpcError(4 /* DeadlineExceeded */, `stream ${name} was not acked within ${timeoutMs}ms`));
+          this.pending.delete(rid);
+        }
+      }, timeoutMs);
+      p.ready.promise.then(
+        () => clearTimeout(establishTimer),
+        () => clearTimeout(establishTimer)
+      );
+      if (opts.signal) {
+        const onAbort = () => {
+          this.cancelRequest(rid);
+          p.fail(new VrpcError(2 /* Canceled */, `stream ${name} aborted`));
+          this.pending.delete(rid);
+        };
+        if (opts.signal.aborted) onAbort();
+        else opts.signal.addEventListener("abort", onAbort, { once: true });
+      }
+      this.sendFrame(
+        this.protocol.request(mt, rid, name, args, timeoutMs, this.buildMetadata(name, opts.metadata))
+      );
+      if (p.queue) {
+        p.ready.promise.then(
+          () => this.trySendFrame(this.protocol.streamCredit(rid, p.window)),
+          () => {
+          }
+        );
+      }
+    } catch (err) {
+      p.fail(err instanceof VrpcError ? err : new VrpcError(7 /* Unavailable */, String(err), { cause: err }));
+      this.pending.delete(rid);
+    }
+  }
+  retireGetSide(p) {
+    p.getClosed = true;
+    if (p.kind !== "chat" || p.putClosed) this.pending.delete(p.requestId);
+  }
+  /**
+   * Opens a client->server stream and sends every value from source, honoring
+   * the server's flow-control credit. Resolves once the stream ended cleanly.
+   */
+  async putStream(name, args, source, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
+    await this.ensureOpen(opts.signal);
+    const rid = ++this.nextRequestId;
+    const p = new PendingRequest(rid, "put", name, 1);
+    this.pending.set(rid, p);
+    const abortErr = () => p.error ?? new VrpcError(2 /* Canceled */, `stream ${name} aborted`);
+    if (opts.signal) {
+      const onAbort = () => {
+        this.cancelRequest(rid);
+        p.fail(new VrpcError(2 /* Canceled */, `stream ${name} aborted`));
+        this.pending.delete(rid);
+      };
+      if (opts.signal.aborted) onAbort();
+      else opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      const establishTimer = setTimeout(() => {
+        if (!p.putClosed) {
+          this.cancelRequest(rid);
+          p.fail(new VrpcError(4 /* DeadlineExceeded */, `stream ${name} was not acked within ${timeoutMs}ms`));
+          this.pending.delete(rid);
+        }
+      }, timeoutMs);
+      p.ready.promise.then(
+        () => clearTimeout(establishTimer),
+        () => clearTimeout(establishTimer)
+      );
+      this.sendFrame(
+        this.protocol.request(5 /* PutStreamRequest */, rid, name, args, timeoutMs, this.buildMetadata(name, opts.metadata))
+      );
+      await p.ready.promise;
+      for await (const v of source) {
+        const gate = p.sendCredit;
+        const ok = await gate.acquire();
+        if (!ok) throw abortErr();
+        this.sendFrame(this.protocol.streamValue(rid, v));
+      }
+      this.sendFrame(this.protocol.streamEnd(rid));
+      p.putClosed = true;
+    } finally {
+      p.finish();
+      this.pending.delete(rid);
+    }
+  }
+  /** Opens a bidirectional stream (chat). */
+  chat(name, args, opts = {}) {
+    const rid = ++this.nextRequestId;
+    const p = new PendingRequest(rid, "chat", name, this.maxPending);
+    const stream = this.openConsumingStream(p, 6 /* ChatRequest */, name, args, opts);
+    const self = this;
+    let ended = false;
+    return {
+      requestId: rid,
+      ready: p.ready.promise,
+      incoming: stream,
+      async send(v) {
+        if (ended) throw new VrpcError(9 /* Internal */, `chat ${name}: send after end`);
+        await p.ready.promise;
+        const ok = await p.sendCredit.acquire();
+        if (!ok) throw p.error ?? errConnectionLost();
+        self.sendFrame(self.protocol.streamValue(rid, v));
+      },
+      end() {
+        if (ended || p.putClosed) return;
+        ended = true;
+        p.ready.promise.then(
+          () => {
+            if (!p.putClosed) {
+              p.putClosed = true;
+              self.trySendFrame(self.protocol.streamEnd(rid));
+              if (p.getClosed) self.pending.delete(rid);
+            }
+          },
+          () => {
+          }
+        );
+      },
+      cancel() {
+        ended = true;
+        stream.cancel();
+      },
+      [Symbol.asyncIterator]() {
+        return stream;
+      }
+    };
+  }
+  // ------------------------------------------------- reverse-call registrar
+  /** Registers a unary function the server may call on this client. */
+  addFunction(name, fn) {
+    this.handlers.set(name, { kind: "unary", fn });
+  }
+  /** Registers a stream the server can consume from this client (GetStream). */
+  addOutgoingStream(name, fn) {
+    this.handlers.set(name, { kind: "out", fn });
+  }
+  /** Registers a stream the server can send to this client (PutStream). */
+  addIncomingStream(name, fn) {
+    this.handlers.set(name, { kind: "in", fn });
+  }
+  /** Registers a bidirectional stream the server can open (Chat). */
+  addChat(name, fn) {
+    this.handlers.set(name, { kind: "chat", fn });
+  }
+  removeHandler(name) {
+    this.handlers.delete(name);
+  }
+  // ------------------------------------------------------------- dispatch
+  onFrame(transport, data) {
+    if (transport !== this.transport && transport !== this.handshakeTransport) return;
+    let msg;
+    try {
+      msg = this.codec.decode(data);
+    } catch (err) {
+      this.emit("error", new VrpcError(9 /* Internal */, `malformed frame: ${String(err)}`, { cause: err }));
+      this.handshakeWaiter?.reject(new VrpcError(9 /* Internal */, `malformed handshake frame: ${String(err)}`));
+      transport.onClose = null;
+      transport.close();
+      this.onTransportClose(transport, errConnectionLost());
+      return;
+    }
+    const mt = this.protocol.messageType(msg);
+    if (mt === void 0) {
+      this.emit("error", new VrpcError(9 /* Internal */, "message type not found"));
+      return;
+    }
+    if (mt === 1 /* HandshakeResponse */) {
+      this.handshakeWaiter?.resolve(msg);
+      return;
+    }
+    if (mt === 2 /* FunctionRequest */) {
+      this.serveInboundCall(msg);
+      return;
+    }
+    if (mt === 4 /* GetStreamRequest */ || mt === 5 /* PutStreamRequest */ || mt === 6 /* ChatRequest */) {
+      this.serveInboundStream(mt, msg);
+      return;
+    }
+    const rid = this.protocol.requestId(msg);
+    if (rid === void 0) {
+      this.emit("error", new VrpcError(9 /* Internal */, "request id not found"));
+      return;
+    }
+    const sr = this.serving.get(rid);
+    if (sr) {
+      this.serveRunning(sr, mt, msg);
+      return;
+    }
+    const p = this.pending.get(rid);
+    if (p) {
+      this.processResponse(p, mt, msg);
+      return;
+    }
+    if (mt !== 9 /* StreamValue */ && mt !== 10 /* StreamEnd */ && mt !== 11 /* CancelRequest */) {
+      this.emit("error", new VrpcError(9 /* Internal */, `no request ${rid} for message type ${mt}`));
+    }
+  }
+  processResponse(p, mt, msg) {
+    switch (mt) {
+      case 3 /* FunctionResponse */: {
+        p.unary?.resolve(this.protocol.result(msg));
+        this.pending.delete(p.requestId);
+        break;
+      }
+      case 7 /* ErrorResponse */: {
+        const { code, message } = this.protocol.errorOf(msg);
+        p.fail(new VrpcError(code, message || "server error"));
+        this.pending.delete(p.requestId);
+        break;
+      }
+      case 8 /* StreamReady */: {
+        p.ready.resolve();
+        break;
+      }
+      case 9 /* StreamValue */: {
+        const v = this.protocol.streamVal(msg);
+        if (v === null || !p.queue) break;
+        if (!p.queue.push(v)) {
+          if (!p.queue.isEnded) {
+            const err = new VrpcError(
+              6 /* ResourceExhausted */,
+              `stream ${p.requestId} truncated: server exceeded flow-control credit`
+            );
+            this.cancelRequest(p.requestId);
+            p.fail(err);
+            this.pending.delete(p.requestId);
+          }
+        }
+        break;
+      }
+      case 10 /* StreamEnd */: {
+        const v = this.protocol.streamVal(msg);
+        if (v !== null && p.queue) p.queue.push(v);
+        p.queue?.end();
+        p.getClosed = true;
+        p.ready.resolve();
+        if (p.kind !== "chat" || p.putClosed) this.pending.delete(p.requestId);
+        break;
+      }
+      case 11 /* CancelRequest */: {
+        p.finish();
+        this.pending.delete(p.requestId);
+        break;
+      }
+      case 14 /* StreamCredit */: {
+        const cr = this.protocol.credit(msg);
+        if (cr !== void 0) p.sendCredit?.grant(cr);
+        break;
+      }
+      default:
+        this.emit("error", new VrpcError(9 /* Internal */, `unsupported message type ${mt}`));
+    }
+  }
+  // ------------------------------------------------------- reverse serving
+  handlerCtx(sr, msg) {
+    return {
+      requestId: sr.requestId,
+      metadata: this.protocol.metadata(msg),
+      signal: sr.abort.signal
+    };
+  }
+  serveInboundCall(msg) {
+    const rid = this.protocol.requestId(msg);
+    if (rid === void 0) {
+      this.emit("error", new VrpcError(9 /* Internal */, "reverse call without request id"));
+      return;
+    }
+    const name = this.protocol.functionName(msg);
+    if (name === void 0) {
+      this.trySendFrame(this.protocol.errorResponse(rid, 3 /* InvalidArgument */, "function name field not found"));
+      return;
+    }
+    const h = this.handlers.get(name);
+    if (!h) {
+      this.trySendFrame(this.protocol.errorResponse(rid, 5 /* NotFound */, `function not found ${name}`));
+      return;
+    }
+    if (h.kind !== "unary") {
+      this.trySendFrame(this.protocol.errorResponse(rid, 3 /* InvalidArgument */, `function '${name}' is not unary`));
+      return;
+    }
+    const sr = new ServingRequest(rid, "unary", 1);
+    const args = this.protocol.args(msg);
+    void (async () => {
+      try {
+        const res = await h.fn(args, this.handlerCtx(sr, msg));
+        this.trySendFrame(this.protocol.functionResult(rid, res ?? null));
+      } catch (err) {
+        this.trySendFrame(
+          this.protocol.errorResponse(rid, handlerCode(err), `function ${name}: ${errMessage(err)}`)
+        );
+      }
+    })();
+  }
+  serveInboundStream(mt, msg) {
+    const rid = this.protocol.requestId(msg);
+    if (rid === void 0) {
+      this.emit("error", new VrpcError(9 /* Internal */, "reverse stream without request id"));
+      return;
+    }
+    const name = this.protocol.functionName(msg);
+    if (name === void 0) {
+      this.trySendFrame(this.protocol.errorResponse(rid, 3 /* InvalidArgument */, "function name field not found"));
+      return;
+    }
+    const wanted = mt === 4 /* GetStreamRequest */ ? "out" : mt === 5 /* PutStreamRequest */ ? "in" : "chat";
+    const h = this.handlers.get(name);
+    if (!h) {
+      this.trySendFrame(this.protocol.errorResponse(rid, 5 /* NotFound */, `function not found ${name}`));
+      return;
+    }
+    if (h.kind !== wanted) {
+      this.trySendFrame(this.protocol.errorResponse(rid, 3 /* InvalidArgument */, `function '${name}' wrong stream type`));
+      return;
+    }
+    const sr = new ServingRequest(rid, wanted, this.maxPending);
+    this.serving.set(rid, sr);
+    const args = this.protocol.args(msg);
+    const ctx = this.handlerCtx(sr, msg);
+    if (sr.inQueue) {
+      sr.onConsume = () => {
+        sr.delivered++;
+        const batch = Math.max(1, Math.floor(sr.window / 2));
+        if (sr.delivered >= batch) {
+          const n = sr.delivered;
+          sr.delivered = 0;
+          this.trySendFrame(this.protocol.streamCredit(rid, n));
+        }
+      };
+      this.trySendFrame(this.protocol.streamCredit(rid, sr.window));
+    }
+    const incoming = sr.inQueue ? queueIterator(sr.inQueue) : emptyIterator();
+    void (async () => {
+      try {
+        if (wanted === "in") {
+          this.trySendFrame(this.protocol.streamReady(rid));
+          await h.fn(args, incoming, ctx);
+          return;
+        }
+        const iterable = await h.fn(args, incoming, ctx);
+        this.trySendFrame(this.protocol.streamReady(rid));
+        for await (const v of iterable) {
+          const gate = sr.sendCredit;
+          const ok = await gate.acquire();
+          if (!ok || sr.closed) return;
+          this.trySendFrame(this.protocol.streamValue(rid, v));
+        }
+        this.trySendFrame(this.protocol.streamEnd(rid));
+      } catch (err) {
+        if (!sr.closed) {
+          this.trySendFrame(
+            this.protocol.errorResponse(rid, handlerCode(err), `${kindLabel(wanted)} ${name}: ${errMessage(err)}`)
+          );
+        }
+      } finally {
+        if (wanted !== "in") {
+          this.serving.delete(rid);
+          sr.close();
+        }
+      }
+    })();
+  }
+  serveRunning(sr, mt, msg) {
+    switch (mt) {
+      case 11 /* CancelRequest */: {
+        this.serving.delete(sr.requestId);
+        sr.close();
+        break;
+      }
+      case 9 /* StreamValue */: {
+        const v = this.protocol.streamVal(msg);
+        if (v === null || !sr.inQueue) break;
+        if (!sr.inQueue.push(v) && !sr.inQueue.isEnded) {
+          this.trySendFrame(
+            this.protocol.errorResponse(
+              sr.requestId,
+              6 /* ResourceExhausted */,
+              `inbound stream ${sr.requestId} truncated: peer exceeded flow-control credit`
+            )
+          );
+          this.serving.delete(sr.requestId);
+          sr.close();
+        }
+        break;
+      }
+      case 10 /* StreamEnd */: {
+        const v = this.protocol.streamVal(msg);
+        if (v !== null && sr.inQueue) sr.inQueue.push(v);
+        sr.inQueue?.end();
+        if (sr.kind !== "chat") this.serving.delete(sr.requestId);
+        break;
+      }
+      case 14 /* StreamCredit */: {
+        const cr = this.protocol.credit(msg);
+        if (cr !== void 0) sr.sendCredit?.grant(cr);
+        break;
+      }
+      case 7 /* ErrorResponse */: {
+        const { code, message } = this.protocol.errorOf(msg);
+        this.emit("error", new VrpcError(code, `reverse stream ${sr.requestId}: ${message}`));
+        this.serving.delete(sr.requestId);
+        sr.close();
+        break;
+      }
+      default:
+        this.emit("error", new VrpcError(9 /* Internal */, `unsupported message type ${mt} for serving request`));
+    }
+  }
+};
+function handlerCode(err) {
+  const c = codeOf(err);
+  return c === 1 /* Unknown */ ? 9 /* Internal */ : c;
+}
+function errMessage(err) {
+  if (err instanceof VrpcError) return err.detail;
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function kindLabel(kind) {
+  switch (kind) {
+    case "out":
+      return "out stream";
+    case "in":
+      return "in stream";
+    case "chat":
+      return "chat";
+    default:
+      return "function";
+  }
+}
+function queueIterator(q) {
+  return {
+    next: () => q.next(),
+    async return(value) {
+      q.abort();
+      return { value, done: true };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function emptyIterator() {
+  return {
+    next: () => Promise.resolve({ value: void 0, done: true }),
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function createClient(options) {
+  return new VrpcClient(options);
+}
+
+// src/typed.ts
+function typedClient(client) {
+  return {
+    client,
+    call: (name, args, opts) => client.call(name, args, opts),
+    getStream: (name, args, opts) => client.getStream(name, args, opts),
+    putStream: (name, args, source, opts) => client.putStream(name, args, source, opts),
+    chat: (name, args, opts) => client.chat(name, args, opts)
+  };
+}
+export {
+  Code,
+  DEFAULT_LIMITS,
+  HashChain,
+  MessageType,
+  Protocol,
+  VrpcClient,
+  VrpcDecimal,
+  VrpcDouble,
+  VrpcError,
+  VrpcExt,
+  codeName,
+  codeOf,
+  codecByName,
+  createClient,
+  decimal,
+  double,
+  jsonCodec,
+  jsonDecode,
+  jsonEncode,
+  msgpackCodec,
+  msgpackDecode,
+  msgpackEncode,
+  newDialect,
+  typedClient,
+  webSocketDialer
+};
+//# sourceMappingURL=index.js.map