@playcademy/vite-plugin 0.0.1-beta.16 → 0.0.1-beta.18

package/dist/index.js

@@ -41067,9 +41067,8 @@ import { constants, KeyObject as KeyObject3 } from "node:crypto";
 import * as crypto5 from "node:crypto";
 import { promisify } from "node:util";
 import { KeyObject as KeyObject4, createSecretKey } from "node:crypto";
+import http from "node:http";
 import crypto7 from "node:crypto";
-import fs32 from "node:fs";
-import path22 from "node:path";
 var __create2 = Object.create;
 var __getProtoOf2 = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
@@ -43841,7 +43840,7 @@ ${file}:${line2}:${column}: ERROR: ${pluginText}${e.text}`;
       result = `(?${regexp.flags})${result}`;
     return result;
   }
-  var fs33 = __require2("fs");
+  var fs32 = __require2("fs");
   var os2 = __require2("os");
   var path3 = __require2("path");
   var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
@@ -43906,14 +43905,14 @@ ${file}:${line2}:${column}: ERROR: ${pluginText}${e.text}`;
       for (const unixKey in knownUnixlikePackages) {
         try {
           const pkg = knownUnixlikePackages[unixKey];
-          if (fs33.existsSync(path3.join(nodeModulesDirectory, pkg)))
+          if (fs32.existsSync(path3.join(nodeModulesDirectory, pkg)))
             return pkg;
         } catch {}
       }
       for (const windowsKey in knownWindowsPackages) {
         try {
           const pkg = knownWindowsPackages[windowsKey];
-          if (fs33.existsSync(path3.join(nodeModulesDirectory, pkg)))
+          if (fs32.existsSync(path3.join(nodeModulesDirectory, pkg)))
             return pkg;
         } catch {}
       }
@@ -43926,7 +43925,7 @@ ${file}:${line2}:${column}: ERROR: ${pluginText}${e.text}`;
   }
   function generateBinPath() {
     if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
-      if (!fs33.existsSync(ESBUILD_BINARY_PATH)) {
+      if (!fs32.existsSync(ESBUILD_BINARY_PATH)) {
         console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
       } else {
         return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
@@ -43938,7 +43937,7 @@ ${file}:${line2}:${column}: ERROR: ${pluginText}${e.text}`;
       binPath = __require2.resolve(`${pkg}/${subpath}`);
     } catch (e) {
       binPath = downloadedBinPath(pkg, subpath);
-      if (!fs33.existsSync(binPath)) {
+      if (!fs32.existsSync(binPath)) {
         try {
           __require2.resolve(pkg);
         } catch {
@@ -44014,10 +44013,10 @@ for your current platform.`);
       if (pnpapi) {
         const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
         const binTargetPath = path3.join(root, "node_modules", ".cache", "esbuild", `pnpapi-${pkg.replace("/", "-")}-0.25.5-${path3.basename(subpath)}`);
-        if (!fs33.existsSync(binTargetPath)) {
-          fs33.mkdirSync(path3.dirname(binTargetPath), { recursive: true });
-          fs33.copyFileSync(binPath, binTargetPath);
-          fs33.chmodSync(binTargetPath, 493);
+        if (!fs32.existsSync(binTargetPath)) {
+          fs32.mkdirSync(path3.dirname(binTargetPath), { recursive: true });
+          fs32.copyFileSync(binPath, binTargetPath);
+          fs32.chmodSync(binTargetPath, 493);
         }
         return { binPath: binTargetPath, isWASM };
       }
@@ -44026,7 +44025,7 @@ for your current platform.`);
   }
   var child_process = __require2("child_process");
   var crypto32 = __require2("crypto");
-  var path23 = __require2("path");
+  var path22 = __require2("path");
   var fs222 = __require2("fs");
   var os22 = __require2("os");
   var tty2 = __require2("tty");
@@ -44043,7 +44042,7 @@ for your current platform.`);
   var _a;
   var isInternalWorkerThread = ((_a = worker_threads == null ? undefined : worker_threads.workerData) == null ? undefined : _a.esbuildVersion) === "0.25.5";
   var esbuildCommandAndArgs = () => {
-    if ((!ESBUILD_BINARY_PATH || false) && (path23.basename(__filename2) !== "main.js" || path23.basename(__dirname2) !== "lib")) {
+    if ((!ESBUILD_BINARY_PATH || false) && (path22.basename(__filename2) !== "main.js" || path22.basename(__dirname2) !== "lib")) {
       throw new Error(`The esbuild JavaScript API cannot be bundled. Please mark the "esbuild" package as external so it's not included in the bundle.
 
 More information: The file containing the code for esbuild's JavaScript API (${__filename2}) does not appear to be inside the esbuild package on the file system, which usually means that the esbuild package was bundled into another file. This is problematic because the API needs to run a binary executable inside the esbuild package which is located using a relative path from the API code to the executable. If the esbuild package is bundled, the relative path will be incorrect and the executable won't be found.`);
@@ -44339,7 +44338,7 @@ More information: The file containing the code for esbuild's JavaScript API (${_
     afterClose(null);
   };
   var randomFileName = () => {
-    return path23.join(os22.tmpdir(), `esbuild-${crypto32.randomBytes(32).toString("hex")}`);
+    return path22.join(os22.tmpdir(), `esbuild-${crypto32.randomBytes(32).toString("hex")}`);
   };
   var workerThreadService = null;
   var startWorkerThreadService = (worker_threads2) => {
@@ -46918,11 +46917,11 @@ var require_node22 = __commonJS2((exports) => {
   var require_source_map_support = __commonJS22((exports2, module22) => {
     var SourceMapConsumer = require_source_map().SourceMapConsumer;
     var path3 = __require2("path");
-    var fs33;
+    var fs32;
     try {
-      fs33 = __require2("fs");
-      if (!fs33.existsSync || !fs33.readFileSync) {
-        fs33 = null;
+      fs32 = __require2("fs");
+      if (!fs32.existsSync || !fs32.readFileSync) {
+        fs32 = null;
       }
     } catch (err2) {}
     var bufferFrom = require_buffer_from();
@@ -46960,30 +46959,30 @@ var require_node22 = __commonJS2((exports) => {
       };
     }
     var retrieveFile = handlerExec(retrieveFileHandlers);
-    retrieveFileHandlers.push(function(path23) {
-      path23 = path23.trim();
-      if (/^file:/.test(path23)) {
-        path23 = path23.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
+    retrieveFileHandlers.push(function(path22) {
+      path22 = path22.trim();
+      if (/^file:/.test(path22)) {
+        path22 = path22.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
           return drive ? "" : "/";
         });
       }
-      if (path23 in fileContentsCache) {
-        return fileContentsCache[path23];
+      if (path22 in fileContentsCache) {
+        return fileContentsCache[path22];
       }
       var contents = "";
       try {
-        if (!fs33) {
+        if (!fs32) {
           var xhr = new XMLHttpRequest;
-          xhr.open("GET", path23, false);
+          xhr.open("GET", path22, false);
           xhr.send(null);
           if (xhr.readyState === 4 && xhr.status === 200) {
             contents = xhr.responseText;
           }
-        } else if (fs33.existsSync(path23)) {
-          contents = fs33.readFileSync(path23, "utf8");
+        } else if (fs32.existsSync(path22)) {
+          contents = fs32.readFileSync(path22, "utf8");
         }
       } catch (er2) {}
-      return fileContentsCache[path23] = contents;
+      return fileContentsCache[path22] = contents;
     });
     function supportRelativeURL(file, url) {
       if (!file)
@@ -47244,9 +47243,9 @@ var require_node22 = __commonJS2((exports) => {
         var line2 = +match[2];
         var column = +match[3];
         var contents = fileContentsCache[source];
-        if (!contents && fs33 && fs33.existsSync(source)) {
+        if (!contents && fs32 && fs32.existsSync(source)) {
           try {
-            contents = fs33.readFileSync(source, "utf8");
+            contents = fs32.readFileSync(source, "utf8");
           } catch (er2) {
             contents = "";
           }
@@ -47790,13 +47789,13 @@ If you have no idea what this means or what Pirates is, let me explain: Pirates
   var require_filesystem = __commonJS22((exports2) => {
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.removeExtension = exports2.fileExistsAsync = exports2.readJsonFromDiskAsync = exports2.readJsonFromDiskSync = exports2.fileExistsSync = undefined;
-    var fs33 = __require2("fs");
+    var fs32 = __require2("fs");
     function fileExistsSync(path3) {
-      if (!fs33.existsSync(path3)) {
+      if (!fs32.existsSync(path3)) {
         return false;
       }
       try {
-        var stats = fs33.statSync(path3);
+        var stats = fs32.statSync(path3);
         return stats.isFile();
       } catch (err2) {
         return false;
@@ -47804,14 +47803,14 @@ If you have no idea what this means or what Pirates is, let me explain: Pirates
     }
     exports2.fileExistsSync = fileExistsSync;
     function readJsonFromDiskSync(packageJsonPath) {
-      if (!fs33.existsSync(packageJsonPath)) {
+      if (!fs32.existsSync(packageJsonPath)) {
         return;
       }
       return __require2(packageJsonPath);
     }
     exports2.readJsonFromDiskSync = readJsonFromDiskSync;
     function readJsonFromDiskAsync(path3, callback) {
-      fs33.readFile(path3, "utf8", function(err2, result) {
+      fs32.readFile(path3, "utf8", function(err2, result) {
         if (err2 || !result) {
           return callback();
         }
@@ -47820,8 +47819,8 @@ If you have no idea what this means or what Pirates is, let me explain: Pirates
       });
     }
     exports2.readJsonFromDiskAsync = readJsonFromDiskAsync;
-    function fileExistsAsync(path23, callback2) {
-      fs33.stat(path23, function(err2, stats) {
+    function fileExistsAsync(path22, callback2) {
+      fs32.stat(path22, function(err2, stats) {
         if (err2) {
           return callback2(undefined, false);
         }
@@ -49264,7 +49263,7 @@ If you have no idea what this means or what Pirates is, let me explain: Pirates
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.loadTsconfig = exports2.walkForTsConfig = exports2.tsConfigLoader = undefined;
     var path3 = __require2("path");
-    var fs33 = __require2("fs");
+    var fs32 = __require2("fs");
     var JSON5 = require_lib3();
     var StripBom = require_strip_bom();
     function tsConfigLoader(_a) {
@@ -49293,10 +49292,10 @@ If you have no idea what this means or what Pirates is, let me explain: Pirates
     }
     function resolveConfigPath(cwd, filename) {
       if (filename) {
-        var absolutePath = fs33.lstatSync(filename).isDirectory() ? path3.resolve(filename, "./tsconfig.json") : path3.resolve(cwd, filename);
+        var absolutePath = fs32.lstatSync(filename).isDirectory() ? path3.resolve(filename, "./tsconfig.json") : path3.resolve(cwd, filename);
         return absolutePath;
       }
-      if (fs33.statSync(cwd).isFile()) {
+      if (fs32.statSync(cwd).isFile()) {
         return path3.resolve(cwd);
       }
       var configAbsolutePath = walkForTsConfig(cwd);
@@ -49304,7 +49303,7 @@ If you have no idea what this means or what Pirates is, let me explain: Pirates
     }
     function walkForTsConfig(directory, readdirSync) {
       if (readdirSync === undefined) {
-        readdirSync = fs33.readdirSync;
+        readdirSync = fs32.readdirSync;
       }
       var files = readdirSync(directory);
       var filesToCheck = ["tsconfig.json", "jsconfig.json"];
@@ -49323,11 +49322,11 @@ If you have no idea what this means or what Pirates is, let me explain: Pirates
     exports2.walkForTsConfig = walkForTsConfig;
     function loadTsconfig(configFilePath, existsSync2, readFileSync2) {
       if (existsSync2 === undefined) {
-        existsSync2 = fs33.existsSync;
+        existsSync2 = fs32.existsSync;
       }
       if (readFileSync2 === undefined) {
         readFileSync2 = function(filename) {
-          return fs33.readFileSync(filename, "utf8");
+          return fs32.readFileSync(filename, "utf8");
         };
       }
       if (!existsSync2(configFilePath)) {
@@ -50957,7 +50956,7 @@ function mapColumnsInSQLToAlias2(query, alias) {
 }
 function mapResultRow2(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
-  const result = columns.reduce((result2, { path: path23, field }, columnIndex) => {
+  const result = columns.reduce((result2, { path: path22, field }, columnIndex) => {
     let decoder;
     if (is2(field, Column2)) {
       decoder = field;
@@ -50967,8 +50966,8 @@ function mapResultRow2(columns, row, joinsNotNullableMap) {
       decoder = field.sql.decoder;
     }
     let node = result2;
-    for (const [pathChunkIndex, pathChunk] of path23.entries()) {
-      if (pathChunkIndex < path23.length - 1) {
+    for (const [pathChunkIndex, pathChunk] of path22.entries()) {
+      if (pathChunkIndex < path22.length - 1) {
         if (!(pathChunk in node)) {
           node[pathChunk] = {};
         }
@@ -50976,8 +50975,8 @@ function mapResultRow2(columns, row, joinsNotNullableMap) {
       } else {
         const rawValue = row[columnIndex];
         const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-        if (joinsNotNullableMap && is2(field, Column2) && path23.length === 2) {
-          const objectName = path23[0];
+        if (joinsNotNullableMap && is2(field, Column2) && path22.length === 2) {
+          const objectName = path22[0];
           if (!(objectName in nullifyMap)) {
             nullifyMap[objectName] = value === null ? getTableName2(field.table) : false;
           } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName2(field.table)) {
@@ -55789,7 +55788,7 @@ var init_api = __esm(() => {
     "../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports) {
       var pathModule = __require22("path");
       var isWindows = process.platform === "win32";
-      var fs33 = __require22("fs");
+      var fs32 = __require22("fs");
       var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
       function rethrow() {
         var callback;
@@ -55854,7 +55853,7 @@ var init_api = __esm(() => {
           base = m4[0];
           previous = "";
           if (isWindows && !knownHard[base]) {
-            fs33.lstatSync(base);
+            fs32.lstatSync(base);
             knownHard[base] = true;
           }
         }
@@ -55872,7 +55871,7 @@ var init_api = __esm(() => {
           if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
             resolvedLink = cache[base];
           } else {
-            var stat = fs33.lstatSync(base);
+            var stat = fs32.lstatSync(base);
             if (!stat.isSymbolicLink()) {
               knownHard[base] = true;
               if (cache)
@@ -55887,8 +55886,8 @@ var init_api = __esm(() => {
               }
             }
             if (linkTarget === null) {
-              fs33.statSync(base);
-              linkTarget = fs33.readlinkSync(base);
+              fs32.statSync(base);
+              linkTarget = fs32.readlinkSync(base);
             }
             resolvedLink = pathModule.resolve(previous, linkTarget);
             if (cache)
@@ -55925,7 +55924,7 @@ var init_api = __esm(() => {
           base = m4[0];
           previous = "";
           if (isWindows && !knownHard[base]) {
-            fs33.lstat(base, function(err2) {
+            fs32.lstat(base, function(err2) {
               if (err2)
                 return cb(err2);
               knownHard[base] = true;
@@ -55953,7 +55952,7 @@ var init_api = __esm(() => {
           if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
             return gotResolvedLink(cache[base]);
           }
-          return fs33.lstat(base, gotStat);
+          return fs32.lstat(base, gotStat);
         }
         function gotStat(err2, stat) {
           if (err2)
@@ -55970,10 +55969,10 @@ var init_api = __esm(() => {
               return gotTarget(null, seenLinks[id], base);
             }
           }
-          fs33.stat(base, function(err22) {
+          fs32.stat(base, function(err22) {
             if (err22)
               return cb(err22);
-            fs33.readlink(base, function(err3, target) {
+            fs32.readlink(base, function(err3, target) {
               if (!isWindows)
                 seenLinks[id] = target;
               gotTarget(err3, target);
@@ -56003,9 +56002,9 @@ var init_api = __esm(() => {
       realpath.realpathSync = realpathSync;
       realpath.monkeypatch = monkeypatch;
       realpath.unmonkeypatch = unmonkeypatch;
-      var fs33 = __require22("fs");
-      var origRealpath = fs33.realpath;
-      var origRealpathSync = fs33.realpathSync;
+      var fs32 = __require22("fs");
+      var origRealpath = fs32.realpath;
+      var origRealpathSync = fs32.realpathSync;
       var version22 = process.version;
       var ok = /^v[0-5]\./.test(version22);
       var old = require_old();
@@ -56043,12 +56042,12 @@ var init_api = __esm(() => {
         }
       }
       function monkeypatch() {
-        fs33.realpath = realpath;
-        fs33.realpathSync = realpathSync;
+        fs32.realpath = realpath;
+        fs32.realpathSync = realpathSync;
       }
       function unmonkeypatch() {
-        fs33.realpath = origRealpath;
-        fs33.realpathSync = origRealpathSync;
+        fs32.realpath = origRealpath;
+        fs32.realpathSync = origRealpathSync;
       }
     }
   });
@@ -56274,8 +56273,8 @@ var init_api = __esm(() => {
         return new Minimatch2(pattern, options).match(p3);
       };
       module2.exports = minimatch2;
-      var path23 = require_path2();
-      minimatch2.sep = path23.sep;
+      var path22 = require_path2();
+      minimatch2.sep = path22.sep;
       var GLOBSTAR2 = Symbol("globstar **");
       minimatch2.GLOBSTAR = GLOBSTAR2;
       var expand2 = require_brace_expansion3();
@@ -56788,8 +56787,8 @@ globstar while`, file, fr, pattern, pr2, swallowee);
           if (f3 === "/" && partial)
             return true;
           const options = this.options;
-          if (path23.sep !== "/") {
-            f3 = f3.split(path23.sep).join("/");
+          if (path22.sep !== "/") {
+            f3 = f3.split(path22.sep).join("/");
           }
           f3 = f3.split(slashSplit);
           this.debug(this.pattern, "split", f3);
@@ -56879,8 +56878,8 @@ globstar while`, file, fr, pattern, pr2, swallowee);
       function ownProp(obj, field) {
         return Object.prototype.hasOwnProperty.call(obj, field);
       }
-      var fs33 = __require22("fs");
-      var path23 = __require22("path");
+      var fs32 = __require22("fs");
+      var path22 = __require22("path");
       var minimatch2 = require_minimatch2();
       var isAbsolute2 = __require22("path").isAbsolute;
       var Minimatch2 = minimatch2.Minimatch;
@@ -56938,7 +56937,7 @@ globstar while`, file, fr, pattern, pr2, swallowee);
         self2.stat = !!options.stat;
         self2.noprocess = !!options.noprocess;
         self2.absolute = !!options.absolute;
-        self2.fs = options.fs || fs33;
+        self2.fs = options.fs || fs32;
         self2.maxLength = options.maxLength || Infinity;
         self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
         self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
@@ -56947,13 +56946,13 @@ globstar while`, file, fr, pattern, pr2, swallowee);
         self2.changedCwd = false;
         var cwd = process.cwd();
         if (!ownProp(options, "cwd"))
-          self2.cwd = path23.resolve(cwd);
+          self2.cwd = path22.resolve(cwd);
         else {
-          self2.cwd = path23.resolve(options.cwd);
+          self2.cwd = path22.resolve(options.cwd);
           self2.changedCwd = self2.cwd !== cwd;
         }
-        self2.root = options.root || path23.resolve(self2.cwd, "/");
-        self2.root = path23.resolve(self2.root);
+        self2.root = options.root || path22.resolve(self2.cwd, "/");
+        self2.root = path22.resolve(self2.root);
         self2.cwdAbs = isAbsolute2(self2.cwd) ? self2.cwd : makeAbs(self2, self2.cwd);
         self2.nomount = !!options.nomount;
         if (process.platform === "win32") {
@@ -57035,13 +57034,13 @@ globstar while`, file, fr, pattern, pr2, swallowee);
       function makeAbs(self2, f3) {
         var abs = f3;
         if (f3.charAt(0) === "/") {
-          abs = path23.join(self2.root, f3);
+          abs = path22.join(self2.root, f3);
         } else if (isAbsolute2(f3) || f3 === "") {
           abs = f3;
         } else if (self2.changedCwd) {
-          abs = path23.resolve(self2.cwd, f3);
+          abs = path22.resolve(self2.cwd, f3);
         } else {
-          abs = path23.resolve(f3);
+          abs = path22.resolve(f3);
         }
         if (process.platform === "win32")
           abs = abs.replace(/\\/g, "/");
@@ -57072,7 +57071,7 @@ globstar while`, file, fr, pattern, pr2, swallowee);
       var Minimatch2 = minimatch2.Minimatch;
       var Glob = require_glob2().Glob;
       var util22 = __require22("util");
-      var path23 = __require22("path");
+      var path22 = __require22("path");
       var assert2 = __require22("assert");
       var isAbsolute2 = __require22("path").isAbsolute;
       var common = require_common2();
@@ -57202,7 +57201,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
                 e = prefix2 + e;
             }
             if (e.charAt(0) === "/" && !this.nomount) {
-              e = path23.join(this.root, e);
+              e = path22.join(this.root, e);
             }
             this._emitMatch(index6, e);
           }
@@ -57351,9 +57350,9 @@ See: https://github.com/isaacs/node-glob/issues/167`);
         if (prefix2 && isAbsolute2(prefix2) && !this.nomount) {
           var trail = /[\/\\]$/.test(prefix2);
           if (prefix2.charAt(0) === "/") {
-            prefix2 = path23.join(this.root, prefix2);
+            prefix2 = path22.join(this.root, prefix2);
           } else {
-            prefix2 = path23.resolve(this.root, prefix2);
+            prefix2 = path22.resolve(this.root, prefix2);
             if (trail)
               prefix2 += "/";
           }
@@ -57540,7 +57539,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
       var Minimatch2 = minimatch2.Minimatch;
       var inherits = require_inherits2();
       var EE = __require22("events").EventEmitter;
-      var path23 = __require22("path");
+      var path22 = __require22("path");
       var assert2 = __require22("assert");
       var isAbsolute2 = __require22("path").isAbsolute;
       var globSync = require_sync();
@@ -57823,7 +57822,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
                 e = prefix2 + e;
             }
             if (e.charAt(0) === "/" && !this.nomount) {
-              e = path23.join(this.root, e);
+              e = path22.join(this.root, e);
             }
             this._emitMatch(index6, e);
           }
@@ -58010,9 +58009,9 @@ See: https://github.com/isaacs/node-glob/issues/167`);
         if (prefix2 && isAbsolute2(prefix2) && !this.nomount) {
           var trail = /[\/\\]$/.test(prefix2);
           if (prefix2.charAt(0) === "/") {
-            prefix2 = path23.join(this.root, prefix2);
+            prefix2 = path22.join(this.root, prefix2);
           } else {
-            prefix2 = path23.resolve(this.root, prefix2);
+            prefix2 = path22.resolve(this.root, prefix2);
             if (trail)
               prefix2 += "/";
           }
@@ -58975,8 +58974,8 @@ See: https://github.com/isaacs/node-glob/issues/167`);
       };
       overrideErrorMap = errorMap;
       makeIssue = (params) => {
-        const { data, path: path23, errorMaps, issueData } = params;
-        const fullPath = [...path23, ...issueData.path || []];
+        const { data, path: path22, errorMaps, issueData } = params;
+        const fullPath = [...path22, ...issueData.path || []];
         const fullIssue = {
           ...issueData,
           path: fullPath
@@ -59067,11 +59066,11 @@ See: https://github.com/isaacs/node-glob/issues/167`);
         errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === undefined ? undefined : message.message;
       })(errorUtil || (errorUtil = {}));
       ParseInputLazyPath = class {
-        constructor(parent, value, path23, key) {
+        constructor(parent, value, path22, key) {
           this._cachedPath = [];
           this.parent = parent;
           this.data = value;
-          this._path = path23;
+          this._path = path22;
           this._key = key;
         }
         get path() {
@@ -92880,6 +92879,2821 @@ var init_dist2 = __esm(() => {
     console.debug = log3("DEBUG");
   }
 });
+var require_constants3 = __commonJS2((exports, module2) => {
+  var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
+  var hasBlob = typeof Blob !== "undefined";
+  if (hasBlob)
+    BINARY_TYPES.push("blob");
+  module2.exports = {
+    BINARY_TYPES,
+    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: () => {}
+  };
+});
+var require_buffer_util = __commonJS2((exports, module2) => {
+  var { EMPTY_BUFFER } = require_constants3();
+  var FastBuffer = Buffer[Symbol.species];
+  function concat2(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 i3 = 0;i3 < list.length; i3++) {
+      const buf = list[i3];
+      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 i3 = 0;i3 < length; i3++) {
+      output[offset + i3] = source[i3] ^ mask[i3 & 3];
+    }
+  }
+  function _unmask(buffer, mask) {
+    for (let i3 = 0;i3 < buffer.length; i3++) {
+      buffer[i3] ^= mask[i3 & 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;
+  }
+  module2.exports = {
+    concat: concat2,
+    mask: _mask,
+    toArrayBuffer,
+    toBuffer,
+    unmask: _unmask
+  };
+  if (!process.env.WS_NO_BUFFER_UTIL) {
+    try {
+      const bufferUtil = (() => {
+        throw new Error("Cannot require module bufferutil");
+      })();
+      module2.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);
+      };
+      module2.exports.unmask = function(buffer, mask) {
+        if (buffer.length < 32)
+          _unmask(buffer, mask);
+        else
+          bufferUtil.unmask(buffer, mask);
+      };
+    } catch (e) {}
+  }
+});
+var require_limiter = __commonJS2((exports, module2) => {
+  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]);
+      }
+    }
+  }
+  module2.exports = Limiter;
+});
+var require_permessage_deflate = __commonJS2((exports, module2) => {
+  var zlib = __require2("zlib");
+  var bufferUtil = require_buffer_util();
+  var Limiter = require_limiter();
+  var { kStatusCode } = require_constants3();
+  var FastBuffer = Buffer[Symbol.species];
+  var TRAILER = Buffer.from([0, 0, 255, 255]);
+  var kPerMessageDeflate = Symbol("permessage-deflate");
+  var kTotalLength = Symbol("total-length");
+  var kCallback = Symbol("callback");
+  var kBuffers = Symbol("buffers");
+  var kError = Symbol("error");
+  var zlibLimiter;
+
+  class PerMessageDeflate {
+    constructor(options, isServer, maxPayload) {
+      this._maxPayload = maxPayload | 0;
+      this._options = options || {};
+      this._threshold = this._options.threshold !== undefined ? this._options.threshold : 1024;
+      this._isServer = !!isServer;
+      this._deflate = null;
+      this._inflate = null;
+      this.params = null;
+      if (!zlibLimiter) {
+        const concurrency = this._options.concurrencyLimit !== undefined ? this._options.concurrencyLimit : 10;
+        zlibLimiter = new Limiter(concurrency);
+      }
+    }
+    static get extensionName() {
+      return "permessage-deflate";
+    }
+    offer() {
+      const params = {};
+      if (this._options.serverNoContextTakeover) {
+        params.server_no_context_takeover = true;
+      }
+      if (this._options.clientNoContextTakeover) {
+        params.client_no_context_takeover = true;
+      }
+      if (this._options.serverMaxWindowBits) {
+        params.server_max_window_bits = this._options.serverMaxWindowBits;
+      }
+      if (this._options.clientMaxWindowBits) {
+        params.client_max_window_bits = this._options.clientMaxWindowBits;
+      } else if (this._options.clientMaxWindowBits == null) {
+        params.client_max_window_bits = true;
+      }
+      return params;
+    }
+    accept(configurations) {
+      configurations = this.normalizeParams(configurations);
+      this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
+      return this.params;
+    }
+    cleanup() {
+      if (this._inflate) {
+        this._inflate.close();
+        this._inflate = null;
+      }
+      if (this._deflate) {
+        const callback = this._deflate[kCallback];
+        this._deflate.close();
+        this._deflate = null;
+        if (callback) {
+          callback(new Error("The deflate stream was closed while data was being processed"));
+        }
+      }
+    }
+    acceptAsServer(offers) {
+      const opts = this._options;
+      const accepted = offers.find((params) => {
+        if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
+          return false;
+        }
+        return true;
+      });
+      if (!accepted) {
+        throw new Error("None of the extension offers can be accepted");
+      }
+      if (opts.serverNoContextTakeover) {
+        accepted.server_no_context_takeover = true;
+      }
+      if (opts.clientNoContextTakeover) {
+        accepted.client_no_context_takeover = true;
+      }
+      if (typeof opts.serverMaxWindowBits === "number") {
+        accepted.server_max_window_bits = opts.serverMaxWindowBits;
+      }
+      if (typeof opts.clientMaxWindowBits === "number") {
+        accepted.client_max_window_bits = opts.clientMaxWindowBits;
+      } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
+        delete accepted.client_max_window_bits;
+      }
+      return accepted;
+    }
+    acceptAsClient(response) {
+      const params = response[0];
+      if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
+        throw new Error('Unexpected parameter "client_no_context_takeover"');
+      }
+      if (!params.client_max_window_bits) {
+        if (typeof this._options.clientMaxWindowBits === "number") {
+          params.client_max_window_bits = this._options.clientMaxWindowBits;
+        }
+      } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
+        throw new Error('Unexpected or invalid parameter "client_max_window_bits"');
+      }
+      return params;
+    }
+    normalizeParams(configurations) {
+      configurations.forEach((params) => {
+        Object.keys(params).forEach((key) => {
+          let value = params[key];
+          if (value.length > 1) {
+            throw new Error(`Parameter "${key}" must have only a single value`);
+          }
+          value = value[0];
+          if (key === "client_max_window_bits") {
+            if (value !== true) {
+              const num = +value;
+              if (!Number.isInteger(num) || num < 8 || num > 15) {
+                throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+              }
+              value = num;
+            } else if (!this._isServer) {
+              throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+            }
+          } else if (key === "server_max_window_bits") {
+            const num = +value;
+            if (!Number.isInteger(num) || num < 8 || num > 15) {
+              throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+            }
+            value = num;
+          } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
+            if (value !== true) {
+              throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+            }
+          } else {
+            throw new Error(`Unknown parameter "${key}"`);
+          }
+          params[key] = value;
+        });
+      });
+      return configurations;
+    }
+    decompress(data, fin, callback) {
+      zlibLimiter.add((done) => {
+        this._decompress(data, fin, (err2, result) => {
+          done();
+          callback(err2, result);
+        });
+      });
+    }
+    compress(data, fin, callback) {
+      zlibLimiter.add((done) => {
+        this._compress(data, fin, (err2, result) => {
+          done();
+          callback(err2, 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 err2 = this._inflate[kError];
+        if (err2) {
+          this._inflate.close();
+          this._inflate = null;
+          callback(err2);
+          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);
+      });
+    }
+  }
+  module2.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(err2) {
+    this[kPerMessageDeflate]._inflate = null;
+    if (this[kError]) {
+      this[kCallback](this[kError]);
+      return;
+    }
+    err2[kStatusCode] = 1007;
+    this[kCallback](err2);
+  }
+});
+var require_validation = __commonJS2((exports, module2) => {
+  var { isUtf8 } = __require2("buffer");
+  var { hasBlob } = require_constants3();
+  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 i3 = 0;
+    while (i3 < len) {
+      if ((buf[i3] & 128) === 0) {
+        i3++;
+      } else if ((buf[i3] & 224) === 192) {
+        if (i3 + 1 === len || (buf[i3 + 1] & 192) !== 128 || (buf[i3] & 254) === 192) {
+          return false;
+        }
+        i3 += 2;
+      } else if ((buf[i3] & 240) === 224) {
+        if (i3 + 2 >= len || (buf[i3 + 1] & 192) !== 128 || (buf[i3 + 2] & 192) !== 128 || buf[i3] === 224 && (buf[i3 + 1] & 224) === 128 || buf[i3] === 237 && (buf[i3 + 1] & 224) === 160) {
+          return false;
+        }
+        i3 += 3;
+      } else if ((buf[i3] & 248) === 240) {
+        if (i3 + 3 >= len || (buf[i3 + 1] & 192) !== 128 || (buf[i3 + 2] & 192) !== 128 || (buf[i3 + 3] & 192) !== 128 || buf[i3] === 240 && (buf[i3 + 1] & 240) === 128 || buf[i3] === 244 && buf[i3 + 1] > 143 || buf[i3] > 244) {
+          return false;
+        }
+        i3 += 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");
+  }
+  module2.exports = {
+    isBlob,
+    isValidStatusCode,
+    isValidUTF8: _isValidUTF8,
+    tokenChars
+  };
+  if (isUtf8) {
+    module2.exports.isValidUTF8 = function(buf) {
+      return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
+    };
+  } else if (!process.env.WS_NO_UTF_8_VALIDATE) {
+    try {
+      const isValidUTF8 = (() => {
+        throw new Error("Cannot require module utf-8-validate");
+      })();
+      module2.exports.isValidUTF8 = function(buf) {
+        return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
+      };
+    } catch (e) {}
+  }
+});
+var require_receiver = __commonJS2((exports, module2) => {
+  var { Writable } = __require2("stream");
+  var PerMessageDeflate = require_permessage_deflate();
+  var {
+    BINARY_TYPES,
+    EMPTY_BUFFER,
+    kStatusCode,
+    kWebSocket
+  } = require_constants3();
+  var { concat: concat2, 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(n3) {
+      this._bufferedBytes -= n3;
+      if (n3 === this._buffers[0].length)
+        return this._buffers.shift();
+      if (n3 < this._buffers[0].length) {
+        const buf = this._buffers[0];
+        this._buffers[0] = new FastBuffer(buf.buffer, buf.byteOffset + n3, buf.length - n3);
+        return new FastBuffer(buf.buffer, buf.byteOffset, n3);
+      }
+      const dst = Buffer.allocUnsafe(n3);
+      do {
+        const buf = this._buffers[0];
+        const offset = dst.length - n3;
+        if (n3 >= buf.length) {
+          dst.set(this._buffers.shift(), offset);
+        } else {
+          dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n3), offset);
+          this._buffers[0] = new FastBuffer(buf.buffer, buf.byteOffset + n3, buf.length - n3);
+        }
+        n3 -= buf.length;
+      } while (n3 > 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 error2 = this.createError(RangeError, "RSV2 and RSV3 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_2_3");
+        cb(error2);
+        return;
+      }
+      const compressed = (buf[0] & 64) === 64;
+      if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+        const error2 = this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+        cb(error2);
+        return;
+      }
+      this._fin = (buf[0] & 128) === 128;
+      this._opcode = buf[0] & 15;
+      this._payloadLength = buf[1] & 127;
+      if (this._opcode === 0) {
+        if (compressed) {
+          const error2 = this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+          cb(error2);
+          return;
+        }
+        if (!this._fragmented) {
+          const error2 = this.createError(RangeError, "invalid opcode 0", true, 1002, "WS_ERR_INVALID_OPCODE");
+          cb(error2);
+          return;
+        }
+        this._opcode = this._fragmented;
+      } else if (this._opcode === 1 || this._opcode === 2) {
+        if (this._fragmented) {
+          const error2 = this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE");
+          cb(error2);
+          return;
+        }
+        this._compressed = compressed;
+      } else if (this._opcode > 7 && this._opcode < 11) {
+        if (!this._fin) {
+          const error2 = this.createError(RangeError, "FIN must be set", true, 1002, "WS_ERR_EXPECTED_FIN");
+          cb(error2);
+          return;
+        }
+        if (compressed) {
+          const error2 = this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+          cb(error2);
+          return;
+        }
+        if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
+          const error2 = this.createError(RangeError, `invalid payload length ${this._payloadLength}`, true, 1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH");
+          cb(error2);
+          return;
+        }
+      } else {
+        const error2 = this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE");
+        cb(error2);
+        return;
+      }
+      if (!this._fin && !this._fragmented)
+        this._fragmented = this._opcode;
+      this._masked = (buf[1] & 128) === 128;
+      if (this._isServer) {
+        if (!this._masked) {
+          const error2 = this.createError(RangeError, "MASK must be set", true, 1002, "WS_ERR_EXPECTED_MASK");
+          cb(error2);
+          return;
+        }
+      } else if (this._masked) {
+        const error2 = this.createError(RangeError, "MASK must be clear", true, 1002, "WS_ERR_UNEXPECTED_MASK");
+        cb(error2);
+        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, 21) - 1) {
+        const error2 = this.createError(RangeError, "Unsupported WebSocket frame: payload length > 2^53 - 1", false, 1009, "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH");
+        cb(error2);
+        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 error2 = this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");
+          cb(error2);
+          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, (err2, buf) => {
+        if (err2)
+          return cb(err2);
+        if (buf.length) {
+          this._messageLength += buf.length;
+          if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+            const error2 = this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");
+            cb(error2);
+            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 = concat2(fragments, messageLength);
+        } else if (this._binaryType === "arraybuffer") {
+          data = toArrayBuffer(concat2(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 = concat2(fragments, messageLength);
+        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+          const error2 = this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8");
+          cb(error2);
+          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 error2 = this.createError(RangeError, `invalid status code ${code}`, true, 1002, "WS_ERR_INVALID_CLOSE_CODE");
+            cb(error2);
+            return;
+          }
+          const buf = new FastBuffer(data.buffer, data.byteOffset + 2, data.length - 2);
+          if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+            const error2 = this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8");
+            cb(error2);
+            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, message3, prefix2, statusCode, errorCode) {
+      this._loop = false;
+      this._errored = true;
+      const err2 = new ErrorCtor(prefix2 ? `Invalid WebSocket frame: ${message3}` : message3);
+      Error.captureStackTrace(err2, this.createError);
+      err2.code = errorCode;
+      err2[kStatusCode] = statusCode;
+      return err2;
+    }
+  }
+  module2.exports = Receiver;
+});
+var require_sender = __commonJS2((exports, module2) => {
+  var { Duplex } = __require2("stream");
+  var { randomFillSync } = __require2("crypto");
+  var PerMessageDeflate = require_permessage_deflate();
+  var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants3();
+  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 = 8192;
+  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(blob2, compress, options, cb) {
+      this._bufferedBytes += options[kByteLength];
+      this._state = GET_BLOB_DATA;
+      blob2.arrayBuffer().then((arrayBuffer) => {
+        if (this._socket.destroyed) {
+          const err2 = new Error("The socket was closed while the blob was being read");
+          process.nextTick(callCallbacks, this, err2, 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((err2) => {
+        process.nextTick(onError, this, err2, 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, (_4, buf) => {
+        if (this._socket.destroyed) {
+          const err2 = new Error("The socket was closed while data was being compressed");
+          callCallbacks(this, err2, 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);
+      }
+    }
+  }
+  module2.exports = Sender;
+  function callCallbacks(sender, err2, cb) {
+    if (typeof cb === "function")
+      cb(err2);
+    for (let i3 = 0;i3 < sender._queue.length; i3++) {
+      const params = sender._queue[i3];
+      const callback = params[params.length - 1];
+      if (typeof callback === "function")
+        callback(err2);
+    }
+  }
+  function onError(sender, err2, cb) {
+    callCallbacks(sender, err2, cb);
+    sender.onerror(err2);
+  }
+});
+var require_event_target = __commonJS2((exports, module2) => {
+  var { kForOnEventAttribute, kListener } = require_constants3();
+  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, message3) {
+          const event = new CloseEvent("close", {
+            code,
+            reason: message3.toString(),
+            wasClean: this._closeFrameReceived && this._closeFrameSent
+          });
+          event[kTarget] = this;
+          callListener(handler, this, event);
+        };
+      } else if (type === "error") {
+        wrapper = function onError(error2) {
+          const event = new ErrorEvent("error", {
+            error: error2,
+            message: error2.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;
+        }
+      }
+    }
+  };
+  module2.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);
+    }
+  }
+});
+var require_extension = __commonJS2((exports, module2) => {
+  var { tokenChars } = require_validation();
+  function push(dest, name3, elem) {
+    if (dest[name3] === undefined)
+      dest[name3] = [elem];
+    else
+      dest[name3].push(elem);
+  }
+  function parse2(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 start2 = -1;
+    let code = -1;
+    let end = -1;
+    let i3 = 0;
+    for (;i3 < header.length; i3++) {
+      code = header.charCodeAt(i3);
+      if (extensionName === undefined) {
+        if (end === -1 && tokenChars[code] === 1) {
+          if (start2 === -1)
+            start2 = i3;
+        } else if (i3 !== 0 && (code === 32 || code === 9)) {
+          if (end === -1 && start2 !== -1)
+            end = i3;
+        } else if (code === 59 || code === 44) {
+          if (start2 === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i3}`);
+          }
+          if (end === -1)
+            end = i3;
+          const name3 = header.slice(start2, end);
+          if (code === 44) {
+            push(offers, name3, params);
+            params = Object.create(null);
+          } else {
+            extensionName = name3;
+          }
+          start2 = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i3}`);
+        }
+      } else if (paramName === undefined) {
+        if (end === -1 && tokenChars[code] === 1) {
+          if (start2 === -1)
+            start2 = i3;
+        } else if (code === 32 || code === 9) {
+          if (end === -1 && start2 !== -1)
+            end = i3;
+        } else if (code === 59 || code === 44) {
+          if (start2 === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i3}`);
+          }
+          if (end === -1)
+            end = i3;
+          push(params, header.slice(start2, end), true);
+          if (code === 44) {
+            push(offers, extensionName, params);
+            params = Object.create(null);
+            extensionName = undefined;
+          }
+          start2 = end = -1;
+        } else if (code === 61 && start2 !== -1 && end === -1) {
+          paramName = header.slice(start2, i3);
+          start2 = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i3}`);
+        }
+      } else {
+        if (isEscaping) {
+          if (tokenChars[code] !== 1) {
+            throw new SyntaxError(`Unexpected character at index ${i3}`);
+          }
+          if (start2 === -1)
+            start2 = i3;
+          else if (!mustUnescape)
+            mustUnescape = true;
+          isEscaping = false;
+        } else if (inQuotes) {
+          if (tokenChars[code] === 1) {
+            if (start2 === -1)
+              start2 = i3;
+          } else if (code === 34 && start2 !== -1) {
+            inQuotes = false;
+            end = i3;
+          } else if (code === 92) {
+            isEscaping = true;
+          } else {
+            throw new SyntaxError(`Unexpected character at index ${i3}`);
+          }
+        } else if (code === 34 && header.charCodeAt(i3 - 1) === 61) {
+          inQuotes = true;
+        } else if (end === -1 && tokenChars[code] === 1) {
+          if (start2 === -1)
+            start2 = i3;
+        } else if (start2 !== -1 && (code === 32 || code === 9)) {
+          if (end === -1)
+            end = i3;
+        } else if (code === 59 || code === 44) {
+          if (start2 === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i3}`);
+          }
+          if (end === -1)
+            end = i3;
+          let value = header.slice(start2, 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;
+          start2 = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i3}`);
+        }
+      }
+    }
+    if (start2 === -1 || inQuotes || code === 32 || code === 9) {
+      throw new SyntaxError("Unexpected end of input");
+    }
+    if (end === -1)
+      end = i3;
+    const token = header.slice(start2, 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 format2(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((k3) => {
+          let values = params[k3];
+          if (!Array.isArray(values))
+            values = [values];
+          return values.map((v3) => v3 === true ? k3 : `${k3}=${v3}`).join("; ");
+        })).join("; ");
+      }).join(", ");
+    }).join(", ");
+  }
+  module2.exports = { format: format2, parse: parse2 };
+});
+var require_websocket = __commonJS2((exports, module2) => {
+  var EventEmitter = __require2("events");
+  var https = __require2("https");
+  var http2 = __require2("http");
+  var net = __require2("net");
+  var tls = __require2("tls");
+  var { randomBytes, createHash } = __require2("crypto");
+  var { Duplex, Readable: Readable2 } = __require2("stream");
+  var { URL: URL2 } = __require2("url");
+  var PerMessageDeflate = require_permessage_deflate();
+  var Receiver = require_receiver();
+  var Sender = require_sender();
+  var { isBlob } = require_validation();
+  var {
+    BINARY_TYPES,
+    EMPTY_BUFFER,
+    GUID,
+    kForOnEventAttribute,
+    kListener,
+    kStatusCode,
+    kWebSocket,
+    NOOP
+  } = require_constants3();
+  var {
+    EventTarget: { addEventListener: addEventListener2, removeEventListener }
+  } = require_event_target();
+  var { format: format2, parse: parse2 } = require_extension();
+  var { toBuffer } = require_buffer_util();
+  var closeTimeout = 30000;
+  var kAborted = Symbol("kAborted");
+  var protocolVersions = [8, 13];
+  var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+  var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+
+  class WebSocket2 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 = WebSocket2.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._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 = WebSocket2.OPEN;
+      this.emit("open");
+    }
+    emitClose() {
+      if (!this._socket) {
+        this._readyState = WebSocket2.CLOSED;
+        this.emit("close", this._closeCode, this._closeMessage);
+        return;
+      }
+      if (this._extensions[PerMessageDeflate.extensionName]) {
+        this._extensions[PerMessageDeflate.extensionName].cleanup();
+      }
+      this._receiver.removeAllListeners();
+      this._readyState = WebSocket2.CLOSED;
+      this.emit("close", this._closeCode, this._closeMessage);
+    }
+    close(code, data) {
+      if (this.readyState === WebSocket2.CLOSED)
+        return;
+      if (this.readyState === WebSocket2.CONNECTING) {
+        const msg = "WebSocket was closed before the connection was established";
+        abortHandshake(this, this._req, msg);
+        return;
+      }
+      if (this.readyState === WebSocket2.CLOSING) {
+        if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
+          this._socket.end();
+        }
+        return;
+      }
+      this._readyState = WebSocket2.CLOSING;
+      this._sender.close(code, data, !this._isServer, (err2) => {
+        if (err2)
+          return;
+        this._closeFrameSent = true;
+        if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
+          this._socket.end();
+        }
+      });
+      setCloseTimer(this);
+    }
+    pause() {
+      if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) {
+        return;
+      }
+      this._paused = true;
+      this._socket.pause();
+    }
+    ping(data, mask, cb) {
+      if (this.readyState === WebSocket2.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 !== WebSocket2.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 === WebSocket2.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 !== WebSocket2.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      if (mask === undefined)
+        mask = !this._isServer;
+      this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+    }
+    resume() {
+      if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) {
+        return;
+      }
+      this._paused = false;
+      if (!this._receiver._writableState.needDrain)
+        this._socket.resume();
+    }
+    send(data, options, cb) {
+      if (this.readyState === WebSocket2.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 !== WebSocket2.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 === WebSocket2.CLOSED)
+        return;
+      if (this.readyState === WebSocket2.CONNECTING) {
+        const msg = "WebSocket was closed before the connection was established";
+        abortHandshake(this, this._req, msg);
+        return;
+      }
+      if (this._socket) {
+        this._readyState = WebSocket2.CLOSING;
+        this._socket.destroy();
+      }
+    }
+  }
+  Object.defineProperty(WebSocket2, "CONNECTING", {
+    enumerable: true,
+    value: readyStates.indexOf("CONNECTING")
+  });
+  Object.defineProperty(WebSocket2.prototype, "CONNECTING", {
+    enumerable: true,
+    value: readyStates.indexOf("CONNECTING")
+  });
+  Object.defineProperty(WebSocket2, "OPEN", {
+    enumerable: true,
+    value: readyStates.indexOf("OPEN")
+  });
+  Object.defineProperty(WebSocket2.prototype, "OPEN", {
+    enumerable: true,
+    value: readyStates.indexOf("OPEN")
+  });
+  Object.defineProperty(WebSocket2, "CLOSING", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSING")
+  });
+  Object.defineProperty(WebSocket2.prototype, "CLOSING", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSING")
+  });
+  Object.defineProperty(WebSocket2, "CLOSED", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSED")
+  });
+  Object.defineProperty(WebSocket2.prototype, "CLOSED", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSED")
+  });
+  [
+    "binaryType",
+    "bufferedAmount",
+    "extensions",
+    "isPaused",
+    "protocol",
+    "readyState",
+    "url"
+  ].forEach((property) => {
+    Object.defineProperty(WebSocket2.prototype, property, { enumerable: true });
+  });
+  ["open", "error", "close", "message"].forEach((method) => {
+    Object.defineProperty(WebSocket2.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
+        });
+      }
+    });
+  });
+  WebSocket2.prototype.addEventListener = addEventListener2;
+  WebSocket2.prototype.removeEventListener = removeEventListener;
+  module2.exports = WebSocket2;
+  function initAsClient(websocket, address, protocols, options) {
+    const opts = {
+      allowSynchronousEvents: true,
+      autoPong: true,
+      protocolVersion: protocolVersions[1],
+      maxPayload: 104857600,
+      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;
+    if (!protocolVersions.includes(opts.protocolVersion)) {
+      throw new RangeError(`Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`);
+    }
+    let parsedUrl;
+    if (address instanceof URL2) {
+      parsedUrl = address;
+    } else {
+      try {
+        parsedUrl = new URL2(address);
+      } catch (e) {
+        throw new SyntaxError(`Invalid URL: ${address}`);
+      }
+    }
+    if (parsedUrl.protocol === "http:") {
+      parsedUrl.protocol = "ws:";
+    } else if (parsedUrl.protocol === "https:") {
+      parsedUrl.protocol = "wss:";
+    }
+    websocket._url = parsedUrl.href;
+    const isSecure = parsedUrl.protocol === "wss:";
+    const isIpcUrl = parsedUrl.protocol === "ws+unix:";
+    let invalidUrlMessage;
+    if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
+      invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"`;
+    } else if (isIpcUrl && !parsedUrl.pathname) {
+      invalidUrlMessage = "The URL's pathname is empty";
+    } else if (parsedUrl.hash) {
+      invalidUrlMessage = "The URL contains a fragment identifier";
+    }
+    if (invalidUrlMessage) {
+      const err2 = new SyntaxError(invalidUrlMessage);
+      if (websocket._redirects === 0) {
+        throw err2;
+      } else {
+        emitErrorAndClose(websocket, err2);
+        return;
+      }
+    }
+    const defaultPort = isSecure ? 443 : 80;
+    const key = randomBytes(16).toString("base64");
+    const request = isSecure ? https.request : http2.request;
+    const protocolSet = new Set;
+    let perMessageDeflate;
+    opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
+    opts.defaultPort = opts.defaultPort || defaultPort;
+    opts.port = parsedUrl.port || defaultPort;
+    opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
+    opts.headers = {
+      ...opts.headers,
+      "Sec-WebSocket-Version": opts.protocolVersion,
+      "Sec-WebSocket-Key": key,
+      Connection: "Upgrade",
+      Upgrade: "websocket"
+    };
+    opts.path = parsedUrl.pathname + parsedUrl.search;
+    opts.timeout = opts.handshakeTimeout;
+    if (opts.perMessageDeflate) {
+      perMessageDeflate = new PerMessageDeflate(opts.perMessageDeflate !== true ? opts.perMessageDeflate : {}, false, opts.maxPayload);
+      opts.headers["Sec-WebSocket-Extensions"] = format2({
+        [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 parts2 = opts.path.split(":");
+      opts.socketPath = parts2[0];
+      opts.path = parts2[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", (err2) => {
+      if (req === null || req[kAborted])
+        return;
+      req = websocket._req = null;
+      emitErrorAndClose(websocket, err2);
+    });
+    req.on("response", (res) => {
+      const location2 = res.headers.location;
+      const statusCode = res.statusCode;
+      if (location2 && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
+        if (++websocket._redirects > opts.maxRedirects) {
+          abortHandshake(websocket, req, "Maximum redirects exceeded");
+          return;
+        }
+        req.abort();
+        let addr2;
+        try {
+          addr2 = new URL2(location2, address);
+        } catch (e) {
+          const err2 = new SyntaxError(`Invalid URL: ${location2}`);
+          emitErrorAndClose(websocket, err2);
+          return;
+        }
+        initAsClient(websocket, addr2, protocols, options);
+      } else if (!websocket.emit("unexpected-response", req, res)) {
+        abortHandshake(websocket, req, `Unexpected server response: ${res.statusCode}`);
+      }
+    });
+    req.on("upgrade", (res, socket, head) => {
+      websocket.emit("upgrade", res);
+      if (websocket.readyState !== WebSocket2.CONNECTING)
+        return;
+      req = websocket._req = null;
+      const 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 message3 = "Server sent a Sec-WebSocket-Extensions header but no extension was requested";
+          abortHandshake(websocket, socket, message3);
+          return;
+        }
+        let extensions;
+        try {
+          extensions = parse2(secWebSocketExtensions);
+        } catch (err2) {
+          const message3 = "Invalid Sec-WebSocket-Extensions header";
+          abortHandshake(websocket, socket, message3);
+          return;
+        }
+        const extensionNames = Object.keys(extensions);
+        if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
+          const message3 = "Server indicated an extension that was not requested";
+          abortHandshake(websocket, socket, message3);
+          return;
+        }
+        try {
+          perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+        } catch (err2) {
+          const message3 = "Invalid Sec-WebSocket-Extensions header";
+          abortHandshake(websocket, socket, message3);
+          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, err2) {
+    websocket._readyState = WebSocket2.CLOSING;
+    websocket._errorEmitted = true;
+    websocket.emit("error", err2);
+    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, message3) {
+    websocket._readyState = WebSocket2.CLOSING;
+    const err2 = new Error(message3);
+    Error.captureStackTrace(err2, abortHandshake);
+    if (stream.setHeader) {
+      stream[kAborted] = true;
+      stream.abort();
+      if (stream.socket && !stream.socket.destroyed) {
+        stream.socket.destroy();
+      }
+      process.nextTick(emitErrorAndClose, websocket, err2);
+    } else {
+      stream.destroy(err2);
+      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 err2 = new Error(`WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`);
+      process.nextTick(cb, err2);
+    }
+  }
+  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(err2) {
+    const websocket = this[kWebSocket];
+    if (websocket._socket[kWebSocket] !== undefined) {
+      websocket._socket.removeListener("data", socketOnData);
+      process.nextTick(resume, websocket._socket);
+      websocket.close(err2[kStatusCode]);
+    }
+    if (!websocket._errorEmitted) {
+      websocket._errorEmitted = true;
+      websocket.emit("error", err2);
+    }
+  }
+  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(err2) {
+    const websocket = this[kWebSocket];
+    if (websocket.readyState === WebSocket2.CLOSED)
+      return;
+    if (websocket.readyState === WebSocket2.OPEN) {
+      websocket._readyState = WebSocket2.CLOSING;
+      setCloseTimer(websocket);
+    }
+    this._socket.end();
+    if (!websocket._errorEmitted) {
+      websocket._errorEmitted = true;
+      websocket.emit("error", err2);
+    }
+  }
+  function setCloseTimer(websocket) {
+    websocket._closeTimer = setTimeout(websocket._socket.destroy.bind(websocket._socket), closeTimeout);
+  }
+  function socketOnClose() {
+    const websocket = this[kWebSocket];
+    this.removeListener("close", socketOnClose);
+    this.removeListener("data", socketOnData);
+    this.removeListener("end", socketOnEnd);
+    websocket._readyState = WebSocket2.CLOSING;
+    let chunk;
+    if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
+      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 = WebSocket2.CLOSING;
+    websocket._receiver.end();
+    this.end();
+  }
+  function socketOnError() {
+    const websocket = this[kWebSocket];
+    this.removeListener("error", socketOnError);
+    this.on("error", NOOP);
+    if (websocket) {
+      websocket._readyState = WebSocket2.CLOSING;
+      this.destroy();
+    }
+  }
+});
+var require_stream5 = __commonJS2((exports, module2) => {
+  var WebSocket2 = require_websocket();
+  var { Duplex } = __require2("stream");
+  function emitClose(stream) {
+    stream.emit("close");
+  }
+  function duplexOnEnd() {
+    if (!this.destroyed && this._writableState.finished) {
+      this.destroy();
+    }
+  }
+  function duplexOnError(err2) {
+    this.removeListener("error", duplexOnError);
+    this.destroy();
+    if (this.listenerCount("error") === 0) {
+      this.emit("error", err2);
+    }
+  }
+  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(err2) {
+      if (duplex.destroyed)
+        return;
+      terminateOnDestroy = false;
+      duplex.destroy(err2);
+    });
+    ws.once("close", function close() {
+      if (duplex.destroyed)
+        return;
+      duplex.push(null);
+    });
+    duplex._destroy = function(err2, callback) {
+      if (ws.readyState === ws.CLOSED) {
+        callback(err2);
+        process.nextTick(emitClose, duplex);
+        return;
+      }
+      let called = false;
+      ws.once("error", function error(err3) {
+        called = true;
+        callback(err3);
+      });
+      ws.once("close", function close() {
+        if (!called)
+          callback(err2);
+        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;
+  }
+  module2.exports = createWebSocketStream;
+});
+var require_subprotocol = __commonJS2((exports, module2) => {
+  var { tokenChars } = require_validation();
+  function parse2(header) {
+    const protocols = new Set;
+    let start2 = -1;
+    let end = -1;
+    let i3 = 0;
+    for (i3;i3 < header.length; i3++) {
+      const code = header.charCodeAt(i3);
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start2 === -1)
+          start2 = i3;
+      } else if (i3 !== 0 && (code === 32 || code === 9)) {
+        if (end === -1 && start2 !== -1)
+          end = i3;
+      } else if (code === 44) {
+        if (start2 === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i3}`);
+        }
+        if (end === -1)
+          end = i3;
+        const protocol2 = header.slice(start2, end);
+        if (protocols.has(protocol2)) {
+          throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
+        }
+        protocols.add(protocol2);
+        start2 = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i3}`);
+      }
+    }
+    if (start2 === -1 || end !== -1) {
+      throw new SyntaxError("Unexpected end of input");
+    }
+    const protocol = header.slice(start2, i3);
+    if (protocols.has(protocol)) {
+      throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+    }
+    protocols.add(protocol);
+    return protocols;
+  }
+  module2.exports = { parse: parse2 };
+});
+var require_websocket_server = __commonJS2((exports, module2) => {
+  var EventEmitter = __require2("events");
+  var http2 = __require2("http");
+  var { Duplex } = __require2("stream");
+  var { createHash } = __require2("crypto");
+  var extension = require_extension();
+  var PerMessageDeflate = require_permessage_deflate();
+  var subprotocol = require_subprotocol();
+  var WebSocket2 = require_websocket();
+  var { GUID, kWebSocket } = require_constants3();
+  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: 104857600,
+        skipUTF8Validation: false,
+        perMessageDeflate: false,
+        handleProtocols: null,
+        clientTracking: true,
+        verifyClient: null,
+        noServer: false,
+        backlog: null,
+        server: null,
+        host: null,
+        path: null,
+        port: null,
+        WebSocket: WebSocket2,
+        ...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 = http2.createServer((req, res) => {
+          const body2 = http2.STATUS_CODES[426];
+          res.writeHead(426, {
+            "Content-Length": body2.length,
+            "Content-Type": "text/plain"
+          });
+          res.end(body2);
+        });
+        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 server2 = this._server;
+        this._removeListeners();
+        this._removeListeners = this._server = null;
+        server2.close(() => {
+          emitClose(this);
+        });
+      }
+    }
+    shouldHandle(req) {
+      if (this.options.path) {
+        const index6 = req.url.indexOf("?");
+        const pathname = index6 !== -1 ? req.url.slice(0, index6) : 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 version3 = +req.headers["sec-websocket-version"];
+      if (req.method !== "GET") {
+        const message3 = "Invalid HTTP method";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 405, message3);
+        return;
+      }
+      if (upgrade === undefined || upgrade.toLowerCase() !== "websocket") {
+        const message3 = "Invalid Upgrade header";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message3);
+        return;
+      }
+      if (key === undefined || !keyRegex.test(key)) {
+        const message3 = "Missing or invalid Sec-WebSocket-Key header";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message3);
+        return;
+      }
+      if (version3 !== 8 && version3 !== 13) {
+        const message3 = "Missing or invalid Sec-WebSocket-Version header";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message3);
+        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 (err2) {
+          const message3 = "Invalid Sec-WebSocket-Protocol header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message3);
+          return;
+        }
+      }
+      const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
+      const extensions = {};
+      if (this.options.perMessageDeflate && secWebSocketExtensions !== undefined) {
+        const perMessageDeflate = new PerMessageDeflate(this.options.perMessageDeflate, true, this.options.maxPayload);
+        try {
+          const offers = extension.parse(secWebSocketExtensions);
+          if (offers[PerMessageDeflate.extensionName]) {
+            perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+            extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+          }
+        } catch (err2) {
+          const message3 = "Invalid or unacceptable Sec-WebSocket-Extensions header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message3);
+          return;
+        }
+      }
+      if (this.options.verifyClient) {
+        const info2 = {
+          origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
+          secure: !!(req.socket.authorized || req.socket.encrypted),
+          req
+        };
+        if (this.options.verifyClient.length === 2) {
+          this.options.verifyClient(info2, (verified, code, message3, headers) => {
+            if (!verified) {
+              return abortHandshake(socket, code || 401, message3, headers);
+            }
+            this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+          });
+          return;
+        }
+        if (!this.options.verifyClient(info2))
+          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);
+    }
+  }
+  module2.exports = WebSocketServer;
+  function addListeners(server2, map) {
+    for (const event of Object.keys(map))
+      server2.on(event, map[event]);
+    return function removeListeners() {
+      for (const event of Object.keys(map)) {
+        server2.removeListener(event, map[event]);
+      }
+    };
+  }
+  function emitClose(server2) {
+    server2._state = CLOSED;
+    server2.emit("close");
+  }
+  function socketOnError() {
+    this.destroy();
+  }
+  function abortHandshake(socket, code, message3, headers) {
+    message3 = message3 || http2.STATUS_CODES[code];
+    headers = {
+      Connection: "close",
+      "Content-Type": "text/html",
+      "Content-Length": Buffer.byteLength(message3),
+      ...headers
+    };
+    socket.once("finish", socket.destroy);
+    socket.end(`HTTP/1.1 ${code} ${http2.STATUS_CODES[code]}\r
+` + Object.keys(headers).map((h3) => `${h3}: ${headers[h3]}`).join(`\r
+`) + `\r
+\r
+` + message3);
+  }
+  function abortHandshakeOrEmitwsClientError(server2, req, socket, code, message3) {
+    if (server2.listenerCount("wsClientError")) {
+      const err2 = new Error(message3);
+      Error.captureStackTrace(err2, abortHandshakeOrEmitwsClientError);
+      server2.emit("wsClientError", err2, socket, req);
+    } else {
+      abortHandshake(socket, code, message3);
+    }
+  }
+});
 var RequestError = class extends Error {
   constructor(message, options) {
     super(message, options);
@@ -94503,13 +97317,13 @@ var RegExpRouter = class {
     }
     const paths = checkOptionalParameter(path4) || [path4];
     for (let i22 = 0, len = paths.length;i22 < len; i22++) {
-      const path23 = paths[i22];
+      const path22 = paths[i22];
       Object.keys(routes).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
-          routes[m][path23] ||= [
-            ...findMiddleware(middleware[m], path23) || findMiddleware(middleware[METHOD_NAME_ALL], path23) || []
+          routes[m][path22] ||= [
+            ...findMiddleware(middleware[m], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
           ];
-          routes[m][path23].push([handler, paramCount - len + i22 + 1]);
+          routes[m][path22].push([handler, paramCount - len + i22 + 1]);
         }
       });
     }
@@ -94517,13 +97331,13 @@ var RegExpRouter = class {
   match(method, path4) {
     clearWildcardRegExpCache();
     const matchers = this.#buildAllMatchers();
-    this.match = (method2, path23) => {
+    this.match = (method2, path22) => {
       const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-      const staticMatch = matcher[2][path23];
+      const staticMatch = matcher[2][path22];
       if (staticMatch) {
         return staticMatch;
       }
-      const match2 = path23.match(matcher[0]);
+      const match2 = path22.match(matcher[0]);
       if (!match2) {
         return [[], emptyParam];
       }
@@ -94915,7 +97729,7 @@ var logger = (fn = console.log) => {
 };
 var package_default = {
   name: "@playcademy/sandbox",
-  version: "0.1.0-beta.12",
+  version: "0.1.0-beta.15",
   description: "Local development server for Playcademy game development",
   type: "module",
   exports: {
@@ -108112,10 +110926,105 @@ async function createRealtimeServer(options = {}) {
   }
   return server;
 }
+var import_stream2 = __toESM2(require_stream5(), 1);
+var import_receiver = __toESM2(require_receiver(), 1);
+var import_sender = __toESM2(require_sender(), 1);
+var import_websocket = __toESM2(require_websocket(), 1);
+var import_websocket_server = __toESM2(require_websocket_server(), 1);
+async function createSandboxRealtimeServer(options = {}) {
+  const config2 = await loadConfig(options);
+  const httpServer = http.createServer((req, res) => {
+    if (req.url?.endsWith(config2.healthCheckPath)) {
+      const body2 = JSON.stringify({
+        status: "OK",
+        connections: getActiveConnections(),
+        timestamp: new Date().toISOString()
+      });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(body2);
+      return;
+    }
+    res.writeHead(200);
+    res.end("Playcademy realtime relay (sandbox)");
+  });
+  const wss = new import_websocket_server.default({ noServer: true });
+  wss.on("connection", (ws) => {
+    addConnection();
+    ws.on("close", () => {
+      removeConnection();
+    });
+    ws.on("message", (data) => {
+      wss.clients.forEach((client2) => {
+        if (client2.readyState === import_websocket.default.OPEN) {
+          client2.send(data);
+        }
+      });
+    });
+  });
+  httpServer.on("upgrade", async (request, socket, head) => {
+    const fullUrl = `http://${request.headers.host}${request.url}`;
+    const token = extractTokenFromUrl(fullUrl);
+    if (!token) {
+      socket.write(`HTTP/1.1 401 Unauthorized\r
+\r
+`);
+      socket.destroy();
+      return;
+    }
+    const authResult = await verifyToken(token, config2.betterAuthSecret);
+    if (!authResult.success) {
+      socket.write(`HTTP/1.1 401 Unauthorized\r
+\r
+`);
+      socket.destroy();
+      return;
+    }
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      const data = {
+        userId: authResult.userId,
+        gameId: authResult.gameId,
+        joinedChannels: new Set,
+        requestedChannel: null,
+        isAuthenticated: true
+      };
+      ws.data = data;
+      wss.emit("connection", ws, request);
+    });
+  });
+  await new Promise((resolve2) => {
+    httpServer.listen(config2.port, () => resolve2());
+  });
+  if (!options.quiet) {
+    log2.info("Sandbox realtime server started", {
+      port: config2.port,
+      healthCheck: `http://localhost:${config2.port}${config2.healthCheckPath}`
+    });
+  }
+  return {
+    port: config2.port,
+    stop() {
+      wss.clients.forEach((client2) => client2.close());
+      wss.close();
+      httpServer.close();
+    }
+  };
+}
 async function startRealtimeServer(realtimeOptions, betterAuthSecret) {
   if (!realtimeOptions.enabled) {
     return null;
   }
+  if (typeof Bun === "undefined") {
+    try {
+      return await createSandboxRealtimeServer({
+        port: realtimeOptions.port,
+        betterAuthSecret,
+        quiet: true
+      });
+    } catch (err2) {
+      console.warn("[sandbox] Bun runtime not detected - fallback realtime server failed to start.", err2);
+      return null;
+    }
+  }
   try {
     return await createRealtimeServer({
       port: realtimeOptions.port,
@@ -108626,8 +111535,8 @@ function getErrorMap2() {
   return overrideErrorMap2;
 }
 var makeIssue2 = (params) => {
-  const { data, path: path23, errorMaps, issueData } = params;
-  const fullPath = [...path23, ...issueData.path || []];
+  const { data, path: path22, errorMaps, issueData } = params;
+  const fullPath = [...path22, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -108737,11 +111646,11 @@ var errorUtil2;
 })(errorUtil2 || (errorUtil2 = {}));
 
 class ParseInputLazyPath2 {
-  constructor(parent, value, path23, key) {
+  constructor(parent, value, path22, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path23;
+    this._path = path22;
     this._key = key;
   }
   get path() {
@@ -112420,10 +115329,10 @@ var CreateDeveloperKeyInputSchema = InsertDeveloperKeySchema.pick({
 });
 var safeRelativePathRegex = /^(?!.*\.\.)(?!\/)[\w\-./]+$/;
 var invalidPathMessage = "Path must be relative, contain only alphanumeric, -, _, ., / characters, and not contain .. segments.";
-var validateRelativePath = (path23, fieldName) => {
-  if (path23 == null)
+var validateRelativePath = (path22, fieldName) => {
+  if (path22 == null)
     return true;
-  if (typeof path23 !== "string" || !safeRelativePathRegex.test(path23)) {
+  if (typeof path22 !== "string" || !safeRelativePathRegex.test(path22)) {
     throw new exports_external.ZodError([
       {
         code: exports_external.ZodIssueCode.custom,
@@ -112535,10 +115444,10 @@ var ManifestV1Schema = exports_external.object({
 });
 var safeRelativePathRegex2 = /^(?!.*\.\.)(?!\/)[\w\-./]+$/;
 var invalidPathMessage2 = "Path must be relative, contain only alphanumeric, -, _, ., / characters, and not contain .. segments.";
-var validateRelativePath2 = (path23, fieldName) => {
-  if (path23 == null)
+var validateRelativePath2 = (path22, fieldName) => {
+  if (path22 == null)
     return true;
-  if (typeof path23 !== "string" || !safeRelativePathRegex2.test(path23)) {
+  if (typeof path22 !== "string" || !safeRelativePathRegex2.test(path22)) {
     throw new exports_external.ZodError([
       {
         code: exports_external.ZodIssueCode.custom,
@@ -114359,37 +117268,6 @@ async function saveGameState(ctx) {
     throw ApiError.internal("Internal server error", error2);
   }
 }
-function findMonorepoRootInternal(startDir) {
-  let currentDir = startDir;
-  while (true) {
-    const packageJsonPath = path22.join(currentDir, "package.json");
-    if (fs32.existsSync(packageJsonPath)) {
-      try {
-        const packageJsonContent = fs32.readFileSync(packageJsonPath, "utf-8");
-        const packageJson = JSON.parse(packageJsonContent);
-        if (packageJson && typeof packageJson === "object" && "workspaces" in packageJson) {
-          return currentDir;
-        }
-      } catch (parseError) {
-        log2.warn(`[utils/paths] Error parsing ${packageJsonPath}:`, {
-          error: parseError
-        });
-      }
-    }
-    const parentDir = path22.dirname(currentDir);
-    if (parentDir === currentDir) {
-      throw new Error("Could not find monorepo root (package.json with workspaces) starting from " + startDir);
-    }
-    currentDir = parentDir;
-  }
-}
-var determinedRoot;
-try {
-  determinedRoot = findMonorepoRootInternal(process.cwd());
-} catch (error2) {
-  determinedRoot = process.cwd();
-  log2.warn("[utils/paths] Could not locate monorepo root via workspace package.json scan. Falling back to process.cwd() (", { root: determinedRoot, error: error2 });
-}
 var UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 function isValidUUID(value) {
   if (!value || typeof value !== "string") {