@blinkdotnew/dev-sdk 2.2.3 → 2.3.0

package/dist/index.js

@@ -1,11 +1,2584 @@
 '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() {
@@ -896,6 +3469,63 @@ var HttpClient = class {
       signal
     });
   }
+  /**
+   * AI Agent request (non-streaming)
+   * Returns JSON response with text, steps, usage, and billing
+   */
+  async aiAgent(requestBody, signal) {
+    return this.request(`/api/ai/${this.projectId}/agent`, {
+      method: "POST",
+      body: requestBody,
+      signal
+    });
+  }
+  /**
+   * AI Agent streaming request
+   * Returns raw Response for SSE streaming (compatible with AI SDK useChat)
+   */
+  async aiAgentStream(requestBody, signal) {
+    const url = this.buildUrl(`/api/ai/${this.projectId}/agent`);
+    const token = this.getValidToken ? await this.getValidToken() : this.getToken();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const auth = this.getAuthorizationHeader(url, token);
+    if (auth) headers.Authorization = auth;
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody),
+      signal
+    });
+    if (!response.ok) {
+      await this.handleErrorResponse(response);
+    }
+    return response;
+  }
+  /**
+   * RAG AI Search streaming request
+   * Returns raw Response for SSE streaming
+   */
+  async ragAiSearchStream(body, signal) {
+    const url = this.buildUrl(`/api/rag/${this.projectId}/ai-search`);
+    const token = this.getValidToken ? await this.getValidToken() : this.getToken();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const auth = this.getAuthorizationHeader(url, token);
+    if (auth) headers.Authorization = auth;
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      await this.handleErrorResponse(response);
+    }
+    return response;
+  }
   /**
    * Data-specific requests
    */
@@ -2642,6 +5272,83 @@ var BlinkAuth = class {
     const user = await this.me();
     return user;
   }
+  /**
+   * Verify a Blink Auth token using the introspection endpoint.
+   * 
+   * **Server-side / Edge Function use only.**
+   * 
+   * This is the recommended way to verify user tokens in Deno Edge Functions
+   * and other server-side contexts. It calls the Blink API introspection 
+   * endpoint which validates the token without exposing the JWT secret.
+   * 
+   * @param token - The raw JWT token (without "Bearer " prefix) or full Authorization header
+   * @returns Token introspection result with validity and claims
+   * 
+   * @example
+   * // Deno Edge Function usage
+   * import { createClient } from "npm:@blinkdotnew/sdk";
+   * 
+   * const blink = createClient({
+   *   projectId: Deno.env.get("BLINK_PROJECT_ID")!,
+   *   secretKey: Deno.env.get("BLINK_SECRET_KEY"),
+   * });
+   * 
+   * async function handler(req: Request): Promise<Response> {
+   *   const authHeader = req.headers.get("Authorization");
+   *   const result = await blink.auth.verifyToken(authHeader);
+   *   
+   *   if (!result.valid) {
+   *     return new Response(JSON.stringify({ error: result.error }), { status: 401 });
+   *   }
+   *   
+   *   // User is authenticated
+   *   console.log("User ID:", result.userId);
+   *   console.log("Email:", result.email);
+   *   console.log("Project:", result.projectId);
+   *   
+   *   // Continue with your logic...
+   * }
+   */
+  async verifyToken(token) {
+    if (!token) {
+      return { valid: false, error: "Token required" };
+    }
+    let cleanToken = token.toLowerCase().startsWith("bearer ") ? token.slice(7) : token;
+    cleanToken = cleanToken.trim();
+    if (!cleanToken) {
+      return { valid: false, error: "Token required" };
+    }
+    try {
+      const response = await fetch(`${this.coreUrl}/api/auth/introspect`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${cleanToken}`,
+          "Content-Type": "application/json"
+        }
+      });
+      const contentType = response.headers.get("content-type")?.toLowerCase();
+      if (!contentType || !contentType.includes("application/json")) {
+        return {
+          valid: false,
+          error: `Server error: ${response.status} ${response.statusText}`
+        };
+      }
+      const result = await response.json();
+      if (!result || typeof result !== "object" || typeof result.valid !== "boolean") {
+        return {
+          valid: false,
+          error: result && (result.error || result.message) || `Request failed: ${response.status}`
+        };
+      }
+      return result;
+    } catch (error) {
+      console.error("[BlinkAuth] Token verification failed:", error);
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : "Token verification failed"
+      };
+    }
+  }
   /**
    * Refresh access token using refresh token
    */
@@ -3665,6 +6372,253 @@ var BlinkStorageImpl = class {
   }
 };
 
+// src/tools/core.ts
+var webSearch = "web_search";
+var fetchUrl = "fetch_url";
+var runCode = "run_code";
+var coreTools = [webSearch, fetchUrl, runCode];
+
+// src/tools/sandbox.ts
+var readFile = "read_file";
+var listDir = "list_dir";
+var writeFile = "write_file";
+var searchReplace = "search_replace";
+var grep = "grep";
+var globFileSearch = "glob_file_search";
+var runTerminalCmd = "run_terminal_cmd";
+var getHost = "get_host";
+var sandboxTools = [
+  readFile,
+  listDir,
+  writeFile,
+  searchReplace,
+  grep,
+  globFileSearch,
+  runTerminalCmd,
+  getHost
+];
+
+// src/tools/db.ts
+var dbInsert = "db_insert";
+var dbList = "db_list";
+var dbGet = "db_get";
+var dbUpdate = "db_update";
+var dbDelete = "db_delete";
+var dbTools = [dbInsert, dbList, dbGet, dbUpdate, dbDelete];
+
+// src/tools/storage.ts
+var storageUpload = "storage_upload";
+var storageDownload = "storage_download";
+var storageList = "storage_list";
+var storageDelete = "storage_delete";
+var storagePublicUrl = "storage_public_url";
+var storageMove = "storage_move";
+var storageCopy = "storage_copy";
+var storageTools = [
+  storageUpload,
+  storageDownload,
+  storageList,
+  storageDelete,
+  storagePublicUrl,
+  storageMove,
+  storageCopy
+];
+
+// src/tools/rag.ts
+var ragSearch = "rag_search";
+var ragTools = [ragSearch];
+
+// src/tools/media.ts
+var generateImage = "generate_image";
+var editImage = "edit_image";
+var generateVideo = "generate_video";
+var imageToVideo = "image_to_video";
+var mediaTools = [generateImage, editImage, generateVideo, imageToVideo];
+
+// src/tools/index.ts
+function serializeTools(tools) {
+  return tools;
+}
+
+// src/agent.ts
+function createStopConditions(maxSteps, stopWhen) {
+  if (stopWhen && stopWhen.length > 0) {
+    return stopWhen;
+  }
+  if (maxSteps && maxSteps > 0) {
+    return [{ type: "step_count_is", count: maxSteps }];
+  }
+  return void 0;
+}
+var Agent = class {
+  httpClient = null;
+  config;
+  /**
+   * Create a new Agent instance
+   * @param options - Agent configuration options
+   */
+  constructor(options) {
+    if (!options.model) {
+      throw new BlinkAIError("Agent model is required");
+    }
+    this.config = options;
+  }
+  /**
+   * Internal: Set the HTTP client (called by BlinkClient)
+   */
+  _setHttpClient(client) {
+    this.httpClient = client;
+  }
+  /**
+   * Internal: Get the agent config for API requests
+   */
+  getAgentConfig() {
+    const { model, system, instructions, tools, webhookTools, clientTools, toolChoice, stopWhen, maxSteps } = this.config;
+    const serializedTools = tools ? serializeTools(tools) : void 0;
+    const stopConditions = createStopConditions(maxSteps, stopWhen);
+    return {
+      model,
+      system: system || instructions,
+      tools: serializedTools,
+      webhook_tools: webhookTools,
+      client_tools: clientTools,
+      tool_choice: toolChoice,
+      stop_when: stopConditions
+    };
+  }
+  /**
+   * Generate a response (non-streaming)
+   * 
+   * @param options - Generation options (prompt or messages)
+   * @returns Promise<AgentResponse> with text, steps, usage, and billing
+   * 
+   * @example
+   * ```ts
+   * const result = await agent.generate({
+   *   prompt: 'What is the weather in San Francisco?',
+   * })
+   * console.log(result.text)
+   * console.log(result.steps)
+   * ```
+   */
+  async generate(options) {
+    if (!this.httpClient) {
+      throw new BlinkAIError(
+        "Agent not initialized. Use blink.ai.createAgent() or pass the agent to useAgent()."
+      );
+    }
+    if (!options.prompt && !options.messages) {
+      throw new BlinkAIError("Either prompt or messages is required");
+    }
+    if (options.prompt && options.messages) {
+      throw new BlinkAIError("prompt and messages are mutually exclusive");
+    }
+    try {
+      const requestBody = {
+        stream: false,
+        agent: this.getAgentConfig()
+      };
+      if (options.prompt) {
+        requestBody.prompt = options.prompt;
+      } else if (options.messages) {
+        requestBody.messages = options.messages;
+      }
+      if (options.sandbox) {
+        requestBody.sandbox_id = typeof options.sandbox === "string" ? options.sandbox : options.sandbox.id;
+      }
+      const response = await this.httpClient.aiAgent(requestBody, options.signal);
+      return response.data;
+    } catch (error) {
+      console.error("[Agent] generate failed:", error);
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Agent generate failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Stream a response (real-time)
+   * 
+   * @param options - Stream options (prompt or messages)
+   * @returns Promise<Response> - AI SDK UI Message Stream for useChat compatibility
+   * 
+   * @example
+   * ```ts
+   * const stream = await agent.stream({
+   *   prompt: 'Tell me a story',
+   * })
+   * 
+   * // Process stream
+   * for await (const chunk of stream.body) {
+   *   // Handle chunk
+   * }
+   * ```
+   */
+  async stream(options) {
+    if (!this.httpClient) {
+      throw new BlinkAIError(
+        "Agent not initialized. Use blink.ai.createAgent() or pass the agent to useAgent()."
+      );
+    }
+    if (!options.prompt && !options.messages) {
+      throw new BlinkAIError("Either prompt or messages is required");
+    }
+    if (options.prompt && options.messages) {
+      throw new BlinkAIError("prompt and messages are mutually exclusive");
+    }
+    try {
+      const requestBody = {
+        stream: true,
+        agent: this.getAgentConfig()
+      };
+      if (options.prompt) {
+        requestBody.prompt = options.prompt;
+      } else if (options.messages) {
+        requestBody.messages = options.messages;
+      }
+      if (options.sandbox) {
+        requestBody.sandbox_id = typeof options.sandbox === "string" ? options.sandbox : options.sandbox.id;
+      }
+      return await this.httpClient.aiAgentStream(requestBody, options.signal);
+    } catch (error) {
+      console.error("[Agent] stream failed:", error);
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Agent stream failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Get the agent's model
+   */
+  get model() {
+    return this.config.model;
+  }
+  /**
+   * Get the agent's system prompt
+   */
+  get system() {
+    return this.config.system || this.config.instructions;
+  }
+  /**
+   * Get the agent's tools
+   */
+  get tools() {
+    return this.config.tools;
+  }
+};
+function stepCountIs(count) {
+  return { type: "step_count_is", count };
+}
+
 // src/ai.ts
 var BlinkAIImpl = class {
   constructor(httpClient) {
@@ -4635,6 +7589,104 @@ var BlinkAIImpl = class {
       );
     }
   }
+  async agent(options) {
+    try {
+      if (!options.agent?.model) {
+        throw new BlinkAIError("agent.model is required");
+      }
+      if (!options.prompt && !options.messages) {
+        throw new BlinkAIError("Either prompt or messages is required");
+      }
+      if (options.prompt && options.messages) {
+        throw new BlinkAIError("prompt and messages are mutually exclusive");
+      }
+      const serializedTools = options.agent.tools ? serializeTools(options.agent.tools) : void 0;
+      const requestBody = {
+        stream: options.stream,
+        agent: {
+          model: options.agent.model,
+          system: options.agent.system,
+          tools: serializedTools,
+          webhook_tools: options.agent.webhook_tools,
+          client_tools: options.agent.client_tools,
+          tool_choice: options.agent.tool_choice,
+          stop_when: options.agent.stop_when,
+          prepare_step: options.agent.prepare_step
+        }
+      };
+      if (options.prompt) {
+        requestBody.prompt = options.prompt;
+      } else if (options.messages) {
+        requestBody.messages = options.messages;
+      }
+      if (options.stream) {
+        return await this.httpClient.aiAgentStream(requestBody, options.signal);
+      } else {
+        const response = await this.httpClient.aiAgent(requestBody, options.signal);
+        return response.data;
+      }
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Agent request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  // ============================================================================
+  // Agent Factory
+  // ============================================================================
+  /**
+   * Creates a reusable Agent instance with the Vercel AI SDK pattern.
+   * 
+   * The Agent can be used multiple times with different prompts:
+   * - `agent.generate({ prompt })` for non-streaming
+   * - `agent.stream({ prompt })` for streaming
+   * 
+   * @param options - Agent configuration (model, tools, system, etc.)
+   * @returns Agent instance
+   * 
+   * @example
+   * ```ts
+   * const weatherAgent = blink.ai.createAgent({
+   *   model: 'anthropic/claude-sonnet-4-20250514',
+   *   system: 'You are a helpful weather assistant.',
+   *   tools: [webSearch, fetchUrl],
+   *   maxSteps: 10,
+   * })
+   * 
+   * // Non-streaming
+   * const result = await weatherAgent.generate({
+   *   prompt: 'What is the weather in San Francisco?',
+   * })
+   * 
+   * // Streaming
+   * const stream = await weatherAgent.stream({
+   *   prompt: 'Tell me about weather patterns',
+   * })
+   * ```
+   */
+  createAgent(options) {
+    const agent = new Agent(options);
+    agent._setHttpClient(this.httpClient);
+    return agent;
+  }
+  /**
+   * Binds an existing Agent instance to this client's HTTP client.
+   * 
+   * Used internally by useAgent() when an Agent instance is passed.
+   * This allows agents created with `new Agent()` to be used with the hook.
+   * 
+   * @param agent - Existing Agent instance
+   * @returns The same Agent instance (with httpClient set)
+   */
+  bindAgent(agent) {
+    agent._setHttpClient(this.httpClient);
+    return agent;
+  }
 };
 
 // src/data.ts
@@ -4744,7 +7796,7 @@ var getWebSocketClass = () => {
     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.');
@@ -5753,6 +8805,411 @@ var BlinkFunctionsImpl = class {
   }
 };
 
+// src/rag.ts
+function removeUndefined(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== void 0)
+  );
+}
+function convertCollection(api) {
+  return {
+    id: api.id,
+    name: api.name,
+    description: api.description,
+    embeddingModel: api.embedding_model,
+    embeddingDimensions: api.embedding_dimensions,
+    indexMetric: api.index_metric,
+    chunkMaxTokens: api.chunk_max_tokens,
+    chunkOverlapTokens: api.chunk_overlap_tokens,
+    documentCount: api.document_count,
+    chunkCount: api.chunk_count,
+    shared: api.shared,
+    createdAt: api.created_at,
+    updatedAt: api.updated_at
+  };
+}
+function convertDocument(api) {
+  return {
+    id: api.id,
+    collectionId: api.collection_id,
+    filename: api.filename,
+    sourceType: api.source_type,
+    sourceUrl: api.source_url,
+    contentType: api.content_type,
+    fileSize: api.file_size,
+    status: api.status,
+    errorMessage: api.error_message,
+    processingStartedAt: api.processing_started_at,
+    processingCompletedAt: api.processing_completed_at,
+    chunkCount: api.chunk_count,
+    tokenCount: api.token_count,
+    metadata: api.metadata,
+    createdAt: api.created_at,
+    updatedAt: api.updated_at
+  };
+}
+function convertPartialDocument(api, options) {
+  let sourceType = "text";
+  if (options.url) sourceType = "url";
+  if (options.file) sourceType = "file";
+  return {
+    id: api.id || "",
+    collectionId: api.collection_id || options.collectionId || "",
+    filename: api.filename || options.filename,
+    sourceType: api.source_type || sourceType,
+    sourceUrl: api.source_url ?? options.url ?? null,
+    contentType: api.content_type ?? options.file?.contentType ?? null,
+    fileSize: api.file_size ?? null,
+    status: api.status || "pending",
+    errorMessage: api.error_message ?? null,
+    processingStartedAt: api.processing_started_at ?? null,
+    processingCompletedAt: api.processing_completed_at ?? null,
+    chunkCount: api.chunk_count ?? 0,
+    tokenCount: api.token_count ?? null,
+    metadata: api.metadata || options.metadata || {},
+    createdAt: api.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: api.updated_at || api.created_at || (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function convertSearchResult(api) {
+  return {
+    chunkId: api.chunk_id,
+    documentId: api.document_id,
+    filename: api.filename,
+    content: api.content,
+    score: api.score,
+    chunkIndex: api.chunk_index,
+    metadata: api.metadata
+  };
+}
+function convertSearchResponse(api) {
+  return {
+    results: api.results.map(convertSearchResult),
+    query: api.query,
+    collectionId: api.collection_id,
+    totalResults: api.total_results
+  };
+}
+function convertAISearchSource(api) {
+  return {
+    documentId: api.document_id,
+    filename: api.filename,
+    chunkId: api.chunk_id,
+    excerpt: api.excerpt,
+    score: api.score
+  };
+}
+function convertAISearchResult(api) {
+  return {
+    answer: api.answer,
+    sources: api.sources.map(convertAISearchSource),
+    query: api.query,
+    model: api.model,
+    usage: {
+      inputTokens: api.usage.input_tokens,
+      outputTokens: api.usage.output_tokens
+    }
+  };
+}
+var BlinkRAGImpl = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+    this.projectId = httpClient.projectId;
+  }
+  projectId;
+  /**
+   * Build URL with project_id prefix
+   */
+  url(path) {
+    return `/api/rag/${this.projectId}${path}`;
+  }
+  // ============================================================================
+  // Collections
+  // ============================================================================
+  /**
+   * Create a new RAG collection
+   */
+  async createCollection(options) {
+    const body = removeUndefined({
+      name: options.name,
+      description: options.description,
+      embedding_model: options.embeddingModel,
+      embedding_dimensions: options.embeddingDimensions,
+      index_metric: options.indexMetric,
+      chunk_max_tokens: options.chunkMaxTokens,
+      chunk_overlap_tokens: options.chunkOverlapTokens,
+      shared: options.shared
+    });
+    const response = await this.httpClient.post(this.url("/collections"), body);
+    return convertCollection(response.data);
+  }
+  /**
+   * List all collections accessible to the current user
+   */
+  async listCollections() {
+    const response = await this.httpClient.get(this.url("/collections"));
+    return response.data.collections.map(convertCollection);
+  }
+  /**
+   * Get a specific collection by ID
+   */
+  async getCollection(collectionId) {
+    const response = await this.httpClient.get(this.url(`/collections/${collectionId}`));
+    return convertCollection(response.data);
+  }
+  /**
+   * Delete a collection and all its documents
+   */
+  async deleteCollection(collectionId) {
+    await this.httpClient.delete(this.url(`/collections/${collectionId}`));
+  }
+  // ============================================================================
+  // Documents
+  // ============================================================================
+  /**
+   * Upload a document for processing
+   * 
+   * @example
+   * // Upload text content
+   * const doc = await blink.rag.upload({
+   *   collectionName: 'docs',
+   *   filename: 'notes.txt',
+   *   content: 'My document content...'
+   * })
+   * 
+   * @example
+   * // Upload from URL
+   * const doc = await blink.rag.upload({
+   *   collectionId: 'col_abc123',
+   *   filename: 'article.html',
+   *   url: 'https://example.com/article'
+   * })
+   * 
+   * @example
+   * // Upload a file (base64)
+   * const doc = await blink.rag.upload({
+   *   collectionName: 'docs',
+   *   filename: 'report.pdf',
+   *   file: { data: base64Data, contentType: 'application/pdf' }
+   * })
+   */
+  async upload(options) {
+    if (!options.collectionId && !options.collectionName) {
+      throw new Error("collectionId or collectionName is required");
+    }
+    const body = removeUndefined({
+      collection_id: options.collectionId,
+      collection_name: options.collectionName,
+      filename: options.filename,
+      content: options.content,
+      url: options.url,
+      metadata: options.metadata
+    });
+    if (options.file) {
+      body.file = {
+        data: options.file.data,
+        content_type: options.file.contentType
+      };
+    }
+    const response = await this.httpClient.post(this.url("/documents"), body);
+    return convertPartialDocument(response.data, options);
+  }
+  /**
+   * Get document status and metadata
+   */
+  async getDocument(documentId) {
+    const response = await this.httpClient.get(this.url(`/documents/${documentId}`));
+    return convertDocument(response.data);
+  }
+  /**
+   * List documents, optionally filtered by collection or status
+   */
+  async listDocuments(options) {
+    const params = {};
+    if (options?.collectionId) params.collection_id = options.collectionId;
+    if (options?.status) params.status = options.status;
+    const queryString = Object.keys(params).length > 0 ? `?${new URLSearchParams(params).toString()}` : "";
+    const response = await this.httpClient.get(
+      this.url(`/documents${queryString}`)
+    );
+    return response.data.documents.map(convertDocument);
+  }
+  /**
+   * Delete a document and its chunks
+   */
+  async deleteDocument(documentId) {
+    await this.httpClient.delete(this.url(`/documents/${documentId}`));
+  }
+  /**
+   * Wait for a document to finish processing
+   * 
+   * @example
+   * const doc = await blink.rag.upload({ ... })
+   * const readyDoc = await blink.rag.waitForReady(doc.id)
+   * console.log(`Processed ${readyDoc.chunkCount} chunks`)
+   */
+  async waitForReady(documentId, options) {
+    const { timeoutMs = 12e4, pollIntervalMs = 2e3 } = options || {};
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const doc = await this.getDocument(documentId);
+      if (doc.status === "ready") {
+        return doc;
+      }
+      if (doc.status === "error") {
+        throw new Error(`Document processing failed: ${doc.errorMessage}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error(`Document processing timeout after ${timeoutMs}ms`);
+  }
+  // ============================================================================
+  // Search
+  // ============================================================================
+  /**
+   * Search for similar chunks using vector similarity
+   * 
+   * @example
+   * const results = await blink.rag.search({
+   *   collectionName: 'docs',
+   *   query: 'How do I configure authentication?',
+   *   maxResults: 5
+   * })
+   */
+  async search(options) {
+    if (!options.collectionId && !options.collectionName) {
+      throw new Error("collectionId or collectionName is required");
+    }
+    const body = removeUndefined({
+      collection_id: options.collectionId,
+      collection_name: options.collectionName,
+      query: options.query,
+      max_results: options.maxResults,
+      score_threshold: options.scoreThreshold,
+      filters: options.filters,
+      include_content: options.includeContent
+    });
+    const response = await this.httpClient.post(this.url("/search"), body);
+    return convertSearchResponse(response.data);
+  }
+  async aiSearch(options) {
+    if (!options.collectionId && !options.collectionName) {
+      throw new Error("collectionId or collectionName is required");
+    }
+    const body = removeUndefined({
+      collection_id: options.collectionId,
+      collection_name: options.collectionName,
+      query: options.query,
+      model: options.model,
+      max_context_chunks: options.maxContextChunks,
+      score_threshold: options.scoreThreshold,
+      system_prompt: options.systemPrompt,
+      stream: options.stream
+    });
+    if (options.stream) {
+      const response2 = await this.httpClient.ragAiSearchStream(body, options.signal);
+      return response2.body;
+    }
+    const response = await this.httpClient.post(this.url("/ai-search"), body);
+    return convertAISearchResult(response.data);
+  }
+};
+
+// src/sandbox.ts
+var SANDBOX_TEMPLATES = [
+  "devtools-base",
+  // Node 22 + Bun + Python + Git + ripgrep (DEFAULT)
+  "nextjs-app",
+  // Next.js + Tailwind + shadcn UI (Node)
+  "nextjs-app-bun",
+  // Next.js + Tailwind + shadcn UI (Bun)
+  "vite-react",
+  // Vite + React + Tailwind + shadcn (Node)
+  "vite-react-bun",
+  // Vite + React + Tailwind + shadcn (Bun)
+  "expo-app",
+  // Expo + React Native
+  "desktop",
+  // Electron + Vite + React
+  "claude-code"
+  // Node 21 + Python + Git + ripgrep
+];
+var SandboxConnectionError = class extends Error {
+  sandboxId;
+  constructor(sandboxId, cause) {
+    super(`Failed to connect to sandbox ${sandboxId}`);
+    this.name = "SandboxConnectionError";
+    this.sandboxId = sandboxId;
+    if (cause) {
+      this.cause = cause;
+    }
+  }
+};
+var SandboxImpl = class {
+  constructor(id, template, hostPattern) {
+    this.id = id;
+    this.template = template;
+    this.hostPattern = hostPattern;
+  }
+  getHost(port) {
+    return this.hostPattern.replace("{port}", String(port));
+  }
+};
+var MAX_RETRIES = 3;
+var INITIAL_RETRY_DELAY_MS = 250;
+var BlinkSandboxImpl = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+    this.projectId = httpClient.projectId;
+  }
+  projectId;
+  /**
+   * Build URL with project_id prefix
+   */
+  url(path) {
+    return `/api/sandbox/${this.projectId}${path}`;
+  }
+  async create(options = {}) {
+    const body = {
+      template: options.template,
+      timeout_ms: options.timeoutMs,
+      metadata: options.metadata
+    };
+    const response = await this.httpClient.post(this.url("/create"), body);
+    const { id, template, host_pattern } = response.data;
+    return new SandboxImpl(id, template, host_pattern);
+  }
+  async connect(sandboxId, options = {}) {
+    let lastError;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const body = {
+          sandbox_id: sandboxId,
+          timeout_ms: options.timeoutMs
+        };
+        const response = await this.httpClient.post(this.url("/connect"), body);
+        const { id, template, host_pattern } = response.data;
+        return new SandboxImpl(id, template, host_pattern);
+      } catch (error) {
+        console.error(`[Sandbox] Connect attempt ${attempt + 1} failed:`, error);
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (lastError.message.includes("404") || lastError.message.includes("not found") || lastError.message.includes("unauthorized")) {
+          throw new SandboxConnectionError(sandboxId, lastError);
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          const delay = INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    console.error(`[Sandbox] All ${MAX_RETRIES} connection attempts failed for sandbox ${sandboxId}`);
+    throw new SandboxConnectionError(sandboxId, lastError);
+  }
+  async kill(sandboxId) {
+    await this.httpClient.post(this.url("/kill"), { sandbox_id: sandboxId });
+  }
+};
+
 // src/client.ts
 var BlinkClientImpl = class {
   auth;
@@ -5765,6 +9222,8 @@ var BlinkClientImpl = class {
   analytics;
   connectors;
   functions;
+  rag;
+  sandbox;
   httpClient;
   constructor(config) {
     if ((config.secretKey || config.serviceToken) && isBrowser) {
@@ -5789,6 +9248,8 @@ var BlinkClientImpl = class {
       config.projectId,
       () => this.auth.getValidToken()
     );
+    this.rag = new BlinkRAGImpl(this.httpClient);
+    this.sandbox = new BlinkSandboxImpl(this.httpClient);
     this.auth.onAuthStateChanged((state) => {
       if (state.isAuthenticated && state.user) {
         this.analytics.setUserId(state.user.id);
@@ -5807,26 +9268,67 @@ function createClient(config) {
   return new BlinkClientImpl(config);
 }
 
+exports.Agent = Agent;
 exports.AsyncStorageAdapter = AsyncStorageAdapter;
 exports.BlinkAIImpl = BlinkAIImpl;
 exports.BlinkAnalyticsImpl = BlinkAnalyticsImpl;
 exports.BlinkConnectorsImpl = BlinkConnectorsImpl;
 exports.BlinkDataImpl = BlinkDataImpl;
 exports.BlinkDatabase = BlinkDatabase;
+exports.BlinkRAGImpl = BlinkRAGImpl;
 exports.BlinkRealtimeChannel = BlinkRealtimeChannel;
 exports.BlinkRealtimeImpl = BlinkRealtimeImpl;
+exports.BlinkSandboxImpl = BlinkSandboxImpl;
 exports.BlinkStorageImpl = BlinkStorageImpl;
 exports.BlinkTable = BlinkTable;
 exports.NoOpStorageAdapter = NoOpStorageAdapter;
+exports.SANDBOX_TEMPLATES = SANDBOX_TEMPLATES;
+exports.SandboxConnectionError = SandboxConnectionError;
 exports.WebStorageAdapter = WebStorageAdapter;
+exports.coreTools = coreTools;
 exports.createClient = createClient;
+exports.dbDelete = dbDelete;
+exports.dbGet = dbGet;
+exports.dbInsert = dbInsert;
+exports.dbList = dbList;
+exports.dbTools = dbTools;
+exports.dbUpdate = dbUpdate;
+exports.editImage = editImage;
+exports.fetchUrl = fetchUrl;
+exports.generateImage = generateImage;
+exports.generateVideo = generateVideo;
 exports.getDefaultStorageAdapter = getDefaultStorageAdapter;
+exports.getHost = getHost;
+exports.globFileSearch = globFileSearch;
+exports.grep = grep;
+exports.imageToVideo = imageToVideo;
 exports.isBrowser = isBrowser;
 exports.isDeno = isDeno;
 exports.isNode = isNode;
 exports.isReactNative = isReactNative;
 exports.isServer = isServer;
 exports.isWeb = isWeb;
+exports.listDir = listDir;
+exports.mediaTools = mediaTools;
 exports.platform = platform;
+exports.ragSearch = ragSearch;
+exports.ragTools = ragTools;
+exports.readFile = readFile;
+exports.runCode = runCode;
+exports.runTerminalCmd = runTerminalCmd;
+exports.sandboxTools = sandboxTools;
+exports.searchReplace = searchReplace;
+exports.serializeTools = serializeTools;
+exports.stepCountIs = stepCountIs;
+exports.storageCopy = storageCopy;
+exports.storageDelete = storageDelete;
+exports.storageDownload = storageDownload;
+exports.storageList = storageList;
+exports.storageMove = storageMove;
+exports.storagePublicUrl = storagePublicUrl;
+exports.storageTools = storageTools;
+exports.storageUpload = storageUpload;
+exports.webSearch = webSearch;
+exports.writeFile = writeFile;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map