@interncom/diplomatic 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -34,9 +34,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/file-saver/dist/FileSaver.min.js
+// ../node_modules/.bun/file-saver@2.0.5/node_modules/file-saver/dist/FileSaver.min.js
 var require_FileSaver_min = __commonJS({
-  "node_modules/file-saver/dist/FileSaver.min.js"(exports2, module) {
+  "../node_modules/.bun/file-saver@2.0.5/node_modules/file-saver/dist/FileSaver.min.js"(exports2, module) {
     "use strict";
     (function(a, b) {
       if ("function" == typeof define && define.amd) define([], b);
@@ -112,13 +112,13 @@ var require_FileSaver_min = __commonJS({
   }
 });
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/utf8.mjs
 function utf8Count(str) {
-  var strLength = str.length;
-  var byteLength = 0;
-  var pos = 0;
+  const strLength = str.length;
+  let byteLength = 0;
+  let pos = 0;
   while (pos < strLength) {
-    var value = str.charCodeAt(pos++);
+    let value = str.charCodeAt(pos++);
     if ((value & 4294967168) === 0) {
       byteLength++;
       continue;
@@ -127,7 +127,7 @@ function utf8Count(str) {
     } else {
       if (value >= 55296 && value <= 56319) {
         if (pos < strLength) {
-          var extra = str.charCodeAt(pos);
+          const extra = str.charCodeAt(pos);
           if ((extra & 64512) === 56320) {
             ++pos;
             value = ((value & 1023) << 10) + (extra & 1023) + 65536;
@@ -144,11 +144,11 @@ function utf8Count(str) {
   return byteLength;
 }
 function utf8EncodeJs(str, output, outputOffset) {
-  var strLength = str.length;
-  var offset2 = outputOffset;
-  var pos = 0;
+  const strLength = str.length;
+  let offset2 = outputOffset;
+  let pos = 0;
   while (pos < strLength) {
-    var value = str.charCodeAt(pos++);
+    let value = str.charCodeAt(pos++);
     if ((value & 4294967168) === 0) {
       output[offset2++] = value;
       continue;
@@ -157,7 +157,7 @@ function utf8EncodeJs(str, output, outputOffset) {
     } else {
       if (value >= 55296 && value <= 56319) {
         if (pos < strLength) {
-          var extra = str.charCodeAt(pos);
+          const extra = str.charCodeAt(pos);
           if ((extra & 64512) === 56320) {
             ++pos;
             value = ((value & 1023) << 10) + (extra & 1023) + 65536;
@@ -190,26 +190,26 @@ function utf8Encode(str, output, outputOffset) {
 }
 var CHUNK_SIZE = 4096;
 function utf8DecodeJs(bytes, inputOffset, byteLength) {
-  var offset2 = inputOffset;
-  var end = offset2 + byteLength;
-  var units = [];
-  var result = "";
+  let offset2 = inputOffset;
+  const end = offset2 + byteLength;
+  const units = [];
+  let result = "";
   while (offset2 < end) {
-    var byte1 = bytes[offset2++];
+    const byte1 = bytes[offset2++];
     if ((byte1 & 128) === 0) {
       units.push(byte1);
     } else if ((byte1 & 224) === 192) {
-      var byte2 = bytes[offset2++] & 63;
+      const byte2 = bytes[offset2++] & 63;
       units.push((byte1 & 31) << 6 | byte2);
     } else if ((byte1 & 240) === 224) {
-      var byte2 = bytes[offset2++] & 63;
-      var byte3 = bytes[offset2++] & 63;
+      const byte2 = bytes[offset2++] & 63;
+      const byte3 = bytes[offset2++] & 63;
       units.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
     } else if ((byte1 & 248) === 240) {
-      var byte2 = bytes[offset2++] & 63;
-      var byte3 = bytes[offset2++] & 63;
-      var byte4 = bytes[offset2++] & 63;
-      var unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+      const byte2 = bytes[offset2++] & 63;
+      const byte3 = bytes[offset2++] & 63;
+      const byte4 = bytes[offset2++] & 63;
+      let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
       if (unit > 65535) {
         unit -= 65536;
         units.push(unit >>> 10 & 1023 | 55296);
@@ -220,19 +220,19 @@ function utf8DecodeJs(bytes, inputOffset, byteLength) {
       units.push(byte1);
     }
     if (units.length >= CHUNK_SIZE) {
-      result += String.fromCharCode.apply(String, units);
+      result += String.fromCharCode(...units);
       units.length = 0;
     }
   }
   if (units.length > 0) {
-    result += String.fromCharCode.apply(String, units);
+    result += String.fromCharCode(...units);
   }
   return result;
 }
 var sharedTextDecoder = new TextDecoder();
 var TEXT_DECODER_THRESHOLD = 200;
 function utf8DecodeTD(bytes, inputOffset, byteLength) {
-  var stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+  const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
   return sharedTextDecoder.decode(stringBytes);
 }
 function utf8Decode(bytes, inputOffset, byteLength) {
@@ -243,116 +243,88 @@ function utf8Decode(bytes, inputOffset, byteLength) {
   }
 }
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/ExtData.mjs
-var ExtData = (
-  /** @class */
-  /* @__PURE__ */ function() {
-    function ExtData2(type, data) {
-      this.type = type;
-      this.data = data;
-    }
-    return ExtData2;
-  }()
-);
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/ExtData.mjs
+var ExtData = class {
+  type;
+  data;
+  constructor(type, data) {
+    this.type = type;
+    this.data = data;
+  }
+};
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/DecodeError.mjs
-var __extends = /* @__PURE__ */ function() {
-  var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-      d2.__proto__ = b2;
-    } || function(d2, b2) {
-      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
-    };
-    return extendStatics(d, b);
-  };
-  return function(d, b) {
-    if (typeof b !== "function" && b !== null)
-      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() {
-      this.constructor = d;
-    }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  };
-}();
-var DecodeError = (
-  /** @class */
-  function(_super) {
-    __extends(DecodeError2, _super);
-    function DecodeError2(message) {
-      var _this = _super.call(this, message) || this;
-      var proto = Object.create(DecodeError2.prototype);
-      Object.setPrototypeOf(_this, proto);
-      Object.defineProperty(_this, "name", {
-        configurable: true,
-        enumerable: false,
-        value: DecodeError2.name
-      });
-      return _this;
-    }
-    return DecodeError2;
-  }(Error)
-);
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/DecodeError.mjs
+var DecodeError = class _DecodeError extends Error {
+  constructor(message) {
+    super(message);
+    const proto = Object.create(_DecodeError.prototype);
+    Object.setPrototypeOf(this, proto);
+    Object.defineProperty(this, "name", {
+      configurable: true,
+      enumerable: false,
+      value: _DecodeError.name
+    });
+  }
+};
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/int.mjs
 var UINT32_MAX = 4294967295;
 function setUint64(view, offset2, value) {
-  var high = value / 4294967296;
-  var low = value;
+  const high = value / 4294967296;
+  const low = value;
   view.setUint32(offset2, high);
   view.setUint32(offset2 + 4, low);
 }
 function setInt64(view, offset2, value) {
-  var high = Math.floor(value / 4294967296);
-  var low = value;
+  const high = Math.floor(value / 4294967296);
+  const low = value;
   view.setUint32(offset2, high);
   view.setUint32(offset2 + 4, low);
 }
 function getInt64(view, offset2) {
-  var high = view.getInt32(offset2);
-  var low = view.getUint32(offset2 + 4);
+  const high = view.getInt32(offset2);
+  const low = view.getUint32(offset2 + 4);
   return high * 4294967296 + low;
 }
 function getUint64(view, offset2) {
-  var high = view.getUint32(offset2);
-  var low = view.getUint32(offset2 + 4);
+  const high = view.getUint32(offset2);
+  const low = view.getUint32(offset2 + 4);
   return high * 4294967296 + low;
 }
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/timestamp.mjs
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/timestamp.mjs
 var EXT_TIMESTAMP = -1;
 var TIMESTAMP32_MAX_SEC = 4294967296 - 1;
 var TIMESTAMP64_MAX_SEC = 17179869184 - 1;
-function encodeTimeSpecToTimestamp(_a) {
-  var sec = _a.sec, nsec = _a.nsec;
+function encodeTimeSpecToTimestamp({ sec, nsec }) {
   if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
     if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
-      var rv = new Uint8Array(4);
-      var view = new DataView(rv.buffer);
+      const rv = new Uint8Array(4);
+      const view = new DataView(rv.buffer);
       view.setUint32(0, sec);
       return rv;
     } else {
-      var secHigh = sec / 4294967296;
-      var secLow = sec & 4294967295;
-      var rv = new Uint8Array(8);
-      var view = new DataView(rv.buffer);
+      const secHigh = sec / 4294967296;
+      const secLow = sec & 4294967295;
+      const rv = new Uint8Array(8);
+      const view = new DataView(rv.buffer);
       view.setUint32(0, nsec << 2 | secHigh & 3);
       view.setUint32(4, secLow);
       return rv;
     }
   } else {
-    var rv = new Uint8Array(12);
-    var view = new DataView(rv.buffer);
+    const rv = new Uint8Array(12);
+    const view = new DataView(rv.buffer);
     view.setUint32(0, nsec);
     setInt64(view, 4, sec);
     return rv;
   }
 }
 function encodeDateToTimeSpec(date) {
-  var msec = date.getTime();
-  var sec = Math.floor(msec / 1e3);
-  var nsec = (msec - sec * 1e3) * 1e6;
-  var nsecInSec = Math.floor(nsec / 1e9);
+  const msec = date.getTime();
+  const sec = Math.floor(msec / 1e3);
+  const nsec = (msec - sec * 1e3) * 1e6;
+  const nsecInSec = Math.floor(nsec / 1e9);
   return {
     sec: sec + nsecInSec,
     nsec: nsec - nsecInSec * 1e9
@@ -360,38 +332,38 @@ function encodeDateToTimeSpec(date) {
 }
 function encodeTimestampExtension(object) {
   if (object instanceof Date) {
-    var timeSpec = encodeDateToTimeSpec(object);
+    const timeSpec = encodeDateToTimeSpec(object);
     return encodeTimeSpecToTimestamp(timeSpec);
   } else {
     return null;
   }
 }
 function decodeTimestampToTimeSpec(data) {
-  var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
   switch (data.byteLength) {
     case 4: {
-      var sec = view.getUint32(0);
-      var nsec = 0;
+      const sec = view.getUint32(0);
+      const nsec = 0;
       return { sec, nsec };
     }
     case 8: {
-      var nsec30AndSecHigh2 = view.getUint32(0);
-      var secLow32 = view.getUint32(4);
-      var sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
-      var nsec = nsec30AndSecHigh2 >>> 2;
+      const nsec30AndSecHigh2 = view.getUint32(0);
+      const secLow32 = view.getUint32(4);
+      const sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
+      const nsec = nsec30AndSecHigh2 >>> 2;
       return { sec, nsec };
     }
     case 12: {
-      var sec = getInt64(view, 4);
-      var nsec = view.getUint32(0);
+      const sec = getInt64(view, 4);
+      const nsec = view.getUint32(0);
       return { sec, nsec };
     }
     default:
-      throw new DecodeError("Unrecognized data size for timestamp (expected 4, 8, or 12): ".concat(data.length));
+      throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
   }
 }
 function decodeTimestampExtension(data) {
-  var timeSpec = decodeTimestampToTimeSpec(data);
+  const timeSpec = decodeTimestampToTimeSpec(data);
   return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
 }
 var timestampExtension = {
@@ -400,667 +372,629 @@ var timestampExtension = {
   decode: decodeTimestampExtension
 };
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/ExtensionCodec.mjs
-var ExtensionCodec = (
-  /** @class */
-  function() {
-    function ExtensionCodec2() {
-      this.builtInEncoders = [];
-      this.builtInDecoders = [];
-      this.encoders = [];
-      this.decoders = [];
-      this.register(timestampExtension);
-    }
-    ExtensionCodec2.prototype.register = function(_a) {
-      var type = _a.type, encode2 = _a.encode, decode2 = _a.decode;
-      if (type >= 0) {
-        this.encoders[type] = encode2;
-        this.decoders[type] = decode2;
-      } else {
-        var index = 1 + type;
-        this.builtInEncoders[index] = encode2;
-        this.builtInDecoders[index] = decode2;
-      }
-    };
-    ExtensionCodec2.prototype.tryToEncode = function(object, context) {
-      for (var i = 0; i < this.builtInEncoders.length; i++) {
-        var encodeExt = this.builtInEncoders[i];
-        if (encodeExt != null) {
-          var data = encodeExt(object, context);
-          if (data != null) {
-            var type = -1 - i;
-            return new ExtData(type, data);
-          }
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/ExtensionCodec.mjs
+var ExtensionCodec = class _ExtensionCodec {
+  static defaultCodec = new _ExtensionCodec();
+  // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
+  // this will make type errors a lot more clear
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  __brand;
+  // built-in extensions
+  builtInEncoders = [];
+  builtInDecoders = [];
+  // custom extensions
+  encoders = [];
+  decoders = [];
+  constructor() {
+    this.register(timestampExtension);
+  }
+  register({ type, encode: encode2, decode: decode2 }) {
+    if (type >= 0) {
+      this.encoders[type] = encode2;
+      this.decoders[type] = decode2;
+    } else {
+      const index = -1 - type;
+      this.builtInEncoders[index] = encode2;
+      this.builtInDecoders[index] = decode2;
+    }
+  }
+  tryToEncode(object, context) {
+    for (let i = 0; i < this.builtInEncoders.length; i++) {
+      const encodeExt = this.builtInEncoders[i];
+      if (encodeExt != null) {
+        const data = encodeExt(object, context);
+        if (data != null) {
+          const type = -1 - i;
+          return new ExtData(type, data);
         }
       }
-      for (var i = 0; i < this.encoders.length; i++) {
-        var encodeExt = this.encoders[i];
-        if (encodeExt != null) {
-          var data = encodeExt(object, context);
-          if (data != null) {
-            var type = i;
-            return new ExtData(type, data);
-          }
+    }
+    for (let i = 0; i < this.encoders.length; i++) {
+      const encodeExt = this.encoders[i];
+      if (encodeExt != null) {
+        const data = encodeExt(object, context);
+        if (data != null) {
+          const type = i;
+          return new ExtData(type, data);
         }
       }
-      if (object instanceof ExtData) {
-        return object;
-      }
-      return null;
-    };
-    ExtensionCodec2.prototype.decode = function(data, type, context) {
-      var decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
-      if (decodeExt) {
-        return decodeExt(data, type, context);
-      } else {
-        return new ExtData(type, data);
-      }
-    };
-    ExtensionCodec2.defaultCodec = new ExtensionCodec2();
-    return ExtensionCodec2;
-  }()
-);
+    }
+    if (object instanceof ExtData) {
+      return object;
+    }
+    return null;
+  }
+  decode(data, type, context) {
+    const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+    if (decodeExt) {
+      return decodeExt(data, type, context);
+    } else {
+      return new ExtData(type, data);
+    }
+  }
+};
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/utils/typedArrays.mjs
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/typedArrays.mjs
+function isArrayBufferLike(buffer) {
+  return buffer instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+}
 function ensureUint8Array(buffer) {
   if (buffer instanceof Uint8Array) {
     return buffer;
   } else if (ArrayBuffer.isView(buffer)) {
     return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-  } else if (buffer instanceof ArrayBuffer) {
+  } else if (isArrayBufferLike(buffer)) {
     return new Uint8Array(buffer);
   } else {
     return Uint8Array.from(buffer);
   }
 }
-function createDataView(buffer) {
-  if (buffer instanceof ArrayBuffer) {
-    return new DataView(buffer);
-  }
-  var bufferView = ensureUint8Array(buffer);
-  return new DataView(bufferView.buffer, bufferView.byteOffset, bufferView.byteLength);
-}
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/Encoder.mjs
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/Encoder.mjs
 var DEFAULT_MAX_DEPTH = 100;
 var DEFAULT_INITIAL_BUFFER_SIZE = 2048;
-var Encoder = (
-  /** @class */
-  function() {
-    function Encoder3(options) {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
-      this.extensionCodec = (_a = options === null || options === void 0 ? void 0 : options.extensionCodec) !== null && _a !== void 0 ? _a : ExtensionCodec.defaultCodec;
-      this.context = options === null || options === void 0 ? void 0 : options.context;
-      this.useBigInt64 = (_b = options === null || options === void 0 ? void 0 : options.useBigInt64) !== null && _b !== void 0 ? _b : false;
-      this.maxDepth = (_c = options === null || options === void 0 ? void 0 : options.maxDepth) !== null && _c !== void 0 ? _c : DEFAULT_MAX_DEPTH;
-      this.initialBufferSize = (_d = options === null || options === void 0 ? void 0 : options.initialBufferSize) !== null && _d !== void 0 ? _d : DEFAULT_INITIAL_BUFFER_SIZE;
-      this.sortKeys = (_e = options === null || options === void 0 ? void 0 : options.sortKeys) !== null && _e !== void 0 ? _e : false;
-      this.forceFloat32 = (_f = options === null || options === void 0 ? void 0 : options.forceFloat32) !== null && _f !== void 0 ? _f : false;
-      this.ignoreUndefined = (_g = options === null || options === void 0 ? void 0 : options.ignoreUndefined) !== null && _g !== void 0 ? _g : false;
-      this.forceIntegerToFloat = (_h = options === null || options === void 0 ? void 0 : options.forceIntegerToFloat) !== null && _h !== void 0 ? _h : false;
-      this.pos = 0;
-      this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
-      this.bytes = new Uint8Array(this.view.buffer);
-    }
-    Encoder3.prototype.reinitializeState = function() {
-      this.pos = 0;
-    };
-    Encoder3.prototype.encodeSharedRef = function(object) {
+var Encoder = class _Encoder {
+  extensionCodec;
+  context;
+  useBigInt64;
+  maxDepth;
+  initialBufferSize;
+  sortKeys;
+  forceFloat32;
+  ignoreUndefined;
+  forceIntegerToFloat;
+  pos;
+  view;
+  bytes;
+  entered = false;
+  constructor(options) {
+    this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+    this.context = options?.context;
+    this.useBigInt64 = options?.useBigInt64 ?? false;
+    this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+    this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
+    this.sortKeys = options?.sortKeys ?? false;
+    this.forceFloat32 = options?.forceFloat32 ?? false;
+    this.ignoreUndefined = options?.ignoreUndefined ?? false;
+    this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+    this.pos = 0;
+    this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+    this.bytes = new Uint8Array(this.view.buffer);
+  }
+  clone() {
+    return new _Encoder({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      maxDepth: this.maxDepth,
+      initialBufferSize: this.initialBufferSize,
+      sortKeys: this.sortKeys,
+      forceFloat32: this.forceFloat32,
+      ignoreUndefined: this.ignoreUndefined,
+      forceIntegerToFloat: this.forceIntegerToFloat
+    });
+  }
+  reinitializeState() {
+    this.pos = 0;
+  }
+  /**
+   * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+   *
+   * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+   */
+  encodeSharedRef(object) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.encodeSharedRef(object);
+    }
+    try {
+      this.entered = true;
       this.reinitializeState();
       this.doEncode(object, 1);
       return this.bytes.subarray(0, this.pos);
-    };
-    Encoder3.prototype.encode = function(object) {
+    } finally {
+      this.entered = false;
+    }
+  }
+  /**
+   * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+   */
+  encode(object) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.encode(object);
+    }
+    try {
+      this.entered = true;
       this.reinitializeState();
       this.doEncode(object, 1);
       return this.bytes.slice(0, this.pos);
-    };
-    Encoder3.prototype.doEncode = function(object, depth) {
-      if (depth > this.maxDepth) {
-        throw new Error("Too deep objects in depth ".concat(depth));
+    } finally {
+      this.entered = false;
+    }
+  }
+  doEncode(object, depth) {
+    if (depth > this.maxDepth) {
+      throw new Error(`Too deep objects in depth ${depth}`);
+    }
+    if (object == null) {
+      this.encodeNil();
+    } else if (typeof object === "boolean") {
+      this.encodeBoolean(object);
+    } else if (typeof object === "number") {
+      if (!this.forceIntegerToFloat) {
+        this.encodeNumber(object);
+      } else {
+        this.encodeNumberAsFloat(object);
       }
-      if (object == null) {
-        this.encodeNil();
-      } else if (typeof object === "boolean") {
-        this.encodeBoolean(object);
-      } else if (typeof object === "number") {
-        if (!this.forceIntegerToFloat) {
-          this.encodeNumber(object);
+    } else if (typeof object === "string") {
+      this.encodeString(object);
+    } else if (this.useBigInt64 && typeof object === "bigint") {
+      this.encodeBigInt64(object);
+    } else {
+      this.encodeObject(object, depth);
+    }
+  }
+  ensureBufferSizeToWrite(sizeToWrite) {
+    const requiredSize = this.pos + sizeToWrite;
+    if (this.view.byteLength < requiredSize) {
+      this.resizeBuffer(requiredSize * 2);
+    }
+  }
+  resizeBuffer(newSize) {
+    const newBuffer = new ArrayBuffer(newSize);
+    const newBytes = new Uint8Array(newBuffer);
+    const newView = new DataView(newBuffer);
+    newBytes.set(this.bytes);
+    this.view = newView;
+    this.bytes = newBytes;
+  }
+  encodeNil() {
+    this.writeU8(192);
+  }
+  encodeBoolean(object) {
+    if (object === false) {
+      this.writeU8(194);
+    } else {
+      this.writeU8(195);
+    }
+  }
+  encodeNumber(object) {
+    if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+      if (object >= 0) {
+        if (object < 128) {
+          this.writeU8(object);
+        } else if (object < 256) {
+          this.writeU8(204);
+          this.writeU8(object);
+        } else if (object < 65536) {
+          this.writeU8(205);
+          this.writeU16(object);
+        } else if (object < 4294967296) {
+          this.writeU8(206);
+          this.writeU32(object);
+        } else if (!this.useBigInt64) {
+          this.writeU8(207);
+          this.writeU64(object);
         } else {
           this.encodeNumberAsFloat(object);
         }
-      } else if (typeof object === "string") {
-        this.encodeString(object);
-      } else if (this.useBigInt64 && typeof object === "bigint") {
-        this.encodeBigInt64(object);
-      } else {
-        this.encodeObject(object, depth);
-      }
-    };
-    Encoder3.prototype.ensureBufferSizeToWrite = function(sizeToWrite) {
-      var requiredSize = this.pos + sizeToWrite;
-      if (this.view.byteLength < requiredSize) {
-        this.resizeBuffer(requiredSize * 2);
-      }
-    };
-    Encoder3.prototype.resizeBuffer = function(newSize) {
-      var newBuffer = new ArrayBuffer(newSize);
-      var newBytes = new Uint8Array(newBuffer);
-      var newView = new DataView(newBuffer);
-      newBytes.set(this.bytes);
-      this.view = newView;
-      this.bytes = newBytes;
-    };
-    Encoder3.prototype.encodeNil = function() {
-      this.writeU8(192);
-    };
-    Encoder3.prototype.encodeBoolean = function(object) {
-      if (object === false) {
-        this.writeU8(194);
       } else {
-        this.writeU8(195);
-      }
-    };
-    Encoder3.prototype.encodeNumber = function(object) {
-      if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
-        if (object >= 0) {
-          if (object < 128) {
-            this.writeU8(object);
-          } else if (object < 256) {
-            this.writeU8(204);
-            this.writeU8(object);
-          } else if (object < 65536) {
-            this.writeU8(205);
-            this.writeU16(object);
-          } else if (object < 4294967296) {
-            this.writeU8(206);
-            this.writeU32(object);
-          } else if (!this.useBigInt64) {
-            this.writeU8(207);
-            this.writeU64(object);
-          } else {
-            this.encodeNumberAsFloat(object);
-          }
+        if (object >= -32) {
+          this.writeU8(224 | object + 32);
+        } else if (object >= -128) {
+          this.writeU8(208);
+          this.writeI8(object);
+        } else if (object >= -32768) {
+          this.writeU8(209);
+          this.writeI16(object);
+        } else if (object >= -2147483648) {
+          this.writeU8(210);
+          this.writeI32(object);
+        } else if (!this.useBigInt64) {
+          this.writeU8(211);
+          this.writeI64(object);
         } else {
-          if (object >= -32) {
-            this.writeU8(224 | object + 32);
-          } else if (object >= -128) {
-            this.writeU8(208);
-            this.writeI8(object);
-          } else if (object >= -32768) {
-            this.writeU8(209);
-            this.writeI16(object);
-          } else if (object >= -2147483648) {
-            this.writeU8(210);
-            this.writeI32(object);
-          } else if (!this.useBigInt64) {
-            this.writeU8(211);
-            this.writeI64(object);
-          } else {
-            this.encodeNumberAsFloat(object);
-          }
-        }
-      } else {
-        this.encodeNumberAsFloat(object);
-      }
-    };
-    Encoder3.prototype.encodeNumberAsFloat = function(object) {
-      if (this.forceFloat32) {
-        this.writeU8(202);
-        this.writeF32(object);
-      } else {
-        this.writeU8(203);
-        this.writeF64(object);
-      }
-    };
-    Encoder3.prototype.encodeBigInt64 = function(object) {
-      if (object >= BigInt(0)) {
-        this.writeU8(207);
-        this.writeBigUint64(object);
-      } else {
-        this.writeU8(211);
-        this.writeBigInt64(object);
-      }
-    };
-    Encoder3.prototype.writeStringHeader = function(byteLength) {
-      if (byteLength < 32) {
-        this.writeU8(160 + byteLength);
-      } else if (byteLength < 256) {
-        this.writeU8(217);
-        this.writeU8(byteLength);
-      } else if (byteLength < 65536) {
-        this.writeU8(218);
-        this.writeU16(byteLength);
-      } else if (byteLength < 4294967296) {
-        this.writeU8(219);
-        this.writeU32(byteLength);
-      } else {
-        throw new Error("Too long string: ".concat(byteLength, " bytes in UTF-8"));
-      }
-    };
-    Encoder3.prototype.encodeString = function(object) {
-      var maxHeaderSize = 1 + 4;
-      var byteLength = utf8Count(object);
-      this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
-      this.writeStringHeader(byteLength);
-      utf8Encode(object, this.bytes, this.pos);
-      this.pos += byteLength;
-    };
-    Encoder3.prototype.encodeObject = function(object, depth) {
-      var ext = this.extensionCodec.tryToEncode(object, this.context);
-      if (ext != null) {
-        this.encodeExtension(ext);
-      } else if (Array.isArray(object)) {
-        this.encodeArray(object, depth);
-      } else if (ArrayBuffer.isView(object)) {
-        this.encodeBinary(object);
-      } else if (typeof object === "object") {
-        this.encodeMap(object, depth);
-      } else {
-        throw new Error("Unrecognized object: ".concat(Object.prototype.toString.apply(object)));
-      }
-    };
-    Encoder3.prototype.encodeBinary = function(object) {
-      var size = object.byteLength;
-      if (size < 256) {
-        this.writeU8(196);
-        this.writeU8(size);
-      } else if (size < 65536) {
-        this.writeU8(197);
-        this.writeU16(size);
-      } else if (size < 4294967296) {
-        this.writeU8(198);
-        this.writeU32(size);
-      } else {
-        throw new Error("Too large binary: ".concat(size));
-      }
-      var bytes = ensureUint8Array(object);
-      this.writeU8a(bytes);
-    };
-    Encoder3.prototype.encodeArray = function(object, depth) {
-      var size = object.length;
-      if (size < 16) {
-        this.writeU8(144 + size);
-      } else if (size < 65536) {
-        this.writeU8(220);
-        this.writeU16(size);
-      } else if (size < 4294967296) {
-        this.writeU8(221);
-        this.writeU32(size);
-      } else {
-        throw new Error("Too large array: ".concat(size));
-      }
-      for (var _i = 0, object_1 = object; _i < object_1.length; _i++) {
-        var item = object_1[_i];
-        this.doEncode(item, depth + 1);
-      }
-    };
-    Encoder3.prototype.countWithoutUndefined = function(object, keys) {
-      var count = 0;
-      for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-        var key = keys_1[_i];
-        if (object[key] !== void 0) {
-          count++;
+          this.encodeNumberAsFloat(object);
         }
       }
-      return count;
-    };
-    Encoder3.prototype.encodeMap = function(object, depth) {
-      var keys = Object.keys(object);
-      if (this.sortKeys) {
-        keys.sort();
-      }
-      var size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
-      if (size < 16) {
-        this.writeU8(128 + size);
-      } else if (size < 65536) {
-        this.writeU8(222);
-        this.writeU16(size);
-      } else if (size < 4294967296) {
-        this.writeU8(223);
-        this.writeU32(size);
-      } else {
-        throw new Error("Too large map object: ".concat(size));
+    } else {
+      this.encodeNumberAsFloat(object);
+    }
+  }
+  encodeNumberAsFloat(object) {
+    if (this.forceFloat32) {
+      this.writeU8(202);
+      this.writeF32(object);
+    } else {
+      this.writeU8(203);
+      this.writeF64(object);
+    }
+  }
+  encodeBigInt64(object) {
+    if (object >= BigInt(0)) {
+      this.writeU8(207);
+      this.writeBigUint64(object);
+    } else {
+      this.writeU8(211);
+      this.writeBigInt64(object);
+    }
+  }
+  writeStringHeader(byteLength) {
+    if (byteLength < 32) {
+      this.writeU8(160 + byteLength);
+    } else if (byteLength < 256) {
+      this.writeU8(217);
+      this.writeU8(byteLength);
+    } else if (byteLength < 65536) {
+      this.writeU8(218);
+      this.writeU16(byteLength);
+    } else if (byteLength < 4294967296) {
+      this.writeU8(219);
+      this.writeU32(byteLength);
+    } else {
+      throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+    }
+  }
+  encodeString(object) {
+    const maxHeaderSize = 1 + 4;
+    const byteLength = utf8Count(object);
+    this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+    this.writeStringHeader(byteLength);
+    utf8Encode(object, this.bytes, this.pos);
+    this.pos += byteLength;
+  }
+  encodeObject(object, depth) {
+    const ext = this.extensionCodec.tryToEncode(object, this.context);
+    if (ext != null) {
+      this.encodeExtension(ext);
+    } else if (Array.isArray(object)) {
+      this.encodeArray(object, depth);
+    } else if (ArrayBuffer.isView(object)) {
+      this.encodeBinary(object);
+    } else if (typeof object === "object") {
+      this.encodeMap(object, depth);
+    } else {
+      throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+    }
+  }
+  encodeBinary(object) {
+    const size = object.byteLength;
+    if (size < 256) {
+      this.writeU8(196);
+      this.writeU8(size);
+    } else if (size < 65536) {
+      this.writeU8(197);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(198);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large binary: ${size}`);
+    }
+    const bytes = ensureUint8Array(object);
+    this.writeU8a(bytes);
+  }
+  encodeArray(object, depth) {
+    const size = object.length;
+    if (size < 16) {
+      this.writeU8(144 + size);
+    } else if (size < 65536) {
+      this.writeU8(220);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(221);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large array: ${size}`);
+    }
+    for (const item of object) {
+      this.doEncode(item, depth + 1);
+    }
+  }
+  countWithoutUndefined(object, keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (object[key] !== void 0) {
+        count++;
       }
-      for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
-        var key = keys_2[_i];
-        var value = object[key];
-        if (!(this.ignoreUndefined && value === void 0)) {
-          this.encodeString(key);
-          this.doEncode(value, depth + 1);
-        }
+    }
+    return count;
+  }
+  encodeMap(object, depth) {
+    const keys = Object.keys(object);
+    if (this.sortKeys) {
+      keys.sort();
+    }
+    const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+    if (size < 16) {
+      this.writeU8(128 + size);
+    } else if (size < 65536) {
+      this.writeU8(222);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(223);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large map object: ${size}`);
+    }
+    for (const key of keys) {
+      const value = object[key];
+      if (!(this.ignoreUndefined && value === void 0)) {
+        this.encodeString(key);
+        this.doEncode(value, depth + 1);
       }
-    };
-    Encoder3.prototype.encodeExtension = function(ext) {
-      var size = ext.data.length;
-      if (size === 1) {
-        this.writeU8(212);
-      } else if (size === 2) {
-        this.writeU8(213);
-      } else if (size === 4) {
-        this.writeU8(214);
-      } else if (size === 8) {
-        this.writeU8(215);
-      } else if (size === 16) {
-        this.writeU8(216);
-      } else if (size < 256) {
-        this.writeU8(199);
-        this.writeU8(size);
-      } else if (size < 65536) {
-        this.writeU8(200);
-        this.writeU16(size);
-      } else if (size < 4294967296) {
-        this.writeU8(201);
-        this.writeU32(size);
-      } else {
-        throw new Error("Too large extension object: ".concat(size));
+    }
+  }
+  encodeExtension(ext) {
+    if (typeof ext.data === "function") {
+      const data = ext.data(this.pos + 6);
+      const size2 = data.length;
+      if (size2 >= 4294967296) {
+        throw new Error(`Too large extension object: ${size2}`);
       }
+      this.writeU8(201);
+      this.writeU32(size2);
       this.writeI8(ext.type);
-      this.writeU8a(ext.data);
-    };
-    Encoder3.prototype.writeU8 = function(value) {
-      this.ensureBufferSizeToWrite(1);
-      this.view.setUint8(this.pos, value);
-      this.pos++;
-    };
-    Encoder3.prototype.writeU8a = function(values) {
-      var size = values.length;
-      this.ensureBufferSizeToWrite(size);
-      this.bytes.set(values, this.pos);
-      this.pos += size;
-    };
-    Encoder3.prototype.writeI8 = function(value) {
-      this.ensureBufferSizeToWrite(1);
-      this.view.setInt8(this.pos, value);
-      this.pos++;
-    };
-    Encoder3.prototype.writeU16 = function(value) {
-      this.ensureBufferSizeToWrite(2);
-      this.view.setUint16(this.pos, value);
-      this.pos += 2;
-    };
-    Encoder3.prototype.writeI16 = function(value) {
-      this.ensureBufferSizeToWrite(2);
-      this.view.setInt16(this.pos, value);
-      this.pos += 2;
-    };
-    Encoder3.prototype.writeU32 = function(value) {
-      this.ensureBufferSizeToWrite(4);
-      this.view.setUint32(this.pos, value);
-      this.pos += 4;
-    };
-    Encoder3.prototype.writeI32 = function(value) {
-      this.ensureBufferSizeToWrite(4);
-      this.view.setInt32(this.pos, value);
-      this.pos += 4;
-    };
-    Encoder3.prototype.writeF32 = function(value) {
-      this.ensureBufferSizeToWrite(4);
-      this.view.setFloat32(this.pos, value);
-      this.pos += 4;
-    };
-    Encoder3.prototype.writeF64 = function(value) {
-      this.ensureBufferSizeToWrite(8);
-      this.view.setFloat64(this.pos, value);
-      this.pos += 8;
-    };
-    Encoder3.prototype.writeU64 = function(value) {
-      this.ensureBufferSizeToWrite(8);
-      setUint64(this.view, this.pos, value);
-      this.pos += 8;
-    };
-    Encoder3.prototype.writeI64 = function(value) {
-      this.ensureBufferSizeToWrite(8);
-      setInt64(this.view, this.pos, value);
-      this.pos += 8;
-    };
-    Encoder3.prototype.writeBigUint64 = function(value) {
-      this.ensureBufferSizeToWrite(8);
-      this.view.setBigUint64(this.pos, value);
-      this.pos += 8;
-    };
-    Encoder3.prototype.writeBigInt64 = function(value) {
-      this.ensureBufferSizeToWrite(8);
-      this.view.setBigInt64(this.pos, value);
-      this.pos += 8;
-    };
-    return Encoder3;
-  }()
-);
+      this.writeU8a(data);
+      return;
+    }
+    const size = ext.data.length;
+    if (size === 1) {
+      this.writeU8(212);
+    } else if (size === 2) {
+      this.writeU8(213);
+    } else if (size === 4) {
+      this.writeU8(214);
+    } else if (size === 8) {
+      this.writeU8(215);
+    } else if (size === 16) {
+      this.writeU8(216);
+    } else if (size < 256) {
+      this.writeU8(199);
+      this.writeU8(size);
+    } else if (size < 65536) {
+      this.writeU8(200);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(201);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large extension object: ${size}`);
+    }
+    this.writeI8(ext.type);
+    this.writeU8a(ext.data);
+  }
+  writeU8(value) {
+    this.ensureBufferSizeToWrite(1);
+    this.view.setUint8(this.pos, value);
+    this.pos++;
+  }
+  writeU8a(values) {
+    const size = values.length;
+    this.ensureBufferSizeToWrite(size);
+    this.bytes.set(values, this.pos);
+    this.pos += size;
+  }
+  writeI8(value) {
+    this.ensureBufferSizeToWrite(1);
+    this.view.setInt8(this.pos, value);
+    this.pos++;
+  }
+  writeU16(value) {
+    this.ensureBufferSizeToWrite(2);
+    this.view.setUint16(this.pos, value);
+    this.pos += 2;
+  }
+  writeI16(value) {
+    this.ensureBufferSizeToWrite(2);
+    this.view.setInt16(this.pos, value);
+    this.pos += 2;
+  }
+  writeU32(value) {
+    this.ensureBufferSizeToWrite(4);
+    this.view.setUint32(this.pos, value);
+    this.pos += 4;
+  }
+  writeI32(value) {
+    this.ensureBufferSizeToWrite(4);
+    this.view.setInt32(this.pos, value);
+    this.pos += 4;
+  }
+  writeF32(value) {
+    this.ensureBufferSizeToWrite(4);
+    this.view.setFloat32(this.pos, value);
+    this.pos += 4;
+  }
+  writeF64(value) {
+    this.ensureBufferSizeToWrite(8);
+    this.view.setFloat64(this.pos, value);
+    this.pos += 8;
+  }
+  writeU64(value) {
+    this.ensureBufferSizeToWrite(8);
+    setUint64(this.view, this.pos, value);
+    this.pos += 8;
+  }
+  writeI64(value) {
+    this.ensureBufferSizeToWrite(8);
+    setInt64(this.view, this.pos, value);
+    this.pos += 8;
+  }
+  writeBigUint64(value) {
+    this.ensureBufferSizeToWrite(8);
+    this.view.setBigUint64(this.pos, value);
+    this.pos += 8;
+  }
+  writeBigInt64(value) {
+    this.ensureBufferSizeToWrite(8);
+    this.view.setBigInt64(this.pos, value);
+    this.pos += 8;
+  }
+};
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/encode.mjs
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/encode.mjs
 function encode(value, options) {
-  var encoder = new Encoder(options);
+  const encoder = new Encoder(options);
   return encoder.encodeSharedRef(value);
 }
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/utils/prettyByte.mjs
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/prettyByte.mjs
 function prettyByte(byte) {
-  return "".concat(byte < 0 ? "-" : "", "0x").concat(Math.abs(byte).toString(16).padStart(2, "0"));
+  return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
 }
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/CachedKeyDecoder.mjs
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/CachedKeyDecoder.mjs
 var DEFAULT_MAX_KEY_LENGTH = 16;
 var DEFAULT_MAX_LENGTH_PER_KEY = 16;
-var CachedKeyDecoder = (
-  /** @class */
-  function() {
-    function CachedKeyDecoder2(maxKeyLength, maxLengthPerKey) {
-      if (maxKeyLength === void 0) {
-        maxKeyLength = DEFAULT_MAX_KEY_LENGTH;
-      }
-      if (maxLengthPerKey === void 0) {
-        maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY;
-      }
-      this.maxKeyLength = maxKeyLength;
-      this.maxLengthPerKey = maxLengthPerKey;
-      this.hit = 0;
-      this.miss = 0;
-      this.caches = [];
-      for (var i = 0; i < this.maxKeyLength; i++) {
-        this.caches.push([]);
-      }
-    }
-    CachedKeyDecoder2.prototype.canBeCached = function(byteLength) {
-      return byteLength > 0 && byteLength <= this.maxKeyLength;
-    };
-    CachedKeyDecoder2.prototype.find = function(bytes, inputOffset, byteLength) {
-      var records = this.caches[byteLength - 1];
-      FIND_CHUNK: for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {
-        var record = records_1[_i];
-        var recordBytes = record.bytes;
-        for (var j = 0; j < byteLength; j++) {
-          if (recordBytes[j] !== bytes[inputOffset + j]) {
-            continue FIND_CHUNK;
-          }
+var CachedKeyDecoder = class {
+  hit = 0;
+  miss = 0;
+  caches;
+  maxKeyLength;
+  maxLengthPerKey;
+  constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+    this.maxKeyLength = maxKeyLength;
+    this.maxLengthPerKey = maxLengthPerKey;
+    this.caches = [];
+    for (let i = 0; i < this.maxKeyLength; i++) {
+      this.caches.push([]);
+    }
+  }
+  canBeCached(byteLength) {
+    return byteLength > 0 && byteLength <= this.maxKeyLength;
+  }
+  find(bytes, inputOffset, byteLength) {
+    const records = this.caches[byteLength - 1];
+    FIND_CHUNK: for (const record of records) {
+      const recordBytes = record.bytes;
+      for (let j = 0; j < byteLength; j++) {
+        if (recordBytes[j] !== bytes[inputOffset + j]) {
+          continue FIND_CHUNK;
         }
-        return record.str;
-      }
-      return null;
-    };
-    CachedKeyDecoder2.prototype.store = function(bytes, value) {
-      var records = this.caches[bytes.length - 1];
-      var record = { bytes, str: value };
-      if (records.length >= this.maxLengthPerKey) {
-        records[Math.random() * records.length | 0] = record;
-      } else {
-        records.push(record);
-      }
-    };
-    CachedKeyDecoder2.prototype.decode = function(bytes, inputOffset, byteLength) {
-      var cachedValue = this.find(bytes, inputOffset, byteLength);
-      if (cachedValue != null) {
-        this.hit++;
-        return cachedValue;
-      }
-      this.miss++;
-      var str = utf8DecodeJs(bytes, inputOffset, byteLength);
-      var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
-      this.store(slicedCopyOfBytes, str);
-      return str;
-    };
-    return CachedKeyDecoder2;
-  }()
-);
-
-// node_modules/@msgpack/msgpack/dist.es5+esm/Decoder.mjs
-var __awaiter = function(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
-    });
-  }
-  return new (P || (P = Promise))(function(resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
       }
+      return record.str;
     }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    return null;
+  }
+  store(bytes, value) {
+    const records = this.caches[bytes.length - 1];
+    const record = { bytes, str: value };
+    if (records.length >= this.maxLengthPerKey) {
+      records[Math.random() * records.length | 0] = record;
+    } else {
+      records.push(record);
     }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var __generator = function(thisArg, body) {
-  var _ = { label: 0, sent: function() {
-    if (t[0] & 1) throw t[1];
-    return t[1];
-  }, trys: [], ops: [] }, f, y, t, g;
-  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-    return this;
-  }), g;
-  function verb(n) {
-    return function(v) {
-      return step([n, v]);
-    };
   }
-  function step(op) {
-    if (f) throw new TypeError("Generator is already executing.");
-    while (g && (g = 0, op[0] && (_ = 0)), _) try {
-      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-      if (y = 0, t) op = [op[0] & 2, t.value];
-      switch (op[0]) {
-        case 0:
-        case 1:
-          t = op;
-          break;
-        case 4:
-          _.label++;
-          return { value: op[1], done: false };
-        case 5:
-          _.label++;
-          y = op[1];
-          op = [0];
-          continue;
-        case 7:
-          op = _.ops.pop();
-          _.trys.pop();
-          continue;
-        default:
-          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-            _ = 0;
-            continue;
-          }
-          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-            _.label = op[1];
-            break;
-          }
-          if (op[0] === 6 && _.label < t[1]) {
-            _.label = t[1];
-            t = op;
-            break;
-          }
-          if (t && _.label < t[2]) {
-            _.label = t[2];
-            _.ops.push(op);
-            break;
-          }
-          if (t[2]) _.ops.pop();
-          _.trys.pop();
-          continue;
-      }
-      op = body.call(thisArg, _);
-    } catch (e) {
-      op = [6, e];
-      y = 0;
-    } finally {
-      f = t = 0;
+  decode(bytes, inputOffset, byteLength) {
+    const cachedValue = this.find(bytes, inputOffset, byteLength);
+    if (cachedValue != null) {
+      this.hit++;
+      return cachedValue;
     }
-    if (op[0] & 5) throw op[1];
-    return { value: op[0] ? op[1] : void 0, done: true };
+    this.miss++;
+    const str = utf8DecodeJs(bytes, inputOffset, byteLength);
+    const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+    this.store(slicedCopyOfBytes, str);
+    return str;
   }
 };
-var __asyncValues = function(o) {
-  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-  var m = o[Symbol.asyncIterator], i;
-  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-    return this;
-  }, i);
-  function verb(n) {
-    i[n] = o[n] && function(v) {
-      return new Promise(function(resolve, reject) {
-        v = o[n](v), settle(resolve, reject, v.done, v.value);
-      });
-    };
-  }
-  function settle(resolve, reject, d, v) {
-    Promise.resolve(v).then(function(v2) {
-      resolve({ value: v2, done: d });
-    }, reject);
+
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/Decoder.mjs
+var STATE_ARRAY = "array";
+var STATE_MAP_KEY = "map_key";
+var STATE_MAP_VALUE = "map_value";
+var mapKeyConverter = (key) => {
+  if (typeof key === "string" || typeof key === "number") {
+    return key;
   }
+  throw new DecodeError("The type of key must be string or number but " + typeof key);
 };
-var __await = function(v) {
-  return this instanceof __await ? (this.v = v, this) : new __await(v);
-};
-var __asyncGenerator = function(thisArg, _arguments, generator) {
-  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-  var g = generator.apply(thisArg, _arguments || []), i, q = [];
-  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-    return this;
-  }, i;
-  function verb(n) {
-    if (g[n]) i[n] = function(v) {
-      return new Promise(function(a, b) {
-        q.push([n, v, a, b]) > 1 || resume(n, v);
-      });
-    };
-  }
-  function resume(n, v) {
-    try {
-      step(g[n](v));
-    } catch (e) {
-      settle(q[0][3], e);
+var StackPool = class {
+  stack = [];
+  stackHeadPosition = -1;
+  get length() {
+    return this.stackHeadPosition + 1;
+  }
+  top() {
+    return this.stack[this.stackHeadPosition];
+  }
+  pushArrayState(size) {
+    const state = this.getUninitializedStateFromPool();
+    state.type = STATE_ARRAY;
+    state.position = 0;
+    state.size = size;
+    state.array = new Array(size);
+  }
+  pushMapState(size) {
+    const state = this.getUninitializedStateFromPool();
+    state.type = STATE_MAP_KEY;
+    state.readCount = 0;
+    state.size = size;
+    state.map = {};
+  }
+  getUninitializedStateFromPool() {
+    this.stackHeadPosition++;
+    if (this.stackHeadPosition === this.stack.length) {
+      const partialState = {
+        type: void 0,
+        size: 0,
+        array: void 0,
+        position: 0,
+        readCount: 0,
+        map: void 0,
+        key: null
+      };
+      this.stack.push(partialState);
     }
+    return this.stack[this.stackHeadPosition];
   }
-  function step(r) {
-    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
-  }
-  function fulfill(value) {
-    resume("next", value);
-  }
-  function reject(value) {
-    resume("throw", value);
+  release(state) {
+    const topStackState = this.stack[this.stackHeadPosition];
+    if (topStackState !== state) {
+      throw new Error("Invalid stack state. Released state is not on top of the stack.");
+    }
+    if (state.type === STATE_ARRAY) {
+      const partialState = state;
+      partialState.size = 0;
+      partialState.array = void 0;
+      partialState.position = 0;
+      partialState.type = void 0;
+    }
+    if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
+      const partialState = state;
+      partialState.size = 0;
+      partialState.map = void 0;
+      partialState.readCount = 0;
+      partialState.type = void 0;
+    }
+    this.stackHeadPosition--;
   }
-  function settle(f, v) {
-    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  reset() {
+    this.stack.length = 0;
+    this.stackHeadPosition = -1;
   }
 };
-var STATE_ARRAY = "array";
-var STATE_MAP_KEY = "map_key";
-var STATE_MAP_VALUE = "map_value";
-var isValidMapKeyType = function(key) {
-  return typeof key === "string" || typeof key === "number";
-};
 var HEAD_BYTE_REQUIRED = -1;
 var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
 var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
@@ -1071,371 +1005,215 @@ try {
     throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
   }
 }
-var DataViewIndexOutOfBoundsError = RangeError;
-var MORE_DATA = new DataViewIndexOutOfBoundsError("Insufficient data");
+var MORE_DATA = new RangeError("Insufficient data");
 var sharedCachedKeyDecoder = new CachedKeyDecoder();
-var Decoder = (
-  /** @class */
-  function() {
-    function Decoder3(options) {
-      var _a, _b, _c, _d, _e, _f, _g;
-      this.totalPos = 0;
-      this.pos = 0;
-      this.view = EMPTY_VIEW;
-      this.bytes = EMPTY_BYTES;
-      this.headByte = HEAD_BYTE_REQUIRED;
-      this.stack = [];
-      this.extensionCodec = (_a = options === null || options === void 0 ? void 0 : options.extensionCodec) !== null && _a !== void 0 ? _a : ExtensionCodec.defaultCodec;
-      this.context = options === null || options === void 0 ? void 0 : options.context;
-      this.useBigInt64 = (_b = options === null || options === void 0 ? void 0 : options.useBigInt64) !== null && _b !== void 0 ? _b : false;
-      this.maxStrLength = (_c = options === null || options === void 0 ? void 0 : options.maxStrLength) !== null && _c !== void 0 ? _c : UINT32_MAX;
-      this.maxBinLength = (_d = options === null || options === void 0 ? void 0 : options.maxBinLength) !== null && _d !== void 0 ? _d : UINT32_MAX;
-      this.maxArrayLength = (_e = options === null || options === void 0 ? void 0 : options.maxArrayLength) !== null && _e !== void 0 ? _e : UINT32_MAX;
-      this.maxMapLength = (_f = options === null || options === void 0 ? void 0 : options.maxMapLength) !== null && _f !== void 0 ? _f : UINT32_MAX;
-      this.maxExtLength = (_g = options === null || options === void 0 ? void 0 : options.maxExtLength) !== null && _g !== void 0 ? _g : UINT32_MAX;
-      this.keyDecoder = (options === null || options === void 0 ? void 0 : options.keyDecoder) !== void 0 ? options.keyDecoder : sharedCachedKeyDecoder;
-    }
-    Decoder3.prototype.reinitializeState = function() {
-      this.totalPos = 0;
-      this.headByte = HEAD_BYTE_REQUIRED;
-      this.stack.length = 0;
-    };
-    Decoder3.prototype.setBuffer = function(buffer) {
-      this.bytes = ensureUint8Array(buffer);
-      this.view = createDataView(this.bytes);
-      this.pos = 0;
-    };
-    Decoder3.prototype.appendBuffer = function(buffer) {
-      if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
-        this.setBuffer(buffer);
-      } else {
-        var remainingData = this.bytes.subarray(this.pos);
-        var newData = ensureUint8Array(buffer);
-        var newBuffer = new Uint8Array(remainingData.length + newData.length);
-        newBuffer.set(remainingData);
-        newBuffer.set(newData, remainingData.length);
-        this.setBuffer(newBuffer);
-      }
-    };
-    Decoder3.prototype.hasRemaining = function(size) {
-      return this.view.byteLength - this.pos >= size;
-    };
-    Decoder3.prototype.createExtraByteError = function(posToShow) {
-      var _a = this, view = _a.view, pos = _a.pos;
-      return new RangeError("Extra ".concat(view.byteLength - pos, " of ").concat(view.byteLength, " byte(s) found at buffer[").concat(posToShow, "]"));
-    };
-    Decoder3.prototype.decode = function(buffer) {
+var Decoder = class _Decoder {
+  extensionCodec;
+  context;
+  useBigInt64;
+  rawStrings;
+  maxStrLength;
+  maxBinLength;
+  maxArrayLength;
+  maxMapLength;
+  maxExtLength;
+  keyDecoder;
+  mapKeyConverter;
+  totalPos = 0;
+  pos = 0;
+  view = EMPTY_VIEW;
+  bytes = EMPTY_BYTES;
+  headByte = HEAD_BYTE_REQUIRED;
+  stack = new StackPool();
+  entered = false;
+  constructor(options) {
+    this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+    this.context = options?.context;
+    this.useBigInt64 = options?.useBigInt64 ?? false;
+    this.rawStrings = options?.rawStrings ?? false;
+    this.maxStrLength = options?.maxStrLength ?? UINT32_MAX;
+    this.maxBinLength = options?.maxBinLength ?? UINT32_MAX;
+    this.maxArrayLength = options?.maxArrayLength ?? UINT32_MAX;
+    this.maxMapLength = options?.maxMapLength ?? UINT32_MAX;
+    this.maxExtLength = options?.maxExtLength ?? UINT32_MAX;
+    this.keyDecoder = options?.keyDecoder !== void 0 ? options.keyDecoder : sharedCachedKeyDecoder;
+    this.mapKeyConverter = options?.mapKeyConverter ?? mapKeyConverter;
+  }
+  clone() {
+    return new _Decoder({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      rawStrings: this.rawStrings,
+      maxStrLength: this.maxStrLength,
+      maxBinLength: this.maxBinLength,
+      maxArrayLength: this.maxArrayLength,
+      maxMapLength: this.maxMapLength,
+      maxExtLength: this.maxExtLength,
+      keyDecoder: this.keyDecoder
+    });
+  }
+  reinitializeState() {
+    this.totalPos = 0;
+    this.headByte = HEAD_BYTE_REQUIRED;
+    this.stack.reset();
+  }
+  setBuffer(buffer) {
+    const bytes = ensureUint8Array(buffer);
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    this.pos = 0;
+  }
+  appendBuffer(buffer) {
+    if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+      this.setBuffer(buffer);
+    } else {
+      const remainingData = this.bytes.subarray(this.pos);
+      const newData = ensureUint8Array(buffer);
+      const newBuffer = new Uint8Array(remainingData.length + newData.length);
+      newBuffer.set(remainingData);
+      newBuffer.set(newData, remainingData.length);
+      this.setBuffer(newBuffer);
+    }
+  }
+  hasRemaining(size) {
+    return this.view.byteLength - this.pos >= size;
+  }
+  createExtraByteError(posToShow) {
+    const { view, pos } = this;
+    return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
+  }
+  /**
+   * @throws {@link DecodeError}
+   * @throws {@link RangeError}
+   */
+  decode(buffer) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.decode(buffer);
+    }
+    try {
+      this.entered = true;
       this.reinitializeState();
       this.setBuffer(buffer);
-      var object = this.doDecodeSync();
+      const object = this.doDecodeSync();
       if (this.hasRemaining(1)) {
         throw this.createExtraByteError(this.pos);
       }
       return object;
-    };
-    Decoder3.prototype.decodeMulti = function(buffer) {
-      return __generator(this, function(_a) {
-        switch (_a.label) {
-          case 0:
-            this.reinitializeState();
-            this.setBuffer(buffer);
-            _a.label = 1;
-          case 1:
-            if (!this.hasRemaining(1)) return [3, 3];
-            return [4, this.doDecodeSync()];
-          case 2:
-            _a.sent();
-            return [3, 1];
-          case 3:
-            return [
-              2
-              /*return*/
-            ];
+    } finally {
+      this.entered = false;
+    }
+  }
+  *decodeMulti(buffer) {
+    if (this.entered) {
+      const instance = this.clone();
+      yield* instance.decodeMulti(buffer);
+      return;
+    }
+    try {
+      this.entered = true;
+      this.reinitializeState();
+      this.setBuffer(buffer);
+      while (this.hasRemaining(1)) {
+        yield this.doDecodeSync();
+      }
+    } finally {
+      this.entered = false;
+    }
+  }
+  async decodeAsync(stream) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.decodeAsync(stream);
+    }
+    try {
+      this.entered = true;
+      let decoded = false;
+      let object;
+      for await (const buffer of stream) {
+        if (decoded) {
+          this.entered = false;
+          throw this.createExtraByteError(this.totalPos);
         }
-      });
-    };
-    Decoder3.prototype.decodeAsync = function(stream) {
-      var _a, stream_1, stream_1_1;
-      var _b, e_1, _c, _d;
-      return __awaiter(this, void 0, void 0, function() {
-        var decoded, object, buffer, e_1_1, _e, headByte, pos, totalPos;
-        return __generator(this, function(_f) {
-          switch (_f.label) {
-            case 0:
-              decoded = false;
-              _f.label = 1;
-            case 1:
-              _f.trys.push([1, 6, 7, 12]);
-              _a = true, stream_1 = __asyncValues(stream);
-              _f.label = 2;
-            case 2:
-              return [4, stream_1.next()];
-            case 3:
-              if (!(stream_1_1 = _f.sent(), _b = stream_1_1.done, !_b)) return [3, 5];
-              _d = stream_1_1.value;
-              _a = false;
-              try {
-                buffer = _d;
-                if (decoded) {
-                  throw this.createExtraByteError(this.totalPos);
-                }
-                this.appendBuffer(buffer);
-                try {
-                  object = this.doDecodeSync();
-                  decoded = true;
-                } catch (e) {
-                  if (!(e instanceof DataViewIndexOutOfBoundsError)) {
-                    throw e;
-                  }
-                }
-                this.totalPos += this.pos;
-              } finally {
-                _a = true;
-              }
-              _f.label = 4;
-            case 4:
-              return [3, 2];
-            case 5:
-              return [3, 12];
-            case 6:
-              e_1_1 = _f.sent();
-              e_1 = { error: e_1_1 };
-              return [3, 12];
-            case 7:
-              _f.trys.push([7, , 10, 11]);
-              if (!(!_a && !_b && (_c = stream_1.return))) return [3, 9];
-              return [4, _c.call(stream_1)];
-            case 8:
-              _f.sent();
-              _f.label = 9;
-            case 9:
-              return [3, 11];
-            case 10:
-              if (e_1) throw e_1.error;
-              return [
-                7
-                /*endfinally*/
-              ];
-            case 11:
-              return [
-                7
-                /*endfinally*/
-              ];
-            case 12:
-              if (decoded) {
-                if (this.hasRemaining(1)) {
-                  throw this.createExtraByteError(this.totalPos);
-                }
-                return [2, object];
-              }
-              _e = this, headByte = _e.headByte, pos = _e.pos, totalPos = _e.totalPos;
-              throw new RangeError("Insufficient data in parsing ".concat(prettyByte(headByte), " at ").concat(totalPos, " (").concat(pos, " in the current buffer)"));
-          }
-        });
-      });
-    };
-    Decoder3.prototype.decodeArrayStream = function(stream) {
-      return this.decodeMultiAsync(stream, true);
-    };
-    Decoder3.prototype.decodeStream = function(stream) {
-      return this.decodeMultiAsync(stream, false);
-    };
-    Decoder3.prototype.decodeMultiAsync = function(stream, isArray) {
-      return __asyncGenerator(this, arguments, function decodeMultiAsync_1() {
-        var isArrayHeaderRequired, arrayItemsLeft, _a, stream_2, stream_2_1, buffer, e_2, e_3_1;
-        var _b, e_3, _c, _d;
-        return __generator(this, function(_e) {
-          switch (_e.label) {
-            case 0:
-              isArrayHeaderRequired = isArray;
-              arrayItemsLeft = -1;
-              _e.label = 1;
-            case 1:
-              _e.trys.push([1, 15, 16, 21]);
-              _a = true, stream_2 = __asyncValues(stream);
-              _e.label = 2;
-            case 2:
-              return [4, __await(stream_2.next())];
-            case 3:
-              if (!(stream_2_1 = _e.sent(), _b = stream_2_1.done, !_b)) return [3, 14];
-              _d = stream_2_1.value;
-              _a = false;
-              _e.label = 4;
-            case 4:
-              _e.trys.push([4, , 12, 13]);
-              buffer = _d;
-              if (isArray && arrayItemsLeft === 0) {
-                throw this.createExtraByteError(this.totalPos);
-              }
-              this.appendBuffer(buffer);
-              if (isArrayHeaderRequired) {
-                arrayItemsLeft = this.readArraySize();
-                isArrayHeaderRequired = false;
-                this.complete();
-              }
-              _e.label = 5;
-            case 5:
-              _e.trys.push([5, 10, , 11]);
-              _e.label = 6;
-            case 6:
-              if (false) return [3, 9];
-              return [4, __await(this.doDecodeSync())];
-            case 7:
-              return [4, _e.sent()];
-            case 8:
-              _e.sent();
-              if (--arrayItemsLeft === 0) {
-                return [3, 9];
-              }
-              return [3, 6];
-            case 9:
-              return [3, 11];
-            case 10:
-              e_2 = _e.sent();
-              if (!(e_2 instanceof DataViewIndexOutOfBoundsError)) {
-                throw e_2;
-              }
-              return [3, 11];
-            case 11:
-              this.totalPos += this.pos;
-              return [3, 13];
-            case 12:
-              _a = true;
-              return [
-                7
-                /*endfinally*/
-              ];
-            case 13:
-              return [3, 2];
-            case 14:
-              return [3, 21];
-            case 15:
-              e_3_1 = _e.sent();
-              e_3 = { error: e_3_1 };
-              return [3, 21];
-            case 16:
-              _e.trys.push([16, , 19, 20]);
-              if (!(!_a && !_b && (_c = stream_2.return))) return [3, 18];
-              return [4, __await(_c.call(stream_2))];
-            case 17:
-              _e.sent();
-              _e.label = 18;
-            case 18:
-              return [3, 20];
-            case 19:
-              if (e_3) throw e_3.error;
-              return [
-                7
-                /*endfinally*/
-              ];
-            case 20:
-              return [
-                7
-                /*endfinally*/
-              ];
-            case 21:
-              return [
-                2
-                /*return*/
-              ];
+        this.appendBuffer(buffer);
+        try {
+          object = this.doDecodeSync();
+          decoded = true;
+        } catch (e) {
+          if (!(e instanceof RangeError)) {
+            throw e;
           }
-        });
-      });
-    };
-    Decoder3.prototype.doDecodeSync = function() {
-      DECODE: while (true) {
-        var headByte = this.readHeadByte();
-        var object = void 0;
-        if (headByte >= 224) {
-          object = headByte - 256;
-        } else if (headByte < 192) {
-          if (headByte < 128) {
-            object = headByte;
-          } else if (headByte < 144) {
-            var size = headByte - 128;
-            if (size !== 0) {
-              this.pushMapState(size);
-              this.complete();
-              continue DECODE;
-            } else {
-              object = {};
-            }
-          } else if (headByte < 160) {
-            var size = headByte - 144;
-            if (size !== 0) {
-              this.pushArrayState(size);
-              this.complete();
-              continue DECODE;
-            } else {
-              object = [];
+        }
+        this.totalPos += this.pos;
+      }
+      if (decoded) {
+        if (this.hasRemaining(1)) {
+          throw this.createExtraByteError(this.totalPos);
+        }
+        return object;
+      }
+      const { headByte, pos, totalPos } = this;
+      throw new RangeError(`Insufficient data in parsing ${prettyByte(headByte)} at ${totalPos} (${pos} in the current buffer)`);
+    } finally {
+      this.entered = false;
+    }
+  }
+  decodeArrayStream(stream) {
+    return this.decodeMultiAsync(stream, true);
+  }
+  decodeStream(stream) {
+    return this.decodeMultiAsync(stream, false);
+  }
+  async *decodeMultiAsync(stream, isArray) {
+    if (this.entered) {
+      const instance = this.clone();
+      yield* instance.decodeMultiAsync(stream, isArray);
+      return;
+    }
+    try {
+      this.entered = true;
+      let isArrayHeaderRequired = isArray;
+      let arrayItemsLeft = -1;
+      for await (const buffer of stream) {
+        if (isArray && arrayItemsLeft === 0) {
+          throw this.createExtraByteError(this.totalPos);
+        }
+        this.appendBuffer(buffer);
+        if (isArrayHeaderRequired) {
+          arrayItemsLeft = this.readArraySize();
+          isArrayHeaderRequired = false;
+          this.complete();
+        }
+        try {
+          while (true) {
+            yield this.doDecodeSync();
+            if (--arrayItemsLeft === 0) {
+              break;
             }
-          } else {
-            var byteLength = headByte - 160;
-            object = this.decodeUtf8String(byteLength, 0);
-          }
-        } else if (headByte === 192) {
-          object = null;
-        } else if (headByte === 194) {
-          object = false;
-        } else if (headByte === 195) {
-          object = true;
-        } else if (headByte === 202) {
-          object = this.readF32();
-        } else if (headByte === 203) {
-          object = this.readF64();
-        } else if (headByte === 204) {
-          object = this.readU8();
-        } else if (headByte === 205) {
-          object = this.readU16();
-        } else if (headByte === 206) {
-          object = this.readU32();
-        } else if (headByte === 207) {
-          if (this.useBigInt64) {
-            object = this.readU64AsBigInt();
-          } else {
-            object = this.readU64();
-          }
-        } else if (headByte === 208) {
-          object = this.readI8();
-        } else if (headByte === 209) {
-          object = this.readI16();
-        } else if (headByte === 210) {
-          object = this.readI32();
-        } else if (headByte === 211) {
-          if (this.useBigInt64) {
-            object = this.readI64AsBigInt();
-          } else {
-            object = this.readI64();
-          }
-        } else if (headByte === 217) {
-          var byteLength = this.lookU8();
-          object = this.decodeUtf8String(byteLength, 1);
-        } else if (headByte === 218) {
-          var byteLength = this.lookU16();
-          object = this.decodeUtf8String(byteLength, 2);
-        } else if (headByte === 219) {
-          var byteLength = this.lookU32();
-          object = this.decodeUtf8String(byteLength, 4);
-        } else if (headByte === 220) {
-          var size = this.readU16();
-          if (size !== 0) {
-            this.pushArrayState(size);
-            this.complete();
-            continue DECODE;
-          } else {
-            object = [];
           }
-        } else if (headByte === 221) {
-          var size = this.readU32();
-          if (size !== 0) {
-            this.pushArrayState(size);
-            this.complete();
-            continue DECODE;
-          } else {
-            object = [];
+        } catch (e) {
+          if (!(e instanceof RangeError)) {
+            throw e;
           }
-        } else if (headByte === 222) {
-          var size = this.readU16();
+        }
+        this.totalPos += this.pos;
+      }
+    } finally {
+      this.entered = false;
+    }
+  }
+  doDecodeSync() {
+    DECODE: while (true) {
+      const headByte = this.readHeadByte();
+      let object;
+      if (headByte >= 224) {
+        object = headByte - 256;
+      } else if (headByte < 192) {
+        if (headByte < 128) {
+          object = headByte;
+        } else if (headByte < 144) {
+          const size = headByte - 128;
           if (size !== 0) {
             this.pushMapState(size);
             this.complete();
@@ -1443,265 +1221,343 @@ var Decoder = (
           } else {
             object = {};
           }
-        } else if (headByte === 223) {
-          var size = this.readU32();
+        } else if (headByte < 160) {
+          const size = headByte - 144;
           if (size !== 0) {
-            this.pushMapState(size);
+            this.pushArrayState(size);
             this.complete();
             continue DECODE;
           } else {
-            object = {};
+            object = [];
           }
-        } else if (headByte === 196) {
-          var size = this.lookU8();
-          object = this.decodeBinary(size, 1);
-        } else if (headByte === 197) {
-          var size = this.lookU16();
-          object = this.decodeBinary(size, 2);
-        } else if (headByte === 198) {
-          var size = this.lookU32();
-          object = this.decodeBinary(size, 4);
-        } else if (headByte === 212) {
-          object = this.decodeExtension(1, 0);
-        } else if (headByte === 213) {
-          object = this.decodeExtension(2, 0);
-        } else if (headByte === 214) {
-          object = this.decodeExtension(4, 0);
-        } else if (headByte === 215) {
-          object = this.decodeExtension(8, 0);
-        } else if (headByte === 216) {
-          object = this.decodeExtension(16, 0);
-        } else if (headByte === 199) {
-          var size = this.lookU8();
-          object = this.decodeExtension(size, 1);
-        } else if (headByte === 200) {
-          var size = this.lookU16();
-          object = this.decodeExtension(size, 2);
-        } else if (headByte === 201) {
-          var size = this.lookU32();
-          object = this.decodeExtension(size, 4);
         } else {
-          throw new DecodeError("Unrecognized type byte: ".concat(prettyByte(headByte)));
+          const byteLength = headByte - 160;
+          object = this.decodeString(byteLength, 0);
         }
-        this.complete();
-        var stack = this.stack;
-        while (stack.length > 0) {
-          var state = stack[stack.length - 1];
-          if (state.type === STATE_ARRAY) {
-            state.array[state.position] = object;
-            state.position++;
-            if (state.position === state.size) {
-              stack.pop();
-              object = state.array;
-            } else {
-              continue DECODE;
-            }
-          } else if (state.type === STATE_MAP_KEY) {
-            if (!isValidMapKeyType(object)) {
-              throw new DecodeError("The type of key must be string or number but " + typeof object);
-            }
-            if (object === "__proto__") {
-              throw new DecodeError("The key __proto__ is not allowed");
-            }
-            state.key = object;
-            state.type = STATE_MAP_VALUE;
-            continue DECODE;
+      } else if (headByte === 192) {
+        object = null;
+      } else if (headByte === 194) {
+        object = false;
+      } else if (headByte === 195) {
+        object = true;
+      } else if (headByte === 202) {
+        object = this.readF32();
+      } else if (headByte === 203) {
+        object = this.readF64();
+      } else if (headByte === 204) {
+        object = this.readU8();
+      } else if (headByte === 205) {
+        object = this.readU16();
+      } else if (headByte === 206) {
+        object = this.readU32();
+      } else if (headByte === 207) {
+        if (this.useBigInt64) {
+          object = this.readU64AsBigInt();
+        } else {
+          object = this.readU64();
+        }
+      } else if (headByte === 208) {
+        object = this.readI8();
+      } else if (headByte === 209) {
+        object = this.readI16();
+      } else if (headByte === 210) {
+        object = this.readI32();
+      } else if (headByte === 211) {
+        if (this.useBigInt64) {
+          object = this.readI64AsBigInt();
+        } else {
+          object = this.readI64();
+        }
+      } else if (headByte === 217) {
+        const byteLength = this.lookU8();
+        object = this.decodeString(byteLength, 1);
+      } else if (headByte === 218) {
+        const byteLength = this.lookU16();
+        object = this.decodeString(byteLength, 2);
+      } else if (headByte === 219) {
+        const byteLength = this.lookU32();
+        object = this.decodeString(byteLength, 4);
+      } else if (headByte === 220) {
+        const size = this.readU16();
+        if (size !== 0) {
+          this.pushArrayState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = [];
+        }
+      } else if (headByte === 221) {
+        const size = this.readU32();
+        if (size !== 0) {
+          this.pushArrayState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = [];
+        }
+      } else if (headByte === 222) {
+        const size = this.readU16();
+        if (size !== 0) {
+          this.pushMapState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = {};
+        }
+      } else if (headByte === 223) {
+        const size = this.readU32();
+        if (size !== 0) {
+          this.pushMapState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = {};
+        }
+      } else if (headByte === 196) {
+        const size = this.lookU8();
+        object = this.decodeBinary(size, 1);
+      } else if (headByte === 197) {
+        const size = this.lookU16();
+        object = this.decodeBinary(size, 2);
+      } else if (headByte === 198) {
+        const size = this.lookU32();
+        object = this.decodeBinary(size, 4);
+      } else if (headByte === 212) {
+        object = this.decodeExtension(1, 0);
+      } else if (headByte === 213) {
+        object = this.decodeExtension(2, 0);
+      } else if (headByte === 214) {
+        object = this.decodeExtension(4, 0);
+      } else if (headByte === 215) {
+        object = this.decodeExtension(8, 0);
+      } else if (headByte === 216) {
+        object = this.decodeExtension(16, 0);
+      } else if (headByte === 199) {
+        const size = this.lookU8();
+        object = this.decodeExtension(size, 1);
+      } else if (headByte === 200) {
+        const size = this.lookU16();
+        object = this.decodeExtension(size, 2);
+      } else if (headByte === 201) {
+        const size = this.lookU32();
+        object = this.decodeExtension(size, 4);
+      } else {
+        throw new DecodeError(`Unrecognized type byte: ${prettyByte(headByte)}`);
+      }
+      this.complete();
+      const stack = this.stack;
+      while (stack.length > 0) {
+        const state = stack.top();
+        if (state.type === STATE_ARRAY) {
+          state.array[state.position] = object;
+          state.position++;
+          if (state.position === state.size) {
+            object = state.array;
+            stack.release(state);
           } else {
-            state.map[state.key] = object;
-            state.readCount++;
-            if (state.readCount === state.size) {
-              stack.pop();
-              object = state.map;
-            } else {
-              state.key = null;
-              state.type = STATE_MAP_KEY;
-              continue DECODE;
-            }
+            continue DECODE;
           }
-        }
-        return object;
-      }
-    };
-    Decoder3.prototype.readHeadByte = function() {
-      if (this.headByte === HEAD_BYTE_REQUIRED) {
-        this.headByte = this.readU8();
-      }
-      return this.headByte;
-    };
-    Decoder3.prototype.complete = function() {
-      this.headByte = HEAD_BYTE_REQUIRED;
-    };
-    Decoder3.prototype.readArraySize = function() {
-      var headByte = this.readHeadByte();
-      switch (headByte) {
-        case 220:
-          return this.readU16();
-        case 221:
-          return this.readU32();
-        default: {
-          if (headByte < 160) {
-            return headByte - 144;
+        } else if (state.type === STATE_MAP_KEY) {
+          if (object === "__proto__") {
+            throw new DecodeError("The key __proto__ is not allowed");
+          }
+          state.key = this.mapKeyConverter(object);
+          state.type = STATE_MAP_VALUE;
+          continue DECODE;
+        } else {
+          state.map[state.key] = object;
+          state.readCount++;
+          if (state.readCount === state.size) {
+            object = state.map;
+            stack.release(state);
           } else {
-            throw new DecodeError("Unrecognized array type byte: ".concat(prettyByte(headByte)));
+            state.key = null;
+            state.type = STATE_MAP_KEY;
+            continue DECODE;
           }
-        }
-      }
-    };
-    Decoder3.prototype.pushMapState = function(size) {
-      if (size > this.maxMapLength) {
-        throw new DecodeError("Max length exceeded: map length (".concat(size, ") > maxMapLengthLength (").concat(this.maxMapLength, ")"));
-      }
-      this.stack.push({
-        type: STATE_MAP_KEY,
-        size,
-        key: null,
-        readCount: 0,
-        map: {}
-      });
-    };
-    Decoder3.prototype.pushArrayState = function(size) {
-      if (size > this.maxArrayLength) {
-        throw new DecodeError("Max length exceeded: array length (".concat(size, ") > maxArrayLength (").concat(this.maxArrayLength, ")"));
-      }
-      this.stack.push({
-        type: STATE_ARRAY,
-        size,
-        array: new Array(size),
-        position: 0
-      });
-    };
-    Decoder3.prototype.decodeUtf8String = function(byteLength, headerOffset) {
-      var _a;
-      if (byteLength > this.maxStrLength) {
-        throw new DecodeError("Max length exceeded: UTF-8 byte length (".concat(byteLength, ") > maxStrLength (").concat(this.maxStrLength, ")"));
-      }
-      if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
-        throw MORE_DATA;
-      }
-      var offset2 = this.pos + headerOffset;
-      var object;
-      if (this.stateIsMapKey() && ((_a = this.keyDecoder) === null || _a === void 0 ? void 0 : _a.canBeCached(byteLength))) {
-        object = this.keyDecoder.decode(this.bytes, offset2, byteLength);
-      } else {
-        object = utf8Decode(this.bytes, offset2, byteLength);
-      }
-      this.pos += headerOffset + byteLength;
-      return object;
-    };
-    Decoder3.prototype.stateIsMapKey = function() {
-      if (this.stack.length > 0) {
-        var state = this.stack[this.stack.length - 1];
-        return state.type === STATE_MAP_KEY;
-      }
-      return false;
-    };
-    Decoder3.prototype.decodeBinary = function(byteLength, headOffset) {
-      if (byteLength > this.maxBinLength) {
-        throw new DecodeError("Max length exceeded: bin length (".concat(byteLength, ") > maxBinLength (").concat(this.maxBinLength, ")"));
-      }
-      if (!this.hasRemaining(byteLength + headOffset)) {
-        throw MORE_DATA;
+        }
       }
-      var offset2 = this.pos + headOffset;
-      var object = this.bytes.subarray(offset2, offset2 + byteLength);
-      this.pos += headOffset + byteLength;
       return object;
-    };
-    Decoder3.prototype.decodeExtension = function(size, headOffset) {
-      if (size > this.maxExtLength) {
-        throw new DecodeError("Max length exceeded: ext length (".concat(size, ") > maxExtLength (").concat(this.maxExtLength, ")"));
+    }
+  }
+  readHeadByte() {
+    if (this.headByte === HEAD_BYTE_REQUIRED) {
+      this.headByte = this.readU8();
+    }
+    return this.headByte;
+  }
+  complete() {
+    this.headByte = HEAD_BYTE_REQUIRED;
+  }
+  readArraySize() {
+    const headByte = this.readHeadByte();
+    switch (headByte) {
+      case 220:
+        return this.readU16();
+      case 221:
+        return this.readU32();
+      default: {
+        if (headByte < 160) {
+          return headByte - 144;
+        } else {
+          throw new DecodeError(`Unrecognized array type byte: ${prettyByte(headByte)}`);
+        }
       }
-      var extType = this.view.getInt8(this.pos + headOffset);
-      var data = this.decodeBinary(
-        size,
-        headOffset + 1
-        /* extType */
-      );
-      return this.extensionCodec.decode(data, extType, this.context);
-    };
-    Decoder3.prototype.lookU8 = function() {
-      return this.view.getUint8(this.pos);
-    };
-    Decoder3.prototype.lookU16 = function() {
-      return this.view.getUint16(this.pos);
-    };
-    Decoder3.prototype.lookU32 = function() {
-      return this.view.getUint32(this.pos);
-    };
-    Decoder3.prototype.readU8 = function() {
-      var value = this.view.getUint8(this.pos);
-      this.pos++;
-      return value;
-    };
-    Decoder3.prototype.readI8 = function() {
-      var value = this.view.getInt8(this.pos);
-      this.pos++;
-      return value;
-    };
-    Decoder3.prototype.readU16 = function() {
-      var value = this.view.getUint16(this.pos);
-      this.pos += 2;
-      return value;
-    };
-    Decoder3.prototype.readI16 = function() {
-      var value = this.view.getInt16(this.pos);
-      this.pos += 2;
-      return value;
-    };
-    Decoder3.prototype.readU32 = function() {
-      var value = this.view.getUint32(this.pos);
-      this.pos += 4;
-      return value;
-    };
-    Decoder3.prototype.readI32 = function() {
-      var value = this.view.getInt32(this.pos);
-      this.pos += 4;
-      return value;
-    };
-    Decoder3.prototype.readU64 = function() {
-      var value = getUint64(this.view, this.pos);
-      this.pos += 8;
-      return value;
-    };
-    Decoder3.prototype.readI64 = function() {
-      var value = getInt64(this.view, this.pos);
-      this.pos += 8;
-      return value;
-    };
-    Decoder3.prototype.readU64AsBigInt = function() {
-      var value = this.view.getBigUint64(this.pos);
-      this.pos += 8;
-      return value;
-    };
-    Decoder3.prototype.readI64AsBigInt = function() {
-      var value = this.view.getBigInt64(this.pos);
-      this.pos += 8;
-      return value;
-    };
-    Decoder3.prototype.readF32 = function() {
-      var value = this.view.getFloat32(this.pos);
-      this.pos += 4;
-      return value;
-    };
-    Decoder3.prototype.readF64 = function() {
-      var value = this.view.getFloat64(this.pos);
-      this.pos += 8;
-      return value;
-    };
-    return Decoder3;
-  }()
-);
+    }
+  }
+  pushMapState(size) {
+    if (size > this.maxMapLength) {
+      throw new DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);
+    }
+    this.stack.pushMapState(size);
+  }
+  pushArrayState(size) {
+    if (size > this.maxArrayLength) {
+      throw new DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`);
+    }
+    this.stack.pushArrayState(size);
+  }
+  decodeString(byteLength, headerOffset) {
+    if (!this.rawStrings || this.stateIsMapKey()) {
+      return this.decodeUtf8String(byteLength, headerOffset);
+    }
+    return this.decodeBinary(byteLength, headerOffset);
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeUtf8String(byteLength, headerOffset) {
+    if (byteLength > this.maxStrLength) {
+      throw new DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`);
+    }
+    if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
+      throw MORE_DATA;
+    }
+    const offset2 = this.pos + headerOffset;
+    let object;
+    if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
+      object = this.keyDecoder.decode(this.bytes, offset2, byteLength);
+    } else {
+      object = utf8Decode(this.bytes, offset2, byteLength);
+    }
+    this.pos += headerOffset + byteLength;
+    return object;
+  }
+  stateIsMapKey() {
+    if (this.stack.length > 0) {
+      const state = this.stack.top();
+      return state.type === STATE_MAP_KEY;
+    }
+    return false;
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeBinary(byteLength, headOffset) {
+    if (byteLength > this.maxBinLength) {
+      throw new DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);
+    }
+    if (!this.hasRemaining(byteLength + headOffset)) {
+      throw MORE_DATA;
+    }
+    const offset2 = this.pos + headOffset;
+    const object = this.bytes.subarray(offset2, offset2 + byteLength);
+    this.pos += headOffset + byteLength;
+    return object;
+  }
+  decodeExtension(size, headOffset) {
+    if (size > this.maxExtLength) {
+      throw new DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`);
+    }
+    const extType = this.view.getInt8(this.pos + headOffset);
+    const data = this.decodeBinary(
+      size,
+      headOffset + 1
+      /* extType */
+    );
+    return this.extensionCodec.decode(data, extType, this.context);
+  }
+  lookU8() {
+    return this.view.getUint8(this.pos);
+  }
+  lookU16() {
+    return this.view.getUint16(this.pos);
+  }
+  lookU32() {
+    return this.view.getUint32(this.pos);
+  }
+  readU8() {
+    const value = this.view.getUint8(this.pos);
+    this.pos++;
+    return value;
+  }
+  readI8() {
+    const value = this.view.getInt8(this.pos);
+    this.pos++;
+    return value;
+  }
+  readU16() {
+    const value = this.view.getUint16(this.pos);
+    this.pos += 2;
+    return value;
+  }
+  readI16() {
+    const value = this.view.getInt16(this.pos);
+    this.pos += 2;
+    return value;
+  }
+  readU32() {
+    const value = this.view.getUint32(this.pos);
+    this.pos += 4;
+    return value;
+  }
+  readI32() {
+    const value = this.view.getInt32(this.pos);
+    this.pos += 4;
+    return value;
+  }
+  readU64() {
+    const value = getUint64(this.view, this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readI64() {
+    const value = getInt64(this.view, this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readU64AsBigInt() {
+    const value = this.view.getBigUint64(this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readI64AsBigInt() {
+    const value = this.view.getBigInt64(this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readF32() {
+    const value = this.view.getFloat32(this.pos);
+    this.pos += 4;
+    return value;
+  }
+  readF64() {
+    const value = this.view.getFloat64(this.pos);
+    this.pos += 8;
+    return value;
+  }
+};
 
-// node_modules/@msgpack/msgpack/dist.es5+esm/decode.mjs
+// ../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/decode.mjs
 function decode(buffer, options) {
-  var decoder = new Decoder(options);
+  const decoder = new Decoder(options);
   return decoder.decode(buffer);
 }
 
 // src/client.ts
 var import_file_saver = __toESM(require_FileSaver_min(), 1);
 
-// node_modules/libsodium.js/dist/modules/libsodium-esm-wrappers.js
+// ../node_modules/.bun/libsodium-wrappers@git+ssh+++github.com+interncom+libsodium.js+e4e764777860213b5cbea520048847ea0a5cb6be/node_modules/libsodium-wrappers/dist/modules/libsodium-esm-wrappers.js
 var libsodium_esm_wrappers_exports = {};
 __export(libsodium_esm_wrappers_exports, {
   AllocatedBuf: () => AllocatedBuf,
@@ -2203,7 +2059,7 @@ __export(libsodium_esm_wrappers_exports, {
   unpad: () => unpad
 });
 
-// node_modules/libsodium.js/dist/modules/libsodium.esm.js
+// ../node_modules/.bun/libsodium-wrappers@git+ssh+++github.com+interncom+libsodium.js+e4e764777860213b5cbea520048847ea0a5cb6be/node_modules/libsodium-wrappers/dist/modules/libsodium.esm.js
 var Module = (() => {
   var _scriptName = import.meta.url;
   return function(moduleArg = {}) {
@@ -2854,7 +2710,7 @@ var Module = (() => {
 })();
 var libsodium_esm_default = Module;
 
-// node_modules/libsodium.js/dist/modules/libsodium-esm-wrappers.js
+// ../node_modules/.bun/libsodium-wrappers@git+ssh+++github.com+interncom+libsodium.js+e4e764777860213b5cbea520048847ea0a5cb6be/node_modules/libsodium-wrappers/dist/modules/libsodium-esm-wrappers.js
 var output_format = "uint8array";
 var libsodium = await libsodium_esm_default();
 if (libsodium._sodium_init() !== 0) {
@@ -8091,13 +7947,6 @@ var Status = /* @__PURE__ */ ((Status2) => {
   Status2[Status2["ConnectionClosed"] = 28] = "ConnectionClosed";
   return Status2;
 })(Status || {});
-var APICallName = /* @__PURE__ */ ((APICallName2) => {
-  APICallName2[APICallName2["User"] = 0] = "User";
-  APICallName2[APICallName2["Peek"] = 1] = "Peek";
-  APICallName2[APICallName2["Push"] = 2] = "Push";
-  APICallName2[APICallName2["Pull"] = 3] = "Pull";
-  return APICallName2;
-})(APICallName || {});
 
 // ../shared/valstat.ts
 function ok(val) {
@@ -8939,7 +8788,7 @@ var userEnd = {
     return 0 /* Success */;
   },
   decodeResp(_respDec) {
-    return [void 0, 0 /* Success */];
+    return ok(void 0);
   }
 };
 
@@ -8973,7 +8822,7 @@ var WebsocketListener = class {
       recv(bytes);
     };
     this.websocket.onerror = (e) => {
-      console.log(`ERROR: ${e}`);
+      console.log(`ERROR: ${JSON.stringify(e)}`);
     };
     return Promise.resolve(0 /* Success */);
   }
@@ -9035,6 +8884,9 @@ var HTTPTransport = class {
     }
   }
 };
+var hostHTTPTransport = (host) => {
+  return new HTTPTransport(host.handle);
+};
 async function post(url, enc) {
   const response = await fetch(url, {
     method: "POST",
@@ -9097,10 +8949,6 @@ var DiplomaticClientAPI = class {
       return err(statMeta);
     }
     const respVS = endpoint.decodeResp(dec);
-    console.info(`API call: ${APICallName[name]}`, {
-      req: items,
-      resp: respVS
-    });
     return respVS;
   }
   keys = () => {
@@ -9345,7 +9193,7 @@ async function genUpsertHead({ now, eid, ctr, bod, crypto }) {
   return ok({ eid, off, ctr, len, hsh });
 }
 
-// src/sync.ts
+// ../shared/sync.ts
 async function decryptPeekItem(item, hostKeys2, enclave, crypto) {
   const dec = new Decoder2(item.headCph);
   const [peekItem, readStatus] = dec.readStruct(peekItemHeadCodec);
@@ -9370,6 +9218,8 @@ async function decryptPeekItem(item, hostKeys2, enclave, crypto) {
   }
   return ok({ kdm, headEnc });
 }
+
+// src/sync.ts
 async function syncPeek({ conn, store, enclave, host, crypto }) {
   const hostKeys2 = await conn.keys();
   const dls = [];
@@ -9920,57 +9770,59 @@ var SyncClient = class {
     return 0 /* Success */;
   }
   // Manage stored host connections.
-  async link(host) {
+  async link(host, connect = true) {
     this.store.hosts.add(host);
     this.clientState.emit();
+    if (connect) {
+      const row = await this.store.hosts.get(host.label);
+      if (row) {
+        this.connectToHost(row);
+      }
+    }
   }
   async unlink(label) {
     await this.store.hosts.del(label);
     this.clientState.emit();
   }
+  connectToHost = async (host, listen = true, sync = true) => {
+    const { clock, connections, crypto, store, transport } = this;
+    if (connections.has(host.label)) return;
+    const enclave = await store.seed.load();
+    if (!enclave) return;
+    console.info(`Connecting to ${host.handle} (${host.label})`);
+    const conn = new DiplomaticClientAPI(
+      enclave,
+      crypto_default,
+      host,
+      clock,
+      transport(host),
+      (meta) => store.hosts.set(host.label, meta)
+    );
+    await conn.register();
+    if (listen) {
+      await conn.listen(async (bytes) => {
+        const syncParams = { conn, store, enclave, host, crypto, clock };
+        return handleNotif(bytes, syncParams, this.apply, this.scheduleSync);
+      });
+    }
+    connections.set(host.label, conn);
+    if (sync) {
+      this.scheduleSync();
+    }
+  };
   // Manage active host connections.
-  async connect(listen = true) {
-    const { clock, crypto, store, transport } = this;
+  async connect(listen = true, sync = true) {
+    const { connectToHost, scheduleSync, store } = this;
     const enclave = await store.seed.load();
     if (!enclave) {
       return;
     }
     const hosts = await store.hosts.list();
     for (const host of hosts) {
-      const { label } = host;
-      if (this.connections.has(label)) {
-        continue;
-      }
-      console.info(`Connecting to ${host.handle} (${label})`);
-      const txport = transport(host);
-      const conn = new DiplomaticClientAPI(
-        enclave,
-        crypto_default,
-        host,
-        clock,
-        txport,
-        (meta) => this.store.hosts.set(label, meta)
-      );
-      await conn.register();
-      if (listen) {
-        const recv = async (bytes) => {
-          handleNotif(
-            bytes,
-            {
-              conn,
-              store,
-              enclave,
-              host,
-              crypto,
-              clock
-            },
-            this.apply,
-            this.scheduleSync
-          );
-        };
-        await conn.listen(recv);
-      }
-      this.connections.set(host.label, conn);
+      await connectToHost(host, listen, false);
+    }
+    if (sync) {
+      scheduleSync();
     }
   }
   disconnect = async () => {
@@ -10116,7 +9968,7 @@ function applyOp(curr, op) {
 }
 var nullEntDB = {
   getEnt: async () => err(21 /* NotImplemented */),
-  getEntities: async () => err(21 /* NotImplemented */),
+  getEntities: async (_query) => err(21 /* NotImplemented */),
   countEntities: async () => err(21 /* NotImplemented */),
   apply: async (ops) => ({
     stats: ops.map(() => 21 /* NotImplemented */),
@@ -10373,16 +10225,16 @@ var EntIDB = class {
       req.onerror = () => resolve(err(18 /* DatabaseError */));
     });
   }
-  async getAllEntities({ type, gid, pid, updatedBetween }) {
+  async getAllEntities(query) {
     if (!this.db) {
       return err(16 /* DatabaseClosed */);
     }
-    if (pid !== void 0) {
-      const pidB64 = btob64(pid);
+    if ("pid" in query) {
+      const pidB64 = btob64(query.pid);
       const tx = this.db.transaction(entityTableName, "readonly");
       const index = tx.objectStore(entityTableName).index(typeParentIndexName);
       return new Promise((resolve) => {
-        const req = index.getAll(IDBKeyRange.only([type, pidB64]));
+        const req = index.getAll(IDBKeyRange.only([query.type, pidB64]));
         req.onsuccess = () => {
           const storedEnts = req.result;
           const ents = storedEnts.map(storedToEntity);
@@ -10390,16 +10242,16 @@ var EntIDB = class {
         };
         req.onerror = () => resolve(err(18 /* DatabaseError */));
       });
-    } else if (gid !== void 0) {
-      return await this.getGroupMembers(type, gid);
-    } else if (updatedBetween !== void 0) {
+    } else if ("gid" in query) {
+      return await this.getGroupMembers(query.type, query.gid);
+    } else if ("updatedBetween" in query) {
       return await this.getAllOfTypeUpdatedBetween(
-        type,
-        updatedBetween.start,
-        updatedBetween.end
+        query.type,
+        query.updatedBetween.start,
+        query.updatedBetween.end
       );
     }
-    return await this.getAllOfType(type);
+    return await this.getAllOfType(query.type);
   }
   async getEntities(query) {
     const [ents, stat] = await this.getAllEntities(query);
@@ -10422,6 +10274,11 @@ var EntIDB = class {
     });
   }
 };
+async function openEntIDB() {
+  const entDB = new EntIDB();
+  await entDB.init();
+  return entDB;
+}
 
 // src/entdb/memory.ts
 var EntDBMemory = class {
@@ -10515,79 +10372,6 @@ var EntDBMemory = class {
 
 // src/react/useClient.ts
 import { useEffect, useState } from "react";
-function useClientState(client) {
-  const [state, setState] = useState();
-  useEffect(() => {
-    async function updateState() {
-      const state2 = await client.clientState.get();
-      setState(state2);
-    }
-    const unsubscribe = client.clientState.listen(updateState);
-    updateState();
-    return () => {
-      unsubscribe();
-    };
-  }, [client]);
-  return state;
-}
-function useClientXferState(client) {
-  const [state, setState] = useState();
-  useEffect(() => {
-    async function updateState() {
-      const state2 = await client.xferState.get();
-      setState(state2);
-    }
-    const unsubscribe = client.xferState.listen(updateState);
-    updateState();
-    return () => {
-      unsubscribe();
-    };
-  }, [client]);
-  return state;
-}
-function useSyncOnResume(client) {
-  useEffect(() => {
-    async function handleOnline() {
-      await client.connect();
-      await client.sync();
-    }
-    globalThis.addEventListener("online", handleOnline);
-    return () => {
-      globalThis.removeEventListener("online", handleOnline);
-    };
-  }, [client]);
-}
-
-// src/react/useStateWatcher.ts
-import { use, useEffect as useEffect2, useRef, useState as useState2 } from "react";
-function useStateWatcher(mgr, opType, callback) {
-  const [val, setVal] = useState2();
-  useEffect2(() => {
-    async function update() {
-      const newVal = await callback();
-      setVal(newVal);
-    }
-    update();
-    mgr.on(opType, update);
-    return () => {
-      mgr.off(opType, update);
-    };
-  }, [mgr, opType, callback]);
-  return val;
-}
-function useStateWatcherSuspense(mgr, opType, callback) {
-  const promiseRef = useRef(callback());
-  useEffect2(() => {
-    async function update() {
-      promiseRef.current = callback();
-    }
-    mgr.on(opType, update);
-    return () => {
-      mgr.off(opType, update);
-    };
-  }, [mgr, opType, callback]);
-  return use(promiseRef.current);
-}
 
 // src/stores/idb/dnlds.ts
 var IDBDownloadQueue = class {
@@ -11086,7 +10870,7 @@ var IDBStore = class {
     await this.messages.wipe();
   }
 };
-async function openIDBStore() {
+async function openIDBStoreDB() {
   return new Promise((resolve, reject) => {
     const req = indexedDB.open("diplomatic-store-db", 2);
     req.onupgradeneeded = () => {
@@ -11115,6 +10899,104 @@ async function openIDBStore() {
     req.onerror = () => reject(req.error);
   });
 }
+async function openIDBStore(crypto) {
+  const db = await openIDBStoreDB();
+  return new IDBStore(db, crypto);
+}
+
+// src/react/useClient.ts
+function useClientState(client) {
+  const [state, setState] = useState();
+  useEffect(() => {
+    async function updateState() {
+      const state2 = await client.clientState.get();
+      setState(state2);
+    }
+    const unsubscribe = client.clientState.listen(updateState);
+    updateState();
+    return () => {
+      unsubscribe();
+    };
+  }, [client]);
+  return state;
+}
+function useClientXferState(client) {
+  const [state, setState] = useState();
+  useEffect(() => {
+    async function updateState() {
+      const state2 = await client.xferState.get();
+      setState(state2);
+    }
+    const unsubscribe = client.xferState.listen(updateState);
+    updateState();
+    return () => {
+      unsubscribe();
+    };
+  }, [client]);
+  return state;
+}
+function useSyncOnResume(client) {
+  useEffect(() => {
+    async function handleOnline() {
+      await client.connect();
+      await client.sync();
+    }
+    globalThis.addEventListener("online", handleOnline);
+    return () => {
+      globalThis.removeEventListener("online", handleOnline);
+    };
+  }, [client]);
+}
+function useClient({ clock = new Clock(), seed, host }) {
+  const [diplomaticState, setDiplomaticState] = useState({ stateMgr: nullStateManager });
+  useEffect(() => {
+    Promise.all([openIDBStore(crypto_default), openEntIDB()]).then(
+      async ([store, entDB]) => {
+        const entMgr = entStateManager(entDB);
+        const client = new SyncClient(clock, entMgr, store, hostHTTPTransport);
+        if (seed) {
+          await client.setSeed(seed);
+        }
+        if (host) {
+          await client.link(host);
+        }
+        setDiplomaticState({ client, entDB, stateMgr: entMgr });
+      }
+    );
+  }, [clock, seed]);
+  return diplomaticState;
+}
+
+// src/react/useStateWatcher.ts
+import { use, useEffect as useEffect2, useRef, useState as useState2 } from "react";
+function useStateWatcher(mgr, opType, callback) {
+  const [val, setVal] = useState2();
+  useEffect2(() => {
+    async function update() {
+      const newVal = await callback();
+      setVal(newVal);
+    }
+    update();
+    mgr.on(opType, update);
+    return () => {
+      mgr.off(opType, update);
+    };
+  }, [mgr, opType, callback]);
+  return val;
+}
+function useStateWatcherSuspense(mgr, opType, callback) {
+  const promiseRef = useRef(callback());
+  useEffect2(() => {
+    async function update() {
+      promiseRef.current = callback();
+    }
+    mgr.on(opType, update);
+    return () => {
+      mgr.off(opType, update);
+    };
+  }, [mgr, opType, callback]);
+  return use(promiseRef.current);
+}
 
 // src/stores/memory/dnlds.ts
 function keyFor(host, seq) {
@@ -11327,18 +11209,13 @@ var MemoryStore = class {
 };
 
 // src/index.ts
-var hostHTTPTransport = (host) => {
-  return new HTTPTransport(host.handle);
-};
 async function genWebClient(stateMgr, url) {
-  const idb = await openIDBStore();
-  const idbStore = new IDBStore(idb, crypto_default);
-  const transport = (host) => new HTTPTransport(host.handle);
+  const idbStore = await openIDBStore(crypto_default);
   const client = new SyncClient(
     new Clock(),
     stateMgr,
     idbStore,
-    transport
+    hostHTTPTransport
   );
   const setSeed = async (seedHex) => {
     const seed = htob(seedHex);
@@ -11362,12 +11239,13 @@ export {
   entStateManager,
   genSingletonEID,
   genWebClient,
-  hostHTTPTransport,
   htob,
   crypto_default as libsodiumCrypto,
   nullEntDB,
   nullStateManager,
+  openEntIDB,
   openIDBStore,
+  useClient,
   useClientState,
   useClientXferState,
   useStateWatcher,