@blinkdotnew/dev-sdk 2.3.2 → 2.3.4-dev.1

package/dist/index.js

@@ -1,2584 +1,11 @@
 'use strict';
 
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-
-// ../../node_modules/async-limiter/index.js
-var require_async_limiter = __commonJS({
-  "../../node_modules/async-limiter/index.js"(exports, module) {
-    function Queue(options) {
-      if (!(this instanceof Queue)) {
-        return new Queue(options);
-      }
-      options = options || {};
-      this.concurrency = options.concurrency || Infinity;
-      this.pending = 0;
-      this.jobs = [];
-      this.cbs = [];
-      this._done = done.bind(this);
-    }
-    var arrayAddMethods = [
-      "push",
-      "unshift",
-      "splice"
-    ];
-    arrayAddMethods.forEach(function(method) {
-      Queue.prototype[method] = function() {
-        var methodResult = Array.prototype[method].apply(this.jobs, arguments);
-        this._run();
-        return methodResult;
-      };
-    });
-    Object.defineProperty(Queue.prototype, "length", {
-      get: function() {
-        return this.pending + this.jobs.length;
-      }
-    });
-    Queue.prototype._run = function() {
-      if (this.pending === this.concurrency) {
-        return;
-      }
-      if (this.jobs.length) {
-        var job = this.jobs.shift();
-        this.pending++;
-        job(this._done);
-        this._run();
-      }
-      if (this.pending === 0) {
-        while (this.cbs.length !== 0) {
-          var cb = this.cbs.pop();
-          process.nextTick(cb);
-        }
-      }
-    };
-    Queue.prototype.onDone = function(cb) {
-      if (typeof cb === "function") {
-        this.cbs.push(cb);
-        this._run();
-      }
-    };
-    function done() {
-      this.pending--;
-      this._run();
-    }
-    module.exports = Queue;
-  }
-});
-
-// ../../node_modules/ws/lib/constants.js
-var require_constants = __commonJS({
-  "../../node_modules/ws/lib/constants.js"(exports, module) {
-    module.exports = {
-      BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
-      GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
-      kStatusCode: Symbol("status-code"),
-      kWebSocket: Symbol("websocket"),
-      EMPTY_BUFFER: Buffer.alloc(0),
-      NOOP: () => {
-      }
-    };
-  }
-});
-
-// ../../node_modules/ws/lib/buffer-util.js
-var require_buffer_util = __commonJS({
-  "../../node_modules/ws/lib/buffer-util.js"(exports, module) {
-    var { EMPTY_BUFFER } = require_constants();
-    function concat(list, totalLength) {
-      if (list.length === 0) return EMPTY_BUFFER;
-      if (list.length === 1) return list[0];
-      const target = Buffer.allocUnsafe(totalLength);
-      var offset = 0;
-      for (var i = 0; i < list.length; i++) {
-        const buf = list[i];
-        buf.copy(target, offset);
-        offset += buf.length;
-      }
-      return target;
-    }
-    function _mask(source, mask, output, offset, length) {
-      for (var i = 0; i < length; i++) {
-        output[offset + i] = source[i] ^ mask[i & 3];
-      }
-    }
-    function _unmask(buffer, mask) {
-      const length = buffer.length;
-      for (var i = 0; i < length; i++) {
-        buffer[i] ^= mask[i & 3];
-      }
-    }
-    function toArrayBuffer(buf) {
-      if (buf.byteLength === buf.buffer.byteLength) {
-        return buf.buffer;
-      }
-      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-    }
-    function toBuffer(data) {
-      toBuffer.readOnly = true;
-      if (Buffer.isBuffer(data)) return data;
-      var buf;
-      if (data instanceof ArrayBuffer) {
-        buf = Buffer.from(data);
-      } else if (ArrayBuffer.isView(data)) {
-        buf = viewToBuffer(data);
-      } else {
-        buf = Buffer.from(data);
-        toBuffer.readOnly = false;
-      }
-      return buf;
-    }
-    function viewToBuffer(view) {
-      const buf = Buffer.from(view.buffer);
-      if (view.byteLength !== view.buffer.byteLength) {
-        return buf.slice(view.byteOffset, view.byteOffset + view.byteLength);
-      }
-      return buf;
-    }
-    try {
-      const bufferUtil = __require("bufferutil");
-      const bu = bufferUtil.BufferUtil || bufferUtil;
-      module.exports = {
-        concat,
-        mask(source, mask, output, offset, length) {
-          if (length < 48) _mask(source, mask, output, offset, length);
-          else bu.mask(source, mask, output, offset, length);
-        },
-        toArrayBuffer,
-        toBuffer,
-        unmask(buffer, mask) {
-          if (buffer.length < 32) _unmask(buffer, mask);
-          else bu.unmask(buffer, mask);
-        }
-      };
-    } catch (e) {
-      module.exports = {
-        concat,
-        mask: _mask,
-        toArrayBuffer,
-        toBuffer,
-        unmask: _unmask
-      };
-    }
-  }
-});
-
-// ../../node_modules/ws/lib/permessage-deflate.js
-var require_permessage_deflate = __commonJS({
-  "../../node_modules/ws/lib/permessage-deflate.js"(exports, module) {
-    var Limiter = require_async_limiter();
-    var zlib = __require("zlib");
-    var bufferUtil = require_buffer_util();
-    var { kStatusCode, NOOP } = require_constants();
-    var TRAILER = Buffer.from([0, 0, 255, 255]);
-    var EMPTY_BLOCK = Buffer.from([0]);
-    var kPerMessageDeflate = Symbol("permessage-deflate");
-    var kTotalLength = Symbol("total-length");
-    var kCallback = Symbol("callback");
-    var kBuffers = Symbol("buffers");
-    var kError = Symbol("error");
-    var zlibLimiter;
-    var PerMessageDeflate = class {
-      /**
-       * Creates a PerMessageDeflate instance.
-       *
-       * @param {Object} options Configuration options
-       * @param {Boolean} options.serverNoContextTakeover Request/accept disabling
-       *     of server context takeover
-       * @param {Boolean} options.clientNoContextTakeover Advertise/acknowledge
-       *     disabling of client context takeover
-       * @param {(Boolean|Number)} options.serverMaxWindowBits Request/confirm the
-       *     use of a custom server window size
-       * @param {(Boolean|Number)} options.clientMaxWindowBits Advertise support
-       *     for, or request, a custom client window size
-       * @param {Object} options.zlibDeflateOptions Options to pass to zlib on deflate
-       * @param {Object} options.zlibInflateOptions Options to pass to zlib on inflate
-       * @param {Number} options.threshold Size (in bytes) below which messages
-       *     should not be compressed
-       * @param {Number} options.concurrencyLimit The number of concurrent calls to
-       *     zlib
-       * @param {Boolean} isServer Create the instance in either server or client
-       *     mode
-       * @param {Number} maxPayload The maximum allowed message length
-       */
-      constructor(options, isServer2, maxPayload) {
-        this._maxPayload = maxPayload | 0;
-        this._options = options || {};
-        this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
-        this._isServer = !!isServer2;
-        this._deflate = null;
-        this._inflate = null;
-        this.params = null;
-        if (!zlibLimiter) {
-          const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
-          zlibLimiter = new Limiter({ concurrency });
-        }
-      }
-      /**
-       * @type {String}
-       */
-      static get extensionName() {
-        return "permessage-deflate";
-      }
-      /**
-       * Create an extension negotiation offer.
-       *
-       * @return {Object} Extension parameters
-       * @public
-       */
-      offer() {
-        const params = {};
-        if (this._options.serverNoContextTakeover) {
-          params.server_no_context_takeover = true;
-        }
-        if (this._options.clientNoContextTakeover) {
-          params.client_no_context_takeover = true;
-        }
-        if (this._options.serverMaxWindowBits) {
-          params.server_max_window_bits = this._options.serverMaxWindowBits;
-        }
-        if (this._options.clientMaxWindowBits) {
-          params.client_max_window_bits = this._options.clientMaxWindowBits;
-        } else if (this._options.clientMaxWindowBits == null) {
-          params.client_max_window_bits = true;
-        }
-        return params;
-      }
-      /**
-       * Accept an extension negotiation offer/response.
-       *
-       * @param {Array} configurations The extension negotiation offers/reponse
-       * @return {Object} Accepted configuration
-       * @public
-       */
-      accept(configurations) {
-        configurations = this.normalizeParams(configurations);
-        this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
-        return this.params;
-      }
-      /**
-       * Releases all resources used by the extension.
-       *
-       * @public
-       */
-      cleanup() {
-        if (this._inflate) {
-          this._inflate.close();
-          this._inflate = null;
-        }
-        if (this._deflate) {
-          this._deflate.close();
-          this._deflate = null;
-        }
-      }
-      /**
-       *  Accept an extension negotiation offer.
-       *
-       * @param {Array} offers The extension negotiation offers
-       * @return {Object} Accepted configuration
-       * @private
-       */
-      acceptAsServer(offers) {
-        const opts = this._options;
-        const accepted = offers.find((params) => {
-          if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
-            return false;
-          }
-          return true;
-        });
-        if (!accepted) {
-          throw new Error("None of the extension offers can be accepted");
-        }
-        if (opts.serverNoContextTakeover) {
-          accepted.server_no_context_takeover = true;
-        }
-        if (opts.clientNoContextTakeover) {
-          accepted.client_no_context_takeover = true;
-        }
-        if (typeof opts.serverMaxWindowBits === "number") {
-          accepted.server_max_window_bits = opts.serverMaxWindowBits;
-        }
-        if (typeof opts.clientMaxWindowBits === "number") {
-          accepted.client_max_window_bits = opts.clientMaxWindowBits;
-        } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
-          delete accepted.client_max_window_bits;
-        }
-        return accepted;
-      }
-      /**
-       * Accept the extension negotiation response.
-       *
-       * @param {Array} response The extension negotiation response
-       * @return {Object} Accepted configuration
-       * @private
-       */
-      acceptAsClient(response) {
-        const params = response[0];
-        if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
-          throw new Error('Unexpected parameter "client_no_context_takeover"');
-        }
-        if (!params.client_max_window_bits) {
-          if (typeof this._options.clientMaxWindowBits === "number") {
-            params.client_max_window_bits = this._options.clientMaxWindowBits;
-          }
-        } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
-          throw new Error(
-            'Unexpected or invalid parameter "client_max_window_bits"'
-          );
-        }
-        return params;
-      }
-      /**
-       * Normalize parameters.
-       *
-       * @param {Array} configurations The extension negotiation offers/reponse
-       * @return {Array} The offers/response with normalized parameters
-       * @private
-       */
-      normalizeParams(configurations) {
-        configurations.forEach((params) => {
-          Object.keys(params).forEach((key) => {
-            var value = params[key];
-            if (value.length > 1) {
-              throw new Error(`Parameter "${key}" must have only a single value`);
-            }
-            value = value[0];
-            if (key === "client_max_window_bits") {
-              if (value !== true) {
-                const num = +value;
-                if (!Number.isInteger(num) || num < 8 || num > 15) {
-                  throw new TypeError(
-                    `Invalid value for parameter "${key}": ${value}`
-                  );
-                }
-                value = num;
-              } else if (!this._isServer) {
-                throw new TypeError(
-                  `Invalid value for parameter "${key}": ${value}`
-                );
-              }
-            } else if (key === "server_max_window_bits") {
-              const num = +value;
-              if (!Number.isInteger(num) || num < 8 || num > 15) {
-                throw new TypeError(
-                  `Invalid value for parameter "${key}": ${value}`
-                );
-              }
-              value = num;
-            } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
-              if (value !== true) {
-                throw new TypeError(
-                  `Invalid value for parameter "${key}": ${value}`
-                );
-              }
-            } else {
-              throw new Error(`Unknown parameter "${key}"`);
-            }
-            params[key] = value;
-          });
-        });
-        return configurations;
-      }
-      /**
-       * Decompress data. Concurrency limited by async-limiter.
-       *
-       * @param {Buffer} data Compressed data
-       * @param {Boolean} fin Specifies whether or not this is the last fragment
-       * @param {Function} callback Callback
-       * @public
-       */
-      decompress(data, fin, callback) {
-        zlibLimiter.push((done) => {
-          this._decompress(data, fin, (err, result) => {
-            done();
-            callback(err, result);
-          });
-        });
-      }
-      /**
-       * Compress data. Concurrency limited by async-limiter.
-       *
-       * @param {Buffer} data Data to compress
-       * @param {Boolean} fin Specifies whether or not this is the last fragment
-       * @param {Function} callback Callback
-       * @public
-       */
-      compress(data, fin, callback) {
-        zlibLimiter.push((done) => {
-          this._compress(data, fin, (err, result) => {
-            done();
-            callback(err, result);
-          });
-        });
-      }
-      /**
-       * Decompress data.
-       *
-       * @param {Buffer} data Compressed data
-       * @param {Boolean} fin Specifies whether or not this is the last fragment
-       * @param {Function} callback Callback
-       * @private
-       */
-      _decompress(data, fin, callback) {
-        const endpoint = this._isServer ? "client" : "server";
-        if (!this._inflate) {
-          const key = `${endpoint}_max_window_bits`;
-          const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
-          this._inflate = zlib.createInflateRaw(
-            Object.assign({}, this._options.zlibInflateOptions, { windowBits })
-          );
-          this._inflate[kPerMessageDeflate] = this;
-          this._inflate[kTotalLength] = 0;
-          this._inflate[kBuffers] = [];
-          this._inflate.on("error", inflateOnError);
-          this._inflate.on("data", inflateOnData);
-        }
-        this._inflate[kCallback] = callback;
-        this._inflate.write(data);
-        if (fin) this._inflate.write(TRAILER);
-        this._inflate.flush(() => {
-          const err = this._inflate[kError];
-          if (err) {
-            this._inflate.close();
-            this._inflate = null;
-            callback(err);
-            return;
-          }
-          const data2 = bufferUtil.concat(
-            this._inflate[kBuffers],
-            this._inflate[kTotalLength]
-          );
-          if (fin && this.params[`${endpoint}_no_context_takeover`]) {
-            this._inflate.close();
-            this._inflate = null;
-          } else {
-            this._inflate[kTotalLength] = 0;
-            this._inflate[kBuffers] = [];
-          }
-          callback(null, data2);
-        });
-      }
-      /**
-       * Compress data.
-       *
-       * @param {Buffer} data Data to compress
-       * @param {Boolean} fin Specifies whether or not this is the last fragment
-       * @param {Function} callback Callback
-       * @private
-       */
-      _compress(data, fin, callback) {
-        if (!data || data.length === 0) {
-          process.nextTick(callback, null, EMPTY_BLOCK);
-          return;
-        }
-        const endpoint = this._isServer ? "server" : "client";
-        if (!this._deflate) {
-          const key = `${endpoint}_max_window_bits`;
-          const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
-          this._deflate = zlib.createDeflateRaw(
-            Object.assign({}, this._options.zlibDeflateOptions, { windowBits })
-          );
-          this._deflate[kTotalLength] = 0;
-          this._deflate[kBuffers] = [];
-          this._deflate.on("error", NOOP);
-          this._deflate.on("data", deflateOnData);
-        }
-        this._deflate.write(data);
-        this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
-          if (!this._deflate) {
-            return;
-          }
-          var data2 = bufferUtil.concat(
-            this._deflate[kBuffers],
-            this._deflate[kTotalLength]
-          );
-          if (fin) data2 = data2.slice(0, data2.length - 4);
-          if (fin && this.params[`${endpoint}_no_context_takeover`]) {
-            this._deflate.close();
-            this._deflate = null;
-          } else {
-            this._deflate[kTotalLength] = 0;
-            this._deflate[kBuffers] = [];
-          }
-          callback(null, data2);
-        });
-      }
-    };
-    module.exports = PerMessageDeflate;
-    function deflateOnData(chunk) {
-      this[kBuffers].push(chunk);
-      this[kTotalLength] += chunk.length;
-    }
-    function inflateOnData(chunk) {
-      this[kTotalLength] += chunk.length;
-      if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
-        this[kBuffers].push(chunk);
-        return;
-      }
-      this[kError] = new RangeError("Max payload size exceeded");
-      this[kError][kStatusCode] = 1009;
-      this.removeListener("data", inflateOnData);
-      this.reset();
-    }
-    function inflateOnError(err) {
-      this[kPerMessageDeflate]._inflate = null;
-      err[kStatusCode] = 1007;
-      this[kCallback](err);
-    }
-  }
-});
-
-// ../../node_modules/ws/lib/event-target.js
-var require_event_target = __commonJS({
-  "../../node_modules/ws/lib/event-target.js"(exports, module) {
-    var Event = class {
-      /**
-       * Create a new `Event`.
-       *
-       * @param {String} type The name of the event
-       * @param {Object} target A reference to the target to which the event was dispatched
-       */
-      constructor(type, target) {
-        this.target = target;
-        this.type = type;
-      }
-    };
-    var MessageEvent = class extends Event {
-      /**
-       * Create a new `MessageEvent`.
-       *
-       * @param {(String|Buffer|ArrayBuffer|Buffer[])} data The received data
-       * @param {WebSocket} target A reference to the target to which the event was dispatched
-       */
-      constructor(data, target) {
-        super("message", target);
-        this.data = data;
-      }
-    };
-    var CloseEvent = class extends Event {
-      /**
-       * Create a new `CloseEvent`.
-       *
-       * @param {Number} code The status code explaining why the connection is being closed
-       * @param {String} reason A human-readable string explaining why the connection is closing
-       * @param {WebSocket} target A reference to the target to which the event was dispatched
-       */
-      constructor(code, reason, target) {
-        super("close", target);
-        this.wasClean = target._closeFrameReceived && target._closeFrameSent;
-        this.reason = reason;
-        this.code = code;
-      }
-    };
-    var OpenEvent = class extends Event {
-      /**
-       * Create a new `OpenEvent`.
-       *
-       * @param {WebSocket} target A reference to the target to which the event was dispatched
-       */
-      constructor(target) {
-        super("open", target);
-      }
-    };
-    var ErrorEvent = class extends Event {
-      /**
-       * Create a new `ErrorEvent`.
-       *
-       * @param {Object} error The error that generated this event
-       * @param {WebSocket} target A reference to the target to which the event was dispatched
-       */
-      constructor(error, target) {
-        super("error", target);
-        this.message = error.message;
-        this.error = error;
-      }
-    };
-    var EventTarget = {
-      /**
-       * Register an event listener.
-       *
-       * @param {String} method A string representing the event type to listen for
-       * @param {Function} listener The listener to add
-       * @public
-       */
-      addEventListener(method, listener) {
-        if (typeof listener !== "function") return;
-        function onMessage(data) {
-          listener.call(this, new MessageEvent(data, this));
-        }
-        function onClose(code, message) {
-          listener.call(this, new CloseEvent(code, message, this));
-        }
-        function onError(error) {
-          listener.call(this, new ErrorEvent(error, this));
-        }
-        function onOpen() {
-          listener.call(this, new OpenEvent(this));
-        }
-        if (method === "message") {
-          onMessage._listener = listener;
-          this.on(method, onMessage);
-        } else if (method === "close") {
-          onClose._listener = listener;
-          this.on(method, onClose);
-        } else if (method === "error") {
-          onError._listener = listener;
-          this.on(method, onError);
-        } else if (method === "open") {
-          onOpen._listener = listener;
-          this.on(method, onOpen);
-        } else {
-          this.on(method, listener);
-        }
-      },
-      /**
-       * Remove an event listener.
-       *
-       * @param {String} method A string representing the event type to remove
-       * @param {Function} listener The listener to remove
-       * @public
-       */
-      removeEventListener(method, listener) {
-        const listeners = this.listeners(method);
-        for (var i = 0; i < listeners.length; i++) {
-          if (listeners[i] === listener || listeners[i]._listener === listener) {
-            this.removeListener(method, listeners[i]);
-          }
-        }
-      }
-    };
-    module.exports = EventTarget;
-  }
-});
-
-// ../../node_modules/ws/lib/extension.js
-var require_extension = __commonJS({
-  "../../node_modules/ws/lib/extension.js"(exports, module) {
-    var tokenChars = [
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 0 - 15
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 16 - 31
-      0,
-      1,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      1,
-      1,
-      0,
-      1,
-      1,
-      0,
-      // 32 - 47
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 48 - 63
-      0,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      // 64 - 79
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      0,
-      1,
-      1,
-      // 80 - 95
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      // 96 - 111
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      1,
-      0,
-      1,
-      0
-      // 112 - 127
-    ];
-    function push(dest, name, elem) {
-      if (Object.prototype.hasOwnProperty.call(dest, name)) dest[name].push(elem);
-      else dest[name] = [elem];
-    }
-    function parse(header) {
-      const offers = {};
-      if (header === void 0 || header === "") return offers;
-      var params = {};
-      var mustUnescape = false;
-      var isEscaping = false;
-      var inQuotes = false;
-      var extensionName;
-      var paramName;
-      var start = -1;
-      var end = -1;
-      for (var i = 0; i < header.length; i++) {
-        const code = header.charCodeAt(i);
-        if (extensionName === void 0) {
-          if (end === -1 && tokenChars[code] === 1) {
-            if (start === -1) start = i;
-          } else if (code === 32 || code === 9) {
-            if (end === -1 && start !== -1) end = i;
-          } else if (code === 59 || code === 44) {
-            if (start === -1) {
-              throw new SyntaxError(`Unexpected character at index ${i}`);
-            }
-            if (end === -1) end = i;
-            const name = header.slice(start, end);
-            if (code === 44) {
-              push(offers, name, params);
-              params = {};
-            } else {
-              extensionName = name;
-            }
-            start = end = -1;
-          } else {
-            throw new SyntaxError(`Unexpected character at index ${i}`);
-          }
-        } else if (paramName === void 0) {
-          if (end === -1 && tokenChars[code] === 1) {
-            if (start === -1) start = i;
-          } else if (code === 32 || code === 9) {
-            if (end === -1 && start !== -1) end = i;
-          } else if (code === 59 || code === 44) {
-            if (start === -1) {
-              throw new SyntaxError(`Unexpected character at index ${i}`);
-            }
-            if (end === -1) end = i;
-            push(params, header.slice(start, end), true);
-            if (code === 44) {
-              push(offers, extensionName, params);
-              params = {};
-              extensionName = void 0;
-            }
-            start = end = -1;
-          } else if (code === 61 && start !== -1 && end === -1) {
-            paramName = header.slice(start, i);
-            start = end = -1;
-          } else {
-            throw new SyntaxError(`Unexpected character at index ${i}`);
-          }
-        } else {
-          if (isEscaping) {
-            if (tokenChars[code] !== 1) {
-              throw new SyntaxError(`Unexpected character at index ${i}`);
-            }
-            if (start === -1) start = i;
-            else if (!mustUnescape) mustUnescape = true;
-            isEscaping = false;
-          } else if (inQuotes) {
-            if (tokenChars[code] === 1) {
-              if (start === -1) start = i;
-            } else if (code === 34 && start !== -1) {
-              inQuotes = false;
-              end = i;
-            } else if (code === 92) {
-              isEscaping = true;
-            } else {
-              throw new SyntaxError(`Unexpected character at index ${i}`);
-            }
-          } else if (code === 34 && header.charCodeAt(i - 1) === 61) {
-            inQuotes = true;
-          } else if (end === -1 && tokenChars[code] === 1) {
-            if (start === -1) start = i;
-          } else if (start !== -1 && (code === 32 || code === 9)) {
-            if (end === -1) end = i;
-          } else if (code === 59 || code === 44) {
-            if (start === -1) {
-              throw new SyntaxError(`Unexpected character at index ${i}`);
-            }
-            if (end === -1) end = i;
-            var value = header.slice(start, end);
-            if (mustUnescape) {
-              value = value.replace(/\\/g, "");
-              mustUnescape = false;
-            }
-            push(params, paramName, value);
-            if (code === 44) {
-              push(offers, extensionName, params);
-              params = {};
-              extensionName = void 0;
-            }
-            paramName = void 0;
-            start = end = -1;
-          } else {
-            throw new SyntaxError(`Unexpected character at index ${i}`);
-          }
-        }
-      }
-      if (start === -1 || inQuotes) {
-        throw new SyntaxError("Unexpected end of input");
-      }
-      if (end === -1) end = i;
-      const token = header.slice(start, end);
-      if (extensionName === void 0) {
-        push(offers, token, {});
-      } else {
-        if (paramName === void 0) {
-          push(params, token, true);
-        } else if (mustUnescape) {
-          push(params, paramName, token.replace(/\\/g, ""));
-        } else {
-          push(params, paramName, token);
-        }
-        push(offers, extensionName, params);
-      }
-      return offers;
-    }
-    function format(extensions) {
-      return Object.keys(extensions).map((extension) => {
-        var configurations = extensions[extension];
-        if (!Array.isArray(configurations)) configurations = [configurations];
-        return configurations.map((params) => {
-          return [extension].concat(
-            Object.keys(params).map((k) => {
-              var values = params[k];
-              if (!Array.isArray(values)) values = [values];
-              return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
-            })
-          ).join("; ");
-        }).join(", ");
-      }).join(", ");
-    }
-    module.exports = { format, parse };
-  }
-});
-
-// ../../node_modules/ws/lib/validation.js
-var require_validation = __commonJS({
-  "../../node_modules/ws/lib/validation.js"(exports) {
-    try {
-      const isValidUTF8 = __require("utf-8-validate");
-      exports.isValidUTF8 = typeof isValidUTF8 === "object" ? isValidUTF8.Validation.isValidUTF8 : isValidUTF8;
-    } catch (e) {
-      exports.isValidUTF8 = () => true;
-    }
-    exports.isValidStatusCode = (code) => {
-      return code >= 1e3 && code <= 1013 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
-    };
-  }
-});
-
-// ../../node_modules/ws/lib/receiver.js
-var require_receiver = __commonJS({
-  "../../node_modules/ws/lib/receiver.js"(exports, module) {
-    var { Writable } = __require("stream");
-    var PerMessageDeflate = require_permessage_deflate();
-    var {
-      BINARY_TYPES,
-      EMPTY_BUFFER,
-      kStatusCode,
-      kWebSocket
-    } = require_constants();
-    var { concat, toArrayBuffer, unmask } = require_buffer_util();
-    var { isValidStatusCode, isValidUTF8 } = require_validation();
-    var GET_INFO = 0;
-    var GET_PAYLOAD_LENGTH_16 = 1;
-    var GET_PAYLOAD_LENGTH_64 = 2;
-    var GET_MASK = 3;
-    var GET_DATA = 4;
-    var INFLATING = 5;
-    var Receiver = class extends Writable {
-      /**
-       * Creates a Receiver instance.
-       *
-       * @param {String} binaryType The type for binary data
-       * @param {Object} extensions An object containing the negotiated extensions
-       * @param {Number} maxPayload The maximum allowed message length
-       */
-      constructor(binaryType, extensions, maxPayload) {
-        super();
-        this._binaryType = binaryType || BINARY_TYPES[0];
-        this[kWebSocket] = void 0;
-        this._extensions = extensions || {};
-        this._maxPayload = maxPayload | 0;
-        this._bufferedBytes = 0;
-        this._buffers = [];
-        this._compressed = false;
-        this._payloadLength = 0;
-        this._mask = void 0;
-        this._fragmented = 0;
-        this._masked = false;
-        this._fin = false;
-        this._opcode = 0;
-        this._totalPayloadLength = 0;
-        this._messageLength = 0;
-        this._fragments = [];
-        this._state = GET_INFO;
-        this._loop = false;
-      }
-      /**
-       * Implements `Writable.prototype._write()`.
-       *
-       * @param {Buffer} chunk The chunk of data to write
-       * @param {String} encoding The character encoding of `chunk`
-       * @param {Function} cb Callback
-       */
-      _write(chunk, encoding, cb) {
-        if (this._opcode === 8 && this._state == GET_INFO) return cb();
-        this._bufferedBytes += chunk.length;
-        this._buffers.push(chunk);
-        this.startLoop(cb);
-      }
-      /**
-       * Consumes `n` bytes from the buffered data.
-       *
-       * @param {Number} n The number of bytes to consume
-       * @return {Buffer} The consumed bytes
-       * @private
-       */
-      consume(n) {
-        this._bufferedBytes -= n;
-        if (n === this._buffers[0].length) return this._buffers.shift();
-        if (n < this._buffers[0].length) {
-          const buf = this._buffers[0];
-          this._buffers[0] = buf.slice(n);
-          return buf.slice(0, n);
-        }
-        const dst = Buffer.allocUnsafe(n);
-        do {
-          const buf = this._buffers[0];
-          if (n >= buf.length) {
-            this._buffers.shift().copy(dst, dst.length - n);
-          } else {
-            buf.copy(dst, dst.length - n, 0, n);
-            this._buffers[0] = buf.slice(n);
-          }
-          n -= buf.length;
-        } while (n > 0);
-        return dst;
-      }
-      /**
-       * Starts the parsing loop.
-       *
-       * @param {Function} cb Callback
-       * @private
-       */
-      startLoop(cb) {
-        var err;
-        this._loop = true;
-        do {
-          switch (this._state) {
-            case GET_INFO:
-              err = this.getInfo();
-              break;
-            case GET_PAYLOAD_LENGTH_16:
-              err = this.getPayloadLength16();
-              break;
-            case GET_PAYLOAD_LENGTH_64:
-              err = this.getPayloadLength64();
-              break;
-            case GET_MASK:
-              this.getMask();
-              break;
-            case GET_DATA:
-              err = this.getData(cb);
-              break;
-            default:
-              this._loop = false;
-              return;
-          }
-        } while (this._loop);
-        cb(err);
-      }
-      /**
-       * Reads the first two bytes of a frame.
-       *
-       * @return {(RangeError|undefined)} A possible error
-       * @private
-       */
-      getInfo() {
-        if (this._bufferedBytes < 2) {
-          this._loop = false;
-          return;
-        }
-        const buf = this.consume(2);
-        if ((buf[0] & 48) !== 0) {
-          this._loop = false;
-          return error(RangeError, "RSV2 and RSV3 must be clear", true, 1002);
-        }
-        const compressed = (buf[0] & 64) === 64;
-        if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
-          this._loop = false;
-          return error(RangeError, "RSV1 must be clear", true, 1002);
-        }
-        this._fin = (buf[0] & 128) === 128;
-        this._opcode = buf[0] & 15;
-        this._payloadLength = buf[1] & 127;
-        if (this._opcode === 0) {
-          if (compressed) {
-            this._loop = false;
-            return error(RangeError, "RSV1 must be clear", true, 1002);
-          }
-          if (!this._fragmented) {
-            this._loop = false;
-            return error(RangeError, "invalid opcode 0", true, 1002);
-          }
-          this._opcode = this._fragmented;
-        } else if (this._opcode === 1 || this._opcode === 2) {
-          if (this._fragmented) {
-            this._loop = false;
-            return error(RangeError, `invalid opcode ${this._opcode}`, true, 1002);
-          }
-          this._compressed = compressed;
-        } else if (this._opcode > 7 && this._opcode < 11) {
-          if (!this._fin) {
-            this._loop = false;
-            return error(RangeError, "FIN must be set", true, 1002);
-          }
-          if (compressed) {
-            this._loop = false;
-            return error(RangeError, "RSV1 must be clear", true, 1002);
-          }
-          if (this._payloadLength > 125) {
-            this._loop = false;
-            return error(
-              RangeError,
-              `invalid payload length ${this._payloadLength}`,
-              true,
-              1002
-            );
-          }
-        } else {
-          this._loop = false;
-          return error(RangeError, `invalid opcode ${this._opcode}`, true, 1002);
-        }
-        if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
-        this._masked = (buf[1] & 128) === 128;
-        if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
-        else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
-        else return this.haveLength();
-      }
-      /**
-       * Gets extended payload length (7+16).
-       *
-       * @return {(RangeError|undefined)} A possible error
-       * @private
-       */
-      getPayloadLength16() {
-        if (this._bufferedBytes < 2) {
-          this._loop = false;
-          return;
-        }
-        this._payloadLength = this.consume(2).readUInt16BE(0);
-        return this.haveLength();
-      }
-      /**
-       * Gets extended payload length (7+64).
-       *
-       * @return {(RangeError|undefined)} A possible error
-       * @private
-       */
-      getPayloadLength64() {
-        if (this._bufferedBytes < 8) {
-          this._loop = false;
-          return;
-        }
-        const buf = this.consume(8);
-        const num = buf.readUInt32BE(0);
-        if (num > Math.pow(2, 53 - 32) - 1) {
-          this._loop = false;
-          return error(
-            RangeError,
-            "Unsupported WebSocket frame: payload length > 2^53 - 1",
-            false,
-            1009
-          );
-        }
-        this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
-        return this.haveLength();
-      }
-      /**
-       * Payload length has been read.
-       *
-       * @return {(RangeError|undefined)} A possible error
-       * @private
-       */
-      haveLength() {
-        if (this._payloadLength && this._opcode < 8) {
-          this._totalPayloadLength += this._payloadLength;
-          if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
-            this._loop = false;
-            return error(RangeError, "Max payload size exceeded", false, 1009);
-          }
-        }
-        if (this._masked) this._state = GET_MASK;
-        else this._state = GET_DATA;
-      }
-      /**
-       * Reads mask bytes.
-       *
-       * @private
-       */
-      getMask() {
-        if (this._bufferedBytes < 4) {
-          this._loop = false;
-          return;
-        }
-        this._mask = this.consume(4);
-        this._state = GET_DATA;
-      }
-      /**
-       * Reads data bytes.
-       *
-       * @param {Function} cb Callback
-       * @return {(Error|RangeError|undefined)} A possible error
-       * @private
-       */
-      getData(cb) {
-        var data = EMPTY_BUFFER;
-        if (this._payloadLength) {
-          if (this._bufferedBytes < this._payloadLength) {
-            this._loop = false;
-            return;
-          }
-          data = this.consume(this._payloadLength);
-          if (this._masked) unmask(data, this._mask);
-        }
-        if (this._opcode > 7) return this.controlMessage(data);
-        if (this._compressed) {
-          this._state = INFLATING;
-          this.decompress(data, cb);
-          return;
-        }
-        if (data.length) {
-          this._messageLength = this._totalPayloadLength;
-          this._fragments.push(data);
-        }
-        return this.dataMessage();
-      }
-      /**
-       * Decompresses data.
-       *
-       * @param {Buffer} data Compressed data
-       * @param {Function} cb Callback
-       * @private
-       */
-      decompress(data, cb) {
-        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-        perMessageDeflate.decompress(data, this._fin, (err, buf) => {
-          if (err) return cb(err);
-          if (buf.length) {
-            this._messageLength += buf.length;
-            if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
-              return cb(
-                error(RangeError, "Max payload size exceeded", false, 1009)
-              );
-            }
-            this._fragments.push(buf);
-          }
-          const er = this.dataMessage();
-          if (er) return cb(er);
-          this.startLoop(cb);
-        });
-      }
-      /**
-       * Handles a data message.
-       *
-       * @return {(Error|undefined)} A possible error
-       * @private
-       */
-      dataMessage() {
-        if (this._fin) {
-          const messageLength = this._messageLength;
-          const fragments = this._fragments;
-          this._totalPayloadLength = 0;
-          this._messageLength = 0;
-          this._fragmented = 0;
-          this._fragments = [];
-          if (this._opcode === 2) {
-            var data;
-            if (this._binaryType === "nodebuffer") {
-              data = concat(fragments, messageLength);
-            } else if (this._binaryType === "arraybuffer") {
-              data = toArrayBuffer(concat(fragments, messageLength));
-            } else {
-              data = fragments;
-            }
-            this.emit("message", data);
-          } else {
-            const buf = concat(fragments, messageLength);
-            if (!isValidUTF8(buf)) {
-              this._loop = false;
-              return error(Error, "invalid UTF-8 sequence", true, 1007);
-            }
-            this.emit("message", buf.toString());
-          }
-        }
-        this._state = GET_INFO;
-      }
-      /**
-       * Handles a control message.
-       *
-       * @param {Buffer} data Data to handle
-       * @return {(Error|RangeError|undefined)} A possible error
-       * @private
-       */
-      controlMessage(data) {
-        if (this._opcode === 8) {
-          this._loop = false;
-          if (data.length === 0) {
-            this.emit("conclude", 1005, "");
-            this.end();
-          } else if (data.length === 1) {
-            return error(RangeError, "invalid payload length 1", true, 1002);
-          } else {
-            const code = data.readUInt16BE(0);
-            if (!isValidStatusCode(code)) {
-              return error(RangeError, `invalid status code ${code}`, true, 1002);
-            }
-            const buf = data.slice(2);
-            if (!isValidUTF8(buf)) {
-              return error(Error, "invalid UTF-8 sequence", true, 1007);
-            }
-            this.emit("conclude", code, buf.toString());
-            this.end();
-          }
-        } else if (this._opcode === 9) {
-          this.emit("ping", data);
-        } else {
-          this.emit("pong", data);
-        }
-        this._state = GET_INFO;
-      }
-    };
-    module.exports = Receiver;
-    function error(ErrorCtor, message, prefix, statusCode) {
-      const err = new ErrorCtor(
-        prefix ? `Invalid WebSocket frame: ${message}` : message
-      );
-      Error.captureStackTrace(err, error);
-      err[kStatusCode] = statusCode;
-      return err;
-    }
-  }
-});
-
-// ../../node_modules/ws/lib/sender.js
-var require_sender = __commonJS({
-  "../../node_modules/ws/lib/sender.js"(exports, module) {
-    var { randomBytes } = __require("crypto");
-    var PerMessageDeflate = require_permessage_deflate();
-    var { EMPTY_BUFFER } = require_constants();
-    var { isValidStatusCode } = require_validation();
-    var { mask: applyMask, toBuffer } = require_buffer_util();
-    var Sender = class _Sender {
-      /**
-       * Creates a Sender instance.
-       *
-       * @param {net.Socket} socket The connection socket
-       * @param {Object} extensions An object containing the negotiated extensions
-       */
-      constructor(socket, extensions) {
-        this._extensions = extensions || {};
-        this._socket = socket;
-        this._firstFragment = true;
-        this._compress = false;
-        this._bufferedBytes = 0;
-        this._deflating = false;
-        this._queue = [];
-      }
-      /**
-       * Frames a piece of data according to the HyBi WebSocket protocol.
-       *
-       * @param {Buffer} data The data to frame
-       * @param {Object} options Options object
-       * @param {Number} options.opcode The opcode
-       * @param {Boolean} options.readOnly Specifies whether `data` can be modified
-       * @param {Boolean} options.fin Specifies whether or not to set the FIN bit
-       * @param {Boolean} options.mask Specifies whether or not to mask `data`
-       * @param {Boolean} options.rsv1 Specifies whether or not to set the RSV1 bit
-       * @return {Buffer[]} The framed data as a list of `Buffer` instances
-       * @public
-       */
-      static frame(data, options) {
-        const merge = options.mask && options.readOnly;
-        var offset = options.mask ? 6 : 2;
-        var payloadLength = data.length;
-        if (data.length >= 65536) {
-          offset += 8;
-          payloadLength = 127;
-        } else if (data.length > 125) {
-          offset += 2;
-          payloadLength = 126;
-        }
-        const target = Buffer.allocUnsafe(merge ? data.length + offset : offset);
-        target[0] = options.fin ? options.opcode | 128 : options.opcode;
-        if (options.rsv1) target[0] |= 64;
-        target[1] = payloadLength;
-        if (payloadLength === 126) {
-          target.writeUInt16BE(data.length, 2);
-        } else if (payloadLength === 127) {
-          target.writeUInt32BE(0, 2);
-          target.writeUInt32BE(data.length, 6);
-        }
-        if (!options.mask) return [target, data];
-        const mask = randomBytes(4);
-        target[1] |= 128;
-        target[offset - 4] = mask[0];
-        target[offset - 3] = mask[1];
-        target[offset - 2] = mask[2];
-        target[offset - 1] = mask[3];
-        if (merge) {
-          applyMask(data, mask, target, offset, data.length);
-          return [target];
-        }
-        applyMask(data, mask, data, 0, data.length);
-        return [target, data];
-      }
-      /**
-       * Sends a close message to the other peer.
-       *
-       * @param {(Number|undefined)} code The status code component of the body
-       * @param {String} data The message component of the body
-       * @param {Boolean} mask Specifies whether or not to mask the message
-       * @param {Function} cb Callback
-       * @public
-       */
-      close(code, data, mask, cb) {
-        var buf;
-        if (code === void 0) {
-          buf = EMPTY_BUFFER;
-        } else if (typeof code !== "number" || !isValidStatusCode(code)) {
-          throw new TypeError("First argument must be a valid error code number");
-        } else if (data === void 0 || data === "") {
-          buf = Buffer.allocUnsafe(2);
-          buf.writeUInt16BE(code, 0);
-        } else {
-          buf = Buffer.allocUnsafe(2 + Buffer.byteLength(data));
-          buf.writeUInt16BE(code, 0);
-          buf.write(data, 2);
-        }
-        if (this._deflating) {
-          this.enqueue([this.doClose, buf, mask, cb]);
-        } else {
-          this.doClose(buf, mask, cb);
-        }
-      }
-      /**
-       * Frames and sends a close message.
-       *
-       * @param {Buffer} data The message to send
-       * @param {Boolean} mask Specifies whether or not to mask `data`
-       * @param {Function} cb Callback
-       * @private
-       */
-      doClose(data, mask, cb) {
-        this.sendFrame(
-          _Sender.frame(data, {
-            fin: true,
-            rsv1: false,
-            opcode: 8,
-            mask,
-            readOnly: false
-          }),
-          cb
-        );
-      }
-      /**
-       * Sends a ping message to the other peer.
-       *
-       * @param {*} data The message to send
-       * @param {Boolean} mask Specifies whether or not to mask `data`
-       * @param {Function} cb Callback
-       * @public
-       */
-      ping(data, mask, cb) {
-        const buf = toBuffer(data);
-        if (this._deflating) {
-          this.enqueue([this.doPing, buf, mask, toBuffer.readOnly, cb]);
-        } else {
-          this.doPing(buf, mask, toBuffer.readOnly, cb);
-        }
-      }
-      /**
-       * Frames and sends a ping message.
-       *
-       * @param {*} data The message to send
-       * @param {Boolean} mask Specifies whether or not to mask `data`
-       * @param {Boolean} readOnly Specifies whether `data` can be modified
-       * @param {Function} cb Callback
-       * @private
-       */
-      doPing(data, mask, readOnly, cb) {
-        this.sendFrame(
-          _Sender.frame(data, {
-            fin: true,
-            rsv1: false,
-            opcode: 9,
-            mask,
-            readOnly
-          }),
-          cb
-        );
-      }
-      /**
-       * Sends a pong message to the other peer.
-       *
-       * @param {*} data The message to send
-       * @param {Boolean} mask Specifies whether or not to mask `data`
-       * @param {Function} cb Callback
-       * @public
-       */
-      pong(data, mask, cb) {
-        const buf = toBuffer(data);
-        if (this._deflating) {
-          this.enqueue([this.doPong, buf, mask, toBuffer.readOnly, cb]);
-        } else {
-          this.doPong(buf, mask, toBuffer.readOnly, cb);
-        }
-      }
-      /**
-       * Frames and sends a pong message.
-       *
-       * @param {*} data The message to send
-       * @param {Boolean} mask Specifies whether or not to mask `data`
-       * @param {Boolean} readOnly Specifies whether `data` can be modified
-       * @param {Function} cb Callback
-       * @private
-       */
-      doPong(data, mask, readOnly, cb) {
-        this.sendFrame(
-          _Sender.frame(data, {
-            fin: true,
-            rsv1: false,
-            opcode: 10,
-            mask,
-            readOnly
-          }),
-          cb
-        );
-      }
-      /**
-       * Sends a data message to the other peer.
-       *
-       * @param {*} data The message to send
-       * @param {Object} options Options object
-       * @param {Boolean} options.compress Specifies whether or not to compress `data`
-       * @param {Boolean} options.binary Specifies whether `data` is binary or text
-       * @param {Boolean} options.fin Specifies whether the fragment is the last one
-       * @param {Boolean} options.mask Specifies whether or not to mask `data`
-       * @param {Function} cb Callback
-       * @public
-       */
-      send(data, options, cb) {
-        const buf = toBuffer(data);
-        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-        var opcode = options.binary ? 2 : 1;
-        var rsv1 = options.compress;
-        if (this._firstFragment) {
-          this._firstFragment = false;
-          if (rsv1 && perMessageDeflate) {
-            rsv1 = buf.length >= perMessageDeflate._threshold;
-          }
-          this._compress = rsv1;
-        } else {
-          rsv1 = false;
-          opcode = 0;
-        }
-        if (options.fin) this._firstFragment = true;
-        if (perMessageDeflate) {
-          const opts = {
-            fin: options.fin,
-            rsv1,
-            opcode,
-            mask: options.mask,
-            readOnly: toBuffer.readOnly
-          };
-          if (this._deflating) {
-            this.enqueue([this.dispatch, buf, this._compress, opts, cb]);
-          } else {
-            this.dispatch(buf, this._compress, opts, cb);
-          }
-        } else {
-          this.sendFrame(
-            _Sender.frame(buf, {
-              fin: options.fin,
-              rsv1: false,
-              opcode,
-              mask: options.mask,
-              readOnly: toBuffer.readOnly
-            }),
-            cb
-          );
-        }
-      }
-      /**
-       * Dispatches a data message.
-       *
-       * @param {Buffer} data The message to send
-       * @param {Boolean} compress Specifies whether or not to compress `data`
-       * @param {Object} options Options object
-       * @param {Number} options.opcode The opcode
-       * @param {Boolean} options.readOnly Specifies whether `data` can be modified
-       * @param {Boolean} options.fin Specifies whether or not to set the FIN bit
-       * @param {Boolean} options.mask Specifies whether or not to mask `data`
-       * @param {Boolean} options.rsv1 Specifies whether or not to set the RSV1 bit
-       * @param {Function} cb Callback
-       * @private
-       */
-      dispatch(data, compress, options, cb) {
-        if (!compress) {
-          this.sendFrame(_Sender.frame(data, options), cb);
-          return;
-        }
-        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-        this._deflating = true;
-        perMessageDeflate.compress(data, options.fin, (_, buf) => {
-          this._deflating = false;
-          options.readOnly = false;
-          this.sendFrame(_Sender.frame(buf, options), cb);
-          this.dequeue();
-        });
-      }
-      /**
-       * Executes queued send operations.
-       *
-       * @private
-       */
-      dequeue() {
-        while (!this._deflating && this._queue.length) {
-          const params = this._queue.shift();
-          this._bufferedBytes -= params[1].length;
-          params[0].apply(this, params.slice(1));
-        }
-      }
-      /**
-       * Enqueues a send operation.
-       *
-       * @param {Array} params Send operation parameters.
-       * @private
-       */
-      enqueue(params) {
-        this._bufferedBytes += params[1].length;
-        this._queue.push(params);
-      }
-      /**
-       * Sends a frame.
-       *
-       * @param {Buffer[]} list The frame to send
-       * @param {Function} cb Callback
-       * @private
-       */
-      sendFrame(list, cb) {
-        if (list.length === 2) {
-          this._socket.cork();
-          this._socket.write(list[0]);
-          this._socket.write(list[1], cb);
-          this._socket.uncork();
-        } else {
-          this._socket.write(list[0], cb);
-        }
-      }
-    };
-    module.exports = Sender;
-  }
-});
-
-// ../../node_modules/ws/lib/websocket.js
-var require_websocket = __commonJS({
-  "../../node_modules/ws/lib/websocket.js"(exports, module) {
-    var EventEmitter = __require("events");
-    var crypto2 = __require("crypto");
-    var https = __require("https");
-    var http = __require("http");
-    var net = __require("net");
-    var tls = __require("tls");
-    var url = __require("url");
-    var PerMessageDeflate = require_permessage_deflate();
-    var EventTarget = require_event_target();
-    var extension = require_extension();
-    var Receiver = require_receiver();
-    var Sender = require_sender();
-    var {
-      BINARY_TYPES,
-      EMPTY_BUFFER,
-      GUID,
-      kStatusCode,
-      kWebSocket,
-      NOOP
-    } = require_constants();
-    var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
-    var protocolVersions = [8, 13];
-    var closeTimeout = 30 * 1e3;
-    var WebSocket2 = class _WebSocket extends EventEmitter {
-      /**
-       * Create a new `WebSocket`.
-       *
-       * @param {(String|url.Url|url.URL)} address The URL to which to connect
-       * @param {(String|String[])} protocols The subprotocols
-       * @param {Object} options Connection options
-       */
-      constructor(address, protocols, options) {
-        super();
-        this.readyState = _WebSocket.CONNECTING;
-        this.protocol = "";
-        this._binaryType = BINARY_TYPES[0];
-        this._closeFrameReceived = false;
-        this._closeFrameSent = false;
-        this._closeMessage = "";
-        this._closeTimer = null;
-        this._closeCode = 1006;
-        this._extensions = {};
-        this._receiver = null;
-        this._sender = null;
-        this._socket = null;
-        if (address !== null) {
-          this._isServer = false;
-          this._redirects = 0;
-          if (Array.isArray(protocols)) {
-            protocols = protocols.join(", ");
-          } else if (typeof protocols === "object" && protocols !== null) {
-            options = protocols;
-            protocols = void 0;
-          }
-          initAsClient(this, address, protocols, options);
-        } else {
-          this._isServer = true;
-        }
-      }
-      get CONNECTING() {
-        return _WebSocket.CONNECTING;
-      }
-      get CLOSING() {
-        return _WebSocket.CLOSING;
-      }
-      get CLOSED() {
-        return _WebSocket.CLOSED;
-      }
-      get OPEN() {
-        return _WebSocket.OPEN;
-      }
-      /**
-       * This deviates from the WHATWG interface since ws doesn't support the
-       * required default "blob" type (instead we define a custom "nodebuffer"
-       * type).
-       *
-       * @type {String}
-       */
-      get binaryType() {
-        return this._binaryType;
-      }
-      set binaryType(type) {
-        if (!BINARY_TYPES.includes(type)) return;
-        this._binaryType = type;
-        if (this._receiver) this._receiver._binaryType = type;
-      }
-      /**
-       * @type {Number}
-       */
-      get bufferedAmount() {
-        if (!this._socket) return 0;
-        return (this._socket.bufferSize || 0) + this._sender._bufferedBytes;
-      }
-      /**
-       * @type {String}
-       */
-      get extensions() {
-        return Object.keys(this._extensions).join();
-      }
-      /**
-       * Set up the socket and the internal resources.
-       *
-       * @param {net.Socket} socket The network socket between the server and client
-       * @param {Buffer} head The first packet of the upgraded stream
-       * @param {Number} maxPayload The maximum allowed message size
-       * @private
-       */
-      setSocket(socket, head, maxPayload) {
-        const receiver = new Receiver(
-          this._binaryType,
-          this._extensions,
-          maxPayload
-        );
-        this._sender = new Sender(socket, this._extensions);
-        this._receiver = receiver;
-        this._socket = socket;
-        receiver[kWebSocket] = this;
-        socket[kWebSocket] = this;
-        receiver.on("conclude", receiverOnConclude);
-        receiver.on("drain", receiverOnDrain);
-        receiver.on("error", receiverOnError);
-        receiver.on("message", receiverOnMessage);
-        receiver.on("ping", receiverOnPing);
-        receiver.on("pong", receiverOnPong);
-        socket.setTimeout(0);
-        socket.setNoDelay();
-        if (head.length > 0) socket.unshift(head);
-        socket.on("close", socketOnClose);
-        socket.on("data", socketOnData);
-        socket.on("end", socketOnEnd);
-        socket.on("error", socketOnError);
-        this.readyState = _WebSocket.OPEN;
-        this.emit("open");
-      }
-      /**
-       * Emit the `'close'` event.
-       *
-       * @private
-       */
-      emitClose() {
-        this.readyState = _WebSocket.CLOSED;
-        if (!this._socket) {
-          this.emit("close", this._closeCode, this._closeMessage);
-          return;
-        }
-        if (this._extensions[PerMessageDeflate.extensionName]) {
-          this._extensions[PerMessageDeflate.extensionName].cleanup();
-        }
-        this._receiver.removeAllListeners();
-        this.emit("close", this._closeCode, this._closeMessage);
-      }
-      /**
-       * Start a closing handshake.
-       *
-       *          +----------+   +-----------+   +----------+
-       *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
-       *    |     +----------+   +-----------+   +----------+     |
-       *          +----------+   +-----------+         |
-       * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
-       *          +----------+   +-----------+   |
-       *    |           |                        |   +---+        |
-       *                +------------------------+-->|fin| - - - -
-       *    |         +---+                      |   +---+
-       *     - - - - -|fin|<---------------------+
-       *              +---+
-       *
-       * @param {Number} code Status code explaining why the connection is closing
-       * @param {String} data A string explaining why the connection is closing
-       * @public
-       */
-      close(code, data) {
-        if (this.readyState === _WebSocket.CLOSED) return;
-        if (this.readyState === _WebSocket.CONNECTING) {
-          const msg = "WebSocket was closed before the connection was established";
-          return abortHandshake(this, this._req, msg);
-        }
-        if (this.readyState === _WebSocket.CLOSING) {
-          if (this._closeFrameSent && this._closeFrameReceived) this._socket.end();
-          return;
-        }
-        this.readyState = _WebSocket.CLOSING;
-        this._sender.close(code, data, !this._isServer, (err) => {
-          if (err) return;
-          this._closeFrameSent = true;
-          if (this._closeFrameReceived) this._socket.end();
-        });
-        this._closeTimer = setTimeout(
-          this._socket.destroy.bind(this._socket),
-          closeTimeout
-        );
-      }
-      /**
-       * Send a ping.
-       *
-       * @param {*} data The data to send
-       * @param {Boolean} mask Indicates whether or not to mask `data`
-       * @param {Function} cb Callback which is executed when the ping is sent
-       * @public
-       */
-      ping(data, mask, cb) {
-        if (typeof data === "function") {
-          cb = data;
-          data = mask = void 0;
-        } else if (typeof mask === "function") {
-          cb = mask;
-          mask = void 0;
-        }
-        if (this.readyState !== _WebSocket.OPEN) {
-          const err = new Error(
-            `WebSocket is not open: readyState ${this.readyState} (${readyStates[this.readyState]})`
-          );
-          if (cb) return cb(err);
-          throw err;
-        }
-        if (typeof data === "number") data = data.toString();
-        if (mask === void 0) mask = !this._isServer;
-        this._sender.ping(data || EMPTY_BUFFER, mask, cb);
-      }
-      /**
-       * Send a pong.
-       *
-       * @param {*} data The data to send
-       * @param {Boolean} mask Indicates whether or not to mask `data`
-       * @param {Function} cb Callback which is executed when the pong is sent
-       * @public
-       */
-      pong(data, mask, cb) {
-        if (typeof data === "function") {
-          cb = data;
-          data = mask = void 0;
-        } else if (typeof mask === "function") {
-          cb = mask;
-          mask = void 0;
-        }
-        if (this.readyState !== _WebSocket.OPEN) {
-          const err = new Error(
-            `WebSocket is not open: readyState ${this.readyState} (${readyStates[this.readyState]})`
-          );
-          if (cb) return cb(err);
-          throw err;
-        }
-        if (typeof data === "number") data = data.toString();
-        if (mask === void 0) mask = !this._isServer;
-        this._sender.pong(data || EMPTY_BUFFER, mask, cb);
-      }
-      /**
-       * Send a data message.
-       *
-       * @param {*} data The message to send
-       * @param {Object} options Options object
-       * @param {Boolean} options.compress Specifies whether or not to compress `data`
-       * @param {Boolean} options.binary Specifies whether `data` is binary or text
-       * @param {Boolean} options.fin Specifies whether the fragment is the last one
-       * @param {Boolean} options.mask Specifies whether or not to mask `data`
-       * @param {Function} cb Callback which is executed when data is written out
-       * @public
-       */
-      send(data, options, cb) {
-        if (typeof options === "function") {
-          cb = options;
-          options = {};
-        }
-        if (this.readyState !== _WebSocket.OPEN) {
-          const err = new Error(
-            `WebSocket is not open: readyState ${this.readyState} (${readyStates[this.readyState]})`
-          );
-          if (cb) return cb(err);
-          throw err;
-        }
-        if (typeof data === "number") data = data.toString();
-        const opts = Object.assign(
-          {
-            binary: typeof data !== "string",
-            mask: !this._isServer,
-            compress: true,
-            fin: true
-          },
-          options
-        );
-        if (!this._extensions[PerMessageDeflate.extensionName]) {
-          opts.compress = false;
-        }
-        this._sender.send(data || EMPTY_BUFFER, opts, cb);
-      }
-      /**
-       * Forcibly close the connection.
-       *
-       * @public
-       */
-      terminate() {
-        if (this.readyState === _WebSocket.CLOSED) return;
-        if (this.readyState === _WebSocket.CONNECTING) {
-          const msg = "WebSocket was closed before the connection was established";
-          return abortHandshake(this, this._req, msg);
-        }
-        if (this._socket) {
-          this.readyState = _WebSocket.CLOSING;
-          this._socket.destroy();
-        }
-      }
-    };
-    readyStates.forEach((readyState, i) => {
-      WebSocket2[readyState] = i;
-    });
-    ["open", "error", "close", "message"].forEach((method) => {
-      Object.defineProperty(WebSocket2.prototype, `on${method}`, {
-        /**
-         * Return the listener of the event.
-         *
-         * @return {(Function|undefined)} The event listener or `undefined`
-         * @public
-         */
-        get() {
-          const listeners = this.listeners(method);
-          for (var i = 0; i < listeners.length; i++) {
-            if (listeners[i]._listener) return listeners[i]._listener;
-          }
-          return void 0;
-        },
-        /**
-         * Add a listener for the event.
-         *
-         * @param {Function} listener The listener to add
-         * @public
-         */
-        set(listener) {
-          const listeners = this.listeners(method);
-          for (var i = 0; i < listeners.length; i++) {
-            if (listeners[i]._listener) this.removeListener(method, listeners[i]);
-          }
-          this.addEventListener(method, listener);
-        }
-      });
-    });
-    WebSocket2.prototype.addEventListener = EventTarget.addEventListener;
-    WebSocket2.prototype.removeEventListener = EventTarget.removeEventListener;
-    module.exports = WebSocket2;
-    function initAsClient(websocket, address, protocols, options) {
-      const opts = Object.assign(
-        {
-          protocolVersion: protocolVersions[1],
-          maxPayload: 100 * 1024 * 1024,
-          perMessageDeflate: true,
-          followRedirects: false,
-          maxRedirects: 10
-        },
-        options,
-        {
-          createConnection: void 0,
-          socketPath: void 0,
-          hostname: void 0,
-          protocol: void 0,
-          timeout: void 0,
-          method: void 0,
-          auth: void 0,
-          host: void 0,
-          path: void 0,
-          port: void 0
-        }
-      );
-      if (!protocolVersions.includes(opts.protocolVersion)) {
-        throw new RangeError(
-          `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
-        );
-      }
-      var parsedUrl;
-      if (typeof address === "object" && address.href !== void 0) {
-        parsedUrl = address;
-        websocket.url = address.href;
-      } else {
-        parsedUrl = url.URL ? new url.URL(address) : url.parse(address);
-        websocket.url = address;
-      }
-      const isUnixSocket = parsedUrl.protocol === "ws+unix:";
-      if (!parsedUrl.host && (!isUnixSocket || !parsedUrl.pathname)) {
-        throw new Error(`Invalid URL: ${websocket.url}`);
-      }
-      const isSecure = parsedUrl.protocol === "wss:" || parsedUrl.protocol === "https:";
-      const defaultPort = isSecure ? 443 : 80;
-      const key = crypto2.randomBytes(16).toString("base64");
-      const get = isSecure ? https.get : http.get;
-      const path = parsedUrl.search ? `${parsedUrl.pathname || "/"}${parsedUrl.search}` : parsedUrl.pathname || "/";
-      var perMessageDeflate;
-      opts.createConnection = isSecure ? tlsConnect : netConnect;
-      opts.defaultPort = opts.defaultPort || defaultPort;
-      opts.port = parsedUrl.port || defaultPort;
-      opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
-      opts.headers = Object.assign(
-        {
-          "Sec-WebSocket-Version": opts.protocolVersion,
-          "Sec-WebSocket-Key": key,
-          Connection: "Upgrade",
-          Upgrade: "websocket"
-        },
-        opts.headers
-      );
-      opts.path = path;
-      opts.timeout = opts.handshakeTimeout;
-      if (opts.perMessageDeflate) {
-        perMessageDeflate = new PerMessageDeflate(
-          opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
-          false,
-          opts.maxPayload
-        );
-        opts.headers["Sec-WebSocket-Extensions"] = extension.format({
-          [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
-        });
-      }
-      if (protocols) {
-        opts.headers["Sec-WebSocket-Protocol"] = protocols;
-      }
-      if (opts.origin) {
-        if (opts.protocolVersion < 13) {
-          opts.headers["Sec-WebSocket-Origin"] = opts.origin;
-        } else {
-          opts.headers.Origin = opts.origin;
-        }
-      }
-      if (parsedUrl.auth) {
-        opts.auth = parsedUrl.auth;
-      } else if (parsedUrl.username || parsedUrl.password) {
-        opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
-      }
-      if (isUnixSocket) {
-        const parts = path.split(":");
-        opts.socketPath = parts[0];
-        opts.path = parts[1];
-      }
-      var req = websocket._req = get(opts);
-      if (opts.timeout) {
-        req.on("timeout", () => {
-          abortHandshake(websocket, req, "Opening handshake has timed out");
-        });
-      }
-      req.on("error", (err) => {
-        if (websocket._req.aborted) return;
-        req = websocket._req = null;
-        websocket.readyState = WebSocket2.CLOSING;
-        websocket.emit("error", err);
-        websocket.emitClose();
-      });
-      req.on("response", (res) => {
-        const location = res.headers.location;
-        const statusCode = res.statusCode;
-        if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
-          if (++websocket._redirects > opts.maxRedirects) {
-            abortHandshake(websocket, req, "Maximum redirects exceeded");
-            return;
-          }
-          req.abort();
-          const addr = url.URL ? new url.URL(location, address) : url.resolve(address, location);
-          initAsClient(websocket, addr, protocols, options);
-        } else if (!websocket.emit("unexpected-response", req, res)) {
-          abortHandshake(
-            websocket,
-            req,
-            `Unexpected server response: ${res.statusCode}`
-          );
-        }
-      });
-      req.on("upgrade", (res, socket, head) => {
-        websocket.emit("upgrade", res);
-        if (websocket.readyState !== WebSocket2.CONNECTING) return;
-        req = websocket._req = null;
-        const digest = crypto2.createHash("sha1").update(key + GUID).digest("base64");
-        if (res.headers["sec-websocket-accept"] !== digest) {
-          abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
-          return;
-        }
-        const serverProt = res.headers["sec-websocket-protocol"];
-        const protList = (protocols || "").split(/, */);
-        var protError;
-        if (!protocols && serverProt) {
-          protError = "Server sent a subprotocol but none was requested";
-        } else if (protocols && !serverProt) {
-          protError = "Server sent no subprotocol";
-        } else if (serverProt && !protList.includes(serverProt)) {
-          protError = "Server sent an invalid subprotocol";
-        }
-        if (protError) {
-          abortHandshake(websocket, socket, protError);
-          return;
-        }
-        if (serverProt) websocket.protocol = serverProt;
-        if (perMessageDeflate) {
-          try {
-            const extensions = extension.parse(
-              res.headers["sec-websocket-extensions"]
-            );
-            if (extensions[PerMessageDeflate.extensionName]) {
-              perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
-              websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
-            }
-          } catch (err) {
-            abortHandshake(
-              websocket,
-              socket,
-              "Invalid Sec-WebSocket-Extensions header"
-            );
-            return;
-          }
-        }
-        websocket.setSocket(socket, head, opts.maxPayload);
-      });
-    }
-    function netConnect(options) {
-      if (options.protocolVersion) options.path = options.socketPath;
-      return net.connect(options);
-    }
-    function tlsConnect(options) {
-      options.path = void 0;
-      options.servername = options.servername || options.host;
-      return tls.connect(options);
-    }
-    function abortHandshake(websocket, stream, message) {
-      websocket.readyState = WebSocket2.CLOSING;
-      const err = new Error(message);
-      Error.captureStackTrace(err, abortHandshake);
-      if (stream.setHeader) {
-        stream.abort();
-        stream.once("abort", websocket.emitClose.bind(websocket));
-        websocket.emit("error", err);
-      } else {
-        stream.destroy(err);
-        stream.once("error", websocket.emit.bind(websocket, "error"));
-        stream.once("close", websocket.emitClose.bind(websocket));
-      }
-    }
-    function receiverOnConclude(code, reason) {
-      const websocket = this[kWebSocket];
-      websocket._socket.removeListener("data", socketOnData);
-      websocket._socket.resume();
-      websocket._closeFrameReceived = true;
-      websocket._closeMessage = reason;
-      websocket._closeCode = code;
-      if (code === 1005) websocket.close();
-      else websocket.close(code, reason);
-    }
-    function receiverOnDrain() {
-      this[kWebSocket]._socket.resume();
-    }
-    function receiverOnError(err) {
-      const websocket = this[kWebSocket];
-      websocket._socket.removeListener("data", socketOnData);
-      websocket.readyState = WebSocket2.CLOSING;
-      websocket._closeCode = err[kStatusCode];
-      websocket.emit("error", err);
-      websocket._socket.destroy();
-    }
-    function receiverOnFinish() {
-      this[kWebSocket].emitClose();
-    }
-    function receiverOnMessage(data) {
-      this[kWebSocket].emit("message", data);
-    }
-    function receiverOnPing(data) {
-      const websocket = this[kWebSocket];
-      websocket.pong(data, !websocket._isServer, NOOP);
-      websocket.emit("ping", data);
-    }
-    function receiverOnPong(data) {
-      this[kWebSocket].emit("pong", data);
-    }
-    function socketOnClose() {
-      const websocket = this[kWebSocket];
-      this.removeListener("close", socketOnClose);
-      this.removeListener("end", socketOnEnd);
-      websocket.readyState = WebSocket2.CLOSING;
-      websocket._socket.read();
-      websocket._receiver.end();
-      this.removeListener("data", socketOnData);
-      this[kWebSocket] = void 0;
-      clearTimeout(websocket._closeTimer);
-      if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
-        websocket.emitClose();
-      } else {
-        websocket._receiver.on("error", receiverOnFinish);
-        websocket._receiver.on("finish", receiverOnFinish);
-      }
-    }
-    function socketOnData(chunk) {
-      if (!this[kWebSocket]._receiver.write(chunk)) {
-        this.pause();
-      }
-    }
-    function socketOnEnd() {
-      const websocket = this[kWebSocket];
-      websocket.readyState = WebSocket2.CLOSING;
-      websocket._receiver.end();
-      this.end();
-    }
-    function socketOnError() {
-      const websocket = this[kWebSocket];
-      this.removeListener("error", socketOnError);
-      this.on("error", NOOP);
-      websocket.readyState = WebSocket2.CLOSING;
-      this.destroy();
-    }
-  }
-});
-
-// ../../node_modules/ws/lib/websocket-server.js
-var require_websocket_server = __commonJS({
-  "../../node_modules/ws/lib/websocket-server.js"(exports, module) {
-    var EventEmitter = __require("events");
-    var crypto2 = __require("crypto");
-    var http = __require("http");
-    var PerMessageDeflate = require_permessage_deflate();
-    var extension = require_extension();
-    var WebSocket2 = require_websocket();
-    var { GUID } = require_constants();
-    var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
-    var WebSocketServer = class extends EventEmitter {
-      /**
-       * Create a `WebSocketServer` instance.
-       *
-       * @param {Object} options Configuration options
-       * @param {Number} options.backlog The maximum length of the queue of pending
-       *     connections
-       * @param {Boolean} options.clientTracking Specifies whether or not to track
-       *     clients
-       * @param {Function} options.handleProtocols An hook to handle protocols
-       * @param {String} options.host The hostname where to bind the server
-       * @param {Number} options.maxPayload The maximum allowed message size
-       * @param {Boolean} options.noServer Enable no server mode
-       * @param {String} options.path Accept only connections matching this path
-       * @param {(Boolean|Object)} options.perMessageDeflate Enable/disable
-       *     permessage-deflate
-       * @param {Number} options.port The port where to bind the server
-       * @param {http.Server} options.server A pre-created HTTP/S server to use
-       * @param {Function} options.verifyClient An hook to reject connections
-       * @param {Function} callback A listener for the `listening` event
-       */
-      constructor(options, callback) {
-        super();
-        options = Object.assign(
-          {
-            maxPayload: 100 * 1024 * 1024,
-            perMessageDeflate: false,
-            handleProtocols: null,
-            clientTracking: true,
-            verifyClient: null,
-            noServer: false,
-            backlog: null,
-            // use default (511 as implemented in net.js)
-            server: null,
-            host: null,
-            path: null,
-            port: null
-          },
-          options
-        );
-        if (options.port == null && !options.server && !options.noServer) {
-          throw new TypeError(
-            'One of the "port", "server", or "noServer" options must be specified'
-          );
-        }
-        if (options.port != null) {
-          this._server = http.createServer((req, res) => {
-            const body = http.STATUS_CODES[426];
-            res.writeHead(426, {
-              "Content-Length": body.length,
-              "Content-Type": "text/plain"
-            });
-            res.end(body);
-          });
-          this._server.listen(
-            options.port,
-            options.host,
-            options.backlog,
-            callback
-          );
-        } else if (options.server) {
-          this._server = options.server;
-        }
-        if (this._server) {
-          this._removeListeners = addListeners(this._server, {
-            listening: this.emit.bind(this, "listening"),
-            error: this.emit.bind(this, "error"),
-            upgrade: (req, socket, head) => {
-              this.handleUpgrade(req, socket, head, (ws) => {
-                this.emit("connection", ws, req);
-              });
-            }
-          });
-        }
-        if (options.perMessageDeflate === true) options.perMessageDeflate = {};
-        if (options.clientTracking) this.clients = /* @__PURE__ */ new Set();
-        this.options = options;
-      }
-      /**
-       * Returns the bound address, the address family name, and port of the server
-       * as reported by the operating system if listening on an IP socket.
-       * If the server is listening on a pipe or UNIX domain socket, the name is
-       * returned as a string.
-       *
-       * @return {(Object|String|null)} The address of the server
-       * @public
-       */
-      address() {
-        if (this.options.noServer) {
-          throw new Error('The server is operating in "noServer" mode');
-        }
-        if (!this._server) return null;
-        return this._server.address();
-      }
-      /**
-       * Close the server.
-       *
-       * @param {Function} cb Callback
-       * @public
-       */
-      close(cb) {
-        if (cb) this.once("close", cb);
-        if (this.clients) {
-          for (const client of this.clients) client.terminate();
-        }
-        const server = this._server;
-        if (server) {
-          this._removeListeners();
-          this._removeListeners = this._server = null;
-          if (this.options.port != null) {
-            server.close(() => this.emit("close"));
-            return;
-          }
-        }
-        process.nextTick(emitClose, this);
-      }
-      /**
-       * See if a given request should be handled by this server instance.
-       *
-       * @param {http.IncomingMessage} req Request object to inspect
-       * @return {Boolean} `true` if the request is valid, else `false`
-       * @public
-       */
-      shouldHandle(req) {
-        if (this.options.path) {
-          const index = req.url.indexOf("?");
-          const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
-          if (pathname !== this.options.path) return false;
-        }
-        return true;
-      }
-      /**
-       * Handle a HTTP Upgrade request.
-       *
-       * @param {http.IncomingMessage} req The request object
-       * @param {net.Socket} socket The network socket between the server and client
-       * @param {Buffer} head The first packet of the upgraded stream
-       * @param {Function} cb Callback
-       * @public
-       */
-      handleUpgrade(req, socket, head, cb) {
-        socket.on("error", socketOnError);
-        const key = req.headers["sec-websocket-key"] !== void 0 ? req.headers["sec-websocket-key"].trim() : false;
-        const upgrade = req.headers.upgrade;
-        const version = +req.headers["sec-websocket-version"];
-        const extensions = {};
-        if (req.method !== "GET" || upgrade === void 0 || upgrade.toLowerCase() !== "websocket" || !key || !keyRegex.test(key) || version !== 8 && version !== 13 || !this.shouldHandle(req)) {
-          return abortHandshake(socket, 400);
-        }
-        if (this.options.perMessageDeflate) {
-          const perMessageDeflate = new PerMessageDeflate(
-            this.options.perMessageDeflate,
-            true,
-            this.options.maxPayload
-          );
-          try {
-            const offers = extension.parse(req.headers["sec-websocket-extensions"]);
-            if (offers[PerMessageDeflate.extensionName]) {
-              perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
-              extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
-            }
-          } catch (err) {
-            return abortHandshake(socket, 400);
-          }
-        }
-        if (this.options.verifyClient) {
-          const info = {
-            origin: req.headers[`${version === 8 ? "sec-websocket-origin" : "origin"}`],
-            secure: !!(req.connection.authorized || req.connection.encrypted),
-            req
-          };
-          if (this.options.verifyClient.length === 2) {
-            this.options.verifyClient(info, (verified, code, message, headers) => {
-              if (!verified) {
-                return abortHandshake(socket, code || 401, message, headers);
-              }
-              this.completeUpgrade(key, extensions, req, socket, head, cb);
-            });
-            return;
-          }
-          if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
-        }
-        this.completeUpgrade(key, extensions, req, socket, head, cb);
-      }
-      /**
-       * Upgrade the connection to WebSocket.
-       *
-       * @param {String} key The value of the `Sec-WebSocket-Key` header
-       * @param {Object} extensions The accepted extensions
-       * @param {http.IncomingMessage} req The request object
-       * @param {net.Socket} socket The network socket between the server and client
-       * @param {Buffer} head The first packet of the upgraded stream
-       * @param {Function} cb Callback
-       * @private
-       */
-      completeUpgrade(key, extensions, req, socket, head, cb) {
-        if (!socket.readable || !socket.writable) return socket.destroy();
-        const digest = crypto2.createHash("sha1").update(key + GUID).digest("base64");
-        const headers = [
-          "HTTP/1.1 101 Switching Protocols",
-          "Upgrade: websocket",
-          "Connection: Upgrade",
-          `Sec-WebSocket-Accept: ${digest}`
-        ];
-        const ws = new WebSocket2(null);
-        var protocol = req.headers["sec-websocket-protocol"];
-        if (protocol) {
-          protocol = protocol.split(",").map(trim);
-          if (this.options.handleProtocols) {
-            protocol = this.options.handleProtocols(protocol, req);
-          } else {
-            protocol = protocol[0];
-          }
-          if (protocol) {
-            headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
-            ws.protocol = protocol;
-          }
-        }
-        if (extensions[PerMessageDeflate.extensionName]) {
-          const params = extensions[PerMessageDeflate.extensionName].params;
-          const value = extension.format({
-            [PerMessageDeflate.extensionName]: [params]
-          });
-          headers.push(`Sec-WebSocket-Extensions: ${value}`);
-          ws._extensions = extensions;
-        }
-        this.emit("headers", headers, req);
-        socket.write(headers.concat("\r\n").join("\r\n"));
-        socket.removeListener("error", socketOnError);
-        ws.setSocket(socket, head, this.options.maxPayload);
-        if (this.clients) {
-          this.clients.add(ws);
-          ws.on("close", () => this.clients.delete(ws));
-        }
-        cb(ws);
-      }
-    };
-    module.exports = WebSocketServer;
-    function addListeners(server, map) {
-      for (const event of Object.keys(map)) server.on(event, map[event]);
-      return function removeListeners() {
-        for (const event of Object.keys(map)) {
-          server.removeListener(event, map[event]);
-        }
-      };
-    }
-    function emitClose(server) {
-      server.emit("close");
-    }
-    function socketOnError() {
-      this.destroy();
-    }
-    function abortHandshake(socket, code, message, headers) {
-      if (socket.writable) {
-        message = message || http.STATUS_CODES[code];
-        headers = Object.assign(
-          {
-            Connection: "close",
-            "Content-type": "text/html",
-            "Content-Length": Buffer.byteLength(message)
-          },
-          headers
-        );
-        socket.write(
-          `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
-` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
-        );
-      }
-      socket.removeListener("error", socketOnError);
-      socket.destroy();
-    }
-    function trim(str) {
-      return str.trim();
-    }
-  }
-});
-
-// ../../node_modules/ws/index.js
-var require_ws = __commonJS({
-  "../../node_modules/ws/index.js"(exports, module) {
-    var WebSocket2 = require_websocket();
-    WebSocket2.Server = require_websocket_server();
-    WebSocket2.Receiver = require_receiver();
-    WebSocket2.Sender = require_sender();
-    module.exports = WebSocket2;
-  }
-});
 
 // ../core/src/platform.ts
 function detectPlatform() {
@@ -2970,7 +397,7 @@ function convertKeysToCamelCase(obj) {
 }
 var HttpClient = class {
   authUrl = "https://blink.new";
-  coreUrl = "https://core.blink.new";
+  coreUrl = "https://dev.core.blink.new";
   projectId;
   publishableKey;
   secretKey;
@@ -3104,6 +531,28 @@ var HttpClient = class {
       data: convertedData
     };
   }
+  async dbUpsert(table, body, options = {}) {
+    const headers = {};
+    if (options.returning) {
+      headers.Prefer = "return=representation";
+    }
+    const convertedBody = convertKeysToSnakeCase(body);
+    const onConflict = options.onConflict || "id";
+    const response = await this.request(
+      `/api/db/${this.projectId}/rest/v1/${table}`,
+      {
+        method: "POST",
+        body: convertedBody,
+        headers,
+        searchParams: { on_conflict: onConflict }
+      }
+    );
+    const convertedData = convertKeysToCamelCase(response.data);
+    return {
+      ...response,
+      data: convertedData
+    };
+  }
   async dbPatch(table, body, searchParams, options = {}) {
     const headers = {};
     if (options.returning) {
@@ -5825,21 +3274,12 @@ var BlinkTable = class {
    * Upsert a single record (insert or update on conflict)
    */
   async upsert(data, options = {}) {
-    const headers = {};
-    if (options.returning !== false) {
-      headers.Prefer = "return=representation";
-    }
-    if (options.onConflict) {
-      headers["Prefer"] = `${headers["Prefer"] || ""} resolution=merge-duplicates`.trim();
-    }
     const record = ensureRecordId(data);
-    const response = await this.httpClient.request(
-      `/api/db/${this.httpClient.projectId}/rest/v1/${this.actualTableName}?on_conflict=${options.onConflict || "id"}`,
-      {
-        method: "POST",
-        body: record,
-        headers
-      }
+    const onConflict = options.onConflict || "id";
+    const response = await this.httpClient.dbUpsert(
+      this.actualTableName,
+      record,
+      { onConflict, returning: options.returning !== false }
     );
     const result = Array.isArray(response.data) ? response.data[0] : response.data;
     if (!result) {
@@ -5852,20 +3292,11 @@ var BlinkTable = class {
    */
   async upsertMany(data, options = {}) {
     const records = data.map(ensureRecordId);
-    const headers = {};
-    if (options.returning !== false) {
-      headers.Prefer = "return=representation";
-    }
-    if (options.onConflict) {
-      headers["Prefer"] = `${headers["Prefer"] || ""} resolution=merge-duplicates`.trim();
-    }
-    const response = await this.httpClient.request(
-      `/api/db/${this.httpClient.projectId}/rest/v1/${this.actualTableName}?on_conflict=${options.onConflict || "id"}`,
-      {
-        method: "POST",
-        body: records,
-        headers
-      }
+    const onConflict = options.onConflict || "id";
+    const response = await this.httpClient.dbUpsert(
+      this.actualTableName,
+      records,
+      { onConflict, returning: options.returning !== false }
     );
     const results = Array.isArray(response.data) ? response.data : [response.data];
     return results;
@@ -7800,172 +5231,45 @@ var BlinkDataImpl = class {
   }
 };
 
-// src/realtime.ts
+// src/realtime-connection.ts
 var getWebSocketClass = () => {
   if (typeof WebSocket !== "undefined") {
     return WebSocket;
   }
   try {
-    const WS = require_ws();
+    const WS = __require("ws");
     return WS;
   } catch (error) {
     throw new BlinkRealtimeError('WebSocket is not available. Install "ws" package for Node.js environments.');
   }
 };
-var BlinkRealtimeChannel = class {
-  constructor(channelName, httpClient, projectId) {
-    this.channelName = channelName;
+var RealtimeConnection = class {
+  constructor(httpClient, projectId) {
     this.httpClient = httpClient;
     this.projectId = projectId;
   }
-  messageCallbacks = [];
-  presenceCallbacks = [];
   websocket = null;
-  isSubscribed = false;
   isConnected = false;
   isConnecting = false;
   reconnectTimer = null;
   heartbeatTimer = null;
   reconnectAttempts = 0;
-  // Message queuing for when socket is not ready
-  messageQueue = [];
-  pendingSubscription = null;
-  // Connection promise for awaiting readiness
   connectionPromise = null;
+  // Channel management
+  channels = /* @__PURE__ */ new Map();
+  pendingSubscriptions = /* @__PURE__ */ new Map();
+  // Message queue for when socket not ready
+  messageQueue = [];
   /**
-   * Check if channel is ready for publishing
+   * Check if connection is ready
    */
   isReady() {
-    return this.isConnected && this.isSubscribed;
-  }
-  async subscribe(options = {}) {
-    if (this.isSubscribed) {
-      return;
-    }
-    await this.ensureConnected();
-    return new Promise((resolve, reject) => {
-      if (this.pendingSubscription) {
-        clearTimeout(this.pendingSubscription.timeout);
-        this.pendingSubscription.reject(new BlinkRealtimeError("Subscription cancelled by new subscription request"));
-      }
-      const timeout = setTimeout(() => {
-        this.pendingSubscription = null;
-        reject(new BlinkRealtimeError("Subscription timeout - no acknowledgment from server"));
-      }, 1e4);
-      this.pendingSubscription = {
-        options,
-        resolve: () => {
-          clearTimeout(timeout);
-          this.pendingSubscription = null;
-          this.isSubscribed = true;
-          this.startHeartbeat();
-          resolve();
-        },
-        reject: (error) => {
-          clearTimeout(timeout);
-          this.pendingSubscription = null;
-          reject(error);
-        },
-        timeout
-      };
-      const subscribeMessage = {
-        type: "subscribe",
-        payload: {
-          channel: this.channelName,
-          userId: options.userId,
-          metadata: options.metadata
-        }
-      };
-      this.sendMessage(JSON.stringify(subscribeMessage)).catch((error) => {
-        if (this.pendingSubscription) {
-          this.pendingSubscription.reject(error);
-        }
-      });
-    });
-  }
-  async unsubscribe() {
-    if (!this.isSubscribed) {
-      return;
-    }
-    if (this.pendingSubscription) {
-      clearTimeout(this.pendingSubscription.timeout);
-      this.pendingSubscription.reject(new BlinkRealtimeError("Subscription cancelled by unsubscribe"));
-      this.pendingSubscription = null;
-    }
-    if (this.websocket && this.websocket.readyState === 1) {
-      const unsubscribeMessage = {
-        type: "unsubscribe",
-        payload: {
-          channel: this.channelName
-        }
-      };
-      this.websocket.send(JSON.stringify(unsubscribeMessage));
-    }
-    this.cleanup();
-  }
-  async publish(type, data, options = {}) {
-    await this.ensureConnected();
-    const publishMessage = {
-      type: "publish",
-      payload: {
-        channel: this.channelName,
-        type,
-        data,
-        userId: options.userId,
-        metadata: options.metadata
-      }
-    };
-    return this.sendMessage(JSON.stringify(publishMessage));
-  }
-  onMessage(callback) {
-    this.messageCallbacks.push(callback);
-    return () => {
-      const index = this.messageCallbacks.indexOf(callback);
-      if (index > -1) {
-        this.messageCallbacks.splice(index, 1);
-      }
-    };
-  }
-  onPresence(callback) {
-    this.presenceCallbacks.push(callback);
-    return () => {
-      const index = this.presenceCallbacks.indexOf(callback);
-      if (index > -1) {
-        this.presenceCallbacks.splice(index, 1);
-      }
-    };
-  }
-  async getPresence() {
-    try {
-      const response = await this.httpClient.realtimeGetPresence(this.projectId, this.channelName);
-      return response.data.users || [];
-    } catch (error) {
-      throw new BlinkRealtimeError(
-        `Failed to get presence for channel ${this.channelName}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  async getMessages(options = {}) {
-    try {
-      const response = await this.httpClient.realtimeGetMessages(this.projectId, {
-        channel: this.channelName,
-        limit: options.limit,
-        start: options.after || "-",
-        // after = start from this ID onwards, default to oldest
-        end: options.before || "+"
-        // before = end at this ID, default to newest
-      });
-      return response.data.messages || [];
-    } catch (error) {
-      throw new BlinkRealtimeError(
-        `Failed to get messages for channel ${this.channelName}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
+    return this.isConnected && this.websocket?.readyState === 1;
   }
   /**
-   * Ensure WebSocket connection is established and ready
+   * Ensure WebSocket connection is established
    */
-  async ensureConnected() {
+  async connect() {
     if (this.isConnected && this.websocket?.readyState === 1) {
       return;
     }
@@ -7980,100 +5284,111 @@ var BlinkRealtimeChannel = class {
     }
   }
   /**
-   * Send a message, queuing if socket not ready
+   * Join a channel (subscribe)
    */
-  sendMessage(message) {
-    return new Promise((resolve, reject) => {
-      let messageObj;
-      try {
-        messageObj = JSON.parse(message);
-      } catch (error) {
-        reject(new BlinkRealtimeError("Invalid message format"));
-        return;
-      }
+  async joinChannel(channelName, handler, options = {}) {
+    await this.connect();
+    this.channels.set(channelName, { handler, options });
+    return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
-        const index = this.messageQueue.findIndex((q) => q.resolve === resolve);
-        if (index > -1) {
-          this.messageQueue.splice(index, 1);
-        }
-        reject(new BlinkRealtimeError("Message send timeout - no response from server"));
+        this.pendingSubscriptions.delete(channelName);
+        this.channels.delete(channelName);
+        reject(new BlinkRealtimeError("Subscription timeout - no acknowledgment from server"));
       }, 1e4);
-      const queuedMessage = {
-        message,
-        resolve,
-        reject,
-        timeout
-      };
-      if (this.websocket && this.websocket.readyState === 1) {
-        if (messageObj.type === "publish") {
-          this.sendQueuedMessage(queuedMessage);
-        } else {
-          this.websocket.send(message);
-          clearTimeout(timeout);
-          resolve("sent");
+      this.pendingSubscriptions.set(channelName, { resolve, reject, timeout });
+      const subscribeMessage = {
+        type: "subscribe",
+        payload: {
+          channel: channelName,
+          userId: options.userId,
+          metadata: options.metadata
         }
-      } else {
-        this.messageQueue.push(queuedMessage);
+      };
+      try {
+        this.sendRaw(JSON.stringify(subscribeMessage));
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingSubscriptions.delete(channelName);
+        this.channels.delete(channelName);
+        reject(error);
       }
     });
   }
   /**
-   * Send a queued message and set up response handling
+   * Leave a channel (unsubscribe)
    */
-  sendQueuedMessage(queuedMessage) {
-    const { message, resolve, reject, timeout } = queuedMessage;
-    const handleResponse = (event) => {
-      try {
-        const response = JSON.parse(event.data);
-        if (response.type === "published" && response.payload.channel === this.channelName) {
-          clearTimeout(timeout);
-          this.websocket.removeEventListener("message", handleResponse);
-          resolve(response.payload.messageId);
-        } else if (response.type === "error") {
-          clearTimeout(timeout);
-          this.websocket.removeEventListener("message", handleResponse);
-          reject(new BlinkRealtimeError(`Server error: ${response.payload.error}`));
-        }
-      } catch (err) {
+  async leaveChannel(channelName) {
+    this.channels.delete(channelName);
+    const pending = this.pendingSubscriptions.get(channelName);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      pending.reject(new BlinkRealtimeError("Subscription cancelled"));
+      this.pendingSubscriptions.delete(channelName);
+    }
+    if (this.websocket && this.websocket.readyState === 1) {
+      const unsubscribeMessage = {
+        type: "unsubscribe",
+        payload: { channel: channelName }
+      };
+      this.websocket.send(JSON.stringify(unsubscribeMessage));
+    }
+    if (this.channels.size === 0) {
+      this.disconnect();
+    }
+  }
+  /**
+   * Send a message to a channel
+   */
+  async send(channelName, type, data, options = {}) {
+    await this.connect();
+    const publishMessage = {
+      type: "publish",
+      payload: {
+        channel: channelName,
+        type,
+        data,
+        userId: options.userId,
+        metadata: options.metadata
       }
     };
-    const originalTimeout = timeout;
-    const cleanupTimeout = setTimeout(() => {
-      if (this.websocket) {
-        this.websocket.removeEventListener("message", handleResponse);
-      }
-      reject(new BlinkRealtimeError("Message send timeout - no response from server"));
-    }, 1e4);
-    queuedMessage.timeout = cleanupTimeout;
-    clearTimeout(originalTimeout);
-    this.websocket.addEventListener("message", handleResponse);
-    this.websocket.send(message);
+    return this.sendWithResponse(JSON.stringify(publishMessage), channelName);
   }
   /**
-   * Flush all queued messages when connection becomes ready
+   * Disconnect and cleanup
    */
-  flushMessageQueue() {
-    if (!this.websocket || this.websocket.readyState !== 1) {
-      return;
+  disconnect() {
+    this.isConnected = false;
+    this.isConnecting = false;
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
     }
-    const queue = [...this.messageQueue];
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.messageQueue.forEach((q) => {
+      clearTimeout(q.timeout);
+      q.reject(new BlinkRealtimeError("Connection closed"));
+    });
     this.messageQueue = [];
-    queue.forEach((queuedMessage) => {
-      try {
-        const messageObj = JSON.parse(queuedMessage.message);
-        if (messageObj.type === "publish") {
-          this.sendQueuedMessage(queuedMessage);
-        } else {
-          this.websocket.send(queuedMessage.message);
-          clearTimeout(queuedMessage.timeout);
-          queuedMessage.resolve("sent");
-        }
-      } catch (error) {
-        clearTimeout(queuedMessage.timeout);
-        queuedMessage.reject(new BlinkRealtimeError("Invalid queued message format"));
-      }
+    this.pendingSubscriptions.forEach((pending, channel) => {
+      clearTimeout(pending.timeout);
+      pending.reject(new BlinkRealtimeError("Connection closed"));
     });
+    this.pendingSubscriptions.clear();
+    if (this.websocket) {
+      this.websocket.close();
+      this.websocket = null;
+    }
+  }
+  /**
+   * Get count of active channels
+   */
+  getChannelCount() {
+    return this.channels.size;
   }
+  // Private methods
   async connectWebSocket() {
     if (this.websocket && this.websocket.readyState === 1) {
       this.isConnected = true;
@@ -8101,7 +5416,7 @@ var BlinkRealtimeChannel = class {
         const coreUrl = httpClient.coreUrl || "https://core.blink.new";
         const baseUrl = coreUrl.replace("https://", "wss://").replace("http://", "ws://");
         const wsUrl = `${baseUrl}?project_id=${this.projectId}`;
-        console.log(`\u{1F517} Attempting WebSocket connection to: ${wsUrl}`);
+        console.log(`\u{1F517} Connecting to realtime: ${wsUrl}`);
         const WSClass = getWebSocketClass();
         this.websocket = new WSClass(wsUrl);
         if (!this.websocket) {
@@ -8114,13 +5429,14 @@ var BlinkRealtimeChannel = class {
           this.isConnecting = false;
           this.isConnected = true;
           this.reconnectAttempts = 0;
+          this.startHeartbeat();
           this.flushMessageQueue();
           resolve();
         };
         this.websocket.onmessage = (event) => {
           try {
             const message = JSON.parse(event.data);
-            this.handleWebSocketMessage(message);
+            this.handleMessage(message);
           } catch (error) {
             console.error("Failed to parse WebSocket message:", error);
           }
@@ -8129,19 +5445,11 @@ var BlinkRealtimeChannel = class {
           console.log(`\u{1F50C} Disconnected from realtime for project ${this.projectId}`);
           this.isConnecting = false;
           this.isConnected = false;
-          this.isSubscribed = false;
           this.rejectQueuedMessages(new BlinkRealtimeError("WebSocket connection closed"));
-          if (this.pendingSubscription) {
-            clearTimeout(this.pendingSubscription.timeout);
-            this.pendingSubscription.reject(new BlinkRealtimeError("Connection closed during subscription"));
-            this.pendingSubscription = null;
-          }
           this.scheduleReconnect();
         };
         this.websocket.onerror = (error) => {
           console.error("WebSocket error:", error);
-          console.error("WebSocket URL was:", wsUrl);
-          console.error("WebSocket readyState:", this.websocket?.readyState);
           this.isConnecting = false;
           this.isConnected = false;
           reject(new BlinkRealtimeError(`WebSocket connection failed to ${wsUrl}`));
@@ -8158,61 +5466,122 @@ var BlinkRealtimeChannel = class {
       }
     });
   }
-  /**
-   * Reject all queued messages with the given error
-   */
-  rejectQueuedMessages(error) {
-    const queue = [...this.messageQueue];
-    this.messageQueue = [];
-    queue.forEach((queuedMessage) => {
-      clearTimeout(queuedMessage.timeout);
-      queuedMessage.reject(error);
-    });
-  }
-  handleWebSocketMessage(message) {
+  handleMessage(message) {
+    const channelName = message.payload?.channel;
     switch (message.type) {
-      case "message":
-        this.messageCallbacks.forEach((callback) => {
-          try {
-            callback(message.payload);
-          } catch (error) {
-            console.error("Error in message callback:", error);
-          }
-        });
-        break;
-      case "presence":
-        this.presenceCallbacks.forEach((callback) => {
-          try {
-            const users = message.payload.data?.users || [];
-            callback(users);
-          } catch (error) {
-            console.error("Error in presence callback:", error);
-          }
-        });
+      case "connected":
+        console.log(`\u2705 WebSocket connected: ${message.payload?.socketId}`);
         break;
       case "subscribed":
-        console.log(`\u2705 Subscribed to channel: ${message.payload.channel}`);
-        if (this.pendingSubscription && message.payload.channel === this.channelName) {
-          this.pendingSubscription.resolve();
+        console.log(`\u2705 Subscribed to channel: ${channelName}`);
+        const pendingSub = this.pendingSubscriptions.get(channelName);
+        if (pendingSub) {
+          clearTimeout(pendingSub.timeout);
+          pendingSub.resolve();
+          this.pendingSubscriptions.delete(channelName);
+        }
+        const subHandler = this.channels.get(channelName);
+        if (subHandler) {
+          subHandler.handler.onSubscribed();
         }
         break;
-      case "unsubscribed":
-        console.log(`\u274C Unsubscribed from channel: ${message.payload.channel}`);
+      case "message":
+        const msgChannel = this.channels.get(message.payload?.channel);
+        if (msgChannel) {
+          msgChannel.handler.onMessage(message.payload);
+        }
+        break;
+      case "presence":
+        const presChannel = this.channels.get(message.payload?.channel);
+        if (presChannel) {
+          const users = message.payload?.data?.users || [];
+          presChannel.handler.onPresence(users);
+        }
         break;
       case "published":
         break;
       case "pong":
         break;
       case "error":
-        console.error("Realtime error:", message.payload.error);
-        if (this.pendingSubscription && message.payload.channel === this.channelName) {
-          this.pendingSubscription.reject(new BlinkRealtimeError(`Subscription error: ${message.payload.error}`));
+        console.error("Realtime error:", message.payload?.error);
+        const errChannel = this.channels.get(channelName);
+        if (errChannel) {
+          errChannel.handler.onError(message.payload?.error);
         }
+        const pendingErr = this.pendingSubscriptions.get(channelName);
+        if (pendingErr) {
+          clearTimeout(pendingErr.timeout);
+          pendingErr.reject(new BlinkRealtimeError(`Subscription error: ${message.payload?.error}`));
+          this.pendingSubscriptions.delete(channelName);
+        }
+        break;
+      case "unsubscribed":
+        console.log(`\u274C Unsubscribed from channel: ${channelName}`);
         break;
       default:
         console.log("Unknown message type:", message.type);
     }
   }
+  sendRaw(message) {
+    if (this.websocket && this.websocket.readyState === 1) {
+      this.websocket.send(message);
+    } else {
+      throw new BlinkRealtimeError("Cannot send message: WebSocket not connected");
+    }
+  }
+  sendWithResponse(message, channelName) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const index = this.messageQueue.findIndex((q) => q.resolve === resolve);
+        if (index > -1) {
+          this.messageQueue.splice(index, 1);
+        }
+        reject(new BlinkRealtimeError("Message send timeout - no response from server"));
+      }, 1e4);
+      if (this.websocket && this.websocket.readyState === 1) {
+        const handleResponse = (event) => {
+          try {
+            const response = JSON.parse(event.data);
+            if (response.type === "published" && response.payload.channel === channelName) {
+              clearTimeout(timeout);
+              this.websocket.removeEventListener("message", handleResponse);
+              resolve(response.payload.messageId);
+            } else if (response.type === "error") {
+              clearTimeout(timeout);
+              this.websocket.removeEventListener("message", handleResponse);
+              reject(new BlinkRealtimeError(`Server error: ${response.payload.error}`));
+            }
+          } catch (err) {
+          }
+        };
+        this.websocket.addEventListener("message", handleResponse);
+        this.websocket.send(message);
+      } else {
+        this.messageQueue.push({ message, resolve, reject, timeout });
+      }
+    });
+  }
+  flushMessageQueue() {
+    if (!this.websocket || this.websocket.readyState !== 1) return;
+    const queue = [...this.messageQueue];
+    this.messageQueue = [];
+    queue.forEach((q) => {
+      try {
+        this.websocket.send(q.message);
+      } catch (error) {
+        clearTimeout(q.timeout);
+        q.reject(new BlinkRealtimeError("Failed to send queued message"));
+      }
+    });
+  }
+  rejectQueuedMessages(error) {
+    const queue = [...this.messageQueue];
+    this.messageQueue = [];
+    queue.forEach((q) => {
+      clearTimeout(q.timeout);
+      q.reject(error);
+    });
+  }
   startHeartbeat() {
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
@@ -8227,7 +5596,7 @@ var BlinkRealtimeChannel = class {
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
     }
-    if (!this.isSubscribed && !this.pendingSubscription) {
+    if (this.channels.size === 0) {
       return;
     }
     this.reconnectAttempts++;
@@ -8236,48 +5605,146 @@ var BlinkRealtimeChannel = class {
     const delay = baseDelay + jitter;
     console.log(`\u{1F504} Scheduling reconnect attempt ${this.reconnectAttempts} in ${Math.round(delay)}ms`);
     this.reconnectTimer = globalThis.setTimeout(async () => {
-      if (this.isSubscribed || this.pendingSubscription) {
-        try {
-          await this.connectWebSocket();
-          if (this.isSubscribed && this.websocket) {
-            const subscribeMessage = {
-              type: "subscribe",
-              payload: {
-                channel: this.channelName
-              }
-            };
-            this.websocket.send(JSON.stringify(subscribeMessage));
-            this.startHeartbeat();
+      if (this.channels.size === 0) return;
+      try {
+        await this.connectWebSocket();
+        await this.resubscribeAllChannels();
+      } catch (error) {
+        console.error("Reconnection failed:", error);
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  async resubscribeAllChannels() {
+    console.log(`\u{1F504} Resubscribing ${this.channels.size} channels...`);
+    for (const [channelName, subscription] of this.channels) {
+      try {
+        const subscribeMessage = {
+          type: "subscribe",
+          payload: {
+            channel: channelName,
+            userId: subscription.options.userId,
+            metadata: subscription.options.metadata
           }
-        } catch (error) {
-          console.error("Reconnection failed:", error);
-          this.scheduleReconnect();
+        };
+        if (this.websocket && this.websocket.readyState === 1) {
+          this.websocket.send(JSON.stringify(subscribeMessage));
         }
+      } catch (error) {
+        console.error(`Failed to resubscribe to ${channelName}:`, error);
       }
-    }, delay);
+    }
   }
-  cleanup() {
-    this.isSubscribed = false;
-    this.isConnected = false;
-    this.isConnecting = false;
-    if (this.pendingSubscription) {
-      clearTimeout(this.pendingSubscription.timeout);
-      this.pendingSubscription.reject(new BlinkRealtimeError("Channel cleanup"));
-      this.pendingSubscription = null;
+};
+
+// src/realtime.ts
+var BlinkRealtimeChannel = class {
+  constructor(channelName, connection, httpClient, projectId) {
+    this.channelName = channelName;
+    this.connection = connection;
+    this.httpClient = httpClient;
+    this.projectId = projectId;
+  }
+  messageCallbacks = [];
+  presenceCallbacks = [];
+  isSubscribed = false;
+  subscribeOptions = {};
+  /**
+   * Check if channel is ready for publishing
+   */
+  isReady() {
+    return this.isSubscribed && this.connection.isReady();
+  }
+  async subscribe(options = {}) {
+    if (this.isSubscribed) {
+      return;
     }
-    this.rejectQueuedMessages(new BlinkRealtimeError("Channel cleanup"));
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
+    this.subscribeOptions = options;
+    const handler = {
+      onMessage: (message) => {
+        this.messageCallbacks.forEach((callback) => {
+          try {
+            callback(message);
+          } catch (error) {
+            console.error("Error in message callback:", error);
+          }
+        });
+      },
+      onPresence: (users) => {
+        this.presenceCallbacks.forEach((callback) => {
+          try {
+            callback(users);
+          } catch (error) {
+            console.error("Error in presence callback:", error);
+          }
+        });
+      },
+      onSubscribed: () => {
+        this.isSubscribed = true;
+      },
+      onError: (error) => {
+        console.error(`Channel ${this.channelName} error:`, error);
+      }
+    };
+    await this.connection.joinChannel(this.channelName, handler, options);
+    this.isSubscribed = true;
+  }
+  async unsubscribe() {
+    if (!this.isSubscribed) {
+      return;
     }
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
+    await this.connection.leaveChannel(this.channelName);
+    this.cleanup();
+  }
+  async publish(type, data, options = {}) {
+    return this.connection.send(this.channelName, type, data, options);
+  }
+  onMessage(callback) {
+    this.messageCallbacks.push(callback);
+    return () => {
+      const index = this.messageCallbacks.indexOf(callback);
+      if (index > -1) {
+        this.messageCallbacks.splice(index, 1);
+      }
+    };
+  }
+  onPresence(callback) {
+    this.presenceCallbacks.push(callback);
+    return () => {
+      const index = this.presenceCallbacks.indexOf(callback);
+      if (index > -1) {
+        this.presenceCallbacks.splice(index, 1);
+      }
+    };
+  }
+  async getPresence() {
+    try {
+      const response = await this.httpClient.realtimeGetPresence(this.projectId, this.channelName);
+      return response.data.users || [];
+    } catch (error) {
+      throw new BlinkRealtimeError(
+        `Failed to get presence for channel ${this.channelName}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
     }
-    if (this.websocket) {
-      this.websocket.close();
-      this.websocket = null;
+  }
+  async getMessages(options = {}) {
+    try {
+      const response = await this.httpClient.realtimeGetMessages(this.projectId, {
+        channel: this.channelName,
+        limit: options.limit,
+        start: options.after || "-",
+        end: options.before || "+"
+      });
+      return response.data.messages || [];
+    } catch (error) {
+      throw new BlinkRealtimeError(
+        `Failed to get messages for channel ${this.channelName}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
     }
+  }
+  cleanup() {
+    this.isSubscribed = false;
+    this.subscribeOptions = {};
     this.messageCallbacks = [];
     this.presenceCallbacks = [];
   }
@@ -8286,12 +5753,14 @@ var BlinkRealtimeImpl = class {
   constructor(httpClient, projectId) {
     this.httpClient = httpClient;
     this.projectId = projectId;
+    this.connection = new RealtimeConnection(httpClient, projectId);
   }
+  connection;
   channels = /* @__PURE__ */ new Map();
   handlers = {};
   channel(name) {
     if (!this.channels.has(name)) {
-      this.channels.set(name, new BlinkRealtimeChannel(name, this.httpClient, this.projectId));
+      this.channels.set(name, new BlinkRealtimeChannel(name, this.connection, this.httpClient, this.projectId));
     }
     return this.channels.get(name);
   }
@@ -8340,6 +5809,18 @@ var BlinkRealtimeImpl = class {
       }
     };
   }
+  /**
+   * Get the number of active WebSocket connections (should always be 0 or 1)
+   */
+  getConnectionCount() {
+    return this.connection.isReady() ? 1 : 0;
+  }
+  /**
+   * Get the number of active channels
+   */
+  getChannelCount() {
+    return this.connection.getChannelCount();
+  }
 };
 
 // src/notifications.ts