@zqagent/shared 0.0.0-stage → 0.3.8

package/dist/wire/index.js

@@ -0,0 +1,1181 @@
+// src/wire/utf8.ts
+var Utf8Error = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Utf8Error";
+  }
+};
+function utf8Encode(s) {
+  const buf = new Uint8Array(s.length * 4);
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    let cp = s.charCodeAt(i);
+    if (cp >= 55296 && cp <= 56319) {
+      const lo = i + 1 < s.length ? s.charCodeAt(i + 1) : 0;
+      if (lo < 56320 || lo > 57343) throw new Utf8Error("\u5B64\u7ACB\u7684 UTF-16 \u9AD8\u4EE3\u7406\u9879");
+      cp = 65536 + (cp - 55296 << 10) + (lo - 56320);
+      i++;
+    } else if (cp >= 56320 && cp <= 57343) {
+      throw new Utf8Error("\u5B64\u7ACB\u7684 UTF-16 \u4F4E\u4EE3\u7406\u9879");
+    }
+    if (cp < 128) {
+      buf[n++] = cp;
+    } else if (cp < 2048) {
+      buf[n++] = 192 | cp >> 6;
+      buf[n++] = 128 | cp & 63;
+    } else if (cp < 65536) {
+      buf[n++] = 224 | cp >> 12;
+      buf[n++] = 128 | cp >> 6 & 63;
+      buf[n++] = 128 | cp & 63;
+    } else {
+      buf[n++] = 240 | cp >> 18;
+      buf[n++] = 128 | cp >> 12 & 63;
+      buf[n++] = 128 | cp >> 6 & 63;
+      buf[n++] = 128 | cp & 63;
+    }
+  }
+  return buf.slice(0, n);
+}
+function utf8Decode(b) {
+  let out = "";
+  let i = 0;
+  while (i < b.length) {
+    const c = b[i];
+    if (c < 128) {
+      out += String.fromCharCode(c);
+      i++;
+      continue;
+    }
+    let cp;
+    let need;
+    let min;
+    if ((c & 224) === 192) {
+      cp = c & 31;
+      need = 1;
+      min = 128;
+    } else if ((c & 240) === 224) {
+      cp = c & 15;
+      need = 2;
+      min = 2048;
+    } else if ((c & 248) === 240) {
+      cp = c & 7;
+      need = 3;
+      min = 65536;
+    } else {
+      throw new Utf8Error(`\u975E\u6CD5 UTF-8 \u8D77\u59CB\u5B57\u8282 0x${c.toString(16)}`);
+    }
+    if (i + need >= b.length) throw new Utf8Error("UTF-8 \u5E8F\u5217\u88AB\u622A\u65AD");
+    for (let k = 1; k <= need; k++) {
+      const cc = b[i + k];
+      if ((cc & 192) !== 128) throw new Utf8Error(`\u975E\u6CD5 UTF-8 \u7EED\u63A5\u5B57\u8282 0x${cc.toString(16)}`);
+      cp = cp << 6 | cc & 63;
+    }
+    if (cp < min) throw new Utf8Error("UTF-8 \u8FC7\u957F\u7F16\u7801\uFF08overlong\uFF09");
+    if (cp > 1114111) throw new Utf8Error("\u7801\u70B9\u8D85\u51FA U+10FFFF");
+    if (cp >= 55296 && cp <= 57343) throw new Utf8Error("UTF-8 \u7F16\u7801\u4E86 UTF-16 \u4EE3\u7406\u9879");
+    i += need + 1;
+    if (cp < 65536) {
+      out += String.fromCharCode(cp);
+    } else {
+      const v = cp - 65536;
+      out += String.fromCharCode(55296 + (v >> 10), 56320 + (v & 1023));
+    }
+  }
+  return out;
+}
+
+// src/wire/varint.ts
+var WIRE_VARINT = 0;
+var WIRE_FIXED64 = 1;
+var WIRE_LEN = 2;
+var WIRE_FIXED32 = 5;
+var WireError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WireError";
+  }
+};
+var MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+var EMPTY = new Uint8Array(0);
+var Writer = class {
+  buf;
+  len = 0;
+  constructor(initialCapacity = 64) {
+    this.buf = new Uint8Array(Math.max(8, initialCapacity));
+  }
+  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;
+  }
+  /** 裸字节（帧头用，不带任何前缀） */
+  u8(b) {
+    this.ensure(1);
+    this.buf[this.len++] = b & 255;
+  }
+  raw(b) {
+    this.ensure(b.length);
+    this.buf.set(b, this.len);
+    this.len += b.length;
+  }
+  /** 无符号 varint（接受 number 或 bigint） */
+  varint(v) {
+    let x = typeof v === "bigint" ? v : BigInt(v);
+    if (x < 0n) throw new WireError("varint \u4E0D\u63A5\u53D7\u8D1F\u503C");
+    this.ensure(10);
+    while (x >= 0x80n) {
+      this.buf[this.len++] = Number(x & 0x7fn | 0x80n);
+      x >>= 7n;
+    }
+    this.buf[this.len++] = Number(x);
+  }
+  tag(field, wire) {
+    this.varint(field << 3 | wire);
+  }
+  /** length-delimited：长度 varint + 内容 */
+  lenPrefixed(b) {
+    this.varint(b.length);
+    this.raw(b);
+  }
+  // ---- proto3 字段：默认值不写线 ----
+  uint64Field(field, v) {
+    const x = typeof v === "bigint" ? v : BigInt(v);
+    if (x === 0n) return;
+    this.tag(field, WIRE_VARINT);
+    this.varint(x);
+  }
+  boolField(field, v) {
+    if (!v) return;
+    this.tag(field, WIRE_VARINT);
+    this.varint(1);
+  }
+  stringField(field, v) {
+    if (v === "") return;
+    this.tag(field, WIRE_LEN);
+    this.lenPrefixed(utf8Encode(v));
+  }
+  bytesField(field, v) {
+    if (v.length === 0) return;
+    this.tag(field, WIRE_LEN);
+    this.lenPrefixed(v);
+  }
+  finish() {
+    return this.buf.slice(0, this.len);
+  }
+  get length() {
+    return this.len;
+  }
+};
+var Reader = class {
+  constructor(buf) {
+    this.buf = buf;
+  }
+  buf;
+  pos = 0;
+  get remaining() {
+    return this.buf.length - this.pos;
+  }
+  get eof() {
+    return this.pos >= this.buf.length;
+  }
+  varint() {
+    let shift = 0n;
+    let result = 0n;
+    for (let i = 0; i < 10; i++) {
+      if (this.pos >= this.buf.length) throw new WireError("varint \u8D8A\u754C");
+      const b = this.buf[this.pos++];
+      result |= BigInt(b & 127) << shift;
+      if ((b & 128) === 0) {
+        if (i === 9 && b > 1) throw new WireError("varint \u6EA2\u51FA\uFF08\u8D85\u8FC7 64 \u4F4D\uFF09");
+        return result;
+      }
+      shift += 7n;
+    }
+    throw new WireError("varint \u8D85\u8FC7 10 \u5B57\u8282");
+  }
+  /** u64 → number（超安全整数范围即判错，避免静默精度丢失） */
+  u64() {
+    const v = this.varint();
+    if (v > MAX_SAFE) throw new WireError(`u64 \u8D85\u51FA JS \u5B89\u5168\u6574\u6570\u8303\u56F4: ${v}`);
+    return Number(v);
+  }
+  tag() {
+    const t = this.varint();
+    const field = Number(t >> 3n);
+    const wire = Number(t & 7n);
+    if (field <= 0) throw new WireError("\u5B57\u6BB5\u53F7\u5FC5\u987B \u2265 1");
+    return { field, wire };
+  }
+  /** 取 n 个字节（越界判错） */
+  take(n) {
+    if (!Number.isInteger(n) || n < 0) throw new WireError(`\u975E\u6CD5\u957F\u5EA6: ${n}`);
+    if (this.pos + n > this.buf.length) {
+      throw new WireError(`\u8BFB\u53D6\u8D8A\u754C\uFF1A\u9700\u8981 ${n} \u5B57\u8282\uFF0C\u5269\u4F59 ${this.buf.length - this.pos}`);
+    }
+    const out = this.buf.subarray(this.pos, this.pos + n);
+    this.pos += n;
+    return out;
+  }
+  /** length-delimited：读长度再取其内容 */
+  lenPrefixed() {
+    return this.take(this.u64());
+  }
+  string() {
+    return utf8Decode(this.lenPrefixed());
+  }
+  /** 跳过未知字段（前向兼容的关键：未来新增字段号不应导致解析失败） */
+  skip(wire) {
+    switch (wire) {
+      case WIRE_VARINT:
+        this.varint();
+        return;
+      case WIRE_LEN:
+        this.lenPrefixed();
+        return;
+      case WIRE_FIXED64:
+        this.take(8);
+        return;
+      case WIRE_FIXED32:
+        this.take(4);
+        return;
+      default:
+        throw new WireError(`\u4E0D\u652F\u6301\u7684 wire type: ${wire}`);
+    }
+  }
+};
+
+// src/wire/frame.ts
+var FRAME_MAGIC = [90, 81];
+var PROTOCOL_VERSION = 1;
+var MAX_FRAME_BYTES = 16 * 1024 * 1024;
+var CAP_DEFLATE = 1 << 0;
+var FrameType = {
+  /**
+   * 帧级压缩容器（原 `HELLO` 占位，从未实现握手）。
+   *
+   * payload = `[内部帧类型 1 字节][deflate-raw 压缩后的内部 payload]`；
+   * seq 沿用内层帧的 seq，解压后与原帧语义完全一致。
+   */
+  COMPRESSED: 0,
+  AUTH: 1,
+  SNAPSHOT: 2,
+  STATUS: 3,
+  INFO: 4,
+  EVENT: 5,
+  NOTIFY: 6,
+  CMD: 7,
+  ACK: 8,
+  SUBSCRIBE: 9,
+  UNSUBSCRIBE: 10,
+  RESUME: 11,
+  PING: 12,
+  PONG: 13,
+  /** 握手结果（服务端 → 客户端）。与 AUTH 分开，避免「同类型双向」的解析歧义 */
+  AUTH_OK: 14,
+  /**
+   * 命令终端数据（`TerminalData`）。
+   *
+   * 注意低 4 位的 16 个取值到此用尽：之后再扩帧类型只能升协议版本。
+   * 与 `EVENT` 分开是**性能隔离**（终端数据不进事件环形缓冲、不分配全局游标、
+   * 不走事件扇出队列），理由见 `proto/fleet.proto` 的 `TerminalData`。
+   */
+  TERMINAL: 15
+};
+var KNOWN_TYPES = new Set(Object.values(FrameType));
+var FrameError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FrameError";
+  }
+};
+var MIN_HEADER_BYTES = 5;
+var MAX_STREAM_BUFFER_BYTES = MAX_FRAME_BYTES * 2 + 64;
+function encodeFrame(frame) {
+  if (!Number.isInteger(frame.type) || frame.type < 0 || frame.type > 15) {
+    throw new FrameError(`\u975E\u6CD5\u5E27\u7C7B\u578B: ${frame.type}`);
+  }
+  if (frame.payload.length > MAX_FRAME_BYTES) {
+    throw new FrameError(`\u8F7D\u8377\u8D85\u9650: ${frame.payload.length} > ${MAX_FRAME_BYTES}`);
+  }
+  const w = new Writer(frame.payload.length + MIN_HEADER_BYTES);
+  w.u8(FRAME_MAGIC[0]);
+  w.u8(FRAME_MAGIC[1]);
+  w.u8(PROTOCOL_VERSION << 4 | frame.type);
+  w.varint(frame.seq);
+  w.varint(frame.payload.length);
+  w.raw(frame.payload);
+  return w.finish();
+}
+function decodeFrame(bytes) {
+  if (bytes.length < MIN_HEADER_BYTES) {
+    throw new FrameError(`\u5E27\u8FC7\u77ED: ${bytes.length} \u5B57\u8282`);
+  }
+  if (bytes[0] !== FRAME_MAGIC[0] || bytes[1] !== FRAME_MAGIC[1]) {
+    throw new FrameError("magic \u4E0D\u7B26\uFF08\u975E\u672C\u534F\u8BAE\u6D41\u91CF\uFF09");
+  }
+  const verType = bytes[2];
+  const version = verType >> 4;
+  const type = verType & 15;
+  if (version !== PROTOCOL_VERSION) {
+    throw new FrameError(`\u4E0D\u652F\u6301\u7684\u534F\u8BAE\u7248\u672C: ${version}`);
+  }
+  if (!KNOWN_TYPES.has(type)) {
+    throw new FrameError(`\u672A\u5B9A\u4E49\u7684\u5E27\u7C7B\u578B: ${type}`);
+  }
+  let r;
+  let seq;
+  let len;
+  try {
+    r = new Reader(bytes.subarray(3));
+    seq = r.u64();
+    len = r.u64();
+  } catch (e) {
+    throw new FrameError(`\u5E27\u5934\u89E3\u6790\u5931\u8D25: ${e instanceof WireError ? e.message : String(e)}`);
+  }
+  if (len > MAX_FRAME_BYTES) {
+    throw new FrameError(`\u8F7D\u8377\u8D85\u9650: ${len} > ${MAX_FRAME_BYTES}`);
+  }
+  if (r.remaining !== len) {
+    throw new FrameError(`len(${len}) \u4E0E\u5269\u4F59\u5B57\u8282(${r.remaining})\u4E0D\u7B26`);
+  }
+  const payload = r.take(len);
+  return { type, seq, payload };
+}
+function frameTypeName(type) {
+  for (const [name, value] of Object.entries(FrameType)) {
+    if (value === type) return name;
+  }
+  throw new FrameError(`\u672A\u5B9A\u4E49\u7684\u5E27\u7C7B\u578B: ${type}`);
+}
+function encodeCompressedPayload(innerType, deflated) {
+  if (innerType === FrameType.COMPRESSED) {
+    throw new FrameError("\u538B\u7F29\u5E27\u4E0D\u5F97\u5D4C\u5957");
+  }
+  const out = new Uint8Array(deflated.length + 1);
+  out[0] = innerType;
+  out.set(deflated, 1);
+  return out;
+}
+function decodeCompressedPayload(payload) {
+  if (payload.length < 2) return null;
+  const type = payload[0];
+  if (type === FrameType.COMPRESSED) return null;
+  if (!KNOWN_TYPES.has(type)) return null;
+  return { type, deflated: payload.subarray(1) };
+}
+function frameTypeFromName(name) {
+  if (name === "HELLO") return FrameType.COMPRESSED;
+  if (!(name in FrameType)) throw new FrameError(`\u672A\u77E5\u5E27\u7C7B\u578B\u540D: ${name}`);
+  return FrameType[name];
+}
+function peekVarint(b, at) {
+  let value = 0n;
+  let shift = 0n;
+  for (let i = 0; i < 10; i++) {
+    if (at + i >= b.length) return null;
+    const byte = b[at + i];
+    if (i === 9 && byte > 1) return "bad";
+    value |= BigInt(byte & 127) << shift;
+    if ((byte & 128) === 0) {
+      if (value > BigInt(Number.MAX_SAFE_INTEGER)) return "bad";
+      return { value: Number(value), size: i + 1 };
+    }
+    shift += 7n;
+  }
+  return "bad";
+}
+var StreamDecoder = class {
+  constructor(maxBuffer = MAX_STREAM_BUFFER_BYTES) {
+    this.maxBuffer = maxBuffer;
+  }
+  maxBuffer;
+  buf = new Uint8Array(0);
+  /** 已缓存但尚未解出的字节数 */
+  get buffered() {
+    return this.buf.length;
+  }
+  /** 丢弃缓存（协议错误后重新同步用） */
+  reset() {
+    this.buf = new Uint8Array(0);
+  }
+  push(chunk) {
+    if (this.buf.length === 0) {
+      this.buf = chunk.slice();
+    } else {
+      const next = new Uint8Array(this.buf.length + chunk.length);
+      next.set(this.buf, 0);
+      next.set(chunk, this.buf.length);
+      this.buf = next;
+    }
+    if (this.buf.length > this.maxBuffer) {
+      throw new FrameError(`\u63A5\u6536\u7F13\u51B2\u8D85\u9650: ${this.buf.length} > ${this.maxBuffer}`);
+    }
+  }
+  /** 解出下一帧；不足返回 `null`。协议错误抛 `FrameError`。 */
+  nextFrame() {
+    const b = this.buf;
+    if (b.length < MIN_HEADER_BYTES) return null;
+    if (b[0] !== FRAME_MAGIC[0] || b[1] !== FRAME_MAGIC[1]) {
+      throw new FrameError("magic \u4E0D\u7B26\uFF08\u975E\u672C\u534F\u8BAE\u6D41\u91CF\uFF09");
+    }
+    const verType = b[2];
+    const version = verType >> 4;
+    const type = verType & 15;
+    if (version !== PROTOCOL_VERSION) {
+      throw new FrameError(`\u4E0D\u652F\u6301\u7684\u534F\u8BAE\u7248\u672C: ${version}`);
+    }
+    if (!KNOWN_TYPES.has(type)) {
+      throw new FrameError(`\u672A\u5B9A\u4E49\u7684\u5E27\u7C7B\u578B: ${type}`);
+    }
+    const seqPeek = peekVarint(b, 3);
+    if (seqPeek === null) return null;
+    if (seqPeek === "bad") throw new FrameError("\u5E27\u5934 varint \u975E\u6CD5: seq");
+    const lenPeek = peekVarint(b, 3 + seqPeek.size);
+    if (lenPeek === null) return null;
+    if (lenPeek === "bad") throw new FrameError("\u5E27\u5934 varint \u975E\u6CD5: len");
+    if (lenPeek.value > MAX_FRAME_BYTES) {
+      throw new FrameError(`\u8F7D\u8377\u8D85\u9650: ${lenPeek.value} > ${MAX_FRAME_BYTES}`);
+    }
+    const header = 3 + seqPeek.size + lenPeek.size;
+    const total = header + lenPeek.value;
+    if (b.length < total) return null;
+    const payload = b.slice(header, total);
+    this.buf = b.subarray(total);
+    return { type, seq: seqPeek.value, payload };
+  }
+};
+
+// src/wire/messages.ts
+var MSG_KIND_NODE_STATE = 1;
+var MSG_KIND_STATUS = 2;
+function encodeEnvelope(env) {
+  const w = new Writer(128);
+  w.uint64Field(1, env.t);
+  w.stringField(2, env.nonce);
+  w.stringField(3, env.reqId);
+  w.stringField(4, env.type);
+  w.stringField(5, env.clientId);
+  w.stringField(6, env.nodeId);
+  w.stringField(7, env.projectId ?? "");
+  w.stringField(8, env.sessionId ?? "");
+  w.bytesField(9, env.payload ?? EMPTY);
+  w.uint64Field(10, env.timeoutMs ?? 0);
+  w.bytesField(11, env.sig ?? EMPTY);
+  return w.finish();
+}
+function signableBytes(env) {
+  return encodeEnvelope({ ...env, sig: void 0 });
+}
+function decodeEnvelope(bytes) {
+  const r = new Reader(bytes);
+  const env = { t: 0, nonce: "", reqId: "", type: "", clientId: "", nodeId: "" };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else env.t = r.u64();
+        break;
+      case 2:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else env.nonce = r.string();
+        break;
+      case 3:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else env.reqId = r.string();
+        break;
+      case 4:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else env.type = r.string();
+        break;
+      case 5:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else env.clientId = r.string();
+        break;
+      case 6:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else env.nodeId = r.string();
+        break;
+      case 7:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else env.projectId = r.string();
+        break;
+      case 8:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else env.sessionId = r.string();
+        break;
+      case 9:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else env.payload = r.lenPrefixed();
+        break;
+      case 10:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else env.timeoutMs = r.u64();
+        break;
+      case 11:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else env.sig = r.lenPrefixed();
+        break;
+      default:
+        r.skip(wire);
+    }
+  }
+  return env;
+}
+function encodeAck(ack) {
+  const w = new Writer(64);
+  w.stringField(1, ack.reqId);
+  w.stringField(2, ack.type);
+  w.boolField(3, ack.ok);
+  w.stringField(4, ack.error ?? "");
+  w.bytesField(5, ack.data ?? EMPTY);
+  return w.finish();
+}
+function decodeAck(bytes) {
+  const r = new Reader(bytes);
+  const ack = { reqId: "", type: "", ok: false };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else ack.reqId = r.string();
+        break;
+      case 2:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else ack.type = r.string();
+        break;
+      case 3:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else ack.ok = r.varint() !== 0n;
+        break;
+      case 4:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else ack.error = r.string();
+        break;
+      case 5:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else ack.data = r.lenPrefixed();
+        break;
+      default:
+        r.skip(wire);
+    }
+  }
+  return ack;
+}
+function encodeStatus(st) {
+  const w = new Writer(96);
+  w.stringField(1, st.nodeId);
+  w.boolField(2, st.online);
+  w.uint64Field(3, st.ts);
+  w.stringField(4, st.label ?? "");
+  w.stringField(5, st.platform ?? "");
+  w.stringField(6, st.mode ?? "");
+  w.stringField(7, st.version ?? "");
+  w.stringField(8, st.ip ?? "");
+  w.uint64Field(9, MSG_KIND_STATUS);
+  return w.finish();
+}
+function decodeStatus(bytes) {
+  const r = new Reader(bytes);
+  const st = { nodeId: "", online: false, ts: 0 };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else st.nodeId = r.string();
+        break;
+      case 2:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else st.online = r.varint() !== 0n;
+        break;
+      case 3:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else st.ts = r.u64();
+        break;
+      case 4:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else st.label = r.string();
+        break;
+      case 5:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else st.platform = r.string();
+        break;
+      case 6:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else st.mode = r.string();
+        break;
+      case 7:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else st.version = r.string();
+        break;
+      case 8:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else st.ip = r.string();
+        break;
+      case 9: {
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else checkMsgKind("Status", Number(r.varint()), MSG_KIND_STATUS);
+        break;
+      }
+      default:
+        r.skip(wire);
+    }
+  }
+  return st;
+}
+function encodeEvent(ev) {
+  const w = new Writer(128);
+  w.uint64Field(1, ev.seq);
+  w.uint64Field(2, ev.ts);
+  w.stringField(3, ev.type);
+  w.stringField(4, ev.projectId ?? "");
+  w.stringField(5, ev.sessionId ?? "");
+  w.bytesField(6, ev.data ?? EMPTY);
+  w.stringField(7, ev.nodeId ?? "");
+  return w.finish();
+}
+function decodeEvent(bytes) {
+  const r = new Reader(bytes);
+  const ev = { seq: 0, ts: 0, type: "" };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else ev.seq = r.u64();
+        break;
+      case 2:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else ev.ts = r.u64();
+        break;
+      case 3:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else ev.type = r.string();
+        break;
+      case 4:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else ev.projectId = r.string();
+        break;
+      case 5:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else ev.sessionId = r.string();
+        break;
+      case 6:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else ev.data = r.lenPrefixed();
+        break;
+      case 7:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else ev.nodeId = r.string();
+        break;
+      default:
+        r.skip(wire);
+    }
+  }
+  return ev;
+}
+function encodeInfo(info) {
+  const w = new Writer(96);
+  w.stringField(1, info.nodeId);
+  w.stringField(2, info.platform ?? "");
+  w.stringField(3, info.version ?? "");
+  w.stringField(4, info.ip ?? "");
+  w.uint64Field(5, info.projects);
+  w.uint64Field(6, info.sessions);
+  w.uint64Field(7, info.running);
+  w.uint64Field(8, info.waiting);
+  w.uint64Field(9, info.ts);
+  w.bytesField(10, info.detail ?? EMPTY);
+  return w.finish();
+}
+function decodeInfo(bytes) {
+  const r = new Reader(bytes);
+  const info = { nodeId: "", projects: 0, sessions: 0, running: 0, waiting: 0, ts: 0 };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else info.nodeId = r.string();
+        break;
+      case 2:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else info.platform = r.string();
+        break;
+      case 3:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else info.version = r.string();
+        break;
+      case 4:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else info.ip = r.string();
+        break;
+      case 5:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else info.projects = r.u64();
+        break;
+      case 6:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else info.sessions = r.u64();
+        break;
+      case 7:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else info.running = r.u64();
+        break;
+      case 8:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else info.waiting = r.u64();
+        break;
+      case 9:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else info.ts = r.u64();
+        break;
+      case 10:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else info.detail = r.lenPrefixed();
+        break;
+      default:
+        r.skip(wire);
+    }
+  }
+  return info;
+}
+function encodeNotify(n) {
+  const w = new Writer(160);
+  w.uint64Field(1, n.seq);
+  w.uint64Field(2, n.ts);
+  w.stringField(3, n.kind);
+  w.stringField(4, n.projectId ?? "");
+  w.stringField(5, n.sessionId ?? "");
+  w.bytesField(6, n.data ?? EMPTY);
+  w.stringField(7, n.nodeId ?? "");
+  return w.finish();
+}
+function decodeNotify(bytes) {
+  const r = new Reader(bytes);
+  const n = { seq: 0, ts: 0, kind: "" };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else n.seq = r.u64();
+        break;
+      case 2:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else n.ts = r.u64();
+        break;
+      case 3:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.kind = r.string();
+        break;
+      case 4:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.projectId = r.string();
+        break;
+      case 5:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.sessionId = r.string();
+        break;
+      case 6:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.data = r.lenPrefixed();
+        break;
+      case 7:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.nodeId = r.string();
+        break;
+      default:
+        r.skip(wire);
+    }
+  }
+  return n;
+}
+function encodeAuth(auth) {
+  const w = new Writer(64);
+  w.stringField(1, auth.id);
+  w.uint64Field(2, auth.ts);
+  w.stringField(3, auth.nonce);
+  w.uint64Field(4, auth.proto);
+  w.stringField(5, auth.kind);
+  w.stringField(6, auth.client ?? "");
+  w.bytesField(7, auth.token ?? EMPTY);
+  for (const id of auth.scope ?? []) w.stringField(8, id);
+  w.uint64Field(9, auth.expires ?? 0);
+  w.uint64Field(10, auth.caps ?? 0);
+  return w.finish();
+}
+function signableAuthBytes(auth) {
+  return encodeAuth({ ...auth, token: void 0 });
+}
+function decodeAuth(bytes) {
+  const r = new Reader(bytes);
+  const auth = { id: "", ts: 0, nonce: "", proto: 0, kind: "" };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else auth.id = r.string();
+        break;
+      case 2:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else auth.ts = r.u64();
+        break;
+      case 3:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else auth.nonce = r.string();
+        break;
+      case 4:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else auth.proto = r.u64();
+        break;
+      case 5:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else auth.kind = r.string();
+        break;
+      case 6:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else auth.client = r.string();
+        break;
+      case 7:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else auth.token = r.lenPrefixed();
+        break;
+      case 8:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else (auth.scope ??= []).push(r.string());
+        break;
+      case 9:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else auth.expires = r.u64();
+        break;
+      case 10:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else auth.caps = r.u64();
+        break;
+      default:
+        r.skip(wire);
+    }
+  }
+  return auth;
+}
+function encodeAuthOk(ok) {
+  const w = new Writer(48);
+  w.boolField(1, ok.ok);
+  w.stringField(2, ok.error ?? "");
+  w.uint64Field(3, ok.serverTs);
+  w.uint64Field(4, ok.caps ?? 0);
+  return w.finish();
+}
+function decodeAuthOk(bytes) {
+  const r = new Reader(bytes);
+  const out = { ok: false, serverTs: 0 };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else out.ok = r.varint() !== 0n;
+        break;
+      case 2:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else out.error = r.string();
+        break;
+      case 3:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else out.serverTs = r.u64();
+        break;
+      case 4:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else out.caps = r.u64();
+        break;
+      default:
+        r.skip(wire);
+    }
+  }
+  return out;
+}
+function encodeTerminalData(td) {
+  const w = new Writer(64 + (td.data?.length ?? 0));
+  w.stringField(1, td.nodeId ?? "");
+  w.stringField(2, td.terminalId);
+  w.stringField(3, td.kind);
+  w.bytesField(4, td.data ?? EMPTY);
+  w.uint64Field(5, td.seq ?? 0);
+  if (td.channel) w.uint64Field(6, td.channel);
+  if (td.session) w.stringField(7, td.session);
+  return w.finish();
+}
+function decodeTerminalData(bytes) {
+  const r = new Reader(bytes);
+  const td = { terminalId: "", kind: "" };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else td.nodeId = r.string();
+        break;
+      case 2:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else td.terminalId = r.string();
+        break;
+      case 3:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else td.kind = r.string();
+        break;
+      case 4:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else td.data = r.lenPrefixed();
+        break;
+      case 5:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else td.seq = r.u64();
+        break;
+      case 6:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else td.channel = r.u64();
+        break;
+      case 7:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else td.session = r.string();
+        break;
+      default:
+        r.skip(wire);
+    }
+  }
+  return td;
+}
+function encodeNodeState(n) {
+  const w = new Writer(96);
+  w.stringField(1, n.nodeId);
+  w.boolField(2, n.online);
+  w.uint64Field(3, n.lastSeen);
+  w.stringField(4, n.platform ?? "");
+  w.stringField(5, n.version ?? "");
+  w.stringField(6, n.ip ?? "");
+  w.bytesField(7, n.detail ?? EMPTY);
+  w.uint64Field(9, MSG_KIND_NODE_STATE);
+  return w.finish();
+}
+function decodeNodeState(bytes) {
+  const r = new Reader(bytes);
+  const n = { nodeId: "", online: false, lastSeen: 0 };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.nodeId = r.string();
+        break;
+      case 2:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else n.online = r.varint() !== 0n;
+        break;
+      case 3:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else n.lastSeen = r.u64();
+        break;
+      case 4:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.platform = r.string();
+        break;
+      case 5:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.version = r.string();
+        break;
+      case 6:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.ip = r.string();
+        break;
+      case 7:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else n.detail = r.lenPrefixed();
+        break;
+      case 9: {
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else checkMsgKind("NodeState", Number(r.varint()), MSG_KIND_NODE_STATE);
+        break;
+      }
+      default:
+        r.skip(wire);
+    }
+  }
+  return n;
+}
+function checkMsgKind(label, actual, expected) {
+  if (actual !== 0 && actual !== expected) {
+    throw new WireError(
+      `${label} \u5E27\u7684\u8EAB\u4EFD\u6807\u8BB0\u4E0D\u7B26\uFF08msg_kind=${actual}\uFF0C\u671F\u671B ${expected}\uFF09\uFF1A\u5F88\u53EF\u80FD\u7528\u9519\u4E86\u89E3\u7801\u5668`
+    );
+  }
+}
+function encodeSnapshot(snap) {
+  const w = new Writer(128);
+  for (const node of snap.nodes) {
+    w.tag(1, WIRE_LEN);
+    w.lenPrefixed(encodeNodeState(node));
+  }
+  w.uint64Field(2, snap.seq);
+  return w.finish();
+}
+function decodeSnapshot(bytes) {
+  const r = new Reader(bytes);
+  const snap = { nodes: [], seq: 0 };
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    switch (field) {
+      case 1:
+        if (wire !== WIRE_LEN) r.skip(wire);
+        else snap.nodes.push(decodeNodeState(r.lenPrefixed()));
+        break;
+      case 2:
+        if (wire !== WIRE_VARINT) r.skip(wire);
+        else snap.seq = r.u64();
+        break;
+      default:
+        r.skip(wire);
+    }
+  }
+  return snap;
+}
+function encodeNodeIds(ids) {
+  const w = new Writer(64);
+  for (const id of ids) w.stringField(1, id);
+  return w.finish();
+}
+function decodeNodeIds(bytes) {
+  const r = new Reader(bytes);
+  const ids = [];
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    if (field === 1 && wire === WIRE_LEN) ids.push(r.string());
+    else r.skip(wire);
+  }
+  return ids;
+}
+function encodeSubscribe(ids, noDetail = false) {
+  if (!noDetail) return encodeNodeIds(ids);
+  const w = new Writer(64);
+  for (const id of ids) w.stringField(1, id);
+  w.boolField(2, true);
+  return w.finish();
+}
+var decodeSubscribe = decodeNodeIds;
+function decodeSubscribeDetail(bytes) {
+  const r = new Reader(bytes);
+  const nodeIds = [];
+  let noDetail = false;
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    if (field === 1 && wire === WIRE_LEN) nodeIds.push(r.string());
+    else if (field === 2 && wire === WIRE_VARINT) noDetail = r.varint() !== 0n;
+    else r.skip(wire);
+  }
+  return { nodeIds, noDetail };
+}
+var encodeUnsubscribe = encodeNodeIds;
+var decodeUnsubscribe = decodeNodeIds;
+function encodeResume(since, nodeIds = []) {
+  const w = new Writer(16 + nodeIds.length * 16);
+  w.uint64Field(1, since);
+  for (const id of nodeIds) w.stringField(2, id);
+  return w.finish();
+}
+function decodeResume(bytes) {
+  const r = new Reader(bytes);
+  let since = 0;
+  const nodeIds = [];
+  while (!r.eof) {
+    const { field, wire } = r.tag();
+    if (field === 1 && wire === WIRE_VARINT) since = r.u64();
+    else if (field === 2 && wire === WIRE_LEN) nodeIds.push(r.string());
+    else r.skip(wire);
+  }
+  return { since, nodeIds };
+}
+
+// src/wire/hex.ts
+function toHex(bytes) {
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function fromHex(hex) {
+  const s = hex.trim();
+  if (s.length % 2 !== 0) throw new Error(`\u5341\u516D\u8FDB\u5236\u957F\u5EA6\u5FC5\u987B\u4E3A\u5076\u6570: ${s.length}`);
+  const out = new Uint8Array(s.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    const byte = Number.parseInt(s.slice(i * 2, i * 2 + 2), 16);
+    if (Number.isNaN(byte)) throw new Error(`\u975E\u6CD5\u5341\u516D\u8FDB\u5236\u5185\u5BB9: ${s.slice(i * 2, i * 2 + 2)}`);
+    out[i] = byte;
+  }
+  return out;
+}
+export {
+  CAP_DEFLATE,
+  EMPTY as EMPTY_BYTES,
+  FRAME_MAGIC,
+  FrameError,
+  FrameType,
+  MAX_FRAME_BYTES,
+  MAX_STREAM_BUFFER_BYTES,
+  PROTOCOL_VERSION,
+  Reader,
+  StreamDecoder,
+  Utf8Error,
+  WIRE_FIXED32,
+  WIRE_FIXED64,
+  WIRE_LEN,
+  WIRE_VARINT,
+  WireError,
+  Writer,
+  decodeAck,
+  decodeAuth,
+  decodeAuthOk,
+  decodeCompressedPayload,
+  decodeEnvelope,
+  decodeEvent,
+  decodeFrame,
+  decodeInfo,
+  decodeNodeState,
+  decodeNotify,
+  decodeResume,
+  decodeSnapshot,
+  decodeStatus,
+  decodeSubscribe,
+  decodeSubscribeDetail,
+  decodeTerminalData,
+  decodeUnsubscribe,
+  encodeAck,
+  encodeAuth,
+  encodeAuthOk,
+  encodeCompressedPayload,
+  encodeEnvelope,
+  encodeEvent,
+  encodeFrame,
+  encodeInfo,
+  encodeNodeState,
+  encodeNotify,
+  encodeResume,
+  encodeSnapshot,
+  encodeStatus,
+  encodeSubscribe,
+  encodeTerminalData,
+  encodeUnsubscribe,
+  frameTypeFromName,
+  frameTypeName,
+  fromHex,
+  signableAuthBytes,
+  signableBytes,
+  toHex,
+  utf8Decode,
+  utf8Encode
+};
+//# sourceMappingURL=index.js.map