@base44-preview/cli 0.1.32-pr.664.478a865 → 0.1.32-pr.664.f359bf9

package/dist/cli/index.js

@@ -253402,8 +253402,12 @@ var deno2 = Object.freeze({
 });
 globalThis.Deno = deno2;
 globalThis.Buffer = Buffer2;
-AsyncLocalStorage.prototype.enterWith = () => {
-};
+try {
+  new AsyncLocalStorage().enterWith(void 0);
+} catch {
+  AsyncLocalStorage.prototype.enterWith = () => {
+  };
+}
 function getRegisteredHandler() {
   return registeredHandler;
 }
@@ -260998,27 +261002,43 @@ var NAMESPACE4 = "base44-ws-native";
 var WS_SPECIFIER = /^(npm:)?ws(@[^/]+)?$/;
 var ADAPTER = `"use strict";
 const toBuffer = (value) => (globalThis.Buffer ? globalThis.Buffer.from(value) : value);
+const READY_STATES = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+const later = (fn, ...args) => queueMicrotask(() => fn(...args));
+const upgradeHeaders = (options) => {
+  const headers = new Headers(options?.headers);
+  for (const name of headers.keys()) if (name !== "user-agent") return headers;
+  return null;
+};
 class WebSocket {
   static CONNECTING = 0;
   static OPEN = 1;
   static CLOSING = 2;
   static CLOSED = 3;
-  #socket;
+  #socket = null;
+  #state = 0;
+  #url;
+  #closeRequested = null;
+  #terminated = false;
   #listeners = new Map();
-  constructor(address, protocols) {
-    this.#socket = new globalThis.WebSocket(String(address), typeof protocols === "string" || Array.isArray(protocols) ? protocols : undefined);
-    try { this.#socket.binaryType = "arraybuffer"; } catch {}
-    this.#socket.addEventListener("open", () => this.emit("open"));
-    this.#socket.addEventListener("message", (event) => {
-      const isBinary = typeof event.data !== "string";
-      this.emit("message", toBuffer(isBinary ? new Uint8Array(event.data) : event.data), isBinary);
-    });
-    this.#socket.addEventListener("error", (event) => this.emit("error", event.error ?? new Error(event.message || "WebSocket error")));
-    this.#socket.addEventListener("close", (event) => this.emit("close", event.code, toBuffer(event.reason ?? "")));
+  constructor(address, protocols, options) {
+    if (protocols && typeof protocols === "object" && !Array.isArray(protocols)) {
+      options = protocols;
+      protocols = undefined;
+    }
+    this.#url = String(address);
+    const headers = upgradeHeaders(options);
+    if (headers) {
+      this.#upgrade(headers, protocols);
+    } else {
+      this.#attach(new globalThis.WebSocket(this.#url, protocols));
+    }
   }
-  get readyState() { return this.#socket.readyState; }
-  get url() { return this.#socket.url; }
-  get protocol() { return this.#socket.protocol; }
+  get readyState() {
+    if (this.#terminated) return 3;
+    return this.#socket ? this.#socket.readyState : this.#state;
+  }
+  get url() { return this.#url; }
+  get protocol() { return this.#socket ? this.#socket.protocol ?? "" : ""; }
   on(name, listener) { return this.#add(name, listener, false); }
   addListener(name, listener) { return this.#add(name, listener, false); }
   once(name, listener) { return this.#add(name, listener, true); }
@@ -261042,6 +261062,9 @@ class WebSocket {
   send(data, options, callback) {
     const done = typeof options === "function" ? options : callback;
     try {
+      if (!this.#socket) {
+        throw new Error("WebSocket is not open: readyState " + this.#state + " (" + READY_STATES[this.#state] + ")");
+      }
       this.#socket.send(data);
       done?.();
     } catch (error) {
@@ -261049,8 +261072,66 @@ class WebSocket {
       done(error);
     }
   }
-  close(code, reason) { this.#socket.close(code, reason); }
-  terminate() { this.#socket.close(); }
+  close(code, reason) {
+    if (this.#socket) this.#socket.close(code, reason);
+    else if (this.#state === 0) {
+      // Upgrade still in flight: close as soon as it lands.
+      this.#closeRequested = [code, reason];
+      this.#state = 2;
+    }
+  }
+  // \`ws\` tears the connection down at once. workerd has no abrupt close, so the
+  // socket is closed normally and "close" is reported now, not on the reply.
+  terminate() {
+    if (this.#terminated || this.readyState === 3) return;
+    this.#terminated = true;
+    if (this.#socket) {
+      try { this.#socket.close(); } catch {}
+    } else {
+      // Upgrade still in flight: close it on arrival, without an "open".
+      this.#closeRequested = [];
+      this.#state = 3;
+    }
+    later(() => this.emit("close", 1006, toBuffer("")));
+  }
+  #attach(socket) {
+    this.#socket = socket;
+    try { socket.binaryType = "arraybuffer"; } catch {}
+    socket.addEventListener("open", () => this.emit("open"));
+    socket.addEventListener("message", (event) => {
+      const isBinary = typeof event.data !== "string";
+      this.emit("message", toBuffer(isBinary ? new Uint8Array(event.data) : event.data), isBinary);
+    });
+    socket.addEventListener("error", (event) => this.emit("error", event.error ?? new Error(event.message || "WebSocket error")));
+    socket.addEventListener("close", (event) => {
+      if (!this.#terminated) this.emit("close", event.code, toBuffer(event.reason ?? ""));
+    });
+  }
+  #upgrade(headers, protocols) {
+    headers.set("Upgrade", "websocket");
+    if (protocols) headers.set("Sec-WebSocket-Protocol", [].concat(protocols).join(", "));
+    const httpUrl = this.#url.replace(/^ws(s?):/i, "http$1:");
+    const fail = (error) => {
+      this.#state = 3;
+      if (this.#terminated) return;
+      this.emit("error", error);
+      this.emit("close", 1006, toBuffer(""));
+    };
+    // Two-argument then(): an exception from an "open" listener must not be
+    // reported as a failed upgrade.
+    fetch(httpUrl, { headers }).then((response) => {
+      const socket = response.webSocket;
+      if (!socket) {
+        response.body?.cancel();
+        return fail(new Error("Unexpected server response: " + response.status));
+      }
+      socket.accept();
+      this.#attach(socket);
+      if (this.#closeRequested) return socket.close(...this.#closeRequested);
+      // accept() opens the socket without dispatching an "open" event.
+      this.emit("open");
+    }, fail);
+  }
   #add(name, listener, once) {
     const listeners = this.#listeners.get(name) ?? [];
     listeners.push({ listener, once });
@@ -271496,4 +271577,4 @@ export {
   runCLI
 };
 
-//# debugId=F78FCF622784F43164756E2164756E21
+//# debugId=FAC4CC784F55ED6664756E2164756E21