@elizaos/plugin-minecraft 2.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,4664 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../../../node_modules/ws/lib/constants.js
+var require_constants = __commonJS((exports, module) => {
+  var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
+  var hasBlob = typeof Blob !== "undefined";
+  if (hasBlob)
+    BINARY_TYPES.push("blob");
+  module.exports = {
+    BINARY_TYPES,
+    CLOSE_TIMEOUT: 30000,
+    EMPTY_BUFFER: Buffer.alloc(0),
+    GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+    hasBlob,
+    kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
+    kListener: Symbol("kListener"),
+    kStatusCode: Symbol("status-code"),
+    kWebSocket: Symbol("websocket"),
+    NOOP: () => {}
+  };
+});
+
+// ../../../node_modules/node-gyp-build/node-gyp-build.js
+var require_node_gyp_build = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var path = __require("path");
+  var os = __require("os");
+  var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+  var vars = process.config && process.config.variables || {};
+  var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
+  var abi = process.versions.modules;
+  var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
+  var arch = process.env.npm_config_arch || os.arch();
+  var platform = process.env.npm_config_platform || os.platform();
+  var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
+  var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
+  var uv = (process.versions.uv || "").split(".")[0];
+  module.exports = load;
+  function load(dir) {
+    return runtimeRequire(load.resolve(dir));
+  }
+  load.resolve = load.path = function(dir) {
+    dir = path.resolve(dir || ".");
+    try {
+      var name = runtimeRequire(path.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+      if (process.env[name + "_PREBUILD"])
+        dir = process.env[name + "_PREBUILD"];
+    } catch (err) {}
+    if (!prebuildsOnly) {
+      var release = getFirst(path.join(dir, "build/Release"), matchBuild);
+      if (release)
+        return release;
+      var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
+      if (debug)
+        return debug;
+    }
+    var prebuild = resolve(dir);
+    if (prebuild)
+      return prebuild;
+    var nearby = resolve(path.dirname(process.execPath));
+    if (nearby)
+      return nearby;
+    var target = [
+      "platform=" + platform,
+      "arch=" + arch,
+      "runtime=" + runtime,
+      "abi=" + abi,
+      "uv=" + uv,
+      armv ? "armv=" + armv : "",
+      "libc=" + libc,
+      "node=" + process.versions.node,
+      process.versions.electron ? "electron=" + process.versions.electron : "",
+      typeof __webpack_require__ === "function" ? "webpack=true" : ""
+    ].filter(Boolean).join(" ");
+    throw new Error("No native build was found for " + target + `
+    loaded from: ` + dir + `
+`);
+    function resolve(dir2) {
+      var tuples = readdirSync(path.join(dir2, "prebuilds")).map(parseTuple);
+      var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
+      if (!tuple)
+        return;
+      var prebuilds = path.join(dir2, "prebuilds", tuple.name);
+      var parsed = readdirSync(prebuilds).map(parseTags);
+      var candidates = parsed.filter(matchTags(runtime, abi));
+      var winner = candidates.sort(compareTags(runtime))[0];
+      if (winner)
+        return path.join(prebuilds, winner.file);
+    }
+  };
+  function readdirSync(dir) {
+    try {
+      return fs.readdirSync(dir);
+    } catch (err) {
+      return [];
+    }
+  }
+  function getFirst(dir, filter) {
+    var files = readdirSync(dir).filter(filter);
+    return files[0] && path.join(dir, files[0]);
+  }
+  function matchBuild(name) {
+    return /\.node$/.test(name);
+  }
+  function parseTuple(name) {
+    var arr = name.split("-");
+    if (arr.length !== 2)
+      return;
+    var platform2 = arr[0];
+    var architectures = arr[1].split("+");
+    if (!platform2)
+      return;
+    if (!architectures.length)
+      return;
+    if (!architectures.every(Boolean))
+      return;
+    return { name, platform: platform2, architectures };
+  }
+  function matchTuple(platform2, arch2) {
+    return function(tuple) {
+      if (tuple == null)
+        return false;
+      if (tuple.platform !== platform2)
+        return false;
+      return tuple.architectures.includes(arch2);
+    };
+  }
+  function compareTuples(a, b) {
+    return a.architectures.length - b.architectures.length;
+  }
+  function parseTags(file) {
+    var arr = file.split(".");
+    var extension = arr.pop();
+    var tags = { file, specificity: 0 };
+    if (extension !== "node")
+      return;
+    for (var i = 0;i < arr.length; i++) {
+      var tag = arr[i];
+      if (tag === "node" || tag === "electron" || tag === "node-webkit") {
+        tags.runtime = tag;
+      } else if (tag === "napi") {
+        tags.napi = true;
+      } else if (tag.slice(0, 3) === "abi") {
+        tags.abi = tag.slice(3);
+      } else if (tag.slice(0, 2) === "uv") {
+        tags.uv = tag.slice(2);
+      } else if (tag.slice(0, 4) === "armv") {
+        tags.armv = tag.slice(4);
+      } else if (tag === "glibc" || tag === "musl") {
+        tags.libc = tag;
+      } else {
+        continue;
+      }
+      tags.specificity++;
+    }
+    return tags;
+  }
+  function matchTags(runtime2, abi2) {
+    return function(tags) {
+      if (tags == null)
+        return false;
+      if (tags.runtime && tags.runtime !== runtime2 && !runtimeAgnostic(tags))
+        return false;
+      if (tags.abi && tags.abi !== abi2 && !tags.napi)
+        return false;
+      if (tags.uv && tags.uv !== uv)
+        return false;
+      if (tags.armv && tags.armv !== armv)
+        return false;
+      if (tags.libc && tags.libc !== libc)
+        return false;
+      return true;
+    };
+  }
+  function runtimeAgnostic(tags) {
+    return tags.runtime === "node" && tags.napi;
+  }
+  function compareTags(runtime2) {
+    return function(a, b) {
+      if (a.runtime !== b.runtime) {
+        return a.runtime === runtime2 ? -1 : 1;
+      } else if (a.abi !== b.abi) {
+        return a.abi ? -1 : 1;
+      } else if (a.specificity !== b.specificity) {
+        return a.specificity > b.specificity ? -1 : 1;
+      } else {
+        return 0;
+      }
+    };
+  }
+  function isNwjs() {
+    return !!(process.versions && process.versions.nw);
+  }
+  function isElectron() {
+    if (process.versions && process.versions.electron)
+      return true;
+    if (process.env.ELECTRON_RUN_AS_NODE)
+      return true;
+    return typeof window !== "undefined" && window.process && window.process.type === "renderer";
+  }
+  function isAlpine(platform2) {
+    return platform2 === "linux" && fs.existsSync("/etc/alpine-release");
+  }
+  load.parseTags = parseTags;
+  load.matchTags = matchTags;
+  load.compareTags = compareTags;
+  load.parseTuple = parseTuple;
+  load.matchTuple = matchTuple;
+  load.compareTuples = compareTuples;
+});
+
+// ../../../node_modules/node-gyp-build/index.js
+var require_node_gyp_build2 = __commonJS((exports, module) => {
+  var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+  if (typeof runtimeRequire.addon === "function") {
+    module.exports = runtimeRequire.addon.bind(runtimeRequire);
+  } else {
+    module.exports = require_node_gyp_build();
+  }
+});
+
+// ../../../node_modules/bufferutil/fallback.js
+var require_fallback = __commonJS((exports, module) => {
+  var mask = (source, mask2, output, offset, length) => {
+    for (var i = 0;i < length; i++) {
+      output[offset + i] = source[i] ^ mask2[i & 3];
+    }
+  };
+  var unmask = (buffer, mask2) => {
+    const length = buffer.length;
+    for (var i = 0;i < length; i++) {
+      buffer[i] ^= mask2[i & 3];
+    }
+  };
+  module.exports = { mask, unmask };
+});
+
+// ../../../node_modules/bufferutil/index.js
+var require_bufferutil = __commonJS((exports, module) => {
+  var __dirname = "/Users/shawwalters/eliza-ok/node_modules/bufferutil";
+  try {
+    module.exports = require_node_gyp_build2()(__dirname);
+  } catch (e) {
+    module.exports = require_fallback();
+  }
+});
+
+// ../../../node_modules/ws/lib/buffer-util.js
+var require_buffer_util = __commonJS((exports, module) => {
+  var { EMPTY_BUFFER } = require_constants();
+  var FastBuffer = Buffer[Symbol.species];
+  function concat(list, totalLength) {
+    if (list.length === 0)
+      return EMPTY_BUFFER;
+    if (list.length === 1)
+      return list[0];
+    const target = Buffer.allocUnsafe(totalLength);
+    let offset = 0;
+    for (let i = 0;i < list.length; i++) {
+      const buf = list[i];
+      target.set(buf, offset);
+      offset += buf.length;
+    }
+    if (offset < totalLength) {
+      return new FastBuffer(target.buffer, target.byteOffset, offset);
+    }
+    return target;
+  }
+  function _mask(source, mask, output, offset, length) {
+    for (let i = 0;i < length; i++) {
+      output[offset + i] = source[i] ^ mask[i & 3];
+    }
+  }
+  function _unmask(buffer, mask) {
+    for (let i = 0;i < buffer.length; i++) {
+      buffer[i] ^= mask[i & 3];
+    }
+  }
+  function toArrayBuffer(buf) {
+    if (buf.length === buf.buffer.byteLength) {
+      return buf.buffer;
+    }
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+  }
+  function toBuffer(data) {
+    toBuffer.readOnly = true;
+    if (Buffer.isBuffer(data))
+      return data;
+    let buf;
+    if (data instanceof ArrayBuffer) {
+      buf = new FastBuffer(data);
+    } else if (ArrayBuffer.isView(data)) {
+      buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
+    } else {
+      buf = Buffer.from(data);
+      toBuffer.readOnly = false;
+    }
+    return buf;
+  }
+  module.exports = {
+    concat,
+    mask: _mask,
+    toArrayBuffer,
+    toBuffer,
+    unmask: _unmask
+  };
+  if (!process.env.WS_NO_BUFFER_UTIL) {
+    try {
+      const bufferUtil = require_bufferutil();
+      module.exports.mask = function(source, mask, output, offset, length) {
+        if (length < 48)
+          _mask(source, mask, output, offset, length);
+        else
+          bufferUtil.mask(source, mask, output, offset, length);
+      };
+      module.exports.unmask = function(buffer, mask) {
+        if (buffer.length < 32)
+          _unmask(buffer, mask);
+        else
+          bufferUtil.unmask(buffer, mask);
+      };
+    } catch (e) {}
+  }
+});
+
+// ../../../node_modules/ws/lib/limiter.js
+var require_limiter = __commonJS((exports, module) => {
+  var kDone = Symbol("kDone");
+  var kRun = Symbol("kRun");
+
+  class Limiter {
+    constructor(concurrency) {
+      this[kDone] = () => {
+        this.pending--;
+        this[kRun]();
+      };
+      this.concurrency = concurrency || Infinity;
+      this.jobs = [];
+      this.pending = 0;
+    }
+    add(job) {
+      this.jobs.push(job);
+      this[kRun]();
+    }
+    [kRun]() {
+      if (this.pending === this.concurrency)
+        return;
+      if (this.jobs.length) {
+        const job = this.jobs.shift();
+        this.pending++;
+        job(this[kDone]);
+      }
+    }
+  }
+  module.exports = Limiter;
+});
+
+// ../../../node_modules/ws/lib/permessage-deflate.js
+var require_permessage_deflate = __commonJS((exports, module) => {
+  var zlib = __require("zlib");
+  var bufferUtil = require_buffer_util();
+  var Limiter = require_limiter();
+  var { kStatusCode } = require_constants();
+  var FastBuffer = Buffer[Symbol.species];
+  var TRAILER = Buffer.from([0, 0, 255, 255]);
+  var kPerMessageDeflate = Symbol("permessage-deflate");
+  var kTotalLength = Symbol("total-length");
+  var kCallback = Symbol("callback");
+  var kBuffers = Symbol("buffers");
+  var kError = Symbol("error");
+  var zlibLimiter;
+
+  class PerMessageDeflate {
+    constructor(options, isServer, maxPayload) {
+      this._maxPayload = maxPayload | 0;
+      this._options = options || {};
+      this._threshold = this._options.threshold !== undefined ? this._options.threshold : 1024;
+      this._isServer = !!isServer;
+      this._deflate = null;
+      this._inflate = null;
+      this.params = null;
+      if (!zlibLimiter) {
+        const concurrency = this._options.concurrencyLimit !== undefined ? this._options.concurrencyLimit : 10;
+        zlibLimiter = new Limiter(concurrency);
+      }
+    }
+    static get extensionName() {
+      return "permessage-deflate";
+    }
+    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(configurations) {
+      configurations = this.normalizeParams(configurations);
+      this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
+      return this.params;
+    }
+    cleanup() {
+      if (this._inflate) {
+        this._inflate.close();
+        this._inflate = null;
+      }
+      if (this._deflate) {
+        const callback = this._deflate[kCallback];
+        this._deflate.close();
+        this._deflate = null;
+        if (callback) {
+          callback(new Error("The deflate stream was closed while data was being processed"));
+        }
+      }
+    }
+    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;
+    }
+    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;
+    }
+    normalizeParams(configurations) {
+      configurations.forEach((params) => {
+        Object.keys(params).forEach((key) => {
+          let 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, fin, callback) {
+      zlibLimiter.add((done) => {
+        this._decompress(data, fin, (err, result) => {
+          done();
+          callback(err, result);
+        });
+      });
+    }
+    compress(data, fin, callback) {
+      zlibLimiter.add((done) => {
+        this._compress(data, fin, (err, result) => {
+          done();
+          callback(err, result);
+        });
+      });
+    }
+    _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({
+          ...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 (this._inflate._readableState.endEmitted) {
+          this._inflate.close();
+          this._inflate = null;
+        } else {
+          this._inflate[kTotalLength] = 0;
+          this._inflate[kBuffers] = [];
+          if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+            this._inflate.reset();
+          }
+        }
+        callback(null, data2);
+      });
+    }
+    _compress(data, fin, callback) {
+      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({
+          ...this._options.zlibDeflateOptions,
+          windowBits
+        });
+        this._deflate[kTotalLength] = 0;
+        this._deflate[kBuffers] = [];
+        this._deflate.on("data", deflateOnData);
+      }
+      this._deflate[kCallback] = callback;
+      this._deflate.write(data);
+      this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+        if (!this._deflate) {
+          return;
+        }
+        let data2 = bufferUtil.concat(this._deflate[kBuffers], this._deflate[kTotalLength]);
+        if (fin) {
+          data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4);
+        }
+        this._deflate[kCallback] = null;
+        this._deflate[kTotalLength] = 0;
+        this._deflate[kBuffers] = [];
+        if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+          this._deflate.reset();
+        }
+        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].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
+    this[kError][kStatusCode] = 1009;
+    this.removeListener("data", inflateOnData);
+    this.reset();
+  }
+  function inflateOnError(err) {
+    this[kPerMessageDeflate]._inflate = null;
+    if (this[kError]) {
+      this[kCallback](this[kError]);
+      return;
+    }
+    err[kStatusCode] = 1007;
+    this[kCallback](err);
+  }
+});
+
+// ../../../node_modules/utf-8-validate/fallback.js
+var require_fallback2 = __commonJS((exports, module) => {
+  function isValidUTF8(buf) {
+    const len = buf.length;
+    let i = 0;
+    while (i < len) {
+      if ((buf[i] & 128) === 0) {
+        i++;
+      } else if ((buf[i] & 224) === 192) {
+        if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
+          return false;
+        }
+        i += 2;
+      } else if ((buf[i] & 240) === 224) {
+        if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || buf[i] === 237 && (buf[i + 1] & 224) === 160) {
+          return false;
+        }
+        i += 3;
+      } else if ((buf[i] & 248) === 240) {
+        if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
+          return false;
+        }
+        i += 4;
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+  module.exports = isValidUTF8;
+});
+
+// ../../../node_modules/utf-8-validate/index.js
+var require_utf_8_validate = __commonJS((exports, module) => {
+  var __dirname = "/Users/shawwalters/eliza-ok/node_modules/utf-8-validate";
+  try {
+    module.exports = require_node_gyp_build2()(__dirname);
+  } catch (e) {
+    module.exports = require_fallback2();
+  }
+});
+
+// ../../../node_modules/ws/lib/validation.js
+var require_validation = __commonJS((exports, module) => {
+  var { isUtf8 } = __require("buffer");
+  var { hasBlob } = require_constants();
+  var tokenChars = [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    1,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    1,
+    0,
+    1,
+    0
+  ];
+  function isValidStatusCode(code) {
+    return code >= 1000 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3000 && code <= 4999;
+  }
+  function _isValidUTF8(buf) {
+    const len = buf.length;
+    let i = 0;
+    while (i < len) {
+      if ((buf[i] & 128) === 0) {
+        i++;
+      } else if ((buf[i] & 224) === 192) {
+        if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
+          return false;
+        }
+        i += 2;
+      } else if ((buf[i] & 240) === 224) {
+        if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || buf[i] === 237 && (buf[i + 1] & 224) === 160) {
+          return false;
+        }
+        i += 3;
+      } else if ((buf[i] & 248) === 240) {
+        if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
+          return false;
+        }
+        i += 4;
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+  function isBlob(value) {
+    return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File");
+  }
+  module.exports = {
+    isBlob,
+    isValidStatusCode,
+    isValidUTF8: _isValidUTF8,
+    tokenChars
+  };
+  if (isUtf8) {
+    module.exports.isValidUTF8 = function(buf) {
+      return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
+    };
+  } else if (!process.env.WS_NO_UTF_8_VALIDATE) {
+    try {
+      const isValidUTF8 = require_utf_8_validate();
+      module.exports.isValidUTF8 = function(buf) {
+        return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
+      };
+    } catch (e) {}
+  }
+});
+
+// ../../../node_modules/ws/lib/receiver.js
+var require_receiver = __commonJS((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 FastBuffer = Buffer[Symbol.species];
+  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 DEFER_EVENT = 6;
+
+  class Receiver extends Writable {
+    constructor(options = {}) {
+      super();
+      this._allowSynchronousEvents = options.allowSynchronousEvents !== undefined ? options.allowSynchronousEvents : true;
+      this._binaryType = options.binaryType || BINARY_TYPES[0];
+      this._extensions = options.extensions || {};
+      this._isServer = !!options.isServer;
+      this._maxPayload = options.maxPayload | 0;
+      this._skipUTF8Validation = !!options.skipUTF8Validation;
+      this[kWebSocket] = undefined;
+      this._bufferedBytes = 0;
+      this._buffers = [];
+      this._compressed = false;
+      this._payloadLength = 0;
+      this._mask = undefined;
+      this._fragmented = 0;
+      this._masked = false;
+      this._fin = false;
+      this._opcode = 0;
+      this._totalPayloadLength = 0;
+      this._messageLength = 0;
+      this._fragments = [];
+      this._errored = false;
+      this._loop = false;
+      this._state = GET_INFO;
+    }
+    _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);
+    }
+    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] = new FastBuffer(buf.buffer, buf.byteOffset + n, buf.length - n);
+        return new FastBuffer(buf.buffer, buf.byteOffset, n);
+      }
+      const dst = Buffer.allocUnsafe(n);
+      do {
+        const buf = this._buffers[0];
+        const offset = dst.length - n;
+        if (n >= buf.length) {
+          dst.set(this._buffers.shift(), offset);
+        } else {
+          dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+          this._buffers[0] = new FastBuffer(buf.buffer, buf.byteOffset + n, buf.length - n);
+        }
+        n -= buf.length;
+      } while (n > 0);
+      return dst;
+    }
+    startLoop(cb) {
+      this._loop = true;
+      do {
+        switch (this._state) {
+          case GET_INFO:
+            this.getInfo(cb);
+            break;
+          case GET_PAYLOAD_LENGTH_16:
+            this.getPayloadLength16(cb);
+            break;
+          case GET_PAYLOAD_LENGTH_64:
+            this.getPayloadLength64(cb);
+            break;
+          case GET_MASK:
+            this.getMask();
+            break;
+          case GET_DATA:
+            this.getData(cb);
+            break;
+          case INFLATING:
+          case DEFER_EVENT:
+            this._loop = false;
+            return;
+        }
+      } while (this._loop);
+      if (!this._errored)
+        cb();
+    }
+    getInfo(cb) {
+      if (this._bufferedBytes < 2) {
+        this._loop = false;
+        return;
+      }
+      const buf = this.consume(2);
+      if ((buf[0] & 48) !== 0) {
+        const error = this.createError(RangeError, "RSV2 and RSV3 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_2_3");
+        cb(error);
+        return;
+      }
+      const compressed = (buf[0] & 64) === 64;
+      if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+        const error = this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+        cb(error);
+        return;
+      }
+      this._fin = (buf[0] & 128) === 128;
+      this._opcode = buf[0] & 15;
+      this._payloadLength = buf[1] & 127;
+      if (this._opcode === 0) {
+        if (compressed) {
+          const error = this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+          cb(error);
+          return;
+        }
+        if (!this._fragmented) {
+          const error = this.createError(RangeError, "invalid opcode 0", true, 1002, "WS_ERR_INVALID_OPCODE");
+          cb(error);
+          return;
+        }
+        this._opcode = this._fragmented;
+      } else if (this._opcode === 1 || this._opcode === 2) {
+        if (this._fragmented) {
+          const error = this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE");
+          cb(error);
+          return;
+        }
+        this._compressed = compressed;
+      } else if (this._opcode > 7 && this._opcode < 11) {
+        if (!this._fin) {
+          const error = this.createError(RangeError, "FIN must be set", true, 1002, "WS_ERR_EXPECTED_FIN");
+          cb(error);
+          return;
+        }
+        if (compressed) {
+          const error = this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+          cb(error);
+          return;
+        }
+        if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
+          const error = this.createError(RangeError, `invalid payload length ${this._payloadLength}`, true, 1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH");
+          cb(error);
+          return;
+        }
+      } else {
+        const error = this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE");
+        cb(error);
+        return;
+      }
+      if (!this._fin && !this._fragmented)
+        this._fragmented = this._opcode;
+      this._masked = (buf[1] & 128) === 128;
+      if (this._isServer) {
+        if (!this._masked) {
+          const error = this.createError(RangeError, "MASK must be set", true, 1002, "WS_ERR_EXPECTED_MASK");
+          cb(error);
+          return;
+        }
+      } else if (this._masked) {
+        const error = this.createError(RangeError, "MASK must be clear", true, 1002, "WS_ERR_UNEXPECTED_MASK");
+        cb(error);
+        return;
+      }
+      if (this._payloadLength === 126)
+        this._state = GET_PAYLOAD_LENGTH_16;
+      else if (this._payloadLength === 127)
+        this._state = GET_PAYLOAD_LENGTH_64;
+      else
+        this.haveLength(cb);
+    }
+    getPayloadLength16(cb) {
+      if (this._bufferedBytes < 2) {
+        this._loop = false;
+        return;
+      }
+      this._payloadLength = this.consume(2).readUInt16BE(0);
+      this.haveLength(cb);
+    }
+    getPayloadLength64(cb) {
+      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) {
+        const error = this.createError(RangeError, "Unsupported WebSocket frame: payload length > 2^53 - 1", false, 1009, "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH");
+        cb(error);
+        return;
+      }
+      this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+      this.haveLength(cb);
+    }
+    haveLength(cb) {
+      if (this._payloadLength && this._opcode < 8) {
+        this._totalPayloadLength += this._payloadLength;
+        if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+          const error = this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");
+          cb(error);
+          return;
+        }
+      }
+      if (this._masked)
+        this._state = GET_MASK;
+      else
+        this._state = GET_DATA;
+    }
+    getMask() {
+      if (this._bufferedBytes < 4) {
+        this._loop = false;
+        return;
+      }
+      this._mask = this.consume(4);
+      this._state = GET_DATA;
+    }
+    getData(cb) {
+      let data = EMPTY_BUFFER;
+      if (this._payloadLength) {
+        if (this._bufferedBytes < this._payloadLength) {
+          this._loop = false;
+          return;
+        }
+        data = this.consume(this._payloadLength);
+        if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
+          unmask(data, this._mask);
+        }
+      }
+      if (this._opcode > 7) {
+        this.controlMessage(data, cb);
+        return;
+      }
+      if (this._compressed) {
+        this._state = INFLATING;
+        this.decompress(data, cb);
+        return;
+      }
+      if (data.length) {
+        this._messageLength = this._totalPayloadLength;
+        this._fragments.push(data);
+      }
+      this.dataMessage(cb);
+    }
+    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) {
+            const error = this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");
+            cb(error);
+            return;
+          }
+          this._fragments.push(buf);
+        }
+        this.dataMessage(cb);
+        if (this._state === GET_INFO)
+          this.startLoop(cb);
+      });
+    }
+    dataMessage(cb) {
+      if (!this._fin) {
+        this._state = GET_INFO;
+        return;
+      }
+      const messageLength = this._messageLength;
+      const fragments = this._fragments;
+      this._totalPayloadLength = 0;
+      this._messageLength = 0;
+      this._fragmented = 0;
+      this._fragments = [];
+      if (this._opcode === 2) {
+        let data;
+        if (this._binaryType === "nodebuffer") {
+          data = concat(fragments, messageLength);
+        } else if (this._binaryType === "arraybuffer") {
+          data = toArrayBuffer(concat(fragments, messageLength));
+        } else if (this._binaryType === "blob") {
+          data = new Blob(fragments);
+        } else {
+          data = fragments;
+        }
+        if (this._allowSynchronousEvents) {
+          this.emit("message", data, true);
+          this._state = GET_INFO;
+        } else {
+          this._state = DEFER_EVENT;
+          setImmediate(() => {
+            this.emit("message", data, true);
+            this._state = GET_INFO;
+            this.startLoop(cb);
+          });
+        }
+      } else {
+        const buf = concat(fragments, messageLength);
+        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+          const error = this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8");
+          cb(error);
+          return;
+        }
+        if (this._state === INFLATING || this._allowSynchronousEvents) {
+          this.emit("message", buf, false);
+          this._state = GET_INFO;
+        } else {
+          this._state = DEFER_EVENT;
+          setImmediate(() => {
+            this.emit("message", buf, false);
+            this._state = GET_INFO;
+            this.startLoop(cb);
+          });
+        }
+      }
+    }
+    controlMessage(data, cb) {
+      if (this._opcode === 8) {
+        if (data.length === 0) {
+          this._loop = false;
+          this.emit("conclude", 1005, EMPTY_BUFFER);
+          this.end();
+        } else {
+          const code = data.readUInt16BE(0);
+          if (!isValidStatusCode(code)) {
+            const error = this.createError(RangeError, `invalid status code ${code}`, true, 1002, "WS_ERR_INVALID_CLOSE_CODE");
+            cb(error);
+            return;
+          }
+          const buf = new FastBuffer(data.buffer, data.byteOffset + 2, data.length - 2);
+          if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+            const error = this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8");
+            cb(error);
+            return;
+          }
+          this._loop = false;
+          this.emit("conclude", code, buf);
+          this.end();
+        }
+        this._state = GET_INFO;
+        return;
+      }
+      if (this._allowSynchronousEvents) {
+        this.emit(this._opcode === 9 ? "ping" : "pong", data);
+        this._state = GET_INFO;
+      } else {
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit(this._opcode === 9 ? "ping" : "pong", data);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
+      }
+    }
+    createError(ErrorCtor, message, prefix, statusCode, errorCode) {
+      this._loop = false;
+      this._errored = true;
+      const err = new ErrorCtor(prefix ? `Invalid WebSocket frame: ${message}` : message);
+      Error.captureStackTrace(err, this.createError);
+      err.code = errorCode;
+      err[kStatusCode] = statusCode;
+      return err;
+    }
+  }
+  module.exports = Receiver;
+});
+
+// ../../../node_modules/ws/lib/sender.js
+var require_sender = __commonJS((exports, module) => {
+  var { Duplex } = __require("stream");
+  var { randomFillSync } = __require("crypto");
+  var PerMessageDeflate = require_permessage_deflate();
+  var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
+  var { isBlob, isValidStatusCode } = require_validation();
+  var { mask: applyMask, toBuffer } = require_buffer_util();
+  var kByteLength = Symbol("kByteLength");
+  var maskBuffer = Buffer.alloc(4);
+  var RANDOM_POOL_SIZE = 8 * 1024;
+  var randomPool;
+  var randomPoolPointer = RANDOM_POOL_SIZE;
+  var DEFAULT = 0;
+  var DEFLATING = 1;
+  var GET_BLOB_DATA = 2;
+
+  class Sender {
+    constructor(socket, extensions, generateMask) {
+      this._extensions = extensions || {};
+      if (generateMask) {
+        this._generateMask = generateMask;
+        this._maskBuffer = Buffer.alloc(4);
+      }
+      this._socket = socket;
+      this._firstFragment = true;
+      this._compress = false;
+      this._bufferedBytes = 0;
+      this._queue = [];
+      this._state = DEFAULT;
+      this.onerror = NOOP;
+      this[kWebSocket] = undefined;
+    }
+    static frame(data, options) {
+      let mask;
+      let merge = false;
+      let offset = 2;
+      let skipMasking = false;
+      if (options.mask) {
+        mask = options.maskBuffer || maskBuffer;
+        if (options.generateMask) {
+          options.generateMask(mask);
+        } else {
+          if (randomPoolPointer === RANDOM_POOL_SIZE) {
+            if (randomPool === undefined) {
+              randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
+            }
+            randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
+            randomPoolPointer = 0;
+          }
+          mask[0] = randomPool[randomPoolPointer++];
+          mask[1] = randomPool[randomPoolPointer++];
+          mask[2] = randomPool[randomPoolPointer++];
+          mask[3] = randomPool[randomPoolPointer++];
+        }
+        skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
+        offset = 6;
+      }
+      let dataLength;
+      if (typeof data === "string") {
+        if ((!options.mask || skipMasking) && options[kByteLength] !== undefined) {
+          dataLength = options[kByteLength];
+        } else {
+          data = Buffer.from(data);
+          dataLength = data.length;
+        }
+      } else {
+        dataLength = data.length;
+        merge = options.mask && options.readOnly && !skipMasking;
+      }
+      let payloadLength = dataLength;
+      if (dataLength >= 65536) {
+        offset += 8;
+        payloadLength = 127;
+      } else if (dataLength > 125) {
+        offset += 2;
+        payloadLength = 126;
+      }
+      const target = Buffer.allocUnsafe(merge ? dataLength + 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(dataLength, 2);
+      } else if (payloadLength === 127) {
+        target[2] = target[3] = 0;
+        target.writeUIntBE(dataLength, 4, 6);
+      }
+      if (!options.mask)
+        return [target, data];
+      target[1] |= 128;
+      target[offset - 4] = mask[0];
+      target[offset - 3] = mask[1];
+      target[offset - 2] = mask[2];
+      target[offset - 1] = mask[3];
+      if (skipMasking)
+        return [target, data];
+      if (merge) {
+        applyMask(data, mask, target, offset, dataLength);
+        return [target];
+      }
+      applyMask(data, mask, data, 0, dataLength);
+      return [target, data];
+    }
+    close(code, data, mask, cb) {
+      let buf;
+      if (code === undefined) {
+        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 === undefined || !data.length) {
+        buf = Buffer.allocUnsafe(2);
+        buf.writeUInt16BE(code, 0);
+      } else {
+        const length = Buffer.byteLength(data);
+        if (length > 123) {
+          throw new RangeError("The message must not be greater than 123 bytes");
+        }
+        buf = Buffer.allocUnsafe(2 + length);
+        buf.writeUInt16BE(code, 0);
+        if (typeof data === "string") {
+          buf.write(data, 2);
+        } else {
+          buf.set(data, 2);
+        }
+      }
+      const options = {
+        [kByteLength]: buf.length,
+        fin: true,
+        generateMask: this._generateMask,
+        mask,
+        maskBuffer: this._maskBuffer,
+        opcode: 8,
+        readOnly: false,
+        rsv1: false
+      };
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.dispatch, buf, false, options, cb]);
+      } else {
+        this.sendFrame(Sender.frame(buf, options), cb);
+      }
+    }
+    ping(data, mask, cb) {
+      let byteLength;
+      let readOnly;
+      if (typeof data === "string") {
+        byteLength = Buffer.byteLength(data);
+        readOnly = false;
+      } else if (isBlob(data)) {
+        byteLength = data.size;
+        readOnly = false;
+      } else {
+        data = toBuffer(data);
+        byteLength = data.length;
+        readOnly = toBuffer.readOnly;
+      }
+      if (byteLength > 125) {
+        throw new RangeError("The data size must not be greater than 125 bytes");
+      }
+      const options = {
+        [kByteLength]: byteLength,
+        fin: true,
+        generateMask: this._generateMask,
+        mask,
+        maskBuffer: this._maskBuffer,
+        opcode: 9,
+        readOnly,
+        rsv1: false
+      };
+      if (isBlob(data)) {
+        if (this._state !== DEFAULT) {
+          this.enqueue([this.getBlobData, data, false, options, cb]);
+        } else {
+          this.getBlobData(data, false, options, cb);
+        }
+      } else if (this._state !== DEFAULT) {
+        this.enqueue([this.dispatch, data, false, options, cb]);
+      } else {
+        this.sendFrame(Sender.frame(data, options), cb);
+      }
+    }
+    pong(data, mask, cb) {
+      let byteLength;
+      let readOnly;
+      if (typeof data === "string") {
+        byteLength = Buffer.byteLength(data);
+        readOnly = false;
+      } else if (isBlob(data)) {
+        byteLength = data.size;
+        readOnly = false;
+      } else {
+        data = toBuffer(data);
+        byteLength = data.length;
+        readOnly = toBuffer.readOnly;
+      }
+      if (byteLength > 125) {
+        throw new RangeError("The data size must not be greater than 125 bytes");
+      }
+      const options = {
+        [kByteLength]: byteLength,
+        fin: true,
+        generateMask: this._generateMask,
+        mask,
+        maskBuffer: this._maskBuffer,
+        opcode: 10,
+        readOnly,
+        rsv1: false
+      };
+      if (isBlob(data)) {
+        if (this._state !== DEFAULT) {
+          this.enqueue([this.getBlobData, data, false, options, cb]);
+        } else {
+          this.getBlobData(data, false, options, cb);
+        }
+      } else if (this._state !== DEFAULT) {
+        this.enqueue([this.dispatch, data, false, options, cb]);
+      } else {
+        this.sendFrame(Sender.frame(data, options), cb);
+      }
+    }
+    send(data, options, cb) {
+      const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+      let opcode = options.binary ? 2 : 1;
+      let rsv1 = options.compress;
+      let byteLength;
+      let readOnly;
+      if (typeof data === "string") {
+        byteLength = Buffer.byteLength(data);
+        readOnly = false;
+      } else if (isBlob(data)) {
+        byteLength = data.size;
+        readOnly = false;
+      } else {
+        data = toBuffer(data);
+        byteLength = data.length;
+        readOnly = toBuffer.readOnly;
+      }
+      if (this._firstFragment) {
+        this._firstFragment = false;
+        if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) {
+          rsv1 = byteLength >= perMessageDeflate._threshold;
+        }
+        this._compress = rsv1;
+      } else {
+        rsv1 = false;
+        opcode = 0;
+      }
+      if (options.fin)
+        this._firstFragment = true;
+      const opts = {
+        [kByteLength]: byteLength,
+        fin: options.fin,
+        generateMask: this._generateMask,
+        mask: options.mask,
+        maskBuffer: this._maskBuffer,
+        opcode,
+        readOnly,
+        rsv1
+      };
+      if (isBlob(data)) {
+        if (this._state !== DEFAULT) {
+          this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
+        } else {
+          this.getBlobData(data, this._compress, opts, cb);
+        }
+      } else if (this._state !== DEFAULT) {
+        this.enqueue([this.dispatch, data, this._compress, opts, cb]);
+      } else {
+        this.dispatch(data, this._compress, opts, cb);
+      }
+    }
+    getBlobData(blob, compress, options, cb) {
+      this._bufferedBytes += options[kByteLength];
+      this._state = GET_BLOB_DATA;
+      blob.arrayBuffer().then((arrayBuffer) => {
+        if (this._socket.destroyed) {
+          const err = new Error("The socket was closed while the blob was being read");
+          process.nextTick(callCallbacks, this, err, cb);
+          return;
+        }
+        this._bufferedBytes -= options[kByteLength];
+        const data = toBuffer(arrayBuffer);
+        if (!compress) {
+          this._state = DEFAULT;
+          this.sendFrame(Sender.frame(data, options), cb);
+          this.dequeue();
+        } else {
+          this.dispatch(data, compress, options, cb);
+        }
+      }).catch((err) => {
+        process.nextTick(onError, this, err, cb);
+      });
+    }
+    dispatch(data, compress, options, cb) {
+      if (!compress) {
+        this.sendFrame(Sender.frame(data, options), cb);
+        return;
+      }
+      const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+      this._bufferedBytes += options[kByteLength];
+      this._state = DEFLATING;
+      perMessageDeflate.compress(data, options.fin, (_, buf) => {
+        if (this._socket.destroyed) {
+          const err = new Error("The socket was closed while data was being compressed");
+          callCallbacks(this, err, cb);
+          return;
+        }
+        this._bufferedBytes -= options[kByteLength];
+        this._state = DEFAULT;
+        options.readOnly = false;
+        this.sendFrame(Sender.frame(buf, options), cb);
+        this.dequeue();
+      });
+    }
+    dequeue() {
+      while (this._state === DEFAULT && this._queue.length) {
+        const params = this._queue.shift();
+        this._bufferedBytes -= params[3][kByteLength];
+        Reflect.apply(params[0], this, params.slice(1));
+      }
+    }
+    enqueue(params) {
+      this._bufferedBytes += params[3][kByteLength];
+      this._queue.push(params);
+    }
+    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;
+  function callCallbacks(sender, err, cb) {
+    if (typeof cb === "function")
+      cb(err);
+    for (let i = 0;i < sender._queue.length; i++) {
+      const params = sender._queue[i];
+      const callback = params[params.length - 1];
+      if (typeof callback === "function")
+        callback(err);
+    }
+  }
+  function onError(sender, err, cb) {
+    callCallbacks(sender, err, cb);
+    sender.onerror(err);
+  }
+});
+
+// ../../../node_modules/ws/lib/event-target.js
+var require_event_target = __commonJS((exports, module) => {
+  var { kForOnEventAttribute, kListener } = require_constants();
+  var kCode = Symbol("kCode");
+  var kData = Symbol("kData");
+  var kError = Symbol("kError");
+  var kMessage = Symbol("kMessage");
+  var kReason = Symbol("kReason");
+  var kTarget = Symbol("kTarget");
+  var kType = Symbol("kType");
+  var kWasClean = Symbol("kWasClean");
+
+  class Event {
+    constructor(type) {
+      this[kTarget] = null;
+      this[kType] = type;
+    }
+    get target() {
+      return this[kTarget];
+    }
+    get type() {
+      return this[kType];
+    }
+  }
+  Object.defineProperty(Event.prototype, "target", { enumerable: true });
+  Object.defineProperty(Event.prototype, "type", { enumerable: true });
+
+  class CloseEvent extends Event {
+    constructor(type, options = {}) {
+      super(type);
+      this[kCode] = options.code === undefined ? 0 : options.code;
+      this[kReason] = options.reason === undefined ? "" : options.reason;
+      this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
+    }
+    get code() {
+      return this[kCode];
+    }
+    get reason() {
+      return this[kReason];
+    }
+    get wasClean() {
+      return this[kWasClean];
+    }
+  }
+  Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
+  Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
+  Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
+
+  class ErrorEvent extends Event {
+    constructor(type, options = {}) {
+      super(type);
+      this[kError] = options.error === undefined ? null : options.error;
+      this[kMessage] = options.message === undefined ? "" : options.message;
+    }
+    get error() {
+      return this[kError];
+    }
+    get message() {
+      return this[kMessage];
+    }
+  }
+  Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
+  Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
+
+  class MessageEvent extends Event {
+    constructor(type, options = {}) {
+      super(type);
+      this[kData] = options.data === undefined ? null : options.data;
+    }
+    get data() {
+      return this[kData];
+    }
+  }
+  Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
+  var EventTarget = {
+    addEventListener(type, handler, options = {}) {
+      for (const listener of this.listeners(type)) {
+        if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+          return;
+        }
+      }
+      let wrapper;
+      if (type === "message") {
+        wrapper = function onMessage(data, isBinary) {
+          const event = new MessageEvent("message", {
+            data: isBinary ? data : data.toString()
+          });
+          event[kTarget] = this;
+          callListener(handler, this, event);
+        };
+      } else if (type === "close") {
+        wrapper = function onClose(code, message) {
+          const event = new CloseEvent("close", {
+            code,
+            reason: message.toString(),
+            wasClean: this._closeFrameReceived && this._closeFrameSent
+          });
+          event[kTarget] = this;
+          callListener(handler, this, event);
+        };
+      } else if (type === "error") {
+        wrapper = function onError(error) {
+          const event = new ErrorEvent("error", {
+            error,
+            message: error.message
+          });
+          event[kTarget] = this;
+          callListener(handler, this, event);
+        };
+      } else if (type === "open") {
+        wrapper = function onOpen() {
+          const event = new Event("open");
+          event[kTarget] = this;
+          callListener(handler, this, event);
+        };
+      } else {
+        return;
+      }
+      wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
+      wrapper[kListener] = handler;
+      if (options.once) {
+        this.once(type, wrapper);
+      } else {
+        this.on(type, wrapper);
+      }
+    },
+    removeEventListener(type, handler) {
+      for (const listener of this.listeners(type)) {
+        if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+          this.removeListener(type, listener);
+          break;
+        }
+      }
+    }
+  };
+  module.exports = {
+    CloseEvent,
+    ErrorEvent,
+    Event,
+    EventTarget,
+    MessageEvent
+  };
+  function callListener(listener, thisArg, event) {
+    if (typeof listener === "object" && listener.handleEvent) {
+      listener.handleEvent.call(listener, event);
+    } else {
+      listener.call(thisArg, event);
+    }
+  }
+});
+
+// ../../../node_modules/ws/lib/extension.js
+var require_extension = __commonJS((exports, module) => {
+  var { tokenChars } = require_validation();
+  function push(dest, name, elem) {
+    if (dest[name] === undefined)
+      dest[name] = [elem];
+    else
+      dest[name].push(elem);
+  }
+  function parse(header) {
+    const offers = Object.create(null);
+    let params = Object.create(null);
+    let mustUnescape = false;
+    let isEscaping = false;
+    let inQuotes = false;
+    let extensionName;
+    let paramName;
+    let start = -1;
+    let code = -1;
+    let end = -1;
+    let i = 0;
+    for (;i < header.length; i++) {
+      code = header.charCodeAt(i);
+      if (extensionName === undefined) {
+        if (end === -1 && tokenChars[code] === 1) {
+          if (start === -1)
+            start = i;
+        } else if (i !== 0 && (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 = Object.create(null);
+          } else {
+            extensionName = name;
+          }
+          start = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else if (paramName === undefined) {
+        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 = Object.create(null);
+            extensionName = undefined;
+          }
+          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;
+          let 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 = Object.create(null);
+            extensionName = undefined;
+          }
+          paramName = undefined;
+          start = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      }
+    }
+    if (start === -1 || inQuotes || code === 32 || code === 9) {
+      throw new SyntaxError("Unexpected end of input");
+    }
+    if (end === -1)
+      end = i;
+    const token = header.slice(start, end);
+    if (extensionName === undefined) {
+      push(offers, token, params);
+    } else {
+      if (paramName === undefined) {
+        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) => {
+      let configurations = extensions[extension];
+      if (!Array.isArray(configurations))
+        configurations = [configurations];
+      return configurations.map((params) => {
+        return [extension].concat(Object.keys(params).map((k) => {
+          let 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/websocket.js
+var require_websocket = __commonJS((exports, module) => {
+  var EventEmitter = __require("events");
+  var https = __require("https");
+  var http = __require("http");
+  var net = __require("net");
+  var tls = __require("tls");
+  var { randomBytes, createHash } = __require("crypto");
+  var { Duplex, Readable } = __require("stream");
+  var { URL } = __require("url");
+  var PerMessageDeflate = require_permessage_deflate();
+  var Receiver = require_receiver();
+  var Sender = require_sender();
+  var { isBlob } = require_validation();
+  var {
+    BINARY_TYPES,
+    CLOSE_TIMEOUT,
+    EMPTY_BUFFER,
+    GUID,
+    kForOnEventAttribute,
+    kListener,
+    kStatusCode,
+    kWebSocket,
+    NOOP
+  } = require_constants();
+  var {
+    EventTarget: { addEventListener, removeEventListener }
+  } = require_event_target();
+  var { format, parse } = require_extension();
+  var { toBuffer } = require_buffer_util();
+  var kAborted = Symbol("kAborted");
+  var protocolVersions = [8, 13];
+  var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+  var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+
+  class WebSocket extends EventEmitter {
+    constructor(address, protocols, options) {
+      super();
+      this._binaryType = BINARY_TYPES[0];
+      this._closeCode = 1006;
+      this._closeFrameReceived = false;
+      this._closeFrameSent = false;
+      this._closeMessage = EMPTY_BUFFER;
+      this._closeTimer = null;
+      this._errorEmitted = false;
+      this._extensions = {};
+      this._paused = false;
+      this._protocol = "";
+      this._readyState = WebSocket.CONNECTING;
+      this._receiver = null;
+      this._sender = null;
+      this._socket = null;
+      if (address !== null) {
+        this._bufferedAmount = 0;
+        this._isServer = false;
+        this._redirects = 0;
+        if (protocols === undefined) {
+          protocols = [];
+        } else if (!Array.isArray(protocols)) {
+          if (typeof protocols === "object" && protocols !== null) {
+            options = protocols;
+            protocols = [];
+          } else {
+            protocols = [protocols];
+          }
+        }
+        initAsClient(this, address, protocols, options);
+      } else {
+        this._autoPong = options.autoPong;
+        this._closeTimeout = options.closeTimeout;
+        this._isServer = true;
+      }
+    }
+    get binaryType() {
+      return this._binaryType;
+    }
+    set binaryType(type) {
+      if (!BINARY_TYPES.includes(type))
+        return;
+      this._binaryType = type;
+      if (this._receiver)
+        this._receiver._binaryType = type;
+    }
+    get bufferedAmount() {
+      if (!this._socket)
+        return this._bufferedAmount;
+      return this._socket._writableState.length + this._sender._bufferedBytes;
+    }
+    get extensions() {
+      return Object.keys(this._extensions).join();
+    }
+    get isPaused() {
+      return this._paused;
+    }
+    get onclose() {
+      return null;
+    }
+    get onerror() {
+      return null;
+    }
+    get onopen() {
+      return null;
+    }
+    get onmessage() {
+      return null;
+    }
+    get protocol() {
+      return this._protocol;
+    }
+    get readyState() {
+      return this._readyState;
+    }
+    get url() {
+      return this._url;
+    }
+    setSocket(socket, head, options) {
+      const receiver = new Receiver({
+        allowSynchronousEvents: options.allowSynchronousEvents,
+        binaryType: this.binaryType,
+        extensions: this._extensions,
+        isServer: this._isServer,
+        maxPayload: options.maxPayload,
+        skipUTF8Validation: options.skipUTF8Validation
+      });
+      const sender = new Sender(socket, this._extensions, options.generateMask);
+      this._receiver = receiver;
+      this._sender = sender;
+      this._socket = socket;
+      receiver[kWebSocket] = this;
+      sender[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);
+      sender.onerror = senderOnError;
+      if (socket.setTimeout)
+        socket.setTimeout(0);
+      if (socket.setNoDelay)
+        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");
+    }
+    emitClose() {
+      if (!this._socket) {
+        this._readyState = WebSocket.CLOSED;
+        this.emit("close", this._closeCode, this._closeMessage);
+        return;
+      }
+      if (this._extensions[PerMessageDeflate.extensionName]) {
+        this._extensions[PerMessageDeflate.extensionName].cleanup();
+      }
+      this._receiver.removeAllListeners();
+      this._readyState = WebSocket.CLOSED;
+      this.emit("close", this._closeCode, this._closeMessage);
+    }
+    close(code, data) {
+      if (this.readyState === WebSocket.CLOSED)
+        return;
+      if (this.readyState === WebSocket.CONNECTING) {
+        const msg = "WebSocket was closed before the connection was established";
+        abortHandshake(this, this._req, msg);
+        return;
+      }
+      if (this.readyState === WebSocket.CLOSING) {
+        if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
+          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._receiver._writableState.errorEmitted) {
+          this._socket.end();
+        }
+      });
+      setCloseTimer(this);
+    }
+    pause() {
+      if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) {
+        return;
+      }
+      this._paused = true;
+      this._socket.pause();
+    }
+    ping(data, mask, cb) {
+      if (this.readyState === WebSocket.CONNECTING) {
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      }
+      if (typeof data === "function") {
+        cb = data;
+        data = mask = undefined;
+      } else if (typeof mask === "function") {
+        cb = mask;
+        mask = undefined;
+      }
+      if (typeof data === "number")
+        data = data.toString();
+      if (this.readyState !== WebSocket.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      if (mask === undefined)
+        mask = !this._isServer;
+      this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+    }
+    pong(data, mask, cb) {
+      if (this.readyState === WebSocket.CONNECTING) {
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      }
+      if (typeof data === "function") {
+        cb = data;
+        data = mask = undefined;
+      } else if (typeof mask === "function") {
+        cb = mask;
+        mask = undefined;
+      }
+      if (typeof data === "number")
+        data = data.toString();
+      if (this.readyState !== WebSocket.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      if (mask === undefined)
+        mask = !this._isServer;
+      this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+    }
+    resume() {
+      if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) {
+        return;
+      }
+      this._paused = false;
+      if (!this._receiver._writableState.needDrain)
+        this._socket.resume();
+    }
+    send(data, options, cb) {
+      if (this.readyState === WebSocket.CONNECTING) {
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      }
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (typeof data === "number")
+        data = data.toString();
+      if (this.readyState !== WebSocket.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      const opts = {
+        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);
+    }
+    terminate() {
+      if (this.readyState === WebSocket.CLOSED)
+        return;
+      if (this.readyState === WebSocket.CONNECTING) {
+        const msg = "WebSocket was closed before the connection was established";
+        abortHandshake(this, this._req, msg);
+        return;
+      }
+      if (this._socket) {
+        this._readyState = WebSocket.CLOSING;
+        this._socket.destroy();
+      }
+    }
+  }
+  Object.defineProperty(WebSocket, "CONNECTING", {
+    enumerable: true,
+    value: readyStates.indexOf("CONNECTING")
+  });
+  Object.defineProperty(WebSocket.prototype, "CONNECTING", {
+    enumerable: true,
+    value: readyStates.indexOf("CONNECTING")
+  });
+  Object.defineProperty(WebSocket, "OPEN", {
+    enumerable: true,
+    value: readyStates.indexOf("OPEN")
+  });
+  Object.defineProperty(WebSocket.prototype, "OPEN", {
+    enumerable: true,
+    value: readyStates.indexOf("OPEN")
+  });
+  Object.defineProperty(WebSocket, "CLOSING", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSING")
+  });
+  Object.defineProperty(WebSocket.prototype, "CLOSING", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSING")
+  });
+  Object.defineProperty(WebSocket, "CLOSED", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSED")
+  });
+  Object.defineProperty(WebSocket.prototype, "CLOSED", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSED")
+  });
+  [
+    "binaryType",
+    "bufferedAmount",
+    "extensions",
+    "isPaused",
+    "protocol",
+    "readyState",
+    "url"
+  ].forEach((property) => {
+    Object.defineProperty(WebSocket.prototype, property, { enumerable: true });
+  });
+  ["open", "error", "close", "message"].forEach((method) => {
+    Object.defineProperty(WebSocket.prototype, `on${method}`, {
+      enumerable: true,
+      get() {
+        for (const listener of this.listeners(method)) {
+          if (listener[kForOnEventAttribute])
+            return listener[kListener];
+        }
+        return null;
+      },
+      set(handler) {
+        for (const listener of this.listeners(method)) {
+          if (listener[kForOnEventAttribute]) {
+            this.removeListener(method, listener);
+            break;
+          }
+        }
+        if (typeof handler !== "function")
+          return;
+        this.addEventListener(method, handler, {
+          [kForOnEventAttribute]: true
+        });
+      }
+    });
+  });
+  WebSocket.prototype.addEventListener = addEventListener;
+  WebSocket.prototype.removeEventListener = removeEventListener;
+  module.exports = WebSocket;
+  function initAsClient(websocket, address, protocols, options) {
+    const opts = {
+      allowSynchronousEvents: true,
+      autoPong: true,
+      closeTimeout: CLOSE_TIMEOUT,
+      protocolVersion: protocolVersions[1],
+      maxPayload: 100 * 1024 * 1024,
+      skipUTF8Validation: false,
+      perMessageDeflate: true,
+      followRedirects: false,
+      maxRedirects: 10,
+      ...options,
+      socketPath: undefined,
+      hostname: undefined,
+      protocol: undefined,
+      timeout: undefined,
+      method: "GET",
+      host: undefined,
+      path: undefined,
+      port: undefined
+    };
+    websocket._autoPong = opts.autoPong;
+    websocket._closeTimeout = opts.closeTimeout;
+    if (!protocolVersions.includes(opts.protocolVersion)) {
+      throw new RangeError(`Unsupported protocol version: ${opts.protocolVersion} ` + `(supported versions: ${protocolVersions.join(", ")})`);
+    }
+    let parsedUrl;
+    if (address instanceof URL) {
+      parsedUrl = address;
+    } else {
+      try {
+        parsedUrl = new URL(address);
+      } catch (e) {
+        throw new SyntaxError(`Invalid URL: ${address}`);
+      }
+    }
+    if (parsedUrl.protocol === "http:") {
+      parsedUrl.protocol = "ws:";
+    } else if (parsedUrl.protocol === "https:") {
+      parsedUrl.protocol = "wss:";
+    }
+    websocket._url = parsedUrl.href;
+    const isSecure = parsedUrl.protocol === "wss:";
+    const isIpcUrl = parsedUrl.protocol === "ws+unix:";
+    let invalidUrlMessage;
+    if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
+      invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", ` + '"http:", "https:", or "ws+unix:"';
+    } else if (isIpcUrl && !parsedUrl.pathname) {
+      invalidUrlMessage = "The URL's pathname is empty";
+    } else if (parsedUrl.hash) {
+      invalidUrlMessage = "The URL contains a fragment identifier";
+    }
+    if (invalidUrlMessage) {
+      const err = new SyntaxError(invalidUrlMessage);
+      if (websocket._redirects === 0) {
+        throw err;
+      } else {
+        emitErrorAndClose(websocket, err);
+        return;
+      }
+    }
+    const defaultPort = isSecure ? 443 : 80;
+    const key = randomBytes(16).toString("base64");
+    const request = isSecure ? https.request : http.request;
+    const protocolSet = new Set;
+    let perMessageDeflate;
+    opts.createConnection = 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 = {
+      ...opts.headers,
+      "Sec-WebSocket-Version": opts.protocolVersion,
+      "Sec-WebSocket-Key": key,
+      Connection: "Upgrade",
+      Upgrade: "websocket"
+    };
+    opts.path = parsedUrl.pathname + parsedUrl.search;
+    opts.timeout = opts.handshakeTimeout;
+    if (opts.perMessageDeflate) {
+      perMessageDeflate = new PerMessageDeflate(opts.perMessageDeflate !== true ? opts.perMessageDeflate : {}, false, opts.maxPayload);
+      opts.headers["Sec-WebSocket-Extensions"] = format({
+        [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
+      });
+    }
+    if (protocols.length) {
+      for (const protocol of protocols) {
+        if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) {
+          throw new SyntaxError("An invalid or duplicated subprotocol was specified");
+        }
+        protocolSet.add(protocol);
+      }
+      opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
+    }
+    if (opts.origin) {
+      if (opts.protocolVersion < 13) {
+        opts.headers["Sec-WebSocket-Origin"] = opts.origin;
+      } else {
+        opts.headers.Origin = opts.origin;
+      }
+    }
+    if (parsedUrl.username || parsedUrl.password) {
+      opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+    }
+    if (isIpcUrl) {
+      const parts = opts.path.split(":");
+      opts.socketPath = parts[0];
+      opts.path = parts[1];
+    }
+    let req;
+    if (opts.followRedirects) {
+      if (websocket._redirects === 0) {
+        websocket._originalIpc = isIpcUrl;
+        websocket._originalSecure = isSecure;
+        websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
+        const headers = options && options.headers;
+        options = { ...options, headers: {} };
+        if (headers) {
+          for (const [key2, value] of Object.entries(headers)) {
+            options.headers[key2.toLowerCase()] = value;
+          }
+        }
+      } else if (websocket.listenerCount("redirect") === 0) {
+        const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
+        if (!isSameHost || websocket._originalSecure && !isSecure) {
+          delete opts.headers.authorization;
+          delete opts.headers.cookie;
+          if (!isSameHost)
+            delete opts.headers.host;
+          opts.auth = undefined;
+        }
+      }
+      if (opts.auth && !options.headers.authorization) {
+        options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
+      }
+      req = websocket._req = request(opts);
+      if (websocket._redirects) {
+        websocket.emit("redirect", websocket.url, req);
+      }
+    } else {
+      req = websocket._req = request(opts);
+    }
+    if (opts.timeout) {
+      req.on("timeout", () => {
+        abortHandshake(websocket, req, "Opening handshake has timed out");
+      });
+    }
+    req.on("error", (err) => {
+      if (req === null || req[kAborted])
+        return;
+      req = websocket._req = null;
+      emitErrorAndClose(websocket, err);
+    });
+    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();
+        let addr;
+        try {
+          addr = new URL(location, address);
+        } catch (e) {
+          const err = new SyntaxError(`Invalid URL: ${location}`);
+          emitErrorAndClose(websocket, err);
+          return;
+        }
+        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 !== WebSocket.CONNECTING)
+        return;
+      req = websocket._req = null;
+      const upgrade = res.headers.upgrade;
+      if (upgrade === undefined || upgrade.toLowerCase() !== "websocket") {
+        abortHandshake(websocket, socket, "Invalid Upgrade header");
+        return;
+      }
+      const digest = 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"];
+      let protError;
+      if (serverProt !== undefined) {
+        if (!protocolSet.size) {
+          protError = "Server sent a subprotocol but none was requested";
+        } else if (!protocolSet.has(serverProt)) {
+          protError = "Server sent an invalid subprotocol";
+        }
+      } else if (protocolSet.size) {
+        protError = "Server sent no subprotocol";
+      }
+      if (protError) {
+        abortHandshake(websocket, socket, protError);
+        return;
+      }
+      if (serverProt)
+        websocket._protocol = serverProt;
+      const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
+      if (secWebSocketExtensions !== undefined) {
+        if (!perMessageDeflate) {
+          const message = "Server sent a Sec-WebSocket-Extensions header but no extension " + "was requested";
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+        let extensions;
+        try {
+          extensions = parse(secWebSocketExtensions);
+        } catch (err) {
+          const message = "Invalid Sec-WebSocket-Extensions header";
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+        const extensionNames = Object.keys(extensions);
+        if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
+          const message = "Server indicated an extension that was not requested";
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+        try {
+          perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+        } catch (err) {
+          const message = "Invalid Sec-WebSocket-Extensions header";
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+        websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+      }
+      websocket.setSocket(socket, head, {
+        allowSynchronousEvents: opts.allowSynchronousEvents,
+        generateMask: opts.generateMask,
+        maxPayload: opts.maxPayload,
+        skipUTF8Validation: opts.skipUTF8Validation
+      });
+    });
+    if (opts.finishRequest) {
+      opts.finishRequest(req, websocket);
+    } else {
+      req.end();
+    }
+  }
+  function emitErrorAndClose(websocket, err) {
+    websocket._readyState = WebSocket.CLOSING;
+    websocket._errorEmitted = true;
+    websocket.emit("error", err);
+    websocket.emitClose();
+  }
+  function netConnect(options) {
+    options.path = options.socketPath;
+    return net.connect(options);
+  }
+  function tlsConnect(options) {
+    options.path = undefined;
+    if (!options.servername && options.servername !== "") {
+      options.servername = net.isIP(options.host) ? "" : options.host;
+    }
+    return tls.connect(options);
+  }
+  function abortHandshake(websocket, stream, message) {
+    websocket._readyState = WebSocket.CLOSING;
+    const err = new Error(message);
+    Error.captureStackTrace(err, abortHandshake);
+    if (stream.setHeader) {
+      stream[kAborted] = true;
+      stream.abort();
+      if (stream.socket && !stream.socket.destroyed) {
+        stream.socket.destroy();
+      }
+      process.nextTick(emitErrorAndClose, websocket, err);
+    } else {
+      stream.destroy(err);
+      stream.once("error", websocket.emit.bind(websocket, "error"));
+      stream.once("close", websocket.emitClose.bind(websocket));
+    }
+  }
+  function sendAfterClose(websocket, data, cb) {
+    if (data) {
+      const length = isBlob(data) ? data.size : toBuffer(data).length;
+      if (websocket._socket)
+        websocket._sender._bufferedBytes += length;
+      else
+        websocket._bufferedAmount += length;
+    }
+    if (cb) {
+      const err = new Error(`WebSocket is not open: readyState ${websocket.readyState} ` + `(${readyStates[websocket.readyState]})`);
+      process.nextTick(cb, err);
+    }
+  }
+  function receiverOnConclude(code, reason) {
+    const websocket = this[kWebSocket];
+    websocket._closeFrameReceived = true;
+    websocket._closeMessage = reason;
+    websocket._closeCode = code;
+    if (websocket._socket[kWebSocket] === undefined)
+      return;
+    websocket._socket.removeListener("data", socketOnData);
+    process.nextTick(resume, websocket._socket);
+    if (code === 1005)
+      websocket.close();
+    else
+      websocket.close(code, reason);
+  }
+  function receiverOnDrain() {
+    const websocket = this[kWebSocket];
+    if (!websocket.isPaused)
+      websocket._socket.resume();
+  }
+  function receiverOnError(err) {
+    const websocket = this[kWebSocket];
+    if (websocket._socket[kWebSocket] !== undefined) {
+      websocket._socket.removeListener("data", socketOnData);
+      process.nextTick(resume, websocket._socket);
+      websocket.close(err[kStatusCode]);
+    }
+    if (!websocket._errorEmitted) {
+      websocket._errorEmitted = true;
+      websocket.emit("error", err);
+    }
+  }
+  function receiverOnFinish() {
+    this[kWebSocket].emitClose();
+  }
+  function receiverOnMessage(data, isBinary) {
+    this[kWebSocket].emit("message", data, isBinary);
+  }
+  function receiverOnPing(data) {
+    const websocket = this[kWebSocket];
+    if (websocket._autoPong)
+      websocket.pong(data, !this._isServer, NOOP);
+    websocket.emit("ping", data);
+  }
+  function receiverOnPong(data) {
+    this[kWebSocket].emit("pong", data);
+  }
+  function resume(stream) {
+    stream.resume();
+  }
+  function senderOnError(err) {
+    const websocket = this[kWebSocket];
+    if (websocket.readyState === WebSocket.CLOSED)
+      return;
+    if (websocket.readyState === WebSocket.OPEN) {
+      websocket._readyState = WebSocket.CLOSING;
+      setCloseTimer(websocket);
+    }
+    this._socket.end();
+    if (!websocket._errorEmitted) {
+      websocket._errorEmitted = true;
+      websocket.emit("error", err);
+    }
+  }
+  function setCloseTimer(websocket) {
+    websocket._closeTimer = setTimeout(websocket._socket.destroy.bind(websocket._socket), websocket._closeTimeout);
+  }
+  function socketOnClose() {
+    const websocket = this[kWebSocket];
+    this.removeListener("close", socketOnClose);
+    this.removeListener("data", socketOnData);
+    this.removeListener("end", socketOnEnd);
+    websocket._readyState = WebSocket.CLOSING;
+    if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && this._readableState.length !== 0) {
+      const chunk = this.read(this._readableState.length);
+      websocket._receiver.write(chunk);
+    }
+    websocket._receiver.end();
+    this[kWebSocket] = undefined;
+    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 = WebSocket.CLOSING;
+    websocket._receiver.end();
+    this.end();
+  }
+  function socketOnError() {
+    const websocket = this[kWebSocket];
+    this.removeListener("error", socketOnError);
+    this.on("error", NOOP);
+    if (websocket) {
+      websocket._readyState = WebSocket.CLOSING;
+      this.destroy();
+    }
+  }
+});
+
+// ../../../node_modules/ws/lib/stream.js
+var require_stream = __commonJS((exports, module) => {
+  var WebSocket = require_websocket();
+  var { Duplex } = __require("stream");
+  function emitClose(stream) {
+    stream.emit("close");
+  }
+  function duplexOnEnd() {
+    if (!this.destroyed && this._writableState.finished) {
+      this.destroy();
+    }
+  }
+  function duplexOnError(err) {
+    this.removeListener("error", duplexOnError);
+    this.destroy();
+    if (this.listenerCount("error") === 0) {
+      this.emit("error", err);
+    }
+  }
+  function createWebSocketStream(ws, options) {
+    let terminateOnDestroy = true;
+    const duplex = new Duplex({
+      ...options,
+      autoDestroy: false,
+      emitClose: false,
+      objectMode: false,
+      writableObjectMode: false
+    });
+    ws.on("message", function message(msg, isBinary) {
+      const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+      if (!duplex.push(data))
+        ws.pause();
+    });
+    ws.once("error", function error(err) {
+      if (duplex.destroyed)
+        return;
+      terminateOnDestroy = false;
+      duplex.destroy(err);
+    });
+    ws.once("close", function close() {
+      if (duplex.destroyed)
+        return;
+      duplex.push(null);
+    });
+    duplex._destroy = function(err, callback) {
+      if (ws.readyState === ws.CLOSED) {
+        callback(err);
+        process.nextTick(emitClose, duplex);
+        return;
+      }
+      let called = false;
+      ws.once("error", function error(err2) {
+        called = true;
+        callback(err2);
+      });
+      ws.once("close", function close() {
+        if (!called)
+          callback(err);
+        process.nextTick(emitClose, duplex);
+      });
+      if (terminateOnDestroy)
+        ws.terminate();
+    };
+    duplex._final = function(callback) {
+      if (ws.readyState === ws.CONNECTING) {
+        ws.once("open", function open() {
+          duplex._final(callback);
+        });
+        return;
+      }
+      if (ws._socket === null)
+        return;
+      if (ws._socket._writableState.finished) {
+        callback();
+        if (duplex._readableState.endEmitted)
+          duplex.destroy();
+      } else {
+        ws._socket.once("finish", function finish() {
+          callback();
+        });
+        ws.close();
+      }
+    };
+    duplex._read = function() {
+      if (ws.isPaused)
+        ws.resume();
+    };
+    duplex._write = function(chunk, encoding, callback) {
+      if (ws.readyState === ws.CONNECTING) {
+        ws.once("open", function open() {
+          duplex._write(chunk, encoding, callback);
+        });
+        return;
+      }
+      ws.send(chunk, callback);
+    };
+    duplex.on("end", duplexOnEnd);
+    duplex.on("error", duplexOnError);
+    return duplex;
+  }
+  module.exports = createWebSocketStream;
+});
+
+// ../../../node_modules/ws/lib/subprotocol.js
+var require_subprotocol = __commonJS((exports, module) => {
+  var { tokenChars } = require_validation();
+  function parse(header) {
+    const protocols = new Set;
+    let start = -1;
+    let end = -1;
+    let i = 0;
+    for (i;i < header.length; i++) {
+      const code = header.charCodeAt(i);
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1)
+          start = i;
+      } else if (i !== 0 && (code === 32 || code === 9)) {
+        if (end === -1 && start !== -1)
+          end = i;
+      } else if (code === 44) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+        if (end === -1)
+          end = i;
+        const protocol2 = header.slice(start, end);
+        if (protocols.has(protocol2)) {
+          throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
+        }
+        protocols.add(protocol2);
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    }
+    if (start === -1 || end !== -1) {
+      throw new SyntaxError("Unexpected end of input");
+    }
+    const protocol = header.slice(start, i);
+    if (protocols.has(protocol)) {
+      throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+    }
+    protocols.add(protocol);
+    return protocols;
+  }
+  module.exports = { parse };
+});
+
+// ../../../node_modules/ws/lib/websocket-server.js
+var require_websocket_server = __commonJS((exports, module) => {
+  var EventEmitter = __require("events");
+  var http = __require("http");
+  var { Duplex } = __require("stream");
+  var { createHash } = __require("crypto");
+  var extension = require_extension();
+  var PerMessageDeflate = require_permessage_deflate();
+  var subprotocol = require_subprotocol();
+  var WebSocket = require_websocket();
+  var { CLOSE_TIMEOUT, GUID, kWebSocket } = require_constants();
+  var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+  var RUNNING = 0;
+  var CLOSING = 1;
+  var CLOSED = 2;
+
+  class WebSocketServer extends EventEmitter {
+    constructor(options, callback) {
+      super();
+      options = {
+        allowSynchronousEvents: true,
+        autoPong: true,
+        maxPayload: 100 * 1024 * 1024,
+        skipUTF8Validation: false,
+        perMessageDeflate: false,
+        handleProtocols: null,
+        clientTracking: true,
+        closeTimeout: CLOSE_TIMEOUT,
+        verifyClient: null,
+        noServer: false,
+        backlog: null,
+        server: null,
+        host: null,
+        path: null,
+        port: null,
+        WebSocket,
+        ...options
+      };
+      if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
+        throw new TypeError('One and only 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) {
+        const emitConnection = this.emit.bind(this, "connection");
+        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, emitConnection);
+          }
+        });
+      }
+      if (options.perMessageDeflate === true)
+        options.perMessageDeflate = {};
+      if (options.clientTracking) {
+        this.clients = new Set;
+        this._shouldEmitClose = false;
+      }
+      this.options = options;
+      this._state = RUNNING;
+    }
+    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(cb) {
+      if (this._state === CLOSED) {
+        if (cb) {
+          this.once("close", () => {
+            cb(new Error("The server is not running"));
+          });
+        }
+        process.nextTick(emitClose, this);
+        return;
+      }
+      if (cb)
+        this.once("close", cb);
+      if (this._state === CLOSING)
+        return;
+      this._state = CLOSING;
+      if (this.options.noServer || this.options.server) {
+        if (this._server) {
+          this._removeListeners();
+          this._removeListeners = this._server = null;
+        }
+        if (this.clients) {
+          if (!this.clients.size) {
+            process.nextTick(emitClose, this);
+          } else {
+            this._shouldEmitClose = true;
+          }
+        } else {
+          process.nextTick(emitClose, this);
+        }
+      } else {
+        const server = this._server;
+        this._removeListeners();
+        this._removeListeners = this._server = null;
+        server.close(() => {
+          emitClose(this);
+        });
+      }
+    }
+    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;
+    }
+    handleUpgrade(req, socket, head, cb) {
+      socket.on("error", socketOnError);
+      const key = req.headers["sec-websocket-key"];
+      const upgrade = req.headers.upgrade;
+      const version = +req.headers["sec-websocket-version"];
+      if (req.method !== "GET") {
+        const message = "Invalid HTTP method";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+        return;
+      }
+      if (upgrade === undefined || upgrade.toLowerCase() !== "websocket") {
+        const message = "Invalid Upgrade header";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+      if (key === undefined || !keyRegex.test(key)) {
+        const message = "Missing or invalid Sec-WebSocket-Key header";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+      if (version !== 13 && version !== 8) {
+        const message = "Missing or invalid Sec-WebSocket-Version header";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
+          "Sec-WebSocket-Version": "13, 8"
+        });
+        return;
+      }
+      if (!this.shouldHandle(req)) {
+        abortHandshake(socket, 400);
+        return;
+      }
+      const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
+      let protocols = new Set;
+      if (secWebSocketProtocol !== undefined) {
+        try {
+          protocols = subprotocol.parse(secWebSocketProtocol);
+        } catch (err) {
+          const message = "Invalid Sec-WebSocket-Protocol header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          return;
+        }
+      }
+      const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
+      const extensions = {};
+      if (this.options.perMessageDeflate && secWebSocketExtensions !== undefined) {
+        const perMessageDeflate = new PerMessageDeflate(this.options.perMessageDeflate, true, this.options.maxPayload);
+        try {
+          const offers = extension.parse(secWebSocketExtensions);
+          if (offers[PerMessageDeflate.extensionName]) {
+            perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+            extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+          }
+        } catch (err) {
+          const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          return;
+        }
+      }
+      if (this.options.verifyClient) {
+        const info = {
+          origin: req.headers[`${version === 8 ? "sec-websocket-origin" : "origin"}`],
+          secure: !!(req.socket.authorized || req.socket.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(extensions, key, protocols, req, socket, head, cb);
+          });
+          return;
+        }
+        if (!this.options.verifyClient(info))
+          return abortHandshake(socket, 401);
+      }
+      this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+    }
+    completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
+      if (!socket.readable || !socket.writable)
+        return socket.destroy();
+      if (socket[kWebSocket]) {
+        throw new Error("server.handleUpgrade() was called more than once with the same " + "socket, possibly due to a misconfiguration");
+      }
+      if (this._state > RUNNING)
+        return abortHandshake(socket, 503);
+      const digest = 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 this.options.WebSocket(null, undefined, this.options);
+      if (protocols.size) {
+        const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
+        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
+`).join(`\r
+`));
+      socket.removeListener("error", socketOnError);
+      ws.setSocket(socket, head, {
+        allowSynchronousEvents: this.options.allowSynchronousEvents,
+        maxPayload: this.options.maxPayload,
+        skipUTF8Validation: this.options.skipUTF8Validation
+      });
+      if (this.clients) {
+        this.clients.add(ws);
+        ws.on("close", () => {
+          this.clients.delete(ws);
+          if (this._shouldEmitClose && !this.clients.size) {
+            process.nextTick(emitClose, this);
+          }
+        });
+      }
+      cb(ws, req);
+    }
+  }
+  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._state = CLOSED;
+    server.emit("close");
+  }
+  function socketOnError() {
+    this.destroy();
+  }
+  function abortHandshake(socket, code, message, headers) {
+    message = message || http.STATUS_CODES[code];
+    headers = {
+      Connection: "close",
+      "Content-Type": "text/html",
+      "Content-Length": Buffer.byteLength(message),
+      ...headers
+    };
+    socket.once("finish", socket.destroy);
+    socket.end(`HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
+` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join(`\r
+`) + `\r
+\r
+` + message);
+  }
+  function abortHandshakeOrEmitwsClientError(server, req, socket, code, message, headers) {
+    if (server.listenerCount("wsClientError")) {
+      const err = new Error(message);
+      Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+      server.emit("wsClientError", err, socket, req);
+    } else {
+      abortHandshake(socket, code, message, headers);
+    }
+  }
+});
+
+// src/index.ts
+import { logger as logger5 } from "@elizaos/core";
+import { z as z9 } from "zod";
+
+// src/services/minecraft-service.ts
+import { logger as logger3, Service } from "@elizaos/core";
+
+// src/types.ts
+import { z } from "zod";
+var minecraftWorldStateSchema = z.object({
+  connected: z.boolean(),
+  username: z.string().nullable().optional(),
+  version: z.string().nullable().optional(),
+  health: z.number().nullable().optional(),
+  food: z.number().nullable().optional(),
+  experience: z.number().nullable().optional(),
+  position: z.object({ x: z.number(), y: z.number(), z: z.number() }).nullable().optional(),
+  yaw: z.number().nullable().optional(),
+  pitch: z.number().nullable().optional(),
+  time: z.number().nullable().optional(),
+  isRaining: z.boolean().nullable().optional(),
+  inventory: z.array(z.object({
+    name: z.string(),
+    displayName: z.string(),
+    count: z.number(),
+    slot: z.number()
+  })).optional(),
+  nearbyEntities: z.array(z.object({
+    id: z.number(),
+    type: z.string(),
+    name: z.string().nullable(),
+    username: z.string().nullable(),
+    kind: z.string().nullable(),
+    position: z.object({ x: z.number(), y: z.number(), z: z.number() })
+  })).optional()
+}).passthrough();
+
+// src/services/process-manager.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { logger } from "@elizaos/core";
+
+class MinecraftProcessManager {
+  serverPort;
+  process = null;
+  isRunning = false;
+  entryPath = null;
+  constructor(serverPort) {
+    this.serverPort = serverPort;
+    this.entryPath = this.findEntry();
+  }
+  findEntry() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const possible = [
+      join(moduleDir, "../../../mineflayer-server/dist/index.js"),
+      join(moduleDir, "../../../mineflayer-server/src/index.ts"),
+      join(moduleDir, "../../../../mineflayer-server/dist/index.js"),
+      join(moduleDir, "../../../../mineflayer-server/src/index.ts")
+    ];
+    for (const p of possible) {
+      if (existsSync(p)) {
+        logger.info(`Found mineflayer-server entry at: ${p}`);
+        return p;
+      }
+    }
+    logger.error("Could not find mineflayer-server entry file");
+    logger.error(`Searched paths: ${possible.join(", ")}`);
+    return null;
+  }
+  async start() {
+    if (this.isRunning)
+      return;
+    if (!this.entryPath) {
+      throw new Error("mineflayer-server entry not found (run: bun run build:server)");
+    }
+    const env = {
+      ...process.env,
+      MC_SERVER_PORT: this.serverPort.toString(),
+      NODE_ENV: "development"
+    };
+    const entry = this.entryPath;
+    const isTypeScript = entry.endsWith(".ts");
+    return await new Promise((resolve, reject) => {
+      if (isTypeScript) {
+        const require2 = createRequire2(import.meta.url);
+        const tsxPath = require2.resolve("tsx/cli", { paths: [process.cwd()] });
+        this.process = spawn("node", [tsxPath, entry], { env });
+      } else {
+        this.process = spawn("node", [entry], { env });
+      }
+      this.process.stdout?.on("data", (data) => {
+        const msg = data.toString().trim();
+        logger.debug(`[MinecraftServer] ${msg}`);
+        if (msg.includes("listening on port")) {
+          this.isRunning = true;
+          resolve();
+        }
+      });
+      this.process.stderr?.on("data", (data) => {
+        logger.error(`[MinecraftServer Error] ${data.toString()}`);
+      });
+      this.process.on("error", (err) => {
+        this.isRunning = false;
+        reject(err);
+      });
+      this.process.on("exit", (code) => {
+        logger.info(`Minecraft server process exited with code ${code ?? "unknown"}`);
+        this.isRunning = false;
+      });
+      setTimeout(() => {
+        if (!this.isRunning) {
+          reject(new Error("mineflayer-server failed to start (timeout)"));
+        }
+      }, 15000);
+    });
+  }
+  async stop() {
+    if (!this.process || !this.isRunning)
+      return;
+    await new Promise((resolve) => {
+      this.process?.on("exit", () => resolve());
+      this.process?.kill("SIGTERM");
+      setTimeout(() => {
+        if (this.isRunning && this.process) {
+          this.process.kill("SIGKILL");
+        }
+      }, 5000);
+    });
+  }
+  isServerRunning() {
+    return this.isRunning;
+  }
+  getServerUrl() {
+    return `ws://localhost:${this.serverPort}`;
+  }
+}
+
+// src/services/websocket-client.ts
+import { logger as logger2 } from "@elizaos/core";
+
+// ../../../node_modules/ws/wrapper.mjs
+var import_stream = __toESM(require_stream(), 1);
+var import_receiver = __toESM(require_receiver(), 1);
+var import_sender = __toESM(require_sender(), 1);
+var import_websocket = __toESM(require_websocket(), 1);
+var import_websocket_server = __toESM(require_websocket_server(), 1);
+var wrapper_default = import_websocket.default;
+
+// src/services/websocket-client.ts
+import { z as z2 } from "zod";
+var jsonValueSchema = z2.lazy(() => z2.union([
+  z2.null(),
+  z2.boolean(),
+  z2.number(),
+  z2.string(),
+  z2.array(jsonValueSchema),
+  z2.record(z2.string(), jsonValueSchema)
+]));
+var responseSchema = z2.object({
+  type: z2.string(),
+  requestId: z2.string(),
+  success: z2.boolean(),
+  data: z2.record(z2.string(), jsonValueSchema).optional(),
+  error: z2.string().optional()
+});
+
+class MinecraftWebSocketClient {
+  serverUrl;
+  ws = null;
+  pending = new Map;
+  constructor(serverUrl) {
+    this.serverUrl = serverUrl;
+  }
+  async connect() {
+    if (this.ws && this.ws.readyState === wrapper_default.OPEN)
+      return;
+    await new Promise((resolve, reject) => {
+      const ws = new wrapper_default(this.serverUrl);
+      this.ws = ws;
+      ws.on("open", () => resolve());
+      ws.on("error", (err) => reject(err));
+      ws.on("message", (data) => this.onMessage(data.toString("utf8")));
+      ws.on("close", () => {
+        for (const [requestId, entry] of this.pending) {
+          clearTimeout(entry.timeoutId);
+          entry.reject(new Error(`WebSocket closed while waiting for ${requestId}`));
+        }
+        this.pending.clear();
+      });
+    });
+    logger2.info(`[Minecraft] Connected to ${this.serverUrl}`);
+  }
+  disconnect() {
+    this.ws?.close();
+    this.ws = null;
+  }
+  async health() {
+    const resp = await this.sendMessage("health", undefined, {});
+    return resp.success && resp.data?.status === "ok";
+  }
+  async sendMessage(type, botId, data, timeoutMs = 30000) {
+    if (!this.ws || this.ws.readyState !== wrapper_default.OPEN) {
+      throw new Error("Not connected to Mineflayer bridge server");
+    }
+    const requestId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const msg = {
+      type,
+      requestId,
+      ...botId ? { botId } : {},
+      ...Object.keys(data).length > 0 ? { data } : {}
+    };
+    const payload = JSON.stringify(msg);
+    const response = await new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error(`Request timeout: ${type}`));
+      }, timeoutMs);
+      this.pending.set(requestId, { resolve, reject, timeoutId });
+      this.ws?.send(payload, (err) => {
+        if (err) {
+          clearTimeout(timeoutId);
+          this.pending.delete(requestId);
+          reject(err);
+        }
+      });
+    });
+    if (!response.success) {
+      throw new Error(response.error ?? `Request failed: ${type}`);
+    }
+    return response;
+  }
+  onMessage(text) {
+    let parsed;
+    try {
+      const json = JSON.parse(text);
+      parsed = responseSchema.parse(json);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger2.error(`[Minecraft] Failed to parse server message: ${msg}`);
+      return;
+    }
+    const pending = this.pending.get(parsed.requestId);
+    if (!pending)
+      return;
+    clearTimeout(pending.timeoutId);
+    this.pending.delete(parsed.requestId);
+    pending.resolve(parsed);
+  }
+}
+
+// src/services/minecraft-service.ts
+var MINECRAFT_SERVICE_TYPE = "minecraft";
+
+class Session {
+  botId;
+  createdAt;
+  constructor(botId, createdAt = new Date) {
+    this.botId = botId;
+    this.createdAt = createdAt;
+  }
+}
+
+class MinecraftService extends Service {
+  static serviceType = MINECRAFT_SERVICE_TYPE;
+  capabilityDescription = "Minecraft automation service (Mineflayer bridge)";
+  session = null;
+  processManager;
+  client;
+  isInitialized = false;
+  constructor(runtime) {
+    super(runtime);
+    if (!runtime)
+      throw new Error("MinecraftService requires a runtime");
+    this.runtime = runtime;
+    const portSetting = runtime.getSetting("MC_SERVER_PORT");
+    const port = typeof portSetting === "number" ? portSetting : Number(portSetting ?? 3457);
+    const serverPort = Number.isFinite(port) ? port : 3457;
+    this.processManager = new MinecraftProcessManager(serverPort);
+    this.client = new MinecraftWebSocketClient(this.processManager.getServerUrl());
+  }
+  static async start(runtime) {
+    const service = new MinecraftService(runtime);
+    try {
+      await service.processManager.start();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger3.warn(`Failed to start Mineflayer server process: ${msg}`);
+    }
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    if (this.isInitialized)
+      return;
+    await this.client.connect();
+    await this.waitForReady();
+    this.isInitialized = true;
+  }
+  async stop() {
+    if (this.session) {
+      try {
+        await this.destroyBot(this.session.botId);
+      } catch {}
+    }
+    this.client.disconnect();
+    await this.processManager.stop();
+    this.isInitialized = false;
+  }
+  getClient() {
+    if (!this.isInitialized) {
+      throw new Error("Minecraft service not initialized");
+    }
+    return this.client;
+  }
+  getCurrentSession() {
+    return this.session;
+  }
+  async createBot(overrides) {
+    if (!this.isInitialized) {
+      throw new Error("Minecraft service not initialized");
+    }
+    const resp = await this.client.sendMessage("createBot", undefined, overrides ?? {});
+    const botId = typeof resp.data?.botId === "string" ? resp.data.botId : null;
+    if (!botId) {
+      throw new Error("Bridge did not return botId");
+    }
+    this.session = new Session(botId);
+    return this.session;
+  }
+  async destroyBot(botId) {
+    if (!this.isInitialized)
+      return;
+    await this.client.sendMessage("destroyBot", botId, {});
+    if (this.session?.botId === botId) {
+      this.session = null;
+    }
+  }
+  async ensureBot() {
+    if (this.session)
+      return this.session;
+    return await this.createBot();
+  }
+  async chat(message) {
+    const session = await this.ensureBot();
+    await this.client.sendMessage("chat", session.botId, { message });
+  }
+  async request(type, data) {
+    const session = await this.ensureBot();
+    const resp = await this.client.sendMessage(type, session.botId, data);
+    return resp.data ?? {};
+  }
+  async getWorldState() {
+    if (!this.session) {
+      return { connected: false };
+    }
+    const resp = await this.client.sendMessage("getState", this.session.botId, {});
+    return minecraftWorldStateSchema.parse(resp.data ?? { connected: false });
+  }
+  async waitForReady(maxAttempts = 20, delayMs = 500) {
+    for (let i = 0;i < maxAttempts; i++) {
+      try {
+        if (await this.client.health())
+          return;
+      } catch {}
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+    throw new Error("Mineflayer bridge server did not become ready");
+  }
+}
+
+// src/actions/attack.ts
+function parseEntityId(text) {
+  const trimmed = text.trim();
+  if (!trimmed)
+    return null;
+  const id = Number(trimmed);
+  return Number.isFinite(id) ? id : null;
+}
+var minecraftAttackAction = {
+  name: "MC_ATTACK",
+  similes: ["MINECRAFT_ATTACK", "HIT_ENTITY"],
+  description: "Attack an entity by numeric entityId (from MC_WORLD_STATE.nearbyEntities).",
+  validate: async (runtime, message) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service) && parseEntityId(message.content.text ?? "") !== null;
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service)
+      return { text: "Minecraft service is not available", success: false };
+    const entityId = parseEntityId(message.content.text ?? "");
+    if (entityId === null)
+      return { text: "Missing entityId", success: false };
+    try {
+      await service.request("attack", { entityId });
+      const content = {
+        text: `Attacked entity ${entityId}.`,
+        actions: ["MC_ATTACK"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to attack: ${msg}`,
+        actions: ["MC_ATTACK"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/actions/chat.ts
+var minecraftChatAction = {
+  name: "MC_CHAT",
+  similes: ["MINECRAFT_CHAT", "SAY_IN_MINECRAFT", "CHAT"],
+  description: "Send a chat message in Minecraft as the bot",
+  validate: async (runtime, message) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service) && (message.content.text ?? "").trim().length > 0;
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service) {
+      return { text: "Minecraft service is not available", success: false };
+    }
+    const text = (message.content.text ?? "").trim();
+    if (!text)
+      return { text: "No chat message provided", success: false };
+    try {
+      await service.chat(text);
+      const content = {
+        text: `Sent Minecraft chat: ${text}`,
+        actions: ["MC_CHAT"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return {
+        text: content.text ?? "",
+        success: true,
+        values: { sent: true }
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to send Minecraft chat: ${msg}`,
+        actions: ["MC_CHAT"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/actions/connect.ts
+import { z as z3 } from "zod";
+var connectOverridesSchema = z3.object({
+  host: z3.string().optional(),
+  port: z3.number().int().positive().optional(),
+  username: z3.string().optional(),
+  auth: z3.enum(["offline", "microsoft"]).optional(),
+  version: z3.string().optional()
+}).passthrough();
+function parseOverrides(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
+    return {};
+  try {
+    const parsed = JSON.parse(trimmed);
+    const validated = connectOverridesSchema.parse(parsed);
+    const out = {};
+    if (typeof validated.host === "string")
+      out.host = validated.host;
+    if (typeof validated.port === "number")
+      out.port = validated.port;
+    if (typeof validated.username === "string")
+      out.username = validated.username;
+    if (typeof validated.auth === "string")
+      out.auth = validated.auth;
+    if (typeof validated.version === "string")
+      out.version = validated.version;
+    return out;
+  } catch {
+    return {};
+  }
+}
+var minecraftConnectAction = {
+  name: "MC_CONNECT",
+  similes: ["MINECRAFT_CONNECT", "JOIN_SERVER", "CONNECT_TO_MINECRAFT"],
+  description: "Connect the Mineflayer bot to a Minecraft server",
+  validate: async (runtime) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service);
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service) {
+      return { text: "Minecraft service is not available", success: false };
+    }
+    try {
+      const overrides = parseOverrides(message.content.text ?? "");
+      const session = await service.createBot(overrides);
+      const content = {
+        text: `Connected Minecraft bot (botId=${session.botId}).`,
+        actions: ["MC_CONNECT"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return {
+        text: content.text ?? "",
+        success: true,
+        data: { botId: session.botId },
+        values: { connected: true }
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to connect Minecraft bot: ${msg}`,
+        actions: ["MC_CONNECT"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return {
+        text: content.text ?? "",
+        success: false,
+        data: { error: msg },
+        values: { connected: false }
+      };
+    }
+  }
+};
+// src/actions/control.ts
+import { z as z4 } from "zod";
+var controlSchema = z4.object({
+  control: z4.string(),
+  state: z4.boolean(),
+  durationMs: z4.number().int().positive().optional()
+});
+function parseControl(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return controlSchema.parse(parsed);
+    } catch {
+      return null;
+    }
+  }
+  const m = trimmed.match(/^(\S+)\s+(true|false)(?:\s+(\d+))?$/i);
+  if (!m)
+    return null;
+  const control = m[1];
+  const state = m[2].toLowerCase() === "true";
+  const durationMs = m[3] ? Number(m[3]) : undefined;
+  if (durationMs !== undefined && !Number.isFinite(durationMs))
+    return null;
+  return durationMs ? { control, state, durationMs } : { control, state };
+}
+var minecraftControlAction = {
+  name: "MC_CONTROL",
+  similes: ["MINECRAFT_CONTROL", "SET_CONTROL_STATE"],
+  description: "Set a control state (e.g. forward/back/left/right/jump/sprint/sneak). Provide JSON {control,state,durationMs?} or 'forward true 1000'.",
+  validate: async (runtime, message) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service) && Boolean(parseControl(message.content.text ?? ""));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service)
+      return { text: "Minecraft service is not available", success: false };
+    const req = parseControl(message.content.text ?? "");
+    if (!req)
+      return { text: "Missing control command", success: false };
+    try {
+      await service.request("control", {
+        control: req.control,
+        state: req.state,
+        ...typeof req.durationMs === "number" ? { durationMs: req.durationMs } : {}
+      });
+      const content = {
+        text: `Set control ${req.control}=${String(req.state)}${req.durationMs ? ` for ${req.durationMs}ms` : ""}.`,
+        actions: ["MC_CONTROL"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to set control: ${msg}`,
+        actions: ["MC_CONTROL"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/actions/utils.ts
+import { z as z5 } from "zod";
+var vec3Schema = z5.object({ x: z5.number(), y: z5.number(), z: z5.number() });
+function extractVec3(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const v = vec3Schema.parse(parsed);
+      return v;
+    } catch {}
+  }
+  const m = trimmed.match(/(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/);
+  if (!m)
+    return null;
+  const x = Number(m[1]);
+  const y = Number(m[2]);
+  const z6 = Number(m[3]);
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z6))
+    return null;
+  return { x, y, z: z6 };
+}
+
+// src/actions/dig.ts
+var minecraftDigAction = {
+  name: "MC_DIG",
+  similes: ["MINECRAFT_DIG", "MINE_BLOCK", "BREAK_BLOCK"],
+  description: `Dig/break the block at (x y z). Provide coordinates like '10 64 -20' or JSON {"x":10,"y":64,"z":-20}.`,
+  validate: async (runtime, message) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service) && Boolean(extractVec3(message.content.text ?? ""));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service)
+      return { text: "Minecraft service is not available", success: false };
+    const vec = extractVec3(message.content.text ?? "");
+    if (!vec)
+      return { text: "Missing coordinates (x y z)", success: false };
+    try {
+      const data = await service.request("dig", {
+        x: vec.x,
+        y: vec.y,
+        z: vec.z
+      });
+      const blockName = typeof data.blockName === "string" ? data.blockName : "block";
+      const content = {
+        text: `Dug ${blockName} at (${vec.x}, ${vec.y}, ${vec.z}).`,
+        actions: ["MC_DIG"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to dig: ${msg}`,
+        actions: ["MC_DIG"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/actions/disconnect.ts
+var minecraftDisconnectAction = {
+  name: "MC_DISCONNECT",
+  similes: ["MINECRAFT_DISCONNECT", "LEAVE_SERVER", "QUIT_MINECRAFT"],
+  description: "Disconnect the Mineflayer bot from the Minecraft server",
+  validate: async (runtime) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service?.getCurrentSession());
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service) {
+      return { text: "Minecraft service is not available", success: false };
+    }
+    const session = service.getCurrentSession();
+    if (!session) {
+      return { text: "No Minecraft bot is connected", success: false };
+    }
+    try {
+      await service.destroyBot(session.botId);
+      const content = {
+        text: "Disconnected Minecraft bot.",
+        actions: ["MC_DISCONNECT"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return {
+        text: content.text ?? "",
+        success: true,
+        values: { connected: false }
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to disconnect Minecraft bot: ${msg}`,
+        actions: ["MC_DISCONNECT"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/actions/goto.ts
+var minecraftGotoAction = {
+  name: "MC_GOTO",
+  similes: ["MINECRAFT_GOTO", "WALK_TO", "MOVE_TO_COORDS"],
+  description: `Pathfind to a target (x y z). Provide coordinates like '10 64 -20' or JSON {"x":10,"y":64,"z":-20}.`,
+  validate: async (runtime, message) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service) && Boolean(extractVec3(message.content.text ?? ""));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service)
+      return { text: "Minecraft service is not available", success: false };
+    const vec = extractVec3(message.content.text ?? "");
+    if (!vec)
+      return { text: "Missing coordinates (x y z)", success: false };
+    try {
+      await service.request("goto", { x: vec.x, y: vec.y, z: vec.z });
+      const content = {
+        text: `Moving to (${vec.x}, ${vec.y}, ${vec.z}).`,
+        actions: ["MC_GOTO"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to pathfind: ${msg}`,
+        actions: ["MC_GOTO"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/actions/look.ts
+import { z as z6 } from "zod";
+var lookSchema = z6.object({ yaw: z6.number(), pitch: z6.number() });
+function parseLook(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return lookSchema.parse(parsed);
+    } catch {
+      return null;
+    }
+  }
+  const m = trimmed.match(/(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/);
+  if (!m)
+    return null;
+  const yaw = Number(m[1]);
+  const pitch = Number(m[2]);
+  if (!Number.isFinite(yaw) || !Number.isFinite(pitch))
+    return null;
+  return { yaw, pitch };
+}
+var minecraftLookAction = {
+  name: "MC_LOOK",
+  similes: ["MINECRAFT_LOOK", "TURN_HEAD"],
+  description: "Look to yaw/pitch (radians). Provide 'yaw pitch' or JSON {yaw,pitch}.",
+  validate: async (runtime, message) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service) && Boolean(parseLook(message.content.text ?? ""));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service)
+      return { text: "Minecraft service is not available", success: false };
+    const req = parseLook(message.content.text ?? "");
+    if (!req)
+      return { text: "Missing yaw/pitch", success: false };
+    try {
+      await service.request("look", { yaw: req.yaw, pitch: req.pitch });
+      const content = {
+        text: "Adjusted view.",
+        actions: ["MC_LOOK"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to look: ${msg}`,
+        actions: ["MC_LOOK"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/actions/place.ts
+import { z as z7 } from "zod";
+var placeSchema = z7.object({
+  x: z7.number(),
+  y: z7.number(),
+  z: z7.number(),
+  face: z7.enum(["up", "down", "north", "south", "east", "west"])
+});
+function parsePlace(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const v = placeSchema.parse(parsed);
+      return v;
+    } catch {
+      return null;
+    }
+  }
+  const m = trimmed.match(/(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(up|down|north|south|east|west)\b/i);
+  if (!m)
+    return null;
+  const x = Number(m[1]);
+  const y = Number(m[2]);
+  const zVal = Number(m[3]);
+  const face = m[4].toLowerCase();
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(zVal))
+    return null;
+  return { x, y, z: zVal, face };
+}
+var minecraftPlaceAction = {
+  name: "MC_PLACE",
+  similes: ["MINECRAFT_PLACE", "PLACE_BLOCK"],
+  description: "Place the currently-held block onto a reference block face. Provide 'x y z face' (face=up/down/north/south/east/west) or JSON {x,y,z,face}.",
+  validate: async (runtime, message) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service) && Boolean(parsePlace(message.content.text ?? ""));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service)
+      return { text: "Minecraft service is not available", success: false };
+    const req = parsePlace(message.content.text ?? "");
+    if (!req)
+      return { text: "Missing placement target (x y z face)", success: false };
+    try {
+      await service.request("place", {
+        x: req.x,
+        y: req.y,
+        z: req.z,
+        face: req.face
+      });
+      const content = {
+        text: `Placed block at (${req.x}, ${req.y}, ${req.z}) face=${req.face}.`,
+        actions: ["MC_PLACE"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to place: ${msg}`,
+        actions: ["MC_PLACE"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/actions/scan.ts
+import { z as z8 } from "zod";
+var scanSchema = z8.object({
+  blocks: z8.array(z8.string()).optional(),
+  radius: z8.number().int().positive().optional(),
+  maxResults: z8.number().int().positive().optional()
+}).passthrough();
+function parseScan(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    const validated = scanSchema.parse({
+      blocks: Array.isArray(parsed.blocks) ? parsed.blocks.filter((b) => typeof b === "string") : undefined,
+      radius: typeof parsed.radius === "number" ? parsed.radius : undefined,
+      maxResults: typeof parsed.maxResults === "number" ? parsed.maxResults : undefined
+    });
+    return {
+      blocks: validated.blocks,
+      radius: validated.radius,
+      maxResults: validated.maxResults
+    };
+  } catch {
+    return {};
+  }
+}
+var minecraftScanAction = {
+  name: "MC_SCAN",
+  similes: ["MINECRAFT_SCAN", "FIND_BLOCKS", "SCAN_BLOCKS"],
+  description: 'Scan nearby blocks. Optional JSON input: {"blocks":["oak_log"],"radius":16,"maxResults":32}. If omitted, scans for any non-air blocks.',
+  validate: async (runtime) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service);
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service)
+      return { text: "Minecraft service is not available", success: false };
+    try {
+      const params = parseScan(message.content.text ?? "");
+      const data = await service.request("scan", {
+        ...params.blocks ? { blocks: params.blocks } : {},
+        ...typeof params.radius === "number" ? { radius: params.radius } : {},
+        ...typeof params.maxResults === "number" ? { maxResults: params.maxResults } : {}
+      });
+      const blocks = Array.isArray(data.blocks) ? data.blocks : [];
+      const content = {
+        text: `Scan found ${blocks.length} blocks.`,
+        actions: ["MC_SCAN"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return {
+        text: content.text ?? "",
+        success: true,
+        data,
+        values: { count: blocks.length }
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Scan failed: ${msg}`,
+        actions: ["MC_SCAN"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/actions/stop.ts
+var minecraftStopAction = {
+  name: "MC_STOP",
+  similes: ["MINECRAFT_STOP", "STOP_PATHFINDER", "STOP_MOVING"],
+  description: "Stop pathfinding / movement goals.",
+  validate: async (runtime) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    return Boolean(service);
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service)
+      return { text: "Minecraft service is not available", success: false };
+    try {
+      await service.request("stop", {});
+      const content = {
+        text: "Stopped movement.",
+        actions: ["MC_STOP"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const content = {
+        text: `Failed to stop: ${msg}`,
+        actions: ["MC_STOP"],
+        source: message.content.source
+      };
+      await callback?.(content);
+      return { text: content.text ?? "", success: false };
+    }
+  }
+};
+// src/services/waypoints-service.ts
+import { ChannelType, MemoryType, Service as Service2, stringToUuid } from "@elizaos/core";
+var WAYPOINTS_SERVICE_TYPE = "minecraft_waypoints";
+
+class WaypointsService extends Service2 {
+  static serviceType = WAYPOINTS_SERVICE_TYPE;
+  capabilityDescription = "Minecraft waypoint storage and navigation helpers";
+  waypoints = new Map;
+  waypointsRoomId;
+  waypointsWorldId;
+  constructor(runtime) {
+    super(runtime);
+    if (!runtime) {
+      throw new Error("WaypointsService requires a runtime");
+    }
+    this.runtime = runtime;
+    this.waypointsWorldId = stringToUuid("00000000-0000-0000-0000-00000000a001");
+    this.waypointsRoomId = stringToUuid(`minecraft-waypoints:${runtime.agentId}`);
+  }
+  static async start(runtime) {
+    const service = new WaypointsService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async stop() {}
+  async initialize() {
+    if (this.runtime.ensureWorldExists) {
+      await this.runtime.ensureWorldExists({
+        id: this.waypointsWorldId,
+        name: "Minecraft Waypoints",
+        agentId: this.runtime.agentId,
+        messageServerId: stringToUuid("00000000-0000-0000-0000-000000000000"),
+        metadata: {
+          type: "minecraft",
+          description: "Persistent waypoint storage"
+        }
+      });
+    }
+    if (this.runtime.ensureRoomExists) {
+      await this.runtime.ensureRoomExists({
+        id: this.waypointsRoomId,
+        name: "Minecraft Waypoints",
+        worldId: this.waypointsWorldId,
+        source: "plugin-minecraft",
+        type: ChannelType.SELF,
+        metadata: {
+          type: "minecraft",
+          description: "Persistent waypoint storage"
+        }
+      });
+    }
+    if (this.runtime.ensureParticipantInRoom) {
+      await this.runtime.ensureParticipantInRoom(this.runtime.agentId, this.waypointsRoomId);
+    }
+    const memories = await this.runtime.getMemories({
+      roomId: this.waypointsRoomId,
+      count: 500,
+      tableName: "memories"
+    });
+    for (const m of memories) {
+      const md = m.metadata;
+      if (!md || md.type !== MemoryType.CUSTOM)
+        continue;
+      const cmd = md;
+      if (cmd.waypointType !== "minecraft_waypoint")
+        continue;
+      if (typeof cmd.waypointName !== "string")
+        continue;
+      if (typeof cmd.x !== "number" || typeof cmd.y !== "number" || typeof cmd.z !== "number")
+        continue;
+      const key = cmd.waypointName.trim().toLowerCase();
+      const createdAt = typeof m.createdAt === "number" ? new Date(m.createdAt) : new Date;
+      const id = m.id ?? stringToUuid(`mc-waypoint:${this.runtime.agentId}:${key}`);
+      this.waypoints.set(key, {
+        id,
+        name: cmd.waypointName,
+        x: cmd.x,
+        y: cmd.y,
+        z: cmd.z,
+        createdAt
+      });
+    }
+  }
+  waypointIdForKey(key) {
+    return stringToUuid(`mc-waypoint:${this.runtime.agentId}:${key}`);
+  }
+  buildWaypointMemory(_key, wp) {
+    const createdAt = Date.now();
+    const content = {
+      text: `Waypoint "${wp.name}" at (${wp.x}, ${wp.y}, ${wp.z})`,
+      source: "plugin-minecraft"
+    };
+    const metadata = {
+      type: MemoryType.CUSTOM,
+      scope: "private",
+      waypointType: "minecraft_waypoint",
+      waypointName: wp.name,
+      x: wp.x,
+      y: wp.y,
+      z: wp.z,
+      tags: ["minecraft", "waypoint"],
+      timestamp: createdAt
+    };
+    return {
+      id: wp.id,
+      entityId: this.runtime.agentId,
+      agentId: this.runtime.agentId,
+      roomId: this.waypointsRoomId,
+      worldId: this.waypointsWorldId,
+      createdAt,
+      content,
+      metadata,
+      unique: true
+    };
+  }
+  async setWaypoint(name, x, y, z9) {
+    const key = name.trim().toLowerCase();
+    const wp = {
+      id: this.waypointIdForKey(key),
+      name: name.trim(),
+      x,
+      y,
+      z: z9,
+      createdAt: new Date
+    };
+    this.waypoints.set(key, wp);
+    const memory = this.buildWaypointMemory(key, wp);
+    const existing = await this.runtime.getMemories({
+      roomId: this.waypointsRoomId,
+      count: 1,
+      tableName: "memories"
+    });
+    if (existing.some((m) => m.id === wp.id)) {
+      await this.runtime.updateMemory({
+        id: wp.id,
+        content: memory.content,
+        metadata: memory.metadata
+      });
+    } else {
+      await this.runtime.createMemory(memory, "memories", true);
+    }
+    return wp;
+  }
+  async deleteWaypoint(name) {
+    const key = name.trim().toLowerCase();
+    const wp = this.waypoints.get(key);
+    const deleted = this.waypoints.delete(key);
+    if (wp) {
+      await this.runtime.deleteMemory(wp.id);
+    }
+    return deleted;
+  }
+  getWaypoint(name) {
+    const key = name.trim().toLowerCase();
+    return this.waypoints.get(key) ?? null;
+  }
+  listWaypoints() {
+    return Array.from(this.waypoints.values()).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+  }
+}
+
+// src/actions/waypoints.ts
+function parseName(text) {
+  const name = text.trim();
+  return name.length > 0 ? name : null;
+}
+var minecraftWaypointSetAction = {
+  name: "MC_WAYPOINT_SET",
+  similes: ["MINECRAFT_WAYPOINT_SET", "SET_WAYPOINT", "SAVE_WAYPOINT"],
+  description: "Save the bot's current position as a named waypoint (message text is the name).",
+  validate: async (runtime, message) => {
+    return Boolean(runtime.getService(WAYPOINTS_SERVICE_TYPE)) && Boolean(parseName(message.content.text ?? ""));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
+    const mc = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    const name = parseName(message.content.text ?? "");
+    if (!waypoints || !mc)
+      return {
+        text: "Waypoint or Minecraft service not available",
+        success: false
+      };
+    if (!name)
+      return { text: "Missing waypoint name", success: false };
+    const ws = await mc.getWorldState();
+    const pos = ws.position;
+    if (!pos)
+      return {
+        text: "No position available (is the bot connected?)",
+        success: false
+      };
+    const wp = await waypoints.setWaypoint(name, pos.x, pos.y, pos.z);
+    const content = {
+      text: `Saved waypoint "${wp.name}" at (${wp.x.toFixed(1)}, ${wp.y.toFixed(1)}, ${wp.z.toFixed(1)}).`,
+      actions: ["MC_WAYPOINT_SET"],
+      source: message.content.source
+    };
+    await callback?.(content);
+    return {
+      text: content.text ?? "",
+      success: true,
+      data: {
+        name: wp.name,
+        x: wp.x,
+        y: wp.y,
+        z: wp.z,
+        createdAt: wp.createdAt.toISOString()
+      }
+    };
+  }
+};
+var minecraftWaypointDeleteAction = {
+  name: "MC_WAYPOINT_DELETE",
+  similes: ["MINECRAFT_WAYPOINT_DELETE", "DELETE_WAYPOINT", "REMOVE_WAYPOINT"],
+  description: "Delete a named waypoint (message text is the name).",
+  validate: async (runtime, message) => {
+    return Boolean(runtime.getService(WAYPOINTS_SERVICE_TYPE)) && Boolean(parseName(message.content.text ?? ""));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
+    const name = parseName(message.content.text ?? "");
+    if (!waypoints)
+      return { text: "Waypoints service not available", success: false };
+    if (!name)
+      return { text: "Missing waypoint name", success: false };
+    const deleted = await waypoints.deleteWaypoint(name);
+    const content = {
+      text: deleted ? `Deleted waypoint "${name}".` : `No waypoint named "${name}".`,
+      actions: ["MC_WAYPOINT_DELETE"],
+      source: message.content.source
+    };
+    await callback?.(content);
+    return { text: content.text ?? "", success: deleted, values: { deleted } };
+  }
+};
+var minecraftWaypointListAction = {
+  name: "MC_WAYPOINT_LIST",
+  similes: ["MINECRAFT_WAYPOINT_LIST", "LIST_WAYPOINTS", "SHOW_WAYPOINTS"],
+  description: "List saved waypoints.",
+  validate: async (runtime) => {
+    return Boolean(runtime.getService(WAYPOINTS_SERVICE_TYPE));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
+    if (!waypoints)
+      return { text: "Waypoints service not available", success: false };
+    const list = waypoints.listWaypoints();
+    const lines = list.map((w) => `- ${w.name}: (${w.x.toFixed(1)}, ${w.y.toFixed(1)}, ${w.z.toFixed(1)})`);
+    const content = {
+      text: list.length ? `Waypoints:
+${lines.join(`
+`)}` : "No waypoints saved.",
+      actions: ["MC_WAYPOINT_LIST"],
+      source: message.content.source
+    };
+    await callback?.(content);
+    return {
+      text: content.text ?? "",
+      success: true,
+      data: {
+        waypoints: list.map((w) => ({
+          name: w.name,
+          x: w.x,
+          y: w.y,
+          z: w.z,
+          createdAt: w.createdAt.toISOString()
+        }))
+      }
+    };
+  }
+};
+var minecraftWaypointGotoAction = {
+  name: "MC_WAYPOINT_GOTO",
+  similes: ["MINECRAFT_WAYPOINT_GOTO", "GOTO_WAYPOINT", "NAVIGATE_WAYPOINT"],
+  description: "Pathfind to a named waypoint (message text is the name).",
+  validate: async (runtime, message) => {
+    return Boolean(runtime.getService(WAYPOINTS_SERVICE_TYPE)) && Boolean(runtime.getService(MINECRAFT_SERVICE_TYPE)) && Boolean(parseName(message.content.text ?? ""));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
+    const mc = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    const name = parseName(message.content.text ?? "");
+    if (!waypoints || !mc)
+      return {
+        text: "Waypoint or Minecraft service not available",
+        success: false
+      };
+    if (!name)
+      return { text: "Missing waypoint name", success: false };
+    const wp = waypoints.getWaypoint(name);
+    if (!wp) {
+      const content2 = {
+        text: `No waypoint named "${name}".`,
+        actions: ["MC_WAYPOINT_GOTO"],
+        source: message.content.source
+      };
+      await callback?.(content2);
+      return { text: content2.text ?? "", success: false };
+    }
+    await mc.request("goto", { x: wp.x, y: wp.y, z: wp.z });
+    const content = {
+      text: `Navigating to waypoint "${wp.name}" at (${wp.x.toFixed(1)}, ${wp.y.toFixed(1)}, ${wp.z.toFixed(1)}).`,
+      actions: ["MC_WAYPOINT_GOTO"],
+      source: message.content.source
+    };
+    await callback?.(content);
+    return { text: content.text ?? "", success: true };
+  }
+};
+// src/providers/vision.ts
+var minecraftVisionProvider = {
+  name: "MC_VISION",
+  description: "Semantic environment context: biome, what I'm looking at, key nearby blocks (logs/ores), nearby entities",
+  get: async (runtime, _message, _state) => {
+    const mc = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!mc) {
+      return {
+        text: "Minecraft service not available",
+        values: { connected: false },
+        data: {}
+      };
+    }
+    const ws = await mc.getWorldState();
+    if (!ws.connected) {
+      return {
+        text: "Minecraft bot not connected",
+        values: { connected: false },
+        data: {}
+      };
+    }
+    const scan = await mc.request("scan", {
+      blocks: [
+        "oak_log",
+        "spruce_log",
+        "birch_log",
+        "jungle_log",
+        "acacia_log",
+        "dark_oak_log",
+        "stone",
+        "coal_ore",
+        "iron_ore"
+      ],
+      radius: 16,
+      maxResults: 24
+    });
+    const blocks = Array.isArray(scan.blocks) ? scan.blocks : [];
+    const pos = ws.position ? `(${ws.position.x.toFixed(1)}, ${ws.position.y.toFixed(1)}, ${ws.position.z.toFixed(1)})` : "(unknown)";
+    const biomeName = ws.biome && typeof ws.biome === "object" && "name" in ws.biome && typeof ws.biome.name === "string" ? ws.biome.name : null;
+    const lookingAt = ws.lookingAt;
+    const laName = lookingAt && typeof lookingAt.name === "string" ? lookingAt.name : null;
+    const laPos = lookingAt?.position ? {
+      x: typeof lookingAt.position.x === "number" ? lookingAt.position.x : null,
+      y: typeof lookingAt.position.y === "number" ? lookingAt.position.y : null,
+      z: typeof lookingAt.position.z === "number" ? lookingAt.position.z : null
+    } : null;
+    const lookingText = laName && laPos && laPos.x !== null && laPos.y !== null && laPos.z !== null ? `Looking at: ${laName} at (${laPos.x}, ${laPos.y}, ${laPos.z})` : "Looking at: (unknown)";
+    const entityCount = Array.isArray(ws.nearbyEntities) ? ws.nearbyEntities.length : 0;
+    return {
+      text: `Biome: ${biomeName ?? "unknown"}
+Position: ${pos}
+${lookingText}
+NearbyEntities: ${entityCount}
+NearbyBlocksFound: ${blocks.length}`,
+      values: {
+        connected: true,
+        biome: biomeName ?? null,
+        entityCount,
+        blocksFound: blocks.length
+      },
+      data: {
+        biome: ws.biome ?? null,
+        position: ws.position ?? null,
+        lookingAt: ws.lookingAt ?? null,
+        nearbyEntities: ws.nearbyEntities ?? [],
+        nearbyBlocks: blocks
+      }
+    };
+  }
+};
+// src/providers/waypoints.ts
+var minecraftWaypointsProvider = {
+  name: "MC_WAYPOINTS",
+  description: "Saved Minecraft waypoints (names and coordinates)",
+  get: async (runtime, _message, _state) => {
+    const service = runtime.getService(WAYPOINTS_SERVICE_TYPE);
+    if (!service) {
+      return {
+        text: "Waypoints service not available",
+        values: { count: 0 },
+        data: { waypoints: [] }
+      };
+    }
+    const list = service.listWaypoints();
+    const lines = list.map((w) => `- ${w.name}: (${w.x.toFixed(1)}, ${w.y.toFixed(1)}, ${w.z.toFixed(1)})`);
+    return {
+      text: list.length ? `Waypoints:
+${lines.join(`
+`)}` : "No waypoints saved.",
+      values: { count: list.length },
+      data: {
+        waypoints: list.map((w) => ({
+          name: w.name,
+          x: w.x,
+          y: w.y,
+          z: w.z,
+          createdAt: w.createdAt.toISOString()
+        }))
+      }
+    };
+  }
+};
+// src/providers/world-state.ts
+import { logger as logger4 } from "@elizaos/core";
+var minecraftWorldStateProvider = {
+  name: "MC_WORLD_STATE",
+  description: "Minecraft world state: position, health, inventory, nearby entities",
+  get: async (runtime, _message, _state) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service) {
+      return {
+        text: "Minecraft service is not available",
+        values: { connected: false },
+        data: {}
+      };
+    }
+    try {
+      const state = await service.getWorldState();
+      if (!state.connected) {
+        return {
+          text: "Minecraft bot is not connected. Use MC_CONNECT to join a server.",
+          values: { connected: false },
+          data: {}
+        };
+      }
+      const pos = state.position ? `(${state.position.x.toFixed(1)}, ${state.position.y.toFixed(1)}, ${state.position.z.toFixed(1)})` : "(unknown)";
+      const invCount = Array.isArray(state.inventory) ? state.inventory.length : 0;
+      const entCount = Array.isArray(state.nearbyEntities) ? state.nearbyEntities.length : 0;
+      return {
+        text: `Minecraft: hp=${state.health ?? "?"} food=${state.food ?? "?"} pos=${pos} invItems=${invCount} nearbyEntities=${entCount}`,
+        values: {
+          connected: true,
+          health: state.health ?? null,
+          food: state.food ?? null,
+          x: state.position?.x ?? null,
+          y: state.position?.y ?? null,
+          z: state.position?.z ?? null,
+          inventoryCount: invCount,
+          nearbyEntitiesCount: entCount
+        },
+        data: state
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger4.error(`[Minecraft] Error getting world state: ${msg}`);
+      return {
+        text: "Error getting Minecraft world state",
+        values: { connected: false, error: true },
+        data: {}
+      };
+    }
+  }
+};
+// src/index.ts
+var configSchema = z9.object({
+  MC_SERVER_PORT: z9.string().optional().default("3457"),
+  MC_HOST: z9.string().optional().default("127.0.0.1"),
+  MC_PORT: z9.string().optional().default("25565"),
+  MC_USERNAME: z9.string().optional(),
+  MC_AUTH: z9.string().optional().default("offline"),
+  MC_VERSION: z9.string().optional()
+});
+var minecraftStateProvider = minecraftWorldStateProvider;
+var minecraftPlugin = {
+  name: "plugin-minecraft",
+  description: "Minecraft automation plugin (Mineflayer bridge)",
+  config: {
+    MC_SERVER_PORT: process.env.MC_SERVER_PORT ?? "3457",
+    MC_HOST: process.env.MC_HOST ?? "127.0.0.1",
+    MC_PORT: process.env.MC_PORT ?? "25565",
+    MC_USERNAME: process.env.MC_USERNAME ?? null,
+    MC_AUTH: process.env.MC_AUTH ?? "offline",
+    MC_VERSION: process.env.MC_VERSION ?? null
+  },
+  async init(config, _runtime) {
+    logger5.info("Initializing Minecraft plugin");
+    const validatedConfig = await configSchema.parseAsync(config);
+    for (const [key, value] of Object.entries(validatedConfig)) {
+      if (value !== undefined && value !== null) {
+        process.env[key] = String(value);
+      }
+    }
+    logger5.info("Minecraft plugin initialized");
+  },
+  services: [MinecraftService, WaypointsService],
+  actions: [
+    minecraftConnectAction,
+    minecraftDisconnectAction,
+    minecraftChatAction,
+    minecraftGotoAction,
+    minecraftStopAction,
+    minecraftLookAction,
+    minecraftControlAction,
+    minecraftDigAction,
+    minecraftPlaceAction,
+    minecraftAttackAction,
+    minecraftScanAction,
+    minecraftWaypointSetAction,
+    minecraftWaypointListAction,
+    minecraftWaypointGotoAction,
+    minecraftWaypointDeleteAction
+  ],
+  providers: [
+    minecraftStateProvider,
+    minecraftWaypointsProvider,
+    minecraftVisionProvider
+  ]
+};
+var src_default = minecraftPlugin;
+export {
+  minecraftWorldStateSchema,
+  minecraftWorldStateProvider,
+  minecraftWaypointsProvider,
+  minecraftWaypointSetAction,
+  minecraftWaypointListAction,
+  minecraftWaypointGotoAction,
+  minecraftWaypointDeleteAction,
+  minecraftVisionProvider,
+  minecraftStopAction,
+  minecraftScanAction,
+  minecraftPlugin,
+  minecraftPlaceAction,
+  minecraftLookAction,
+  minecraftGotoAction,
+  minecraftDisconnectAction,
+  minecraftDigAction,
+  minecraftControlAction,
+  minecraftConnectAction,
+  minecraftChatAction,
+  minecraftAttackAction,
+  src_default as default,
+  WaypointsService,
+  WAYPOINTS_SERVICE_TYPE,
+  Session,
+  MinecraftWebSocketClient,
+  MinecraftService,
+  MinecraftProcessManager,
+  MINECRAFT_SERVICE_TYPE
+};
+
+//# debugId=BB7F89CAAD33745264756E2164756E21