@elizaos/plugin-minecraft 2.0.0-beta.1 → 2.0.11-beta.7

package/dist/index.js

@@ -1,4523 +0,0 @@
-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;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  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: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// ../../node_modules/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/node-gyp-build@4.8.4/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/.bun/node-gyp-build@4.8.4/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/.bun/bufferutil@4.1.0/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/.bun/bufferutil@4.1.0/node_modules/bufferutil/index.js
-var require_bufferutil = __commonJS((exports, module) => {
-  var __dirname = "/Users/shawwalters/eliza-workspace/milady/eliza/node_modules/.bun/bufferutil@4.1.0/node_modules/bufferutil";
-  try {
-    module.exports = require_node_gyp_build2()(__dirname);
-  } catch (e) {
-    module.exports = require_fallback();
-  }
-});
-
-// ../../node_modules/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/ws@8.20.0+4789783d1fa00420/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) {
-      this._options = options || {};
-      this._threshold = this._options.threshold !== undefined ? this._options.threshold : 1024;
-      this._maxPayload = this._options.maxPayload | 0;
-      this._isServer = !!this._options.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/.bun/utf-8-validate@5.0.10/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/.bun/utf-8-validate@5.0.10/node_modules/utf-8-validate/index.js
-var require_utf_8_validate = __commonJS((exports, module) => {
-  var __dirname = "/Users/shawwalters/eliza-workspace/milady/eliza/node_modules/.bun/utf-8-validate@5.0.10/node_modules/utf-8-validate";
-  try {
-    module.exports = require_node_gyp_build2()(__dirname);
-  } catch (e) {
-    module.exports = require_fallback2();
-  }
-});
-
-// ../../node_modules/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/ws@8.20.0+4789783d1fa00420/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 {
-        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,
-        isServer: false,
-        maxPayload: 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/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/ws@8.20.0+4789783d1fa00420/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/.bun/ws@8.20.0+4789783d1fa00420/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,
-          isServer: true,
-          maxPayload: 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 z4 } 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/.bun/ws@8.20.0+4789783d1fa00420/node_modules/ws/wrapper.mjs
-var import_stream = __toESM(require_stream(), 1);
-var import_extension = __toESM(require_extension(), 1);
-var import_permessage_deflate = __toESM(require_permessage_deflate(), 1);
-var import_receiver = __toESM(require_receiver(), 1);
-var import_sender = __toESM(require_sender(), 1);
-var import_subprotocol = __toESM(require_subprotocol(), 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) {
-    const ws = this.ws;
-    if (!ws || 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 });
-      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/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, z3) {
-    const key = name.trim().toLowerCase();
-    const wp = {
-      id: this.waypointIdForKey(key),
-      name: name.trim(),
-      x,
-      y,
-      z: z3,
-      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/utils.ts
-import { z as z3 } from "zod";
-var vec3Schema = z3.object({ x: z3.number(), y: z3.number(), z: z3.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 z4 = Number(m[3]);
-  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z4))
-    return null;
-  return { x, y, z: z4 };
-}
-
-// src/actions/helpers.ts
-var MINECRAFT_ACTION_TIMEOUT_MS = 15000;
-var MAX_MINECRAFT_TEXT_LENGTH = 2000;
-function isRecord(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function parseJsonObject(text) {
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
-    return {};
-  try {
-    const parsed = JSON.parse(trimmed);
-    return isRecord(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function readParams(options) {
-  const maybe = isRecord(options) && isRecord(options.parameters) ? options.parameters : {};
-  return maybe;
-}
-function mergedInput(message, options) {
-  return {
-    ...parseJsonObject(message.content.text ?? ""),
-    ...readParams(options)
-  };
-}
-function readString(params, ...keys) {
-  for (const key of keys) {
-    const value = params[key];
-    if (typeof value === "string" && value.trim())
-      return value.trim();
-  }
-  return null;
-}
-function readNumber(params, ...keys) {
-  for (const key of keys) {
-    const value = params[key];
-    if (typeof value === "number" && Number.isFinite(value))
-      return value;
-    if (typeof value === "string" && value.trim()) {
-      const parsed = Number(value);
-      if (Number.isFinite(parsed))
-        return parsed;
-    }
-  }
-  return null;
-}
-function readBoolean(params, ...keys) {
-  for (const key of keys) {
-    const value = params[key];
-    if (typeof value === "boolean")
-      return value;
-    if (typeof value === "string") {
-      const normalized = value.trim().toLowerCase();
-      if (normalized === "true")
-        return true;
-      if (normalized === "false")
-        return false;
-    }
-  }
-  return null;
-}
-function parseVec3(params, text) {
-  const x = readNumber(params, "x");
-  const y = readNumber(params, "y");
-  const z4 = readNumber(params, "z");
-  if (x !== null && y !== null && z4 !== null)
-    return { x, y, z: z4 };
-  return extractVec3(text);
-}
-function isPlaceFace(value) {
-  return value === "up" || value === "down" || value === "north" || value === "south" || value === "east" || value === "west";
-}
-function callbackContent(actionName, text, source) {
-  return {
-    text,
-    actions: [actionName],
-    source: typeof source === "string" ? source : undefined
-  };
-}
-async function emit(actionName, callback, text, source, result) {
-  const content = callbackContent(actionName, text.slice(0, MAX_MINECRAFT_TEXT_LENGTH), source);
-  await callback?.(content, actionName);
-  return { text: content.text ?? text, ...result };
-}
-async function withMinecraftTimeout(promise, label) {
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timed out`)), MINECRAFT_ACTION_TIMEOUT_MS))
-  ]);
-}
-
-// src/actions/mc.ts
-var ACTION_NAME = "MC";
-var MC_OPS = [
-  "connect",
-  "disconnect",
-  "goto",
-  "stop",
-  "look",
-  "control",
-  "waypoint_goto",
-  "dig",
-  "place",
-  "chat",
-  "attack",
-  "waypoint_set",
-  "waypoint_delete"
-];
-function normalizeOp(value) {
-  if (typeof value !== "string")
-    return null;
-  const normalized = value.trim().replace(/[\s-]+/g, "_").toLowerCase();
-  switch (normalized) {
-    case "connect":
-    case "join":
-    case "mc_connect":
-      return "connect";
-    case "disconnect":
-    case "leave":
-    case "quit":
-    case "mc_disconnect":
-      return "disconnect";
-    case "goto":
-    case "go_to":
-    case "move":
-    case "walk":
-    case "pathfind":
-      return "goto";
-    case "stop":
-    case "cancel":
-      return "stop";
-    case "look":
-    case "view":
-    case "turn":
-      return "look";
-    case "control":
-    case "press":
-    case "key":
-      return "control";
-    case "waypoint_goto":
-    case "waypointgoto":
-    case "navigate":
-      return "waypoint_goto";
-    case "dig":
-    case "mine":
-    case "break":
-      return "dig";
-    case "place":
-    case "build":
-      return "place";
-    case "chat":
-    case "say":
-    case "tell":
-    case "message":
-    case "mc_chat":
-      return "chat";
-    case "attack":
-    case "hit":
-    case "mc_attack":
-      return "attack";
-    case "waypoint_set":
-    case "waypointset":
-    case "save_waypoint":
-      return "waypoint_set";
-    case "waypoint_delete":
-    case "waypointdelete":
-    case "delete_waypoint":
-      return "waypoint_delete";
-    default:
-      return MC_OPS.includes(normalized) ? normalized : null;
-  }
-}
-function parseConnectOverrides(params) {
-  const out = {};
-  const host = readString(params, "host");
-  const port = readNumber(params, "port");
-  const username = readString(params, "username");
-  const auth = readString(params, "auth");
-  const version = readString(params, "version");
-  if (host)
-    out.host = host;
-  if (port !== null && Number.isInteger(port) && port > 0)
-    out.port = port;
-  if (username)
-    out.username = username;
-  if (auth === "offline" || auth === "microsoft")
-    out.auth = auth;
-  if (version)
-    out.version = version;
-  return out;
-}
-function parseControl(params, text) {
-  const control = readString(params, "control", "key", "direction");
-  const state = readBoolean(params, "state", "pressed", "enabled");
-  const durationMs = readNumber(params, "durationMs", "duration");
-  if (control && state !== null) {
-    return durationMs && durationMs > 0 ? { control, state, durationMs } : { control, state };
-  }
-  const match = text.trim().match(/^(\S+)\s+(true|false)(?:\s+(\d+))?$/i);
-  if (!match)
-    return null;
-  const parsedDuration = match[3] ? Number(match[3]) : undefined;
-  if (parsedDuration !== undefined && !Number.isFinite(parsedDuration))
-    return null;
-  return parsedDuration ? {
-    control: match[1],
-    state: match[2].toLowerCase() === "true",
-    durationMs: parsedDuration
-  } : { control: match[1], state: match[2].toLowerCase() === "true" };
-}
-function parseLook(params, text) {
-  const yaw = readNumber(params, "yaw");
-  const pitch = readNumber(params, "pitch");
-  if (yaw !== null && pitch !== null)
-    return { yaw, pitch };
-  const match = text.trim().match(/(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/);
-  if (!match)
-    return null;
-  const parsedYaw = Number(match[1]);
-  const parsedPitch = Number(match[2]);
-  if (!Number.isFinite(parsedYaw) || !Number.isFinite(parsedPitch))
-    return null;
-  return { yaw: parsedYaw, pitch: parsedPitch };
-}
-function parseWaypointName(text, params) {
-  const explicit = readString(params, "name", "waypointName", "waypoint", "target");
-  if (explicit)
-    return explicit;
-  const stripped = text.trim().replace(/\b(?:minecraft|mc|waypoints?|set|save|create|delete|remove|goto|go to|navigate|to)\b/gi, " ").replace(/\s+/g, " ").trim();
-  return stripped || null;
-}
-function parsePlaceFace(params, text) {
-  const explicit = readString(params, "face");
-  if (isPlaceFace(explicit))
-    return explicit;
-  const match = text.trim().match(/\b(up|down|north|south|east|west)\b/i);
-  if (!match)
-    return null;
-  const candidate = match[1].toLowerCase();
-  return isPlaceFace(candidate) ? candidate : null;
-}
-function parseEntityId(params, text) {
-  const fromParams = readNumber(params, "entityId", "entity");
-  if (fromParams !== null)
-    return fromParams;
-  const match = text.trim().match(/\b(?:entity\s*)?(\d+)\b/i);
-  if (!match)
-    return null;
-  const entityId = Number(match[1]);
-  return Number.isFinite(entityId) ? entityId : null;
-}
-var MC_SIMILES = [
-  "MC_ATTACK",
-  "MC_HIT",
-  "MC_BLOCK",
-  "MC_DIG",
-  "MC_PLACE",
-  "MC_BUILD",
-  "MC_MINE",
-  "MC_CHAT",
-  "MC_SAY",
-  "MC_MESSAGE",
-  "MC_CONNECT",
-  "MC_JOIN",
-  "MINECRAFT_CONNECT",
-  "MC_DISCONNECT",
-  "MC_LEAVE",
-  "MC_QUIT",
-  "MC_LOCOMOTE",
-  "MC_MOVE",
-  "MC_GOTO",
-  "MC_STOP",
-  "MC_LOOK",
-  "MC_CONTROL",
-  "MC_WAYPOINT",
-  "MC_WAYPOINT_SET",
-  "MC_WAYPOINT_DELETE",
-  "MC_WAYPOINT_GOTO"
-];
-var minecraftAction = {
-  name: ACTION_NAME,
-  contexts: ["connectors", "automation", "media", "messaging", "memory"],
-  contextGate: {
-    anyOf: ["connectors", "automation", "media", "messaging", "memory"]
-  },
-  roleGate: { minRole: "USER" },
-  similes: MC_SIMILES,
-  description: "Drive a Minecraft bot. Choose one op: connect (host?,port?,username?,auth?,version?), disconnect, goto (x,y,z), stop, look (yaw,pitch), control (control,state,durationMs?), waypoint_goto (name), dig (x,y,z), place (x,y,z,face), chat (message), attack (entityId), waypoint_set (name), waypoint_delete (name).",
-  descriptionCompressed: "minecraft ops: connect|disconnect|goto|stop|look|control|waypoint_*|dig|place|chat|attack",
-  parameters: [
-    {
-      name: "subaction",
-      description: "Operation to run.",
-      descriptionCompressed: "Op.",
-      required: true,
-      schema: { type: "string", enum: MC_OPS }
-    },
-    {
-      name: "params",
-      description: "Optional JSON object containing the fields required by the chosen op.",
-      descriptionCompressed: "Op fields.",
-      required: false,
-      schema: { type: "object" }
-    }
-  ],
-  validate: async (runtime, _message, _state) => {
-    return runtime.getService(MINECRAFT_SERVICE_TYPE) != 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 params = mergedInput(message, options);
-    const text = message.content.text ?? "";
-    const op = normalizeOp(params.op ?? params.subaction ?? params.actionType ?? params.type);
-    if (!op) {
-      return emit(ACTION_NAME, callback, `MC requires an op: one of ${MC_OPS.join("|")}.`, message.content.source, { success: false });
-    }
-    try {
-      switch (op) {
-        case "connect": {
-          const session = await withMinecraftTimeout(service.createBot(parseConnectOverrides(params)), "minecraft connect");
-          return await emit(ACTION_NAME, callback, `Connected Minecraft bot (botId=${session.botId}).`, message.content.source, {
-            success: true,
-            data: { botId: session.botId },
-            values: { connected: true }
-          });
-        }
-        case "disconnect": {
-          const session = service.getCurrentSession();
-          if (!session) {
-            return emit(ACTION_NAME, callback, "No Minecraft bot is connected.", message.content.source, { success: false });
-          }
-          await withMinecraftTimeout(service.destroyBot(session.botId), "minecraft disconnect");
-          return await emit(ACTION_NAME, callback, "Disconnected Minecraft bot.", message.content.source, { success: true, values: { connected: false } });
-        }
-        case "stop": {
-          await withMinecraftTimeout(service.request("stop", {}), "minecraft stop");
-          return await emit(ACTION_NAME, callback, "Stopped movement.", message.content.source, {
-            success: true
-          });
-        }
-        case "goto": {
-          const vec = parseVec3(params, text);
-          if (!vec) {
-            return emit(ACTION_NAME, callback, "Missing coordinates (x y z).", message.content.source, { success: false });
-          }
-          await withMinecraftTimeout(service.request("goto", { x: vec.x, y: vec.y, z: vec.z }), "minecraft goto");
-          return await emit(ACTION_NAME, callback, `Moving to (${vec.x}, ${vec.y}, ${vec.z}).`, message.content.source, { success: true });
-        }
-        case "look": {
-          const req = parseLook(params, text);
-          if (!req) {
-            return emit(ACTION_NAME, callback, "Missing yaw/pitch.", message.content.source, {
-              success: false
-            });
-          }
-          await withMinecraftTimeout(service.request("look", { yaw: req.yaw, pitch: req.pitch }), "minecraft look");
-          return await emit(ACTION_NAME, callback, "Adjusted view.", message.content.source, {
-            success: true
-          });
-        }
-        case "control": {
-          const req = parseControl(params, text);
-          if (!req) {
-            return emit(ACTION_NAME, callback, "Missing control command.", message.content.source, {
-              success: false
-            });
-          }
-          await withMinecraftTimeout(service.request("control", {
-            control: req.control,
-            state: req.state,
-            ...typeof req.durationMs === "number" ? { durationMs: Math.min(req.durationMs, 1e4) } : {}
-          }), "minecraft control");
-          return await emit(ACTION_NAME, callback, `Set control ${req.control}=${String(req.state)}${req.durationMs ? ` for ${req.durationMs}ms` : ""}.`, message.content.source, { success: true });
-        }
-        case "waypoint_goto": {
-          const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
-          if (!waypoints) {
-            return emit(ACTION_NAME, callback, "Waypoints service not available.", message.content.source, { success: false });
-          }
-          const name = parseWaypointName(text, params);
-          if (!name) {
-            return emit(ACTION_NAME, callback, "Missing waypoint name.", message.content.source, {
-              success: false
-            });
-          }
-          const wp = waypoints.getWaypoint(name);
-          if (!wp) {
-            return emit(ACTION_NAME, callback, `No waypoint named "${name}".`, message.content.source, { success: false });
-          }
-          await withMinecraftTimeout(service.request("goto", { x: wp.x, y: wp.y, z: wp.z }), "minecraft waypoint goto");
-          return await emit(ACTION_NAME, callback, `Navigating to waypoint "${wp.name}" at (${wp.x.toFixed(1)}, ${wp.y.toFixed(1)}, ${wp.z.toFixed(1)}).`, message.content.source, { success: true });
-        }
-        case "dig": {
-          const vec = parseVec3(params, text);
-          if (!vec) {
-            return emit(ACTION_NAME, callback, "Missing coordinates (x y z).", message.content.source, { success: false });
-          }
-          const data = await withMinecraftTimeout(service.request("dig", { x: vec.x, y: vec.y, z: vec.z }), "minecraft dig");
-          const blockName = typeof data.blockName === "string" ? data.blockName : "block";
-          return await emit(ACTION_NAME, callback, `Dug ${blockName} at (${vec.x}, ${vec.y}, ${vec.z}).`, message.content.source, { success: true, data });
-        }
-        case "place": {
-          const vec = parseVec3(params, text);
-          if (!vec) {
-            return emit(ACTION_NAME, callback, "Missing coordinates (x y z).", message.content.source, { success: false });
-          }
-          const face = parsePlaceFace(params, text);
-          if (!face) {
-            return emit(ACTION_NAME, callback, "Missing placement face (up/down/north/south/east/west).", message.content.source, { success: false });
-          }
-          await withMinecraftTimeout(service.request("place", { x: vec.x, y: vec.y, z: vec.z, face }), "minecraft place");
-          return await emit(ACTION_NAME, callback, `Placed block at (${vec.x}, ${vec.y}, ${vec.z}) face=${face}.`, message.content.source, { success: true });
-        }
-        case "chat": {
-          const msg = readString(params, "message", "text") ?? text.trim();
-          if (!msg) {
-            return emit(ACTION_NAME, callback, "No chat message provided.", message.content.source, { success: false });
-          }
-          const maxChatPreviewLength = 500;
-          await withMinecraftTimeout(service.chat(msg), "minecraft chat");
-          return await emit(ACTION_NAME, callback, `Sent Minecraft chat: ${msg.slice(0, maxChatPreviewLength)}`, message.content.source, { success: true, values: { sent: true } });
-        }
-        case "attack": {
-          const entityId = parseEntityId(params, text);
-          if (entityId === null) {
-            return emit(ACTION_NAME, callback, "Missing entityId.", message.content.source, {
-              success: false
-            });
-          }
-          await withMinecraftTimeout(service.request("attack", { entityId }), "minecraft attack");
-          return await emit(ACTION_NAME, callback, `Attacked entity ${entityId}.`, message.content.source, { success: true });
-        }
-        case "waypoint_set": {
-          const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
-          if (!waypoints) {
-            return emit(ACTION_NAME, callback, "Waypoints service not available.", message.content.source, { success: false });
-          }
-          const name = parseWaypointName(text, params);
-          if (!name) {
-            return emit(ACTION_NAME, callback, "Missing waypoint name.", message.content.source, {
-              success: false
-            });
-          }
-          const worldState = await withMinecraftTimeout(service.getWorldState(), "minecraft world state");
-          const pos = worldState.position;
-          if (!pos) {
-            return emit(ACTION_NAME, callback, "No position available (is the bot connected?).", message.content.source, { success: false });
-          }
-          const wp = await waypoints.setWaypoint(name, pos.x, pos.y, pos.z);
-          return await emit(ACTION_NAME, callback, `Saved waypoint "${wp.name}" at (${wp.x.toFixed(1)}, ${wp.y.toFixed(1)}, ${wp.z.toFixed(1)}).`, message.content.source, {
-            success: true,
-            data: {
-              name: wp.name,
-              x: wp.x,
-              y: wp.y,
-              z: wp.z,
-              createdAt: wp.createdAt.toISOString()
-            }
-          });
-        }
-        case "waypoint_delete": {
-          const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
-          if (!waypoints) {
-            return emit(ACTION_NAME, callback, "Waypoints service not available.", message.content.source, { success: false });
-          }
-          const name = parseWaypointName(text, params);
-          if (!name) {
-            return emit(ACTION_NAME, callback, "Missing waypoint name.", message.content.source, {
-              success: false
-            });
-          }
-          const deleted = await waypoints.deleteWaypoint(name);
-          return await emit(ACTION_NAME, callback, deleted ? `Deleted waypoint "${name}".` : `No waypoint named "${name}".`, message.content.source, { success: deleted, values: { deleted } });
-        }
-        default: {
-          const _exhaustive = op;
-          return emit(ACTION_NAME, callback, "Unknown MC op.", message.content.source, {
-            success: false
-          });
-        }
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return emit(ACTION_NAME, callback, `MC ${op} failed: ${msg}`, message.content.source, {
-        success: false,
-        data: { error: msg }
-      });
-    }
-  },
-  examples: []
-};
-// src/providers/vision.ts
-var MAX_NEARBY_ENTITIES_IN_STATE = 24;
-var MAX_NEARBY_BLOCKS_IN_STATE = 24;
-var minecraftVisionProvider = {
-  name: "MC_VISION",
-  description: "Semantic environment context: biome, what I'm looking at, key nearby blocks (logs/ores), nearby entities",
-  descriptionCompressed: "Read live Minecraft biome, looked-at block, nearby blocks, and nearby entities.",
-  dynamic: true,
-  contexts: ["automation", "agent_internal"],
-  contextGate: { anyOf: ["automation", "agent_internal"] },
-  cacheStable: false,
-  cacheScope: "turn",
-  get: async (runtime, _message, _state) => {
-    const mc = runtime.getService(MINECRAFT_SERVICE_TYPE);
-    if (!mc) {
-      return {
-        text: "Minecraft service not available",
-        values: { connected: false },
-        data: {}
-      };
-    }
-    try {
-      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: MAX_NEARBY_BLOCKS_IN_STATE
-      });
-      const blocks = Array.isArray(scan.blocks) ? scan.blocks.slice(0, MAX_NEARBY_BLOCKS_IN_STATE) : [];
-      const nearbyEntities = Array.isArray(ws.nearbyEntities) ? ws.nearbyEntities.slice(0, MAX_NEARBY_ENTITIES_IN_STATE) : [];
-      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,
-          shownEntityCount: nearbyEntities.length,
-          blocksFound: blocks.length
-        },
-        data: {
-          biome: ws.biome ?? null,
-          position: ws.position ?? null,
-          lookingAt: ws.lookingAt ?? null,
-          nearbyEntities,
-          nearbyBlocks: blocks
-        }
-      };
-    } catch (error) {
-      return {
-        text: "Unable to load Minecraft vision context",
-        values: { connected: false, error: true },
-        data: { error: error instanceof Error ? error.message : String(error) }
-      };
-    }
-  }
-};
-// src/providers/waypoints.ts
-var MAX_WAYPOINTS_IN_STATE = 50;
-var minecraftWaypointsProvider = {
-  name: "MC_WAYPOINTS",
-  description: "Saved Minecraft waypoints (names and coordinates)",
-  descriptionCompressed: "List saved Minecraft waypoint names and coordinates.",
-  dynamic: true,
-  contexts: ["automation", "agent_internal"],
-  contextGate: { anyOf: ["automation", "agent_internal"] },
-  cacheStable: false,
-  cacheScope: "turn",
-  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: [] }
-      };
-    }
-    try {
-      const list = service.listWaypoints();
-      const shown = list.slice(0, MAX_WAYPOINTS_IN_STATE);
-      const truncated = list.length > shown.length;
-      const lines = shown.map((w) => `- ${w.name}: (${w.x.toFixed(1)}, ${w.y.toFixed(1)}, ${w.z.toFixed(1)})`);
-      return {
-        text: list.length ? `Waypoints (${shown.length}/${list.length}${truncated ? ", truncated" : ""}):
-${lines.join(`
-`)}` : "No waypoints saved.",
-        values: { count: list.length, shown: shown.length, truncated },
-        data: {
-          waypoints: shown.map((w) => ({
-            name: w.name,
-            x: w.x,
-            y: w.y,
-            z: w.z,
-            createdAt: w.createdAt.toISOString()
-          }))
-        }
-      };
-    } catch (error) {
-      return {
-        text: "Unable to load Minecraft waypoints",
-        values: { count: 0, error: true },
-        data: { waypoints: [], error: error instanceof Error ? error.message : String(error) }
-      };
-    }
-  }
-};
-// src/providers/world-state.ts
-import {
-  logger as logger4
-} from "@elizaos/core";
-var MAX_INVENTORY_ROWS_IN_STATE = 36;
-var MAX_ENTITY_ROWS_IN_STATE = 24;
-function isRecord2(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function pickInventoryRows(inventory) {
-  if (!Array.isArray(inventory))
-    return [];
-  const rows = [];
-  for (const item of inventory) {
-    if (!isRecord2(item))
-      continue;
-    const slot = typeof item.slot === "number" ? item.slot : null;
-    const count = typeof item.count === "number" ? item.count : null;
-    const name = typeof item.displayName === "string" ? item.displayName : typeof item.name === "string" ? item.name : null;
-    if (slot === null || count === null || !name)
-      continue;
-    rows.push({ slot, name, count });
-  }
-  return rows;
-}
-function pickEntityRows(nearby) {
-  if (!Array.isArray(nearby))
-    return [];
-  const rows = [];
-  for (const ent of nearby) {
-    if (!isRecord2(ent))
-      continue;
-    const id = typeof ent.id === "number" ? ent.id : null;
-    const type = typeof ent.type === "string" ? ent.type : null;
-    const username = typeof ent.username === "string" ? ent.username : null;
-    const entName = typeof ent.name === "string" ? ent.name : null;
-    const name = username ?? entName ?? type ?? "unknown";
-    const pos = isRecord2(ent.position) ? ent.position : null;
-    const x = pos && typeof pos.x === "number" ? pos.x : null;
-    const y = pos && typeof pos.y === "number" ? pos.y : null;
-    const z4 = pos && typeof pos.z === "number" ? pos.z : null;
-    if (id === null || !type || x === null || y === null || z4 === null)
-      continue;
-    rows.push({
-      id,
-      type,
-      name,
-      x: Math.round(x * 10) / 10,
-      y: Math.round(y * 10) / 10,
-      z: Math.round(z4 * 10) / 10
-    });
-  }
-  return rows;
-}
-var minecraftWorldStateProvider = {
-  name: "MC_WORLD_STATE",
-  description: "Minecraft world state: connection, position, health, inventory, nearby entities",
-  descriptionCompressed: "Read live Minecraft connection, position, health, inventory, and nearby entities.",
-  dynamic: true,
-  contexts: ["automation", "agent_internal"],
-  contextGate: { anyOf: ["automation", "agent_internal"] },
-  cacheStable: false,
-  cacheScope: "turn",
-  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 inventoryRows = pickInventoryRows(state.inventory).slice(0, MAX_INVENTORY_ROWS_IN_STATE);
-      const entityRows = pickEntityRows(state.nearbyEntities).slice(0, MAX_ENTITY_ROWS_IN_STATE);
-      const headerLines = [
-        `Minecraft: hp=${state.health ?? "?"} food=${state.food ?? "?"} pos=${pos} invItems=${inventoryRows.length} nearbyEntities=${entityRows.length}`
-      ];
-      if (inventoryRows.length > 0) {
-        headerLines.push(JSON.stringify({ inventory: inventoryRows }));
-      }
-      if (entityRows.length > 0) {
-        headerLines.push(JSON.stringify({ nearbyEntities: entityRows }));
-      }
-      return {
-        text: headerLines.join(`
-`),
-        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: inventoryRows.length,
-          nearbyEntitiesCount: entityRows.length
-        },
-        data: {
-          ...state,
-          inventory: inventoryRows,
-          nearbyEntities: entityRows
-        }
-      };
-    } 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 = z4.object({
-  MC_SERVER_PORT: z4.string().optional().default("3457"),
-  MC_HOST: z4.string().optional().default("127.0.0.1"),
-  MC_PORT: z4.string().optional().default("25565"),
-  MC_USERNAME: z4.string().optional(),
-  MC_AUTH: z4.string().optional().default("offline"),
-  MC_VERSION: z4.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: [minecraftAction],
-  providers: [minecraftStateProvider, minecraftWaypointsProvider, minecraftVisionProvider]
-};
-var src_default = minecraftPlugin;
-export {
-  minecraftWorldStateSchema,
-  minecraftWorldStateProvider,
-  minecraftWaypointsProvider,
-  minecraftVisionProvider,
-  minecraftPlugin,
-  minecraftAction,
-  src_default as default,
-  WaypointsService,
-  WAYPOINTS_SERVICE_TYPE,
-  Session,
-  MinecraftWebSocketClient,
-  MinecraftService,
-  MinecraftProcessManager,
-  MINECRAFT_SERVICE_TYPE
-};
-
-//# debugId=2AA030689A95D7BF64756E2164756E21