fullstacked 1.0.0-alpha.1783 → 1.0.0-alpha.1804

package/index.js

@@ -507,9 +507,10 @@ var require_DOMParser = __commonJS({
         }
         var key;
         var i;
-        function ParseError(message, locator) {
+        function ParseError(message, locator, cause) {
           this.message = message;
           this.locator = locator;
+          this.cause = cause;
           if (Error.captureStackTrace) Error.captureStackTrace(this, ParseError);
         }
         extendError(ParseError);
@@ -565,7 +566,7 @@ var require_DOMParser = __commonJS({
               }
               return isStr ? part : part.source;
             }).join(""),
-            UNICODE_SUPPORT ? "mu" : "m"
+            UNICODE_SUPPORT ? "u" : ""
           );
         }
         function regg(args2) {
@@ -591,6 +592,7 @@ var require_DOMParser = __commonJS({
         var NameStartChar_s = chars(NameStartChar);
         var NameChar = reg("[", NameStartChar_s, chars(/[-.0-9\xB7]/), chars(/[\u0300-\u036F\u203F-\u2040]/), "]");
         var Name = reg(NameStartChar, NameChar, "*");
+        var Name_exact = reg("^", Name, "$");
         var Nmtoken = reg(NameChar, "+");
         var EntityRef = reg("&", Name, ";");
         var CharRef = regg(/&#[0-9]+;|&#x[0-9a-fA-F]+;/);
@@ -605,11 +607,12 @@ var require_DOMParser = __commonJS({
         var NCNameStartChar = chars_without(NameStartChar, ":");
         var NCNameChar = chars_without(NameChar, ":");
         var NCName = reg(NCNameStartChar, NCNameChar, "*");
+        var NCName_exact = reg("^", NCName, "$");
         var QName = reg(NCName, regg(":", NCName), "?");
         var QName_exact = reg("^", QName, "$");
         var QName_group = reg("(", QName, ")");
         var SystemLiteral = regg(/"[^"]*"|'[^']*'/);
-        var PI = reg(/^<\?/, "(", Name, ")", regg(S, "(", Char, "*?)"), "?", /\?>/);
+        var PI = reg(/^<\?/, "(", Name, ")", regg(S, "(?!", _SChar, ")(", Char, "*?)"), "?", /\?>/);
         var PubidChar = /[\x20\x0D\x0Aa-zA-Z0-9-'()+,./:=?;!*#@$_%]/;
         var PubidLiteral = regg('"', PubidChar, '*"', "|", "'", chars_without(PubidChar, "'"), "*'");
         var COMMENT_START = "<!--";
@@ -698,6 +701,8 @@ var require_DOMParser = __commonJS({
         exports2.ExternalID = ExternalID;
         exports2.ExternalID_match = ExternalID_match;
         exports2.Name = Name;
+        exports2.Name_exact = Name_exact;
+        exports2.NCName_exact = NCName_exact;
         exports2.NotationDecl = NotationDecl;
         exports2.Reference = Reference;
         exports2.PEReference = PEReference;
@@ -987,6 +992,8 @@ var require_DOMParser = __commonJS({
         };
         _extends(LiveNodeList, NodeList);
         function NamedNodeMap() {
+          this._nsIndex = /* @__PURE__ */ Object.create(null);
+          this._noNsIndex = /* @__PURE__ */ Object.create(null);
         }
         function _findNodeIndex(list, node) {
           var i = 0;
@@ -997,6 +1004,30 @@ var require_DOMParser = __commonJS({
             i++;
           }
         }
+        function _nnmBucket(map, namespaceURI, create) {
+          if (!namespaceURI) {
+            return map._noNsIndex;
+          }
+          var bucket = map._nsIndex[namespaceURI];
+          if (!bucket && create) {
+            bucket = map._nsIndex[namespaceURI] = /* @__PURE__ */ Object.create(null);
+          }
+          return bucket;
+        }
+        function _nnmIndexFind(map, namespaceURI, localName) {
+          var bucket = _nnmBucket(map, namespaceURI, false);
+          var found = bucket && bucket[localName];
+          return found ? found : null;
+        }
+        function _nnmIndexAdd(map, attr) {
+          _nnmBucket(map, attr.namespaceURI, true)[attr.localName] = attr;
+        }
+        function _nnmIndexRemove(map, attr) {
+          var bucket = _nnmBucket(map, attr.namespaceURI, false);
+          if (bucket) {
+            delete bucket[attr.localName];
+          }
+        }
         function _addNamedNode(el, list, newAttr, oldAttr) {
           if (oldAttr) {
             list[_findNodeIndex(list, oldAttr)] = newAttr;
@@ -1004,6 +1035,7 @@ var require_DOMParser = __commonJS({
             list[list.length] = newAttr;
             list.length++;
           }
+          _nnmIndexAdd(list, newAttr);
           if (el) {
             newAttr.ownerElement = el;
             var doc = el.ownerDocument;
@@ -1021,6 +1053,7 @@ var require_DOMParser = __commonJS({
               list[i] = list[++i];
             }
             list.length = lastIndex;
+            _nnmIndexRemove(list, attr);
             if (el) {
               var doc = el.ownerDocument;
               if (doc) {
@@ -1076,7 +1109,7 @@ var require_DOMParser = __commonJS({
             if (el && el !== this._ownerElement) {
               throw new DOMException2(DOMException2.INUSE_ATTRIBUTE_ERR);
             }
-            var oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
+            var oldAttr = _nnmIndexFind(this, attr.namespaceURI, attr.localName);
             if (oldAttr === attr) {
               return attr;
             }
@@ -1738,8 +1771,29 @@ var require_DOMParser = __commonJS({
                 while (child) {
                   var next = child.nextSibling;
                   if (next !== null && next.nodeType === TEXT_NODE && child.nodeType === TEXT_NODE) {
-                    node.removeChild(next);
-                    child.appendData(next.data);
+                    var tail = [];
+                    var sibling = next;
+                    while (sibling !== null && sibling.nodeType === TEXT_NODE) {
+                      tail.push(sibling.data);
+                      sibling = sibling.nextSibling;
+                    }
+                    var removed = child.nextSibling;
+                    while (removed !== sibling) {
+                      var following = removed.nextSibling;
+                      removed.parentNode = null;
+                      removed.previousSibling = null;
+                      removed.nextSibling = null;
+                      removed = following;
+                    }
+                    child.nextSibling = sibling;
+                    if (sibling !== null) {
+                      sibling.previousSibling = child;
+                    } else {
+                      node.lastChild = child;
+                    }
+                    child.appendData(tail.join(""));
+                    _onUpdateChild(node.ownerDocument, node);
+                    child = sibling;
                   } else {
                     child = next;
                   }
@@ -2377,10 +2431,10 @@ var require_DOMParser = __commonJS({
            * "InvalidCharacterError".
            *
            * Note: When the resulting document is serialized with `requireWellFormed: true`, the
-           * serializer throws `InvalidStateError` if `.target` contains `:` or is an ASCII
-           * case-insensitive match for `"xml"`, or if `.data` contains `?>` or characters outside the
-           * XML Char production (W3C DOM Parsing §3.2.1.7). Without that option the data is emitted
-           * verbatim.
+           * serializer throws `InvalidStateError` if `.target` is not a valid XML `NCName` (a `Name`
+           * with no colon) or is an ASCII case-insensitive match for `"xml"`, or if `.data` contains
+           * `?>` or characters outside the XML Char production (W3C DOM Parsing §3.2.1.7). Without that
+           * option the target and data are emitted verbatim.
            *
            * @param {string} target
            * @param {string} data
@@ -2435,19 +2489,29 @@ var require_DOMParser = __commonJS({
            * The current implementation does not fill the `childNodes` with those of the corresponding
            * `Entity`
            *
+           * The `name` is validated against the XML `Name` production at creation time; an invalid name
+           * throws `InvalidCharacterError`. When the resulting node is serialized with
+           * `requireWellFormed: true`, the serializer re-validates `nodeName` against the XML `Name`
+           * production and throws `InvalidStateError` if a later `nodeName` mutation made it invalid;
+           * without that option the name is emitted verbatim.
+           *
+           * __This implementation differs from the specification:__ xmldom does not expand entities —
+           * the parser resolves entity references inline and never constructs `EntityReference` nodes,
+           * so this method is the only producer.
+           *
            * @deprecated
            * In DOM Level 4.
            * @param {string} name
            * The name of the entity to reference. No namespace well-formedness checks are performed.
            * @returns {EntityReference}
            * @throws {DOMException}
-           * With code `INVALID_CHARACTER_ERR` when `name` is not valid.
+           * With code `INVALID_CHARACTER_ERR` when `name` is not a valid XML `Name`.
            * @throws {DOMException}
            * with code `NOT_SUPPORTED_ERR` when the document is of type `html`
            * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-392B75AE
            */
           createEntityReference: function(name) {
-            if (!g.Name.test(name)) {
+            if (!g.Name_exact.test(name)) {
               throw new DOMException2(DOMException2.INVALID_CHARACTER_ERR, 'not a valid xml name "' + name + '"');
             }
             if (this.type === "html") {
@@ -2885,7 +2949,13 @@ var require_DOMParser = __commonJS({
           }
           return true;
         }
-        function addSerializedAttribute(buf, qualifiedName, value) {
+        function addSerializedAttribute(buf, qualifiedName, value, requireWellFormed) {
+          if (requireWellFormed && !g.QName_exact.test(qualifiedName)) {
+            throw new DOMException2(
+              'The attribute name "' + qualifiedName + '" is not a valid XML QName',
+              DOMExceptionName.InvalidStateError
+            );
+          }
           buf.push(" ", qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
         }
         function serializeToString(node, buf, visibleNamespaces, opts) {
@@ -2949,6 +3019,12 @@ var require_DOMParser = __commonJS({
                         }
                       }
                     }
+                    if (requireWellFormed && !g.QName_exact.test(prefixedNodeName)) {
+                      throw new DOMException2(
+                        'The element name "' + prefixedNodeName + '" is not a valid XML QName',
+                        DOMExceptionName.InvalidStateError
+                      );
+                    }
                     buf.push("<", prefixedNodeName);
                     var childNamespaces = namespaces.slice();
                     for (var i = 0; i < len; i++) {
@@ -2967,7 +3043,7 @@ var require_DOMParser = __commonJS({
                       if (needNamespaceDefine(attr, isHTML, childNamespaces)) {
                         var attrPrefix = attr.prefix || "";
                         var uri = attr.namespaceURI;
-                        addSerializedAttribute(buf, attrPrefix ? "xmlns:" + attrPrefix : "xmlns", uri);
+                        addSerializedAttribute(buf, attrPrefix ? "xmlns:" + attrPrefix : "xmlns", uri, requireWellFormed);
                         childNamespaces.push({ prefix: attrPrefix, namespace: uri });
                       }
                       var filteredAttr = nodeFilter ? nodeFilter(attr) : attr;
@@ -2975,14 +3051,14 @@ var require_DOMParser = __commonJS({
                         if (typeof filteredAttr === "string") {
                           buf.push(filteredAttr);
                         } else {
-                          addSerializedAttribute(buf, filteredAttr.name, filteredAttr.value);
+                          addSerializedAttribute(buf, filteredAttr.name, filteredAttr.value, requireWellFormed);
                         }
                       }
                     }
                     if (nodeName === prefixedNodeName && needNamespaceDefine(n, isHTML, childNamespaces)) {
                       var nodePrefix = n.prefix || "";
                       var uri = n.namespaceURI;
-                      addSerializedAttribute(buf, nodePrefix ? "xmlns:" + nodePrefix : "xmlns", uri);
+                      addSerializedAttribute(buf, nodePrefix ? "xmlns:" + nodePrefix : "xmlns", uri, requireWellFormed);
                       childNamespaces.push({ prefix: nodePrefix, namespace: uri });
                     }
                     var canCloseTag = !n.firstChild;
@@ -3015,7 +3091,7 @@ var require_DOMParser = __commonJS({
                     }
                     return { ns: namespaces };
                   case ATTRIBUTE_NODE:
-                    addSerializedAttribute(buf, n.name, n.value);
+                    addSerializedAttribute(buf, n.name, n.value, requireWellFormed);
                     return null;
                   case TEXT_NODE:
                     if (requireWellFormed && g.InvalidChar.test(n.data)) {
@@ -3057,6 +3133,12 @@ var require_DOMParser = __commonJS({
                     var pubid = n.publicId;
                     var sysid = n.systemId;
                     if (requireWellFormed) {
+                      if (!g.Name_exact.test(n.name)) {
+                        throw new DOMException2(
+                          'The doctype name "' + n.name + '" is not a valid XML Name',
+                          DOMExceptionName.InvalidStateError
+                        );
+                      }
                       if (pubid && !g.PubidLiteral_match.test(pubid)) {
                         throw new DOMException2("DocumentType publicId is not a valid PubidLiteral", DOMExceptionName.InvalidStateError);
                       }
@@ -3083,8 +3165,11 @@ var require_DOMParser = __commonJS({
                     return null;
                   case PROCESSING_INSTRUCTION_NODE:
                     if (requireWellFormed) {
-                      if (n.target.indexOf(":") !== -1 || n.target.toLowerCase() === "xml") {
-                        throw new DOMException2("The ProcessingInstruction target is not well-formed", DOMExceptionName.InvalidStateError);
+                      if (!g.NCName_exact.test(n.target) || n.target.toLowerCase() === "xml") {
+                        throw new DOMException2(
+                          'The processing instruction target "' + n.target + '" is not a valid XML NCName or is reserved',
+                          DOMExceptionName.InvalidStateError
+                        );
                       }
                       if (g.InvalidChar.test(n.data)) {
                         throw new DOMException2(
@@ -3099,6 +3184,12 @@ var require_DOMParser = __commonJS({
                     buf.push("<?", n.target, " ", n.data, "?>");
                     return null;
                   case ENTITY_REFERENCE_NODE:
+                    if (requireWellFormed && !g.Name_exact.test(n.nodeName)) {
+                      throw new DOMException2(
+                        'The entity reference name "' + n.nodeName + '" is not a valid XML Name',
+                        DOMExceptionName.InvalidStateError
+                      );
+                    }
                     buf.push("&", n.nodeName, ";");
                     return null;
                   //case ENTITY_NODE:
@@ -3236,6 +3327,25 @@ var require_DOMParser = __commonJS({
                 }
               }
             });
+            Object.defineProperty(CharacterData.prototype, "data", {
+              get: function() {
+                return this._data != null ? this._data : "";
+              },
+              set: function(v) {
+                this._data = v;
+                this.length = typeof v === "string" ? v.length : 0;
+              }
+            });
+            Object.defineProperty(CharacterData.prototype, "nodeValue", {
+              get: function() {
+                return this.data;
+              },
+              set: function(v) {
+                this.data = v;
+              },
+              enumerable: true,
+              configurable: true
+            });
             Object.defineProperty(Element.prototype, "children", {
               get: function() {
                 return new LiveNodeList(this, childrenRefresh);
@@ -5545,9 +5655,26 @@ var require_DOMParser = __commonJS({
                   if (!tagNameRaw) {
                     return errorHandler.fatalError("end tag name missing");
                   }
-                  var tagNameMatch = end > 0 && g.reg("^", g.QName_group, g.S_OPT, "$").exec(tagNameRaw);
+                  var endTagNameStrict = g.reg("^", g.QName_group, g.S_OPT, "$");
+                  var tagNameMatch = end > 0 && endTagNameStrict.exec(tagNameRaw);
                   if (!tagNameMatch) {
-                    return errorHandler.fatalError('end tag name contains invalid characters: "' + tagNameRaw + '"');
+                    var leadingTagNameMatch = end > 0 && g.reg("^", g.QName_group).exec(tagNameRaw);
+                    if (isHTML && leadingTagNameMatch) {
+                      errorHandler.warning('end tag name contains invalid trailing characters: "' + tagNameRaw + '"');
+                      tagNameMatch = leadingTagNameMatch;
+                    } else if (
+                      // Backward compatibility, remove this whole `else if` arm in the next breaking release
+                      // (XML then falls through to the `fatalError` below, for a clean mode split: XML fatal,
+                      // HTML warning). A valid end-tag name followed by a line break and trailing content was
+                      // silently accepted while `reg` still used the `m` flag; re-adding `m` here matches exactly
+                      // those inputs, kept recoverable and reported.
+                      leadingTagNameMatch && new RegExp(endTagNameStrict.source, endTagNameStrict.flags + "m").test(tagNameRaw)
+                    ) {
+                      errorHandler.error('end tag name is followed by a line break and trailing content: "' + tagNameRaw + '"');
+                      tagNameMatch = leadingTagNameMatch;
+                    } else {
+                      return errorHandler.fatalError('end tag name contains invalid characters: "' + tagNameRaw + '"');
+                    }
                   }
                   if (!domBuilder.currentElement && !domBuilder.doc.documentElement) {
                     return;
@@ -5621,7 +5748,7 @@ var require_DOMParser = __commonJS({
               if (e instanceof ParseError) {
                 throw e;
               } else if (e instanceof DOMException2) {
-                throw new ParseError(e.name + ": " + e.message, domBuilder.locator, e);
+                return errorHandler.fatalError("Error constructing the DOM: " + e.name + ": " + e.message, e);
               }
               errorHandler.error("element parse error: " + e);
               end = -1;
@@ -5662,6 +5789,9 @@ var require_DOMParser = __commonJS({
           var s = S_TAG;
           while (true) {
             var c = source.charAt(p);
+            if (s === S_TAG && c === "<") {
+              throw new Error("unexpected < in tag name: " + source.slice(start, p));
+            }
             switch (c) {
               case "=":
                 if (s === S_ATTR) {
@@ -5837,7 +5967,7 @@ var require_DOMParser = __commonJS({
             if (nsPrefix !== false) {
               if (localNSMap == null) {
                 localNSMap = /* @__PURE__ */ Object.create(null);
-                _copy(currentNSMap, currentNSMap = /* @__PURE__ */ Object.create(null));
+                currentNSMap = Object.create(currentNSMap);
               }
               currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
               a.uri = NAMESPACE.XMLNS;
@@ -5884,7 +6014,13 @@ var require_DOMParser = __commonJS({
         function parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {
           var isEscapableRaw = isHTMLEscapableRawTextElement(tagName);
           if (isEscapableRaw || isHTMLRawTextElement(tagName)) {
-            var elEndStart = source.indexOf("</" + tagName + ">", elStartEnd);
+            var closeTag = new RegExp("</" + tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + ">", "ig");
+            closeTag.lastIndex = elStartEnd;
+            var match = closeTag.exec(source);
+            var elEndStart = match ? match.index : -1;
+            if (elEndStart < 0) {
+              return elStartEnd + 1;
+            }
             var text = source.substring(elStartEnd + 1, elEndStart);
             if (isEscapableRaw) {
               text = text.replace(ENTITY_REG, entityReplacer);
@@ -6386,14 +6522,16 @@ var require_DOMParser = __commonJS({
            *
            * @param {string} message
            * - The message to be used for reporting and throwing the error.
+           * @param {Error} [cause]
+           * The error that caused this fatal error, preserved as the thrown `ParseError`'s `cause`.
            * @returns {never}
            * This function always throws an error and never returns a value.
            * @throws {ParseError}
            * Always throws a ParseError with the provided message.
            */
-          fatalError: function(message) {
+          fatalError: function(message, cause) {
             this.reportError("fatalError", message);
-            throw new ParseError(message, this.locator);
+            throw new ParseError(message, this.locator, cause);
           }
         };
         function _locator(l) {
@@ -6541,8 +6679,9 @@ async function BridgeNodeInit() {
   webSocketUrl.protocol = webSocketUrl.protocol === "https:" ? "wss:" : "ws:";
   const ctx = await (await fetch("/ctx")).json();
   let ws;
+  const NativeWebSocket = globalThis.fullstacked?.WebSocket || WebSocket;
   const webSocketForCallback = new Promise((res) => {
-    ws = new WebSocket(webSocketUrl);
+    ws = new NativeWebSocket(webSocketUrl);
     ws.binaryType = "arraybuffer";
     ws.onmessage = (e) => {
       globalThis.fullstacked.onStreamData(
@@ -6905,7 +7044,9 @@ async function BridgeLinuxInit() {
       }
     };
     globalThis.fullstacked.window = globalThis.fullstacked.window || {};
-    globalThis.fullstacked.window.getSize = () => (globalThis.fullstacked.fetch || fetch)("/resize").then((r) => r.text());
+    globalThis.fullstacked.window.getSize = () => (globalThis.fullstacked.fetch || fetch)("/resize").then(
+      (r) => r.text()
+    );
     globalThis.fullstacked.window.resize = function(size) {
       (globalThis.fullstacked.fetch || fetch)(`/resize?size=${size}`);
     };
@@ -7053,6 +7194,7 @@ var Fetch = 8;
 var Bundle = 9;
 var Packages = 12;
 var Plugin = 14;
+var WebSocket2 = 15;
 var CoreResponseError = 0;
 var CoreResponseData = 1;
 var CoreResponseStream = 2;
@@ -7820,6 +7962,237 @@ async function fetchCore(request, init2) {
 }
 var fetch_default = fetchCore;
 
+// ../../core/internal/bundle/lib/@types/websocket.ts
+var Connect = 0;
+
+// ../../core/internal/bundle/lib/websocket/index.ts
+var GlobalCloseEvent = typeof CloseEvent !== "undefined" ? CloseEvent : class CloseEvent2 extends Event {
+  code;
+  reason;
+  wasClean;
+  constructor(type2, eventInitDict) {
+    super(type2, eventInitDict);
+    this.code = eventInitDict?.code ?? 0;
+    this.reason = eventInitDict?.reason ?? "";
+    this.wasClean = eventInitDict?.wasClean ?? false;
+  }
+};
+var WebSocketCore = class _WebSocketCore extends EventTarget {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSING = 2;
+  CLOSED = 3;
+  url;
+  readyState = _WebSocketCore.CONNECTING;
+  bufferedAmount = 0;
+  protocol = "";
+  extensions = "";
+  binaryType = "blob";
+  onopen = null;
+  onerror = null;
+  onclose = null;
+  onmessage = null;
+  #duplex = null;
+  #ee = null;
+  constructor(url2, protocols) {
+    super();
+    let parsedUrl;
+    try {
+      if (url2 instanceof URL) {
+        parsedUrl = url2;
+      } else if (typeof url2 === "string") {
+        if (url2.startsWith("/") && typeof globalThis.location !== "undefined") {
+          const origin = globalThis.location.origin || globalThis.location.href || "http://localhost";
+          parsedUrl = new URL(url2, origin);
+          if (parsedUrl.protocol === "http:") {
+            parsedUrl.protocol = "ws:";
+          } else if (parsedUrl.protocol === "https:") {
+            parsedUrl.protocol = "wss:";
+          }
+        } else {
+          parsedUrl = new URL(url2);
+        }
+      } else {
+        throw new Error("Invalid URL");
+      }
+    } catch {
+      throw new DOMException(
+        `The URL '${url2}' is invalid.`,
+        "SyntaxError"
+      );
+    }
+    if (parsedUrl.protocol !== "ws:" && parsedUrl.protocol !== "wss:") {
+      throw new DOMException(
+        `The URL's scheme must be either 'ws' or 'wss'. '${parsedUrl.protocol}' is not allowed.`,
+        "SyntaxError"
+      );
+    }
+    this.url = parsedUrl.toString();
+    let parsedProtocols = [];
+    if (typeof protocols === "string") {
+      parsedProtocols = [protocols];
+    } else if (Array.isArray(protocols)) {
+      parsedProtocols = [...protocols];
+    }
+    this.#init(parsedProtocols);
+  }
+  async #init(protocols) {
+    try {
+      this.#duplex = await globalThis.fullstacked.bridge({
+        mod: WebSocket2,
+        fn: Connect,
+        data: [this.url, protocols]
+      });
+      this.#ee = this.#duplex.eventEmitter();
+      this.#ee.on("open", (selectedProtocol) => {
+        if (this.readyState === _WebSocketCore.CONNECTING) {
+          this.readyState = _WebSocketCore.OPEN;
+          this.protocol = selectedProtocol || "";
+          const event = new Event("open");
+          this.dispatchEvent(event);
+          this.onopen?.(event);
+        }
+      });
+      this.#ee.on(
+        "message",
+        (data, isBinary) => {
+          if (this.readyState !== _WebSocketCore.OPEN && this.readyState !== _WebSocketCore.CLOSING) {
+            return;
+          }
+          let messageData = data;
+          if (isBinary && data instanceof Uint8Array) {
+            if (this.binaryType === "arraybuffer") {
+              messageData = data.buffer.slice(
+                data.byteOffset,
+                data.byteOffset + data.byteLength
+              );
+            } else {
+              messageData = typeof Blob !== "undefined" ? new Blob([data]) : data.buffer.slice(
+                data.byteOffset,
+                data.byteOffset + data.byteLength
+              );
+            }
+          }
+          const event = new MessageEvent("message", {
+            data: messageData,
+            origin: this.url
+          });
+          this.dispatchEvent(event);
+          this.onmessage?.(event);
+        }
+      );
+      this.#ee.on("error", (errorMsg) => {
+        const event = new Event("error");
+        event.message = errorMsg;
+        this.dispatchEvent(event);
+        this.onerror?.(event);
+      });
+      this.#ee.on(
+        "close",
+        (code3, reason, wasClean) => {
+          if (this.readyState === _WebSocketCore.CLOSED) return;
+          this.readyState = _WebSocketCore.CLOSED;
+          const event = new GlobalCloseEvent("close", {
+            code: code3 || 1e3,
+            reason: reason || "",
+            wasClean: wasClean ?? code3 === 1e3
+          });
+          this.dispatchEvent(event);
+          this.onclose?.(event);
+        }
+      );
+      this.#duplex.on("close", () => {
+        if (this.readyState !== _WebSocketCore.CLOSED) {
+          this.readyState = _WebSocketCore.CLOSED;
+          const event = new GlobalCloseEvent("close", {
+            code: 1006,
+            reason: "",
+            wasClean: false
+          });
+          this.dispatchEvent(event);
+          this.onclose?.(event);
+        }
+      });
+    } catch (err) {
+      queueMicrotask(() => {
+        this.readyState = _WebSocketCore.CLOSED;
+        const errorEvent = new Event("error");
+        errorEvent.message = err?.message || String(err);
+        this.dispatchEvent(errorEvent);
+        this.onerror?.(errorEvent);
+        const closeEvent = new GlobalCloseEvent("close", {
+          code: 1006,
+          reason: err?.message || String(err),
+          wasClean: false
+        });
+        this.dispatchEvent(closeEvent);
+        this.onclose?.(closeEvent);
+      });
+    }
+  }
+  send(data) {
+    if (this.readyState === _WebSocketCore.CONNECTING) {
+      throw new DOMException(
+        "WebSocket is still in CONNECTING state.",
+        "InvalidStateError"
+      );
+    }
+    if (this.readyState !== _WebSocketCore.OPEN) {
+      return;
+    }
+    if (typeof data === "string") {
+      this.#duplex?.writeEvent("send", data, false);
+    } else if (data instanceof Uint8Array) {
+      this.#duplex?.writeEvent("send", data, true);
+    } else if (data instanceof ArrayBuffer) {
+      this.#duplex?.writeEvent("send", new Uint8Array(data), true);
+    } else if (ArrayBuffer.isView(data)) {
+      this.#duplex?.writeEvent(
+        "send",
+        new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+        true
+      );
+    } else if (typeof Blob !== "undefined" && data instanceof Blob) {
+      data.arrayBuffer().then((buf) => {
+        if (this.readyState === _WebSocketCore.OPEN) {
+          this.#duplex?.writeEvent("send", new Uint8Array(buf), true);
+        }
+      });
+    } else {
+      this.#duplex?.writeEvent("send", String(data), false);
+    }
+  }
+  close(code3, reason) {
+    if (code3 !== void 0) {
+      if (code3 !== 1e3 && (code3 < 3e3 || code3 > 4999)) {
+        throw new DOMException(
+          `The code must be either 1000, or between 3000 and 4999. Received ${code3}`,
+          "InvalidAccessError"
+        );
+      }
+    }
+    if (reason !== void 0) {
+      const byteLength = new TextEncoder().encode(reason).byteLength;
+      if (byteLength > 123) {
+        throw new DOMException(
+          "The reason must not be longer than 123 bytes.",
+          "SyntaxError"
+        );
+      }
+    }
+    if (this.readyState === _WebSocketCore.CLOSING || this.readyState === _WebSocketCore.CLOSED) {
+      return;
+    }
+    this.readyState = _WebSocketCore.CLOSING;
+    this.#duplex?.writeEvent("close", code3 ?? 1e3, reason ?? "");
+  }
+};
+var websocket_default = WebSocketCore;
+
 // ../../core/internal/bundle/lib/@types/fs.ts
 var Exists = 0;
 var Stats = 1;
@@ -7855,7 +8228,7 @@ var Exit = 5;
 init_isWorker();
 
 // ../../core/internal/bundle/lib/process/version.json
-var version_default = { major: "1", minor: "0", patch: "0-alpha", branch: "v1", build: "1783", hash: "58f6546ee36a4629ac9a7e4ffba71d768b42fdbb" };
+var version_default = { major: "1", minor: "0", patch: "0-alpha", branch: "v1", build: "1804", hash: "ac2b3e1d237ddbb5538d1f42fe7ec23ad7df9c21" };
 
 // ../../core/internal/bundle/lib/timers/index.ts
 var setTimeout2 = globalThis.setTimeout.bind(globalThis);
@@ -7871,12 +8244,12 @@ globalThis.clearImmediate = ((id) => {
 
 // ../../core/internal/bundle/lib/process/index.ts
 var Item = class {
+  fun;
+  array;
   constructor(fun, array) {
     this.fun = fun;
     this.array = array;
   }
-  fun;
-  array;
   run() {
     this.fun.apply(null, this.array);
   }
@@ -8850,8 +9223,14 @@ async function init() {
   globalThis.fullstacked.platformBridge = platformBridge2;
   globalThis.fullstacked.bridge = bridge;
   globalThis.fullstacked.fetch = fetch.bind(globalThis);
+  if (typeof WebSocket !== "undefined") {
+    globalThis.fullstacked.WebSocket = WebSocket;
+  }
   globalThis.fullstacked.onStreamData = duplex_default;
   globalThis.fetch = fetch_default;
+  if (typeof window !== "undefined" || !globalThis.process?.versions?.node) {
+    globalThis.WebSocket = websocket_default;
+  }
   await Promise.all([import("timers"), import("buffer")]);
   if (!globalThis.process) {
     globalThis.process = (await import("process")).default;
@@ -8912,11 +9291,12 @@ function bundleFile(entryPoint) {
 async function run(directoryOrOptions) {
   const directory = typeof directoryOrOptions === "string" ? directoryOrOptions : directoryOrOptions?.directory;
   const env2 = typeof directoryOrOptions === "object" ? directoryOrOptions.env : void 0;
+  const safe = typeof directoryOrOptions === "object" ? directoryOrOptions.safe : void 0;
   const resolved = path_default.resolve(directory ?? ".");
   const newCtx = await globalThis.fullstacked.bridge({
     mod: Core,
     fn: Run,
-    data: [resolved, env2]
+    data: [resolved, env2, safe]
   });
   return newCtx;
 }
@@ -9231,7 +9611,8 @@ function getPositionalArgs(args2) {
     ["-v", "--version"],
     ["-o", "--open"],
     ["-n", "--no-open"],
-    ["-b", "--build"]
+    ["-b", "--build"],
+    ["-s", "--safe"]
   ];
   for (let i = 0; i < args2.length; i++) {
     const arg = args2[i];
@@ -9279,6 +9660,7 @@ function getExtraArgs(args2) {
     ["-v", "--version"],
     ["-o", "--open"],
     ["-n", "--no-open"],
+    ["-s", "--safe"],
     ["-b", "--build"]
   ];
   for (let i = 0; i < args2.length; i++) {
@@ -9374,21 +9756,60 @@ async function bundleAndImportFile(file, startDir, writeErr, extraArgs) {
   }
 }
 async function runFile(file, extraArgs, writeOut, writeErr) {
-  const res = await bundleAndImportFile(
-    file,
-    process.cwd(),
-    writeErr,
-    extraArgs
-  );
-  if (!res) return 1;
+  const originalWebSocket = globalThis.WebSocket;
+  const hasOriginalWindow = "window" in globalThis;
+  const hasOriginalBuffer = "Buffer" in globalThis;
+  const originalBuffer = globalThis.Buffer;
+  const hasOriginalFullstacked = "fullstacked" in globalThis;
+  const originalFullstackedWebSocket = globalThis.fullstacked?.WebSocket;
+  if (!globalThis.fullstacked) {
+    globalThis.fullstacked = {};
+  }
+  if (originalWebSocket && !globalThis.fullstacked.WebSocket) {
+    globalThis.fullstacked.WebSocket = originalWebSocket;
+  }
+  globalThis.WebSocket = websocket_default;
+  if (!hasOriginalWindow) {
+    globalThis.window = globalThis;
+  }
   try {
-    await waitForInterfaces();
+    const res = await bundleAndImportFile(
+      file,
+      process.cwd(),
+      writeErr,
+      extraArgs
+    );
+    if (!res) return 1;
+    try {
+      await waitForInterfaces();
+    } finally {
+      await res.cleanup();
+    }
+    return 0;
   } finally {
-    await res.cleanup();
+    if (originalWebSocket) {
+      globalThis.WebSocket = originalWebSocket;
+    } else {
+      delete globalThis.WebSocket;
+    }
+    if (!hasOriginalWindow) {
+      delete globalThis.window;
+    }
+    if (!hasOriginalBuffer) {
+      delete globalThis.Buffer;
+    } else {
+      globalThis.Buffer = originalBuffer;
+    }
+    if (!hasOriginalFullstacked) {
+      delete globalThis.fullstacked;
+    } else if (originalFullstackedWebSocket) {
+      globalThis.fullstacked.WebSocket = originalFullstackedWebSocket;
+    } else {
+      delete globalThis.fullstacked.WebSocket;
+    }
   }
-  return 0;
 }
-async function runDirectory(positionals, pluginsArgs, buildOnly, noOpen, env2, writeOut, writeErr) {
+async function runDirectory(positionals, pluginsArgs, buildOnly, noOpen, env2, safe, writeOut, writeErr) {
   const targetDirectory = path_default.resolve(positionals.at(-1) || ".");
   const buildPlugins = [];
   const tempPluginFiles = [];
@@ -9453,7 +9874,7 @@ async function runDirectory(positionals, pluginsArgs, buildOnly, noOpen, env2, w
     await cleanupPlugins();
     return 0;
   }
-  const newCtx = await run_default({ directory: targetDirectory, env: env2 });
+  const newCtx = await run_default({ directory: targetDirectory, env: env2, safe });
   await cleanupPlugins();
   if (!noOpen && typeof newCtx === "number") {
     globalThis.fullstacked.open?.(newCtx);
@@ -9527,6 +9948,7 @@ Options:
   -o, --open    Directly open the browser
   -b, --build   Only bundle the project, don't run it afterward
   -f, --file    Bundle and execute a single script file
+  -s, --safe    Skip the initialDirectory config check
   -h, --help    Display this help message
 
 Directory:
@@ -9540,6 +9962,7 @@ Directory:
   const noOpen = hasArgFlag(["-n", "--no-open"], args2);
   const envArgs = findArgValues(["-e", "--env"], args2);
   const pluginsArgs = findArgValues(["-p", "--plugin"], args2);
+  const safe = hasArgFlag(["-s", "--safe"], args2);
   const positionals = getPositionalArgs(args2);
   const env2 = {};
   for (const val of envArgs) {
@@ -9560,6 +9983,7 @@ Directory:
     buildOnly,
     noOpen,
     env2,
+    safe,
     writeOut,
     writeErr
   );

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "fullstacked",
-    "version": "1.0.0-alpha.1783",
+    "version": "1.0.0-alpha.1804",
     "bin": {
         "fullstacked": "index.js"
     },
     "type": "module",
     "scripts": {
-        "build": "node -r @nitrogql/esbuild-register build",
+        "build": "node build.ts",
         "prepack": "npm run build"
     },
     "dependencies": {
@@ -14,18 +14,17 @@
         "ws": "^8.21.1"
     },
     "devDependencies": {
-        "@nitrogql/esbuild-register": "^1.7.2",
         "@types/ws": "^8.18.1",
         "esbuild": "^0.28.1",
         "node-addon-api": "^8.9.0"
     },
     "optionalDependencies": {
-        "@fullstacked/darwin-arm64": "1.0.0-alpha.1783",
-        "@fullstacked/darwin-x64": "1.0.0-alpha.1783",
-        "@fullstacked/linux-arm64": "1.0.0-alpha.1783",
-        "@fullstacked/linux-x64": "1.0.0-alpha.1783",
-        "@fullstacked/win32-arm64": "1.0.0-alpha.1783",
-        "@fullstacked/win32-x64": "1.0.0-alpha.1783"
+        "@fullstacked/darwin-arm64": "1.0.0-alpha.1804",
+        "@fullstacked/darwin-x64": "1.0.0-alpha.1804",
+        "@fullstacked/linux-arm64": "1.0.0-alpha.1804",
+        "@fullstacked/linux-x64": "1.0.0-alpha.1804",
+        "@fullstacked/win32-arm64": "1.0.0-alpha.1804",
+        "@fullstacked/win32-x64": "1.0.0-alpha.1804"
     },
     "author": "FullStacked",
     "license": "MIT",
@@ -45,6 +44,9 @@
         "./bundle": {
             "types": "./types/bundle/index.d.ts"
         },
+        "./config": {
+            "types": "./types/config/index.d.ts"
+        },
         "./git": {
             "types": "./types/git/index.d.ts"
         },

package/types/@types/config.d.ts

@@ -0,0 +1,5 @@
+export type ConfigFn = number;
+export declare const Get: ConfigFn;
+export declare const Set: ConfigFn;
+export declare const List: ConfigFn;
+export declare const Delete: ConfigFn;

package/types/@types/index.d.ts

@@ -14,6 +14,8 @@ export declare const Git: CoreModule;
 export declare const Packages: CoreModule;
 export declare const Dgram: CoreModule;
 export declare const Plugin: CoreModule;
+export declare const WebSocket: CoreModule;
+export declare const Config: CoreModule;
 export type ModuleSwitch = any;
 export type CoreCallResponseType = number;
 export declare const CoreResponseError: CoreCallResponseType;
@@ -85,7 +87,6 @@ export interface Context {
         [key: string]: string;
     };
     Cwd: string;
-    NodePaths: string[];
     Responses: {
         [key: number]: string;
     };
@@ -104,7 +105,7 @@ export interface Context {
         [key: string]: GitAuth | undefined;
     };
     GitAuthsMutex?: any;
-    Exit: boolean;
+    Exited: boolean;
 }
 export type SerializableData = any;
 export type SerializableDataType = number;

package/types/@types/packages.d.ts

@@ -53,25 +53,38 @@ export interface PackageMetadata {
 export interface PackageVersion {
     name: string;
     version: string;
-    dependencies: {
+    dependencies?: {
+        [key: string]: string;
+    };
+    devDependencies?: {
         [key: string]: string;
     };
     optionalDependencies?: {
         [key: string]: string;
     };
-    /**
-     * DevDependencies removed as unused in sub-deps logic
-     */
-    dist: PackageDist;
-    license?: any;
-    engines?: any;
     peerDependencies?: {
         [key: string]: string;
     };
+    peerDependenciesMeta?: {
+        [key: string]: {
+            optional?: boolean;
+        };
+    };
     bundleDependencies?: BundleDependenciesWrapper;
     bundledDependencies?: BundleDependenciesWrapper;
+    dist: PackageDist;
+    license?: any;
+    funding?: any;
+    bin?: any;
+    engines?: any;
     os?: string[];
     cpu?: string[];
+    libc?: string[];
+    deprecated?: any;
+    hasInstallScript?: boolean;
+    scripts?: {
+        [key: string]: string;
+    };
 }
 export type BundleDependenciesWrapper = string[];
 export interface PackageDist {
@@ -89,41 +102,54 @@ export interface PackageLock {
     };
 }
 export interface LockDependency {
+    name?: string;
     version?: string;
     resolved?: string;
     integrity?: string;
-    dependencies?: {
+    dev?: boolean;
+    optional?: boolean;
+    devOptional?: boolean;
+    peer?: boolean;
+    inBundle?: boolean;
+    hasInstallScript?: boolean;
+    hasShrinkwrap?: boolean;
+    license?: string;
+    funding?: any;
+    bin?: {
         [key: string]: string;
     };
-    optionalDependencies?: {
+    dependencies?: {
         [key: string]: string;
     };
-    license?: string;
-    engines?: {
+    devDependencies?: {
         [key: string]: string;
     };
     peerDependencies?: {
         [key: string]: string;
     };
-    peer?: boolean;
-    optional?: boolean;
-    os?: string[];
-    cpu?: string[];
-}
-/**
- * Queue for BFS
- */
-export interface QueueItem {
-    ParentPath: string;
-    Deps: {
-        [key: string]: string;
+    peerDependenciesMeta?: {
+        [key: string]: any;
     };
-    OptionalDeps: {
+    optionalDependencies?: {
         [key: string]: string;
     };
-    PeerDeps: {
+    bundleDependencies?: string[];
+    engines?: {
         [key: string]: string;
     };
+    os?: string[];
+    cpu?: string[];
+    libc?: string[];
+    deprecated?: string;
+}
+export interface DepItem {
+    Name: string;
+    Range: string;
+    Optional: boolean;
+}
+export interface QueueItem {
+    ParentPath: string;
+    Items: DepItem[];
 }
 export interface ProgressReader {
     Reader: any;

package/types/@types/websocket.d.ts

@@ -0,0 +1,2 @@
+export type WebSocketFn = number;
+export declare const Connect: WebSocketFn;

package/types/bridge/duplex.d.ts

@@ -1,4 +1,4 @@
-import { SerializableData } from "../@types/index.ts";
+import { type SerializableData } from "../@types/index.ts";
 import { createEventEmitter } from "./eventEmitter.ts";
 declare function onStreamData(id: number, payload: ArrayBuffer | string): void;
 type StreamData = string | Buffer | Uint8Array | DataView;

package/types/bridge/index.d.ts

@@ -1,4 +1,4 @@
-import { CoreModule, SerializableData } from "../@types/index.ts";
+import { type CoreModule, type SerializableData } from "../@types/index.ts";
 import type platformBridgeType from "./platform/index.ts";
 import type { JSPlugin } from "../plugin/index.ts";
 declare global {
@@ -24,6 +24,7 @@ type FullStacked = {
         respondGetSize?: (response: any) => void;
     };
     fetch: typeof fetch;
+    WebSocket: typeof WebSocket;
     open?: (ctx: number) => void;
 };
 type BridgeOpts = {

package/types/bridge/platform/android.d.ts

@@ -1,4 +1,4 @@
-import { PlatformBridge } from "./index.ts";
+import type { PlatformBridge } from "./index.ts";
 declare global {
     var android: {
         coreCall?: (payloadBase64: string) => string;

package/types/bridge/platform/apple.d.ts

@@ -1,2 +1,2 @@
-import { PlatformBridge } from "./index.ts";
+import type { PlatformBridge } from "./index.ts";
 export declare function BridgeAppleInit(): Promise<PlatformBridge>;

package/types/bridge/platform/linux.d.ts

@@ -1,4 +1,4 @@
-import { PlatformBridge } from "./index.ts";
+import type { PlatformBridge } from "./index.ts";
 declare global {
     var webkit: any;
     var chrome: any;

package/types/bridge/platform/windows.d.ts

@@ -1,2 +1,2 @@
-import { PlatformBridge } from "./index.ts";
+import type { PlatformBridge } from "./index.ts";
 export declare function BridgeWindowsInit(): Promise<PlatformBridge>;

package/types/bridge/serialization.d.ts

@@ -1,4 +1,4 @@
-import { SerializableData, SerializableDataType } from "../@types/index.ts";
+import { type SerializableData, type SerializableDataType } from "../@types/index.ts";
 export declare function numberToUint4Bytes(num: number): Uint8Array<ArrayBuffer>;
 export declare function uint4BytesToNumber(bytes: Uint8Array): number;
 export declare function serializeUndefined(): Uint8Array<ArrayBuffer>;

package/types/bundle/index.d.ts

@@ -1,4 +1,4 @@
-import { EsbuildResult } from "../@types/bundle.ts";
+import { type EsbuildResult } from "../@types/bundle.ts";
 export declare function esbuildVersion(): Promise<string>;
 export declare function bundle(entryPoint?: string): Promise<EsbuildResult>;
 export declare function bundleFile(entryPoint: string): Promise<EsbuildResult>;

package/types/config/index.d.ts

@@ -0,0 +1,21 @@
+export declare function get(key?: string): Promise<string | undefined>;
+export declare function set(key: string, value: string): Promise<void>;
+export declare function list(): Promise<Record<string, string>>;
+export declare function del(key: string): Promise<void>;
+export { del as delete };
+export declare const getConfig: typeof get;
+export declare const setConfig: typeof set;
+export declare const listConfig: typeof list;
+export declare const deleteConfig: typeof del;
+declare const config: {
+    get: typeof get;
+    set: typeof set;
+    list: typeof list;
+    delete: typeof del;
+    del: typeof del;
+    getConfig: typeof get;
+    setConfig: typeof set;
+    listConfig: typeof list;
+    deleteConfig: typeof del;
+};
+export default config;

package/types/fs/common.d.ts

@@ -1,4 +1,4 @@
-import { GoFileInfo } from "../@types/fs";
+import type { GoFileInfo } from "../@types/fs.ts";
 export type PathLike = string | URL | Buffer;
 export declare function formatPathLike(path: PathLike): string;
 export type ReadFileOpts = string | {

package/types/fs/index.d.ts

@@ -1,5 +1,5 @@
 import { Writable } from "stream";
-import { Dirent, PathLike, ReadFileOpts, StatOpts, Stats as StatsInterface } from "./common.ts";
+import { type Dirent, type PathLike, type ReadFileOpts, type StatOpts, type Stats as StatsInterface } from "./common.ts";
 export declare function existsSync(path: PathLike): boolean;
 export declare function statSync(path: PathLike, options?: StatOpts): StatsInterface;
 type StatCallback = (err: Error, stat: StatsInterface) => void;

package/types/fs/promises.d.ts

@@ -1,4 +1,4 @@
-import { Dirent, PathLike, ReadFileOpts, StatOpts, Stats as StatsInterface } from "./common.ts";
+import { type Dirent, type PathLike, type ReadFileOpts, type StatOpts, type Stats as StatsInterface } from "./common.ts";
 export declare function readFile(path: PathLike): Promise<Buffer<ArrayBuffer>>;
 export declare function readFile(path: PathLike, options: ReadFileOpts): Promise<string>;
 export declare function readdir(path: PathLike, options: {

package/types/git/index.d.ts

@@ -1,4 +1,4 @@
-import { GitAuthor, GitBranch, GitCommit, GitHead, GitProxy, GitStatus, GitTag } from "../@types/git.ts";
+import { type GitAuthor, type GitBranch, type GitCommit, type GitHead, type GitProxy, type GitStatus, type GitTag } from "../@types/git.ts";
 import type { Duplex } from "../bridge/duplex.ts";
 export declare function createGitAuthManager(): Promise<{
     on(): void;

package/types/packages/index.d.ts

@@ -1,5 +1,5 @@
-import { Progress } from "../@types/packages.ts";
-import { EventEmitter } from "../bridge/eventEmitter.ts";
+import { type Progress } from "../@types/packages.ts";
+import type { EventEmitter } from "../bridge/eventEmitter.ts";
 export declare function install(directory: string, saveDev: boolean, ...packages: string[]): Promise<EventEmitter<{
     progress: Progress[];
 }>>;

package/types/path/index.d.ts

@@ -1,4 +1,4 @@
-import { ParsedPath } from "../@types/path.ts";
+import { type ParsedPath } from "../@types/path.ts";
 export declare let sep: string;
 export declare function isAbsolute(path: string): boolean;
 export declare function resolve(...paths: string[]): string;

package/types/plugin/index.d.ts

@@ -1,5 +1,5 @@
-import { GitAuth, PluginTypeGitAuth, PluginTypeBuild } from "../@types/index.ts";
-import { PluginBuildData, PluginParams } from "../@types/bundle.ts";
+import { type GitAuth, PluginTypeGitAuth, PluginTypeBuild } from "../@types/index.ts";
+import type { PluginBuildData, PluginParams } from "../@types/bundle.ts";
 type CommonPluginData = {
     name?: string;
 };

package/types/run/index.d.ts

@@ -1,6 +1,7 @@
 type RunOptions = {
     directory?: string;
     env?: Record<string, string>;
+    safe?: boolean;
 };
 export declare function run(directoryOrOptions?: string | RunOptions): Promise<number>;
 export default run;

package/types/tunnel/index.d.ts

@@ -1,4 +1,4 @@
-import { Tunnel } from "../@types/tunnel.ts";
+import { type Tunnel } from "../@types/tunnel.ts";
 export declare function register(tunnel: Tunnel): Promise<string>;
 declare const tunnel: {
     register: typeof register;

package/types/websocket/index.d.ts

@@ -0,0 +1,25 @@
+export declare class WebSocketCore extends EventTarget {
+    #private;
+    static readonly CONNECTING = 0;
+    static readonly OPEN = 1;
+    static readonly CLOSING = 2;
+    static readonly CLOSED = 3;
+    readonly CONNECTING = 0;
+    readonly OPEN = 1;
+    readonly CLOSING = 2;
+    readonly CLOSED = 3;
+    readonly url: string;
+    readyState: number;
+    bufferedAmount: number;
+    protocol: string;
+    extensions: string;
+    binaryType: "blob" | "arraybuffer";
+    onopen: ((this: WebSocketCore, ev: Event) => any) | null;
+    onerror: ((this: WebSocketCore, ev: Event) => any) | null;
+    onclose: ((this: WebSocketCore, ev: CloseEvent) => any) | null;
+    onmessage: ((this: WebSocketCore, ev: MessageEvent) => any) | null;
+    constructor(url: string | URL, protocols?: string | string[]);
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+}
+export default WebSocketCore;