var __bare_os_bundle_exports__ = (() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __commonJS = (cb, mod) => function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

  // ../../node_modules/b4a/index.js
  var require_b4a = __commonJS({
    "../../node_modules/b4a/index.js"(exports, module) {
      function isBuffer(value) {
        return Buffer.isBuffer(value) || value instanceof Uint8Array;
      }
      function isEncoding(encoding) {
        return Buffer.isEncoding(encoding);
      }
      function alloc(size, fill2, encoding) {
        return Buffer.alloc(size, fill2, encoding);
      }
      function allocUnsafe(size) {
        return Buffer.allocUnsafe(size);
      }
      function allocUnsafeSlow(size) {
        return Buffer.allocUnsafeSlow(size);
      }
      function byteLength(string, encoding) {
        return Buffer.byteLength(string, encoding);
      }
      function compare(a, b) {
        return Buffer.compare(a, b);
      }
      function concat(buffers, totalLength) {
        return Buffer.concat(buffers, totalLength);
      }
      function copy(source, target, targetStart, start, end) {
        return toBuffer(source).copy(target, targetStart, start, end);
      }
      function equals(a, b) {
        return toBuffer(a).equals(b);
      }
      function fill(buffer, value, offset, end, encoding) {
        return toBuffer(buffer).fill(value, offset, end, encoding);
      }
      function from(value, encodingOrOffset, length) {
        return Buffer.from(value, encodingOrOffset, length);
      }
      function includes(buffer, value, byteOffset, encoding) {
        return toBuffer(buffer).includes(value, byteOffset, encoding);
      }
      function indexOf(buffer, value, byfeOffset, encoding) {
        return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
      }
      function lastIndexOf(buffer, value, byteOffset, encoding) {
        return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
      }
      function swap16(buffer) {
        return toBuffer(buffer).swap16();
      }
      function swap32(buffer) {
        return toBuffer(buffer).swap32();
      }
      function swap64(buffer) {
        return toBuffer(buffer).swap64();
      }
      function toBuffer(buffer) {
        if (Buffer.isBuffer(buffer)) return buffer;
        return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
      }
      function toString(buffer, encoding, start, end) {
        return toBuffer(buffer).toString(encoding, start, end);
      }
      function write(buffer, string, offset, length, encoding) {
        return toBuffer(buffer).write(string, offset, length, encoding);
      }
      function readDoubleBE(buffer, offset) {
        return toBuffer(buffer).readDoubleBE(offset);
      }
      function readDoubleLE(buffer, offset) {
        return toBuffer(buffer).readDoubleLE(offset);
      }
      function readFloatBE(buffer, offset) {
        return toBuffer(buffer).readFloatBE(offset);
      }
      function readFloatLE(buffer, offset) {
        return toBuffer(buffer).readFloatLE(offset);
      }
      function readInt32BE(buffer, offset) {
        return toBuffer(buffer).readInt32BE(offset);
      }
      function readInt32LE(buffer, offset) {
        return toBuffer(buffer).readInt32LE(offset);
      }
      function readUInt32BE(buffer, offset) {
        return toBuffer(buffer).readUInt32BE(offset);
      }
      function readUInt32LE(buffer, offset) {
        return toBuffer(buffer).readUInt32LE(offset);
      }
      function writeDoubleBE(buffer, value, offset) {
        return toBuffer(buffer).writeDoubleBE(value, offset);
      }
      function writeDoubleLE(buffer, value, offset) {
        return toBuffer(buffer).writeDoubleLE(value, offset);
      }
      function writeFloatBE(buffer, value, offset) {
        return toBuffer(buffer).writeFloatBE(value, offset);
      }
      function writeFloatLE(buffer, value, offset) {
        return toBuffer(buffer).writeFloatLE(value, offset);
      }
      function writeInt32BE(buffer, value, offset) {
        return toBuffer(buffer).writeInt32BE(value, offset);
      }
      function writeInt32LE(buffer, value, offset) {
        return toBuffer(buffer).writeInt32LE(value, offset);
      }
      function writeUInt32BE(buffer, value, offset) {
        return toBuffer(buffer).writeUInt32BE(value, offset);
      }
      function writeUInt32LE(buffer, value, offset) {
        return toBuffer(buffer).writeUInt32LE(value, offset);
      }
      module.exports = {
        isBuffer,
        isEncoding,
        alloc,
        allocUnsafe,
        allocUnsafeSlow,
        byteLength,
        compare,
        concat,
        copy,
        equals,
        fill,
        from,
        includes,
        indexOf,
        lastIndexOf,
        swap16,
        swap32,
        swap64,
        toBuffer,
        toString,
        write,
        readDoubleBE,
        readDoubleLE,
        readFloatBE,
        readFloatLE,
        readInt32BE,
        readInt32LE,
        readUInt32BE,
        readUInt32LE,
        writeDoubleBE,
        writeDoubleLE,
        writeFloatBE,
        writeFloatLE,
        writeInt32BE,
        writeInt32LE,
        writeUInt32BE,
        writeUInt32LE
      };
    }
  });

  // ../../node_modules/protomux/node_modules/compact-encoding/endian.js
  var require_endian = __commonJS({
    "../../node_modules/protomux/node_modules/compact-encoding/endian.js"(exports) {
      var LE = exports.LE = new Uint8Array(new Uint16Array([255]).buffer)[0] === 255;
      exports.BE = !LE;
    }
  });

  // ../../node_modules/protomux/node_modules/compact-encoding/raw.js
  var require_raw = __commonJS({
    "../../node_modules/protomux/node_modules/compact-encoding/raw.js"(exports, module) {
      var b4a = require_b4a();
      var { BE } = require_endian();
      exports = module.exports = {
        preencode(state, b) {
          state.end += b.byteLength;
        },
        encode(state, b) {
          state.buffer.set(b, state.start);
          state.start += b.byteLength;
        },
        decode(state) {
          const b = state.buffer.subarray(state.start, state.end);
          state.start = state.end;
          return b;
        }
      };
      var buffer = exports.buffer = {
        preencode(state, b) {
          uint8array.preencode(state, b);
        },
        encode(state, b) {
          uint8array.encode(state, b);
        },
        decode(state) {
          const b = state.buffer.subarray(state.start);
          state.start = state.end;
          return b;
        }
      };
      exports.binary = {
        ...buffer,
        preencode(state, b) {
          if (typeof b === "string") utf8.preencode(state, b);
          else buffer.preencode(state, b);
        },
        encode(state, b) {
          if (typeof b === "string") utf8.encode(state, b);
          else buffer.encode(state, b);
        }
      };
      exports.arraybuffer = {
        preencode(state, b) {
          state.end += b.byteLength;
        },
        encode(state, b) {
          const view = new Uint8Array(b);
          state.buffer.set(view, state.start);
          state.start += b.byteLength;
        },
        decode(state) {
          const b = new ArrayBuffer(state.end - state.start);
          const view = new Uint8Array(b);
          view.set(state.buffer.subarray(state.start));
          state.start = state.end;
          return b;
        }
      };
      function typedarray(TypedArray, swap) {
        const n = TypedArray.BYTES_PER_ELEMENT;
        return {
          preencode(state, b) {
            state.end += b.byteLength;
          },
          encode(state, b) {
            const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
            if (BE && swap) swap(view);
            state.buffer.set(view, state.start);
            state.start += b.byteLength;
          },
          decode(state) {
            let b = state.buffer.subarray(state.start);
            if (b.byteOffset % n !== 0) b = new Uint8Array(b);
            if (BE && swap) swap(b);
            state.start = state.end;
            return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n);
          }
        };
      }
      var uint8array = exports.uint8array = typedarray(Uint8Array);
      exports.uint16array = typedarray(Uint16Array, b4a.swap16);
      exports.uint32array = typedarray(Uint32Array, b4a.swap32);
      exports.int8array = typedarray(Int8Array);
      exports.int16array = typedarray(Int16Array, b4a.swap16);
      exports.int32array = typedarray(Int32Array, b4a.swap32);
      exports.biguint64array = typedarray(BigUint64Array, b4a.swap64);
      exports.bigint64array = typedarray(BigInt64Array, b4a.swap64);
      exports.float32array = typedarray(Float32Array, b4a.swap32);
      exports.float64array = typedarray(Float64Array, b4a.swap64);
      function string(encoding) {
        return {
          preencode(state, s) {
            state.end += b4a.byteLength(s, encoding);
          },
          encode(state, s) {
            state.start += b4a.write(state.buffer, s, state.start, encoding);
          },
          decode(state) {
            const s = b4a.toString(state.buffer, encoding, state.start);
            state.start = state.end;
            return s;
          }
        };
      }
      var utf8 = exports.string = exports.utf8 = string("utf-8");
      exports.ascii = string("ascii");
      exports.hex = string("hex");
      exports.base64 = string("base64");
      exports.ucs2 = exports.utf16le = string("utf16le");
      exports.array = function array(enc) {
        return {
          preencode(state, list) {
            for (const value of list) enc.preencode(state, value);
          },
          encode(state, list) {
            for (const value of list) enc.encode(state, value);
          },
          decode(state) {
            const arr = [];
            while (state.start < state.end) arr.push(enc.decode(state));
            return arr;
          }
        };
      };
      exports.json = {
        preencode(state, v) {
          utf8.preencode(state, JSON.stringify(v));
        },
        encode(state, v) {
          utf8.encode(state, JSON.stringify(v));
        },
        decode(state) {
          return JSON.parse(utf8.decode(state));
        }
      };
      exports.ndjson = {
        preencode(state, v) {
          utf8.preencode(state, JSON.stringify(v) + "\n");
        },
        encode(state, v) {
          utf8.encode(state, JSON.stringify(v) + "\n");
        },
        decode(state) {
          return JSON.parse(utf8.decode(state));
        }
      };
    }
  });

  // ../../node_modules/protomux/node_modules/compact-encoding/lexint.js
  var require_lexint = __commonJS({
    "../../node_modules/protomux/node_modules/compact-encoding/lexint.js"(exports, module) {
      module.exports = {
        preencode,
        encode,
        decode
      };
      function preencode(state, num) {
        if (num < 251) {
          state.end++;
        } else if (num < 256) {
          state.end += 2;
        } else if (num < 65536) {
          state.end += 3;
        } else if (num < 16777216) {
          state.end += 4;
        } else if (num < 4294967296) {
          state.end += 5;
        } else {
          state.end++;
          const exp = Math.floor(Math.log(num) / Math.log(2)) - 32;
          preencode(state, exp);
          state.end += 6;
        }
      }
      function encode(state, num) {
        const max = 251;
        const x = num - max;
        if (num < max) {
          state.buffer[state.start++] = num;
        } else if (num < 256) {
          state.buffer[state.start++] = max;
          state.buffer[state.start++] = x;
        } else if (num < 65536) {
          state.buffer[state.start++] = max + 1;
          state.buffer[state.start++] = x >> 8 & 255;
          state.buffer[state.start++] = x & 255;
        } else if (num < 16777216) {
          state.buffer[state.start++] = max + 2;
          state.buffer[state.start++] = x >> 16;
          state.buffer[state.start++] = x >> 8 & 255;
          state.buffer[state.start++] = x & 255;
        } else if (num < 4294967296) {
          state.buffer[state.start++] = max + 3;
          state.buffer[state.start++] = x >> 24;
          state.buffer[state.start++] = x >> 16 & 255;
          state.buffer[state.start++] = x >> 8 & 255;
          state.buffer[state.start++] = x & 255;
        } else {
          const exp = Math.floor(Math.log(x) / Math.log(2)) - 32;
          state.buffer[state.start++] = 255;
          encode(state, exp);
          const rem = x / Math.pow(2, exp - 11);
          for (let i = 5; i >= 0; i--) {
            state.buffer[state.start++] = rem / Math.pow(2, 8 * i) & 255;
          }
        }
      }
      function decode(state) {
        const max = 251;
        if (state.end - state.start < 1) throw new Error("Out of bounds");
        const flag = state.buffer[state.start++];
        if (flag < max) return flag;
        if (state.end - state.start < flag - max + 1) {
          throw new Error("Out of bounds.");
        }
        if (flag < 252) {
          return state.buffer[state.start++] + max;
        }
        if (flag < 253) {
          return (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
        }
        if (flag < 254) {
          return (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
        }
        if (flag < 255) {
          return state.buffer[state.start++] * 16777216 + (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
        }
        const exp = decode(state);
        if (state.end - state.start < 6) throw new Error("Out of bounds");
        let rem = 0;
        for (let i = 5; i >= 0; i--) {
          rem += state.buffer[state.start++] * Math.pow(2, 8 * i);
        }
        return rem * Math.pow(2, exp - 11) + max;
      }
    }
  });

  // ../../node_modules/protomux/node_modules/compact-encoding/index.js
  var require_compact_encoding = __commonJS({
    "../../node_modules/protomux/node_modules/compact-encoding/index.js"(exports) {
      var b4a = require_b4a();
      var { BE } = require_endian();
      exports.state = function(start = 0, end = 0, buffer2 = null) {
        return { start, end, buffer: buffer2 };
      };
      var raw = exports.raw = require_raw();
      var uint = exports.uint = {
        preencode(state, n) {
          state.end += n <= 252 ? 1 : n <= 65535 ? 3 : n <= 4294967295 ? 5 : 9;
        },
        encode(state, n) {
          if (n <= 252) uint8.encode(state, n);
          else if (n <= 65535) {
            state.buffer[state.start++] = 253;
            uint16.encode(state, n);
          } else if (n <= 4294967295) {
            state.buffer[state.start++] = 254;
            uint32.encode(state, n);
          } else {
            state.buffer[state.start++] = 255;
            uint64.encode(state, n);
          }
        },
        decode(state) {
          const a = uint8.decode(state);
          if (a <= 252) return a;
          if (a === 253) return uint16.decode(state);
          if (a === 254) return uint32.decode(state);
          return uint64.decode(state);
        }
      };
      var uint8 = exports.uint8 = {
        preencode(state, n) {
          state.end += 1;
        },
        encode(state, n) {
          validateUint(n);
          state.buffer[state.start++] = n;
        },
        decode(state) {
          if (state.start >= state.end) throw new Error("Out of bounds");
          return state.buffer[state.start++];
        }
      };
      var uint16 = exports.uint16 = {
        preencode(state, n) {
          state.end += 2;
        },
        encode(state, n) {
          validateUint(n);
          state.buffer[state.start++] = n;
          state.buffer[state.start++] = n >>> 8;
        },
        decode(state) {
          if (state.end - state.start < 2) throw new Error("Out of bounds");
          return state.buffer[state.start++] + state.buffer[state.start++] * 256;
        }
      };
      var uint24 = exports.uint24 = {
        preencode(state, n) {
          state.end += 3;
        },
        encode(state, n) {
          validateUint(n);
          state.buffer[state.start++] = n;
          state.buffer[state.start++] = n >>> 8;
          state.buffer[state.start++] = n >>> 16;
        },
        decode(state) {
          if (state.end - state.start < 3) throw new Error("Out of bounds");
          return state.buffer[state.start++] + state.buffer[state.start++] * 256 + state.buffer[state.start++] * 65536;
        }
      };
      var uint32 = exports.uint32 = {
        preencode(state, n) {
          state.end += 4;
        },
        encode(state, n) {
          validateUint(n);
          state.buffer[state.start++] = n;
          state.buffer[state.start++] = n >>> 8;
          state.buffer[state.start++] = n >>> 16;
          state.buffer[state.start++] = n >>> 24;
        },
        decode(state) {
          if (state.end - state.start < 4) throw new Error("Out of bounds");
          return state.buffer[state.start++] + state.buffer[state.start++] * 256 + state.buffer[state.start++] * 65536 + state.buffer[state.start++] * 16777216;
        }
      };
      var uint32be = exports.uint32be = {
        preencode(state, n) {
          state.end += 4;
        },
        encode(state, n) {
          validateUint(n);
          state.buffer[state.start++] = n >>> 24;
          state.buffer[state.start++] = n >>> 16;
          state.buffer[state.start++] = n >>> 8;
          state.buffer[state.start++] = n;
        },
        decode(state) {
          if (state.end - state.start < 4) throw new Error("Out of bounds");
          return state.buffer[state.start++] * 16777216 + state.buffer[state.start++] * 65536 + state.buffer[state.start++] * 256 + state.buffer[state.start++];
        }
      };
      var uint40 = exports.uint40 = {
        preencode(state, n) {
          state.end += 5;
        },
        encode(state, n) {
          validateUint(n);
          const r = Math.floor(n / 256);
          uint8.encode(state, n);
          uint32.encode(state, r);
        },
        decode(state) {
          if (state.end - state.start < 5) throw new Error("Out of bounds");
          return uint8.decode(state) + 256 * uint32.decode(state);
        }
      };
      var uint48 = exports.uint48 = {
        preencode(state, n) {
          state.end += 6;
        },
        encode(state, n) {
          validateUint(n);
          const r = Math.floor(n / 65536);
          uint16.encode(state, n);
          uint32.encode(state, r);
        },
        decode(state) {
          if (state.end - state.start < 6) throw new Error("Out of bounds");
          return uint16.decode(state) + 65536 * uint32.decode(state);
        }
      };
      var uint56 = exports.uint56 = {
        preencode(state, n) {
          state.end += 7;
        },
        encode(state, n) {
          validateUint(n);
          const r = Math.floor(n / 16777216);
          uint24.encode(state, n);
          uint32.encode(state, r);
        },
        decode(state) {
          if (state.end - state.start < 7) throw new Error("Out of bounds");
          return validateSafeUint(
            uint24.decode(state) + 16777216 * uint32.decode(state)
          );
        }
      };
      var uint64 = exports.uint64 = {
        preencode(state, n) {
          state.end += 8;
        },
        encode(state, n) {
          validateUint(n);
          const r = Math.floor(n / 4294967296);
          uint32.encode(state, n);
          uint32.encode(state, r);
        },
        decode(state) {
          if (state.end - state.start < 8) throw new Error("Out of bounds");
          return validateSafeUint(
            uint32.decode(state) + 4294967296 * uint32.decode(state)
          );
        }
      };
      exports.uint64be = {
        preencode(state, n) {
          state.end += 8;
        },
        encode(state, n) {
          validateUint(n);
          const r = Math.floor(n / 4294967296);
          uint32be.encode(state, r);
          uint32be.encode(state, n);
        },
        decode(state) {
          if (state.end - state.start < 8) throw new Error("Out of bounds");
          return validateSafeUint(
            4294967296 * uint32be.decode(state) + uint32be.decode(state)
          );
        }
      };
      var int = exports.int = zigZagInt(uint);
      exports.int8 = zigZagInt(uint8);
      exports.int16 = zigZagInt(uint16);
      exports.int24 = zigZagInt(uint24);
      exports.int32 = zigZagInt(uint32);
      exports.int40 = zigZagInt(uint40);
      exports.int48 = zigZagInt(uint48);
      exports.int56 = zigZagInt(uint56);
      exports.int64 = zigZagInt(uint64);
      var biguint64 = exports.biguint64 = {
        preencode(state, n) {
          state.end += 8;
        },
        encode(state, n) {
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8
          );
          view.setBigUint64(0, n, true);
          state.start += 8;
        },
        decode(state) {
          if (state.end - state.start < 8) throw new Error("Out of bounds");
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8
          );
          const n = view.getBigUint64(0, true);
          state.start += 8;
          return n;
        }
      };
      exports.bigint64 = zigZagBigInt(biguint64);
      var biguint = exports.biguint = {
        preencode(state, n) {
          let len = 0;
          for (let m = n; m; m = m >> 64n) len++;
          uint.preencode(state, len);
          state.end += 8 * len;
        },
        encode(state, n) {
          let len = 0;
          for (let m = n; m; m = m >> 64n) len++;
          uint.encode(state, len);
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8 * len
          );
          for (let m = n, i = 0; m; m = m >> 64n, i += 8) {
            view.setBigUint64(i, BigInt.asUintN(64, m), true);
          }
          state.start += 8 * len;
        },
        decode(state) {
          const len = uint.decode(state);
          if (state.end - state.start < 8 * len) throw new Error("Out of bounds");
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8 * len
          );
          let n = 0n;
          for (let i = len - 1; i >= 0; i--)
            n = (n << 64n) + view.getBigUint64(i * 8, true);
          state.start += 8 * len;
          return n;
        }
      };
      exports.bigint = zigZagBigInt(biguint);
      exports.lexint = require_lexint();
      exports.float32 = {
        preencode(state, n) {
          state.end += 4;
        },
        encode(state, n) {
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            4
          );
          view.setFloat32(0, n, true);
          state.start += 4;
        },
        decode(state) {
          if (state.end - state.start < 4) throw new Error("Out of bounds");
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            4
          );
          const float = view.getFloat32(0, true);
          state.start += 4;
          return float;
        }
      };
      exports.float64 = {
        preencode(state, n) {
          state.end += 8;
        },
        encode(state, n) {
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8
          );
          view.setFloat64(0, n, true);
          state.start += 8;
        },
        decode(state) {
          if (state.end - state.start < 8) throw new Error("Out of bounds");
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8
          );
          const float = view.getFloat64(0, true);
          state.start += 8;
          return float;
        }
      };
      var buffer = exports.buffer = {
        preencode(state, b) {
          uint8array.preencode(state, b);
        },
        encode(state, b) {
          uint8array.encode(state, b);
        },
        decode(state) {
          const len = uint.decode(state);
          if (state.end - state.start < len) throw new Error("Out of bounds");
          return state.buffer.subarray(state.start, state.start += len);
        }
      };
      exports.optionalBuffer = {
        preencode(state, b) {
          if (b) uint8array.preencode(state, b);
          else state.end++;
        },
        encode(state, b) {
          if (b) uint8array.encode(state, b);
          else state.buffer[state.start++] = 0;
        },
        decode(state) {
          const len = uint.decode(state);
          if (len === 0) return null;
          if (state.end - state.start < len) throw new Error("Out of bounds");
          return state.buffer.subarray(state.start, state.start += len);
        }
      };
      exports.binary = {
        ...buffer,
        preencode(state, b) {
          if (typeof b === "string") utf8.preencode(state, b);
          else buffer.preencode(state, b);
        },
        encode(state, b) {
          if (typeof b === "string") utf8.encode(state, b);
          else buffer.encode(state, b);
        }
      };
      exports.arraybuffer = {
        preencode(state, b) {
          uint.preencode(state, b.byteLength);
          state.end += b.byteLength;
        },
        encode(state, b) {
          uint.encode(state, b.byteLength);
          const view = new Uint8Array(b);
          state.buffer.set(view, state.start);
          state.start += b.byteLength;
        },
        decode(state) {
          const len = uint.decode(state);
          const b = new ArrayBuffer(len);
          const view = new Uint8Array(b);
          view.set(state.buffer.subarray(state.start, state.start += len));
          return b;
        }
      };
      function typedarray(TypedArray, swap) {
        const n = TypedArray.BYTES_PER_ELEMENT;
        return {
          preencode(state, b) {
            uint.preencode(state, b.length);
            state.end += b.byteLength;
          },
          encode(state, b) {
            uint.encode(state, b.length);
            const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
            if (BE && swap) swap(view);
            state.buffer.set(view, state.start);
            state.start += b.byteLength;
          },
          decode(state) {
            const len = uint.decode(state);
            let b = state.buffer.subarray(state.start, state.start += len * n);
            if (b.byteLength !== len * n) throw new Error("Out of bounds");
            if (b.byteOffset % n !== 0) b = new Uint8Array(b);
            if (BE && swap) swap(b);
            return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n);
          }
        };
      }
      var uint8array = exports.uint8array = typedarray(Uint8Array);
      exports.uint16array = typedarray(Uint16Array, b4a.swap16);
      exports.uint32array = typedarray(Uint32Array, b4a.swap32);
      exports.int8array = typedarray(Int8Array);
      exports.int16array = typedarray(Int16Array, b4a.swap16);
      exports.int32array = typedarray(Int32Array, b4a.swap32);
      exports.biguint64array = typedarray(BigUint64Array, b4a.swap64);
      exports.bigint64array = typedarray(BigInt64Array, b4a.swap64);
      exports.float32array = typedarray(Float32Array, b4a.swap32);
      exports.float64array = typedarray(Float64Array, b4a.swap64);
      function string(encoding) {
        return {
          preencode(state, s) {
            const len = b4a.byteLength(s, encoding);
            uint.preencode(state, len);
            state.end += len;
          },
          encode(state, s) {
            const len = b4a.byteLength(s, encoding);
            uint.encode(state, len);
            b4a.write(state.buffer, s, state.start, encoding);
            state.start += len;
          },
          decode(state) {
            const len = uint.decode(state);
            if (state.end - state.start < len) throw new Error("Out of bounds");
            return b4a.toString(
              state.buffer,
              encoding,
              state.start,
              state.start += len
            );
          },
          fixed(n) {
            return {
              preencode(state) {
                state.end += n;
              },
              encode(state, s) {
                b4a.write(state.buffer, s, state.start, n, encoding);
                state.start += n;
              },
              decode(state) {
                if (state.end - state.start < n) throw new Error("Out of bounds");
                return b4a.toString(
                  state.buffer,
                  encoding,
                  state.start,
                  state.start += n
                );
              }
            };
          }
        };
      }
      var utf8 = exports.string = exports.utf8 = string("utf-8");
      exports.ascii = string("ascii");
      exports.hex = string("hex");
      exports.base64 = string("base64");
      exports.ucs2 = exports.utf16le = string("utf16le");
      exports.bool = {
        preencode(state, b) {
          state.end++;
        },
        encode(state, b) {
          state.buffer[state.start++] = b ? 1 : 0;
        },
        decode(state) {
          if (state.start >= state.end) throw Error("Out of bounds");
          return state.buffer[state.start++] === 1;
        }
      };
      var fixed = exports.fixed = function fixed2(n) {
        return {
          preencode(state, s) {
            if (s.byteLength !== n) throw new Error("Incorrect buffer size");
            state.end += n;
          },
          encode(state, s) {
            state.buffer.set(s, state.start);
            state.start += n;
          },
          decode(state) {
            if (state.end - state.start < n) throw new Error("Out of bounds");
            return state.buffer.subarray(state.start, state.start += n);
          }
        };
      };
      exports.fixed32 = fixed(32);
      exports.fixed64 = fixed(64);
      exports.array = function array(enc) {
        return {
          preencode(state, list) {
            uint.preencode(state, list.length);
            for (let i = 0; i < list.length; i++) enc.preencode(state, list[i]);
          },
          encode(state, list) {
            uint.encode(state, list.length);
            for (let i = 0; i < list.length; i++) enc.encode(state, list[i]);
          },
          decode(state) {
            const len = uint.decode(state);
            if (len > 1048576) throw new Error("Array is too big");
            const arr = new Array(len);
            for (let i = 0; i < len; i++) arr[i] = enc.decode(state);
            return arr;
          }
        };
      };
      exports.frame = function frame(enc) {
        const dummy = exports.state();
        return {
          preencode(state, m) {
            const end = state.end;
            enc.preencode(state, m);
            uint.preencode(state, state.end - end);
          },
          encode(state, m) {
            dummy.end = 0;
            enc.preencode(dummy, m);
            uint.encode(state, dummy.end);
            enc.encode(state, m);
          },
          decode(state) {
            const end = state.end;
            const len = uint.decode(state);
            state.end = state.start + len;
            const m = enc.decode(state);
            state.start = state.end;
            state.end = end;
            return m;
          }
        };
      };
      exports.date = {
        preencode(state, d) {
          int.preencode(state, d.getTime());
        },
        encode(state, d) {
          int.encode(state, d.getTime());
        },
        decode(state, d) {
          return new Date(int.decode(state));
        }
      };
      exports.json = {
        preencode(state, v) {
          utf8.preencode(state, JSON.stringify(v));
        },
        encode(state, v) {
          utf8.encode(state, JSON.stringify(v));
        },
        decode(state) {
          return JSON.parse(utf8.decode(state));
        }
      };
      exports.ndjson = {
        preencode(state, v) {
          utf8.preencode(state, JSON.stringify(v) + "\n");
        },
        encode(state, v) {
          utf8.encode(state, JSON.stringify(v) + "\n");
        },
        decode(state) {
          return JSON.parse(utf8.decode(state));
        }
      };
      exports.none = {
        preencode(state, n) {
        },
        encode(state, n) {
        },
        decode(state) {
          return null;
        }
      };
      var anyArray = {
        preencode(state, arr) {
          uint.preencode(state, arr.length);
          for (let i = 0; i < arr.length; i++) {
            any.preencode(state, arr[i]);
          }
        },
        encode(state, arr) {
          uint.encode(state, arr.length);
          for (let i = 0; i < arr.length; i++) {
            any.encode(state, arr[i]);
          }
        },
        decode(state) {
          const arr = [];
          let len = uint.decode(state);
          while (len-- > 0) {
            arr.push(any.decode(state));
          }
          return arr;
        }
      };
      var anyObject = {
        preencode(state, o) {
          const keys = Object.keys(o);
          uint.preencode(state, keys.length);
          for (const key of keys) {
            utf8.preencode(state, key);
            any.preencode(state, o[key]);
          }
        },
        encode(state, o) {
          const keys = Object.keys(o);
          uint.encode(state, keys.length);
          for (const key of keys) {
            utf8.encode(state, key);
            any.encode(state, o[key]);
          }
        },
        decode(state) {
          let len = uint.decode(state);
          const o = {};
          while (len-- > 0) {
            const key = utf8.decode(state);
            o[key] = any.decode(state);
          }
          return o;
        }
      };
      var anyTypes = [
        exports.none,
        exports.bool,
        exports.string,
        exports.buffer,
        exports.uint,
        exports.int,
        exports.float64,
        anyArray,
        anyObject,
        exports.date
      ];
      var any = exports.any = {
        preencode(state, o) {
          const t = getType(o);
          uint.preencode(state, t);
          anyTypes[t].preencode(state, o);
        },
        encode(state, o) {
          const t = getType(o);
          uint.encode(state, t);
          anyTypes[t].encode(state, o);
        },
        decode(state) {
          const t = uint.decode(state);
          if (t >= anyTypes.length) throw new Error("Unknown type: " + t);
          return anyTypes[t].decode(state);
        }
      };
      var port = exports.port = uint16;
      var address = (host, family) => {
        return {
          preencode(state, m) {
            host.preencode(state, m.host);
            port.preencode(state, m.port);
          },
          encode(state, m) {
            host.encode(state, m.host);
            port.encode(state, m.port);
          },
          decode(state) {
            return {
              host: host.decode(state),
              family,
              port: port.decode(state)
            };
          }
        };
      };
      var ipv4 = exports.ipv4 = {
        preencode(state) {
          state.end += 4;
        },
        encode(state, string2) {
          const start = state.start;
          const end = start + 4;
          let i = 0;
          while (i < string2.length) {
            let n = 0;
            let c;
            while (i < string2.length && (c = string2.charCodeAt(i++)) !== /* . */
            46) {
              n = n * 10 + (c - /* 0 */
              48);
            }
            state.buffer[state.start++] = n;
          }
          state.start = end;
        },
        decode(state) {
          if (state.end - state.start < 4) throw new Error("Out of bounds");
          return state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++];
        }
      };
      exports.ipv4Address = address(ipv4, 4);
      var ipv6 = exports.ipv6 = {
        preencode(state) {
          state.end += 16;
        },
        encode(state, string2) {
          const start = state.start;
          const end = start + 16;
          let i = 0;
          let split = null;
          while (i < string2.length) {
            let n = 0;
            let c;
            while (i < string2.length && (c = string2.charCodeAt(i++)) !== /* : */
            58) {
              if (c >= 48 && c <= 57) n = n * 16 + (c - /* 0 */
              48);
              else if (c >= 65 && c <= 70) n = n * 16 + (c - /* A */
              65 + 10);
              else if (c >= 97 && c <= 102) n = n * 16 + (c - /* a */
              97 + 10);
            }
            state.buffer[state.start++] = n >>> 8;
            state.buffer[state.start++] = n;
            if (i < string2.length && string2.charCodeAt(i) === /* : */
            58) {
              i++;
              split = state.start;
            }
          }
          if (split !== null) {
            const offset = end - state.start;
            state.buffer.copyWithin(split + offset, split).fill(0, split, split + offset);
          }
          state.start = end;
        },
        decode(state) {
          if (state.end - state.start < 16) throw new Error("Out of bounds");
          return (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16);
        }
      };
      exports.ipv6Address = address(ipv6, 6);
      var ip = exports.ip = {
        preencode(state, string2) {
          const family = string2.includes(":") ? 6 : 4;
          uint8.preencode(state, family);
          if (family === 4) ipv4.preencode(state);
          else ipv6.preencode(state);
        },
        encode(state, string2) {
          const family = string2.includes(":") ? 6 : 4;
          uint8.encode(state, family);
          if (family === 4) ipv4.encode(state, string2);
          else ipv6.encode(state, string2);
        },
        decode(state) {
          const family = uint8.decode(state);
          if (family === 4) return ipv4.decode(state);
          else return ipv6.decode(state);
        }
      };
      exports.ipAddress = {
        preencode(state, m) {
          ip.preencode(state, m.host);
          port.preencode(state, m.port);
        },
        encode(state, m) {
          ip.encode(state, m.host);
          port.encode(state, m.port);
        },
        decode(state) {
          const family = uint8.decode(state);
          return {
            host: family === 4 ? ipv4.decode(state) : ipv6.decode(state),
            family,
            port: port.decode(state)
          };
        }
      };
      var record = exports.record = function(keyEncoding, valueEncoding) {
        return {
          preencode(state, v) {
            const keys = Object.keys(v);
            uint.preencode(state, keys.length);
            for (const k of keys) {
              keyEncoding.preencode(state, k);
              valueEncoding.preencode(state, v[k]);
            }
          },
          encode(state, v) {
            const keys = Object.keys(v);
            uint.encode(state, keys.length);
            for (const k of keys) {
              keyEncoding.encode(state, k);
              valueEncoding.encode(state, v[k]);
            }
          },
          decode(state) {
            const out = /* @__PURE__ */ Object.create(null);
            const keys = uint.decode(state);
            for (let i = 0; i < keys; i++) {
              out[keyEncoding.decode(state)] = valueEncoding.decode(state);
            }
            return out;
          }
        };
      };
      exports.stringRecord = record(utf8, utf8);
      function getType(o) {
        if (o === null || o === void 0) return 0;
        if (typeof o === "boolean") return 1;
        if (typeof o === "string") return 2;
        if (b4a.isBuffer(o)) return 3;
        if (typeof o === "number") {
          if (Number.isInteger(o)) return o >= 0 ? 4 : 5;
          return 6;
        }
        if (Array.isArray(o)) return 7;
        if (o instanceof Date) return 9;
        if (typeof o === "object") return 8;
        throw new Error("Unsupported type for " + o);
      }
      exports.from = function from(enc) {
        if (typeof enc === "string") return fromNamed(enc);
        if (enc.preencode) return enc;
        if (enc.encodingLength) return fromAbstractEncoder(enc);
        return fromCodec(enc);
      };
      function fromNamed(enc) {
        switch (enc) {
          case "ascii":
            return raw.ascii;
          case "utf-8":
          case "utf8":
            return raw.utf8;
          case "hex":
            return raw.hex;
          case "base64":
            return raw.base64;
          case "utf16-le":
          case "utf16le":
          case "ucs-2":
          case "ucs2":
            return raw.ucs2;
          case "ndjson":
            return raw.ndjson;
          case "json":
            return raw.json;
          case "binary":
          default:
            return raw.binary;
        }
      }
      function fromCodec(enc) {
        let tmpM = null;
        let tmpBuf = null;
        return {
          preencode(state, m) {
            tmpM = m;
            tmpBuf = enc.encode(m);
            state.end += tmpBuf.byteLength;
          },
          encode(state, m) {
            raw.encode(state, m === tmpM ? tmpBuf : enc.encode(m));
            tmpM = tmpBuf = null;
          },
          decode(state) {
            return enc.decode(raw.decode(state));
          }
        };
      }
      function fromAbstractEncoder(enc) {
        return {
          preencode(state, m) {
            state.end += enc.encodingLength(m);
          },
          encode(state, m) {
            enc.encode(m, state.buffer, state.start);
            state.start += enc.encode.bytes;
          },
          decode(state) {
            const m = enc.decode(state.buffer, state.start, state.end);
            state.start += enc.decode.bytes;
            return m;
          }
        };
      }
      exports.encode = function encode(enc, m) {
        const state = exports.state();
        enc.preencode(state, m);
        state.buffer = b4a.allocUnsafe(state.end);
        enc.encode(state, m);
        return state.buffer;
      };
      exports.decode = function decode(enc, buffer2) {
        return enc.decode(exports.state(0, buffer2.byteLength, buffer2));
      };
      function zigZagInt(enc) {
        return {
          preencode(state, n) {
            enc.preencode(state, zigZagEncodeInt(n));
          },
          encode(state, n) {
            enc.encode(state, zigZagEncodeInt(n));
          },
          decode(state) {
            return zigZagDecodeInt(enc.decode(state));
          }
        };
      }
      function zigZagDecodeInt(n) {
        return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2;
      }
      function zigZagEncodeInt(n) {
        return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n;
      }
      function zigZagBigInt(enc) {
        return {
          preencode(state, n) {
            enc.preencode(state, zigZagEncodeBigInt(n));
          },
          encode(state, n) {
            enc.encode(state, zigZagEncodeBigInt(n));
          },
          decode(state) {
            return zigZagDecodeBigInt(enc.decode(state));
          }
        };
      }
      function zigZagDecodeBigInt(n) {
        return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n;
      }
      function zigZagEncodeBigInt(n) {
        return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n;
      }
      function validateSafeUint(n) {
        if (n > Number.MAX_SAFE_INTEGER)
          throw new Error(
            "uint is greater than the maximum safe integer, use biguint/bigint"
          );
        return n;
      }
      function validateUint(n) {
        if (n >= 0 === false)
          throw new Error("uint must be positive");
        if (n > Number.MAX_SAFE_INTEGER)
          throw new Error(
            "integer is greater than the maximum safe integer, use biguint/bigint"
          );
      }
    }
  });

  // ../../node_modules/queue-tick/queue-microtask.js
  var require_queue_microtask = __commonJS({
    "../../node_modules/queue-tick/queue-microtask.js"(exports, module) {
      module.exports = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => Promise.resolve().then(fn);
    }
  });

  // ../../node_modules/queue-tick/process-next-tick.js
  var require_process_next_tick = __commonJS({
    "../../node_modules/queue-tick/process-next-tick.js"(exports, module) {
      module.exports = typeof process !== "undefined" && typeof process.nextTick === "function" ? process.nextTick.bind(process) : require_queue_microtask();
    }
  });

  // ../../node_modules/safety-catch/index.js
  var require_safety_catch = __commonJS({
    "../../node_modules/safety-catch/index.js"(exports, module) {
      module.exports = safetyCatch;
      function isActuallyUncaught(err) {
        if (!err) return false;
        return err instanceof TypeError || err instanceof SyntaxError || err instanceof ReferenceError || err instanceof EvalError || err instanceof RangeError || err instanceof URIError || err.code === "ERR_ASSERTION" || err.name === "AssertionError";
      }
      function throwErrorNT(err) {
        queueMicrotask(() => {
          throw err;
        });
      }
      function safetyCatch(err) {
        if (isActuallyUncaught(err)) {
          throwErrorNT(err);
          throw err;
        }
      }
    }
  });

  // ../../node_modules/unslab/index.js
  var require_unslab = __commonJS({
    "../../node_modules/unslab/index.js"(exports, module) {
      var b4a = require_b4a();
      unslab.all = all;
      unslab.is = is;
      module.exports = unslab;
      function unslab(buf) {
        if (buf === null || buf.buffer.byteLength === buf.byteLength) return buf;
        const copy = b4a.allocUnsafeSlow(buf.byteLength);
        copy.set(buf, 0);
        return copy;
      }
      function is(buf) {
        return buf.buffer.byteLength !== buf.byteLength;
      }
      function all(list) {
        let size = 0;
        for (let i = 0; i < list.length; i++) {
          const buf = list[i];
          size += buf === null || buf.buffer.byteLength === buf.byteLength ? 0 : buf.byteLength;
        }
        const copy = b4a.allocUnsafeSlow(size);
        const result = new Array(list.length);
        let offset = 0;
        for (let i = 0; i < list.length; i++) {
          let buf = list[i];
          if (buf !== null && buf.buffer.byteLength !== buf.byteLength) {
            copy.set(buf, offset);
            buf = copy.subarray(offset, offset += buf.byteLength);
          }
          result[i] = buf;
        }
        return result;
      }
    }
  });

  // ../../node_modules/protomux/index.js
  var require_protomux = __commonJS({
    "../../node_modules/protomux/index.js"(exports, module) {
      var b4a = require_b4a();
      var c = require_compact_encoding();
      var queueTick = require_process_next_tick();
      var safetyCatch = require_safety_catch();
      var unslab = require_unslab();
      var MAX_BUFFERED = 32768;
      var MAX_BACKLOG = Infinity;
      var MAX_BATCH = 8 * 1024 * 1024;
      var Channel = class {
        constructor(mux, info, userData, protocol, aliases, id, handshake, messages, onopen, onclose, ondestroy, ondrain) {
          this.userData = userData;
          this.protocol = protocol;
          this.aliases = aliases;
          this.id = id;
          this.handshake = null;
          this.messages = [];
          this.opened = false;
          this.closed = false;
          this.destroyed = false;
          this.onopen = onopen;
          this.onclose = onclose;
          this.ondestroy = ondestroy;
          this.ondrain = ondrain;
          this._handshake = handshake;
          this._mux = mux;
          this._info = info;
          this._localId = 0;
          this._remoteId = 0;
          this._active = 0;
          this._extensions = null;
          this._decBound = this._dec.bind(this);
          this._decAndDestroyBound = this._decAndDestroy.bind(this);
          this._openedPromise = null;
          this._openedResolve = null;
          this._destroyedPromise = null;
          this._destroyedResolve = null;
          for (const m of messages) this.addMessage(m);
        }
        get drained() {
          return this._mux.drained;
        }
        fullyOpened() {
          if (this.opened) return Promise.resolve(true);
          if (this.closed) return Promise.resolve(false);
          if (this._openedPromise) return this._openedPromise;
          this._openedPromise = new Promise((resolve) => {
            this._openedResolve = resolve;
          });
          return this._openedPromise;
        }
        fullyClosed() {
          if (this.destroyed) return Promise.resolve();
          if (this._destroyedPromise) return this._destroyedPromise;
          this._destroyedPromise = new Promise((resolve) => {
            this._destroyedResolve = resolve;
          });
          return this._destroyedPromise;
        }
        open(handshake) {
          const id = this._mux._free.length > 0 ? this._mux._free.pop() : this._mux._local.push(null) - 1;
          this._info.opened++;
          this._info.lastChannel = this;
          this._localId = id + 1;
          this._mux._local[id] = this;
          if (this._remoteId === 0) {
            this._info.outgoing.push(this._localId);
          }
          const state = { buffer: null, start: 2, end: 2 };
          c.uint.preencode(state, this._localId);
          c.string.preencode(state, this.protocol);
          c.optionalBuffer.preencode(state, this.id);
          if (this._handshake) this._handshake.preencode(state, handshake);
          state.buffer = this._mux._alloc(state.end);
          state.buffer[0] = 0;
          state.buffer[1] = 1;
          c.uint.encode(state, this._localId);
          c.string.encode(state, this.protocol);
          c.optionalBuffer.encode(state, this.id);
          if (this._handshake) this._handshake.encode(state, handshake);
          this._mux._write0(state.buffer);
        }
        _dec() {
          if (--this._active === 0 && this.closed === true) this._destroy();
        }
        _decAndDestroy(err) {
          this._dec();
          this._mux._safeDestroy(err);
        }
        _fullyOpenSoon() {
          this._mux._remote[this._remoteId - 1].session = this;
          queueTick(this._fullyOpenOrDestroy.bind(this));
        }
        _fullyOpenOrDestroy() {
          try {
            this._fullyOpen();
          } catch (err) {
            this._mux._safeDestroyBound(err);
          }
        }
        _fullyOpen() {
          if (this.opened === true || this.closed === true) return;
          const remote = this._mux._remote[this._remoteId - 1];
          this.handshake = this._handshake ? this._handshake.decode(remote.state) : null;
          this._track(this.onopen(this.handshake, this));
          remote.session = this;
          remote.state = null;
          if (remote.pending !== null) this._drain(remote);
          if (this._mux._destroying === true) return;
          this.opened = true;
          this._resolveOpen(true);
        }
        _resolveOpen(opened) {
          if (this._openedResolve !== null) {
            this._openedResolve(opened);
            this._openedResolve = this._openedPromise = null;
          }
        }
        _resolveDestroyed() {
          if (this._destroyedResolve !== null) {
            this._destroyedResolve();
            this._destroyedResolve = this._destroyedPromise = null;
          }
        }
        _drain(remote) {
          for (let i = 0; i < remote.pending.length; i++) {
            const p = remote.pending[i];
            this._mux._buffered -= byteSize(p.state);
            this._recv(p.type, p.state);
            if (this._mux._destroying === true) return;
          }
          remote.pending = null;
          this._mux._resumeMaybe();
        }
        _track(p) {
          if (isPromise(p) === true) {
            this._active++;
            return p.then(this._decBound, this._decAndDestroyBound);
          }
          return null;
        }
        _close(isRemote) {
          if (this.closed === true) return;
          this.closed = true;
          this._info.opened--;
          if (this._info.lastChannel === this) this._info.lastChannel = null;
          if (this._remoteId > 0) {
            this._mux._remote[this._remoteId - 1] = null;
            this._remoteId = 0;
            this._mux._free.push(this._localId - 1);
          }
          this._mux._local[this._localId - 1] = null;
          this._localId = 0;
          this._mux._gc(this._info);
          this._track(this.onclose(isRemote, this));
          if (this._active === 0) this._destroy();
          this._resolveOpen(false);
        }
        _destroy() {
          if (this.destroyed === true) return;
          this.destroyed = true;
          this._track(this.ondestroy(this));
          this._resolveDestroyed();
        }
        _recv(type, state) {
          if (type < this.messages.length) {
            const m = this.messages[type];
            const p = m.recv(state, this);
            if (m.autoBatch === true) return p;
          }
          return null;
        }
        cork() {
          this._mux.cork();
        }
        uncork() {
          this._mux.uncork();
        }
        close() {
          if (this.closed === true) return;
          const state = { buffer: null, start: 2, end: 2 };
          c.uint.preencode(state, this._localId);
          state.buffer = this._mux._alloc(state.end);
          state.buffer[0] = 0;
          state.buffer[1] = 3;
          c.uint.encode(state, this._localId);
          this._close(false);
          this._mux._write0(state.buffer);
        }
        addMessage(opts) {
          if (!opts) return this._skipMessage();
          const type = this.messages.length;
          const autoBatch = opts.autoBatch !== false;
          const encoding = opts.encoding || c.raw;
          const onmessage = opts.onmessage || noop;
          const s = this;
          const typeLen = encodingLength(c.uint, type);
          const m = {
            type,
            autoBatch,
            encoding,
            onmessage,
            recv(state, session) {
              return session._track(m.onmessage(encoding.decode(state), session));
            },
            send(m2, session = s) {
              if (session.closed === true) return false;
              const mux = session._mux;
              const state = { buffer: null, start: 0, end: typeLen };
              if (mux._batch !== null) {
                encoding.preencode(state, m2);
                state.buffer = mux._alloc(state.end);
                c.uint.encode(state, type);
                encoding.encode(state, m2);
                mux._pushBatch(session._localId, state.buffer);
                return true;
              }
              c.uint.preencode(state, session._localId);
              encoding.preencode(state, m2);
              state.buffer = mux._alloc(state.end);
              c.uint.encode(state, session._localId);
              c.uint.encode(state, type);
              encoding.encode(state, m2);
              mux.drained = mux.stream.write(state.buffer);
              return mux.drained;
            }
          };
          this.messages.push(m);
          return m;
        }
        _skipMessage() {
          const type = this.messages.length;
          const m = {
            type,
            encoding: c.raw,
            onmessage: noop,
            recv(state, session) {
            },
            send(m2, session) {
            }
          };
          this.messages.push(m);
          return m;
        }
      };
      module.exports = class Protomux {
        constructor(stream, { alloc } = {}) {
          if (stream.userData === null) stream.userData = this;
          this.isProtomux = true;
          this.stream = stream;
          this.corked = 0;
          this.drained = true;
          this._alloc = alloc || (typeof stream.alloc === "function" ? stream.alloc.bind(stream) : b4a.allocUnsafe);
          this._safeDestroyBound = this._safeDestroy.bind(this);
          this._uncorkBound = this.uncork.bind(this);
          this._remoteBacklog = 0;
          this._buffered = 0;
          this._paused = false;
          this._remote = [];
          this._local = [];
          this._free = [];
          this._batch = null;
          this._batchState = null;
          this._infos = /* @__PURE__ */ new Map();
          this._notify = /* @__PURE__ */ new Map();
          this._destroying = false;
          this.stream.on("data", this._ondata.bind(this));
          this.stream.on("drain", this._ondrain.bind(this));
          this.stream.on("end", this._onend.bind(this));
          this.stream.on("error", noop);
          this.stream.on("close", this._shutdown.bind(this));
        }
        static from(stream, opts) {
          if (stream.userData && stream.userData.isProtomux) return stream.userData;
          if (stream.isProtomux) return stream;
          return new this(stream, opts);
        }
        static isProtomux(mux) {
          return typeof mux === "object" && mux.isProtomux === true;
        }
        *[Symbol.iterator]() {
          for (const session of this._local) {
            if (session !== null) yield session;
          }
        }
        isIdle() {
          return this._local.length === this._free.length;
        }
        cork() {
          if (++this.corked === 1) {
            this._batch = [];
            this._batchState = { buffer: null, start: 0, end: 1 };
          }
        }
        uncork() {
          if (--this.corked === 0) {
            this._sendBatch(this._batch, this._batchState);
            this._batch = null;
            this._batchState = null;
          }
        }
        getLastChannel({ protocol, id = null }) {
          const key = toKey(protocol, id);
          const info = this._infos.get(key);
          if (info) return info.lastChannel;
          return null;
        }
        pair({ protocol, id = null }, notify) {
          this._notify.set(toKey(protocol, id), notify);
        }
        unpair({ protocol, id = null }) {
          this._notify.delete(toKey(protocol, id));
        }
        opened({ protocol, id = null }) {
          const key = toKey(protocol, id);
          const info = this._infos.get(key);
          return info ? info.opened > 0 : false;
        }
        createChannel({
          userData = null,
          protocol,
          aliases = [],
          id = null,
          unique = true,
          handshake = null,
          messages = [],
          onopen = noop,
          onclose = noop,
          ondestroy = noop,
          ondrain = noop
        }) {
          if (this.stream.destroyed) return null;
          const info = this._get(protocol, id, aliases);
          if (unique && info.opened > 0) return null;
          if (info.incoming.length === 0) {
            return new Channel(
              this,
              info,
              userData,
              protocol,
              aliases,
              id,
              handshake,
              messages,
              onopen,
              onclose,
              ondestroy,
              ondrain
            );
          }
          this._remoteBacklog--;
          const remoteId = info.incoming.shift();
          const r = this._remote[remoteId - 1];
          if (r === null) return null;
          const session = new Channel(
            this,
            info,
            userData,
            protocol,
            aliases,
            id,
            handshake,
            messages,
            onopen,
            onclose,
            ondestroy,
            ondrain
          );
          session._remoteId = remoteId;
          session._fullyOpenSoon();
          return session;
        }
        _pushBatch(localId, buffer) {
          if (this._batchState.end >= MAX_BATCH) {
            this._sendBatch(this._batch, this._batchState);
            this._batch = [];
            this._batchState = { buffer: null, start: 0, end: 1 };
          }
          if (this._batch.length === 0 || this._batch[this._batch.length - 1].localId !== localId) {
            this._batchState.end++;
            c.uint.preencode(this._batchState, localId);
          }
          c.buffer.preencode(this._batchState, buffer);
          this._batch.push({ localId, buffer });
        }
        _sendBatch(batch, state) {
          if (batch.length === 0) return;
          let prev = batch[0].localId;
          state.buffer = this._alloc(state.end);
          state.buffer[state.start++] = 0;
          state.buffer[state.start++] = 0;
          c.uint.encode(state, prev);
          for (let i = 0; i < batch.length; i++) {
            const b = batch[i];
            if (prev !== b.localId) {
              state.buffer[state.start++] = 0;
              c.uint.encode(state, prev = b.localId);
            }
            c.buffer.encode(state, b.buffer);
          }
          this.drained = this.stream.write(state.buffer);
        }
        _get(protocol, id, aliases = []) {
          const key = toKey(protocol, id);
          let info = this._infos.get(key);
          if (info) return info;
          info = {
            key,
            protocol,
            aliases: [],
            id,
            pairing: 0,
            opened: 0,
            incoming: [],
            outgoing: [],
            lastChannel: null
          };
          this._infos.set(key, info);
          for (const alias of aliases) {
            const key2 = toKey(alias, id);
            info.aliases.push(key2);
            this._infos.set(key2, info);
          }
          return info;
        }
        _gc(info) {
          if (info.opened === 0 && info.outgoing.length === 0 && info.incoming.length === 0) {
            this._infos.delete(info.key);
            for (const alias of info.aliases) this._infos.delete(alias);
          }
        }
        _ondata(buffer) {
          if (buffer.byteLength === 0) return;
          try {
            const state = { buffer, start: 0, end: buffer.byteLength };
            this._decode(c.uint.decode(state), state);
          } catch (err) {
            this._safeDestroy(err);
          }
        }
        _ondrain() {
          this.drained = true;
          for (const s of this._local) {
            if (s !== null) s._track(s.ondrain(s));
          }
        }
        _onend() {
          this.stream.end();
        }
        _decode(remoteId, state) {
          const type = c.uint.decode(state);
          if (remoteId === 0) {
            return this._oncontrolsession(type, state);
          }
          const r = remoteId <= this._remote.length ? this._remote[remoteId - 1] : null;
          if (r === null) return null;
          if (r.pending !== null) {
            this._bufferMessage(r, type, state);
            return null;
          }
          return r.session._recv(type, state);
        }
        _oncontrolsession(type, state) {
          switch (type) {
            case 0:
              this._onbatch(state);
              break;
            case 1:
              return this._onopensession(state);
            case 2:
              this._onrejectsession(state);
              break;
            case 3:
              this._onclosesession(state);
              break;
          }
          return null;
        }
        _bufferMessage(r, type, { buffer, start, end }) {
          const state = { buffer, start, end };
          r.pending.push({ type, state });
          this._buffered += byteSize(state);
          this._pauseMaybe();
        }
        _pauseMaybe() {
          if (this._paused === true || this._buffered <= MAX_BUFFERED) return;
          this._paused = true;
          this.stream.pause();
        }
        _resumeMaybe() {
          if (this._paused === false || this._buffered > MAX_BUFFERED) return;
          this._paused = false;
          this.stream.resume();
        }
        _onbatch(state) {
          const end = state.end;
          let remoteId = c.uint.decode(state);
          let waiting = null;
          while (state.end > state.start) {
            const len = c.uint.decode(state);
            if (len === 0) {
              remoteId = c.uint.decode(state);
              continue;
            }
            state.end = state.start + len;
            if (end !== state.end && waiting === null) {
              waiting = [];
              this.cork();
            }
            const p = this._decode(remoteId, state);
            if (waiting !== null && p !== null) waiting.push(p);
            state.start = state.end;
            state.end = end;
          }
          if (waiting !== null) {
            Promise.all(waiting).then(this._uncorkBound, this._safeDestroyBound);
          }
        }
        _onopensession(state) {
          const remoteId = c.uint.decode(state);
          const protocol = c.string.decode(state);
          const id = unslab(c.optionalBuffer.decode(state));
          if (remoteId === 0) {
            this._rejectSession(0);
            return null;
          }
          const rid = remoteId - 1;
          const info = this._get(protocol, id);
          if (this._remote.length === rid) {
            this._remote.push(null);
          }
          if (rid >= this._remote.length || this._remote[rid] !== null) {
            throw new Error("Invalid open message");
          }
          if (info.outgoing.length > 0) {
            const localId = info.outgoing.shift();
            const session = this._local[localId - 1];
            if (session === null) {
              this._free.push(localId - 1);
              return null;
            }
            this._remote[rid] = { state, pending: null, session: null };
            session._remoteId = remoteId;
            session._fullyOpen();
            return null;
          }
          const copyState = { buffer: state.buffer, start: state.start, end: state.end };
          this._remote[rid] = { state: copyState, pending: [], session: null };
          if (++this._remoteBacklog > MAX_BACKLOG) {
            throw new Error("Remote exceeded backlog");
          }
          info.pairing++;
          info.incoming.push(remoteId);
          return this._requestSession(protocol, id, info).catch(this._safeDestroyBound);
        }
        _onrejectsession(state) {
          const localId = c.uint.decode(state);
          for (const info of this._infos.values()) {
            const i = info.outgoing.indexOf(localId);
            if (i === -1) continue;
            info.outgoing.splice(i, 1);
            const session = this._local[localId - 1];
            this._free.push(localId - 1);
            if (session !== null) session._close(true);
            this._gc(info);
            return;
          }
          throw new Error("Invalid reject message");
        }
        _onclosesession(state) {
          const remoteId = c.uint.decode(state);
          if (remoteId === 0) return;
          const rid = remoteId - 1;
          const r = rid < this._remote.length ? this._remote[rid] : null;
          if (r === null) return;
          if (r.session !== null) r.session._close(true);
        }
        async _requestSession(protocol, id, info) {
          const notify = this._notify.get(toKey(protocol, id)) || this._notify.get(toKey(protocol, null));
          if (notify) await notify(id);
          if (--info.pairing > 0) return;
          while (info.incoming.length > 0) {
            this._rejectSession(info, info.incoming.shift());
          }
          this._gc(info);
        }
        _rejectSession(info, remoteId) {
          if (remoteId > 0) {
            const r = this._remote[remoteId - 1];
            if (r.pending !== null) {
              for (let i = 0; i < r.pending.length; i++) {
                this._buffered -= byteSize(r.pending[i].state);
              }
            }
            this._remote[remoteId - 1] = null;
            this._resumeMaybe();
          }
          const state = { buffer: null, start: 2, end: 2 };
          c.uint.preencode(state, remoteId);
          state.buffer = this._alloc(state.end);
          state.buffer[0] = 0;
          state.buffer[1] = 2;
          c.uint.encode(state, remoteId);
          this._write0(state.buffer);
        }
        _write0(buffer) {
          if (this._batch !== null) {
            this._pushBatch(0, buffer.subarray(1));
            return;
          }
          this.drained = this.stream.write(buffer);
        }
        destroy(err) {
          this._destroying = true;
          this.stream.destroy(err);
        }
        _safeDestroy(err) {
          safetyCatch(err);
          this._destroying = true;
          this.stream.destroy(err);
        }
        _shutdown() {
          this._destroying = true;
          for (const s of this._local) {
            if (s !== null) s._close(true);
          }
        }
      };
      function noop() {
      }
      function toKey(protocol, id) {
        return protocol + "##" + (id ? b4a.toString(id, "hex") : "");
      }
      function byteSize(state) {
        return 512 + (state.end - state.start);
      }
      function isPromise(p) {
        return !!(p && typeof p.then === "function");
      }
      function encodingLength(enc, val) {
        const state = { buffer: null, start: 0, end: 0 };
        enc.preencode(state, val);
        return state.end;
      }
    }
  });

  // ../../bare-lib-entry-protomux.js
  var bare_lib_entry_protomux_exports = {};
  __export(bare_lib_entry_protomux_exports, {
    default: () => bare_lib_entry_protomux_default
  });
  var import_protomux = __toESM(require_protomux());
  var bare_lib_entry_protomux_default = import_protomux.default;
  return __toCommonJS(bare_lib_entry_protomux_exports);
})();
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["protomux"]=v;})();