@phpsandbox/sdk 0.0.33 → 0.0.35

package/dist/browser/phpsandbox-sdk.esm.js

@@ -3102,6 +3102,89 @@ var ReconnectingWebSocket = (
 );
 var reconnecting_websocket_mjs_default = ReconnectingWebSocket;
 
+// src/utils/websocket.ts
+var getReadyStateLabel = (state) => {
+  if (typeof state !== "number") {
+    return void 0;
+  }
+  return {
+    0: "CONNECTING",
+    1: "OPEN",
+    2: "CLOSING",
+    3: "CLOSED"
+  }[state] ?? `STATE_${state}`;
+};
+var sanitizeWebSocketUrl = (value) => {
+  try {
+    const url = new URL(value);
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return value;
+  }
+};
+var extractNestedErrorMessage = (value) => {
+  if (value instanceof Error) {
+    return value.message ? `${value.name}: ${value.message}` : value.name;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const record = value;
+  const message = typeof record.message === "string" && record.message ? record.message : typeof record.reason === "string" && record.reason ? record.reason : void 0;
+  if (!message) {
+    return void 0;
+  }
+  const name = typeof record.name === "string" && record.name ? record.name : void 0;
+  return name ? `${name}: ${message}` : message;
+};
+var describeWebSocketEvent = (event) => {
+  if (event instanceof Error) {
+    return event.message ? `${event.name}: ${event.message}` : event.name;
+  }
+  if (typeof event === "string") {
+    return event;
+  }
+  if (!event || typeof event !== "object") {
+    return String(event);
+  }
+  const record = event;
+  const parts = [];
+  const topLevelMessage = extractNestedErrorMessage(record);
+  if (topLevelMessage) {
+    parts.push(topLevelMessage);
+  }
+  const nestedErrorMessage = extractNestedErrorMessage(record.error);
+  if (nestedErrorMessage && nestedErrorMessage !== topLevelMessage) {
+    parts.push(`error=${nestedErrorMessage}`);
+  }
+  if (typeof record.type === "string" && record.type) {
+    parts.push(`type=${record.type}`);
+  }
+  if (typeof record.code === "number") {
+    parts.push(`code=${record.code}`);
+  }
+  if (typeof record.reason === "string" && record.reason && record.reason !== topLevelMessage) {
+    parts.push(`reason=${record.reason}`);
+  }
+  if (typeof record.wasClean === "boolean") {
+    parts.push(`wasClean=${record.wasClean}`);
+  }
+  const target = record.target ?? record.currentTarget;
+  if (target && typeof target === "object") {
+    if (typeof target.url === "string" && target.url) {
+      parts.push(`url=${sanitizeWebSocketUrl(target.url)}`);
+    }
+    const readyState = getReadyStateLabel(target.readyState);
+    if (readyState) {
+      parts.push(`readyState=${readyState}`);
+    }
+  }
+  return parts.length > 0 ? parts.join(" | ") : "Unknown websocket event";
+};
+
 // node_modules/isomorphic-ws/browser.js
 var ws = null;
 if (typeof WebSocket !== "undefined") {
@@ -3139,6 +3222,19 @@ var NamedDisposable = class {
 };
 
 // src/socket/index.ts
+var ConnectionTimeoutError = class extends Error {
+  constructor(message = "WebSocket connection timeout") {
+    super(message);
+    this.name = "ConnectionTimeoutError";
+  }
+};
+var ConnectionFailedError = class extends Error {
+  constructor(message, originalError) {
+    super(message);
+    this.originalError = originalError;
+    this.name = "ConnectionFailedError";
+  }
+};
 var InvalidMessageError = class extends Error {
   constructor(message, data) {
     super(message);
@@ -3190,6 +3286,7 @@ var Transport = class {
     this.validateConfiguration(options);
     this.url = new URL(url);
     this.PING_INTERVAL = options.pingInterval ?? 3e4;
+    this.CONNECT_WAIT_TIMEOUT = options.connectWaitTimeout ?? 3e4;
     this.connectionStats.connectionStartTime = Date.now();
     const startClosed = options.startClosed !== false;
     this.rws = new reconnecting_websocket_mjs_default(this.url.toString(), [], {
@@ -3219,6 +3316,9 @@ var Transport = class {
     if (options.connectionTimeout !== void 0 && (options.connectionTimeout < 100 || options.connectionTimeout > 3e4)) {
       throw new InvalidConfigurationError("connectionTimeout must be between 100ms and 30000ms");
     }
+    if (options.connectWaitTimeout !== void 0 && (options.connectWaitTimeout < 1e3 || options.connectWaitTimeout > 3e5)) {
+      throw new InvalidConfigurationError("connectWaitTimeout must be between 1000ms and 300000ms");
+    }
     if (options.maxRetries !== void 0 && (options.maxRetries < 0 || options.maxRetries > 100)) {
       throw new InvalidConfigurationError("maxRetries must be between 0 and 100");
     }
@@ -3505,7 +3605,8 @@ var Transport = class {
           reject(new RateLimitError(_ev.reason || "Rate limit exceeded", _ev));
           return;
         }
-        reject(this.terminalError || new Error(`Connection lost to the notebook during request: ${_ev.reason || "Unknown reason"}`));
+        const detail = describeWebSocketEvent(_ev);
+        reject(this.terminalError || new ConnectionFailedError(`Connection lost to the notebook during request: ${detail}`, _ev));
       };
       this.rws.addEventListener("close", closeHandler);
       this.rws.addEventListener("error", closeHandler);
@@ -3693,8 +3794,10 @@ var Transport = class {
     });
     this.rws.addEventListener("error", (event) => {
       this.connectionStats.totalErrors++;
+      const detail = describeWebSocketEvent(event);
       this.log("error", "Connection error", {
-        error: event,
+        error: detail,
+        rawError: event,
         totalErrors: this.connectionStats.totalErrors
       });
     });
@@ -3950,33 +4053,50 @@ connect_fn = function() {
       __privateMethod(this, _Transport_instances, startPeriodicPing_fn).call(this);
       return;
     }
-    if (this.rws.readyState === 3) {
-      this.rws.reconnect();
-    }
     let timeoutId;
-    const openHandler = () => {
+    let errorCount = 0;
+    const cleanup = () => {
       this.rws.removeEventListener("open", openHandler);
       this.rws.removeEventListener("error", errorHandler);
+      this.rws.removeEventListener("close", closeHandler);
       clearTimeout(timeoutId);
+    };
+    const openHandler = () => {
+      cleanup();
       this.connectPromise = null;
       resolve();
       __privateMethod(this, _Transport_instances, startPeriodicPing_fn).call(this);
     };
     const errorHandler = (error) => {
-      this.rws.removeEventListener("open", openHandler);
-      this.rws.removeEventListener("error", errorHandler);
-      clearTimeout(timeoutId);
-      this.connectPromise = null;
-      reject(new Error(`WebSocket connection failed: ${error}`));
+      errorCount += 1;
+      this.log("warn", "WebSocket emitted an error while connecting; waiting for reconnect/open", {
+        errorCount,
+        error: describeWebSocketEvent(error)
+      });
+    };
+    const closeHandler = (event) => {
+      const detail = describeWebSocketEvent(event);
+      if ("code" in event && (event.code === 1008 || event.code === 4e3)) {
+        cleanup();
+        this.connectPromise = null;
+        reject(new ConnectionFailedError(`WebSocket connection failed: ${detail}`, event));
+        return;
+      }
+      this.log("warn", "WebSocket closed before opening; waiting for reconnect/open", {
+        error: detail
+      });
     };
-    timeoutId = setTimeout(() => {
-      this.rws.removeEventListener("open", openHandler);
-      this.rws.removeEventListener("error", errorHandler);
-      this.connectPromise = null;
-      reject(new Error("WebSocket connection timeout"));
-    }, 1e4);
     this.rws.addEventListener("open", openHandler);
     this.rws.addEventListener("error", errorHandler);
+    this.rws.addEventListener("close", closeHandler);
+    if (this.rws.readyState === 3) {
+      this.rws.reconnect();
+    }
+    timeoutId = setTimeout(() => {
+      cleanup();
+      this.connectPromise = null;
+      reject(new ConnectionTimeoutError(`WebSocket connection timeout after ${this.CONNECT_WAIT_TIMEOUT}ms`));
+    }, this.CONNECT_WAIT_TIMEOUT);
   });
   return this.connectPromise;
 };