wreq-js 1.7.0 → 2.0.1

package/dist/wreq-js.js

@@ -5,7 +5,7 @@ import { createRequire } from "module";
 import { ReadableStream } from "stream/web";
 
 // src/types.ts
-var RequestError = class extends Error {
+var RequestError = class extends TypeError {
   constructor(message) {
     super(message);
     this.name = "RequestError";
@@ -86,6 +86,7 @@ var bodyHandleFinalizer = typeof FinalizationRegistry === "function" ? new Final
 }) : void 0;
 var DEFAULT_BROWSER = "chrome_142";
 var DEFAULT_OS = "macos";
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
 var SUPPORTED_OSES = ["windows", "macos", "linux", "android", "ios"];
 var UTF8_DECODER = new TextDecoder("utf-8");
 var ephemeralIdCounter = 0;
@@ -254,27 +255,7 @@ var Headers = class _Headers {
   }
 };
 function headersToTuples(init) {
-  if (Array.isArray(init)) {
-    return init;
-  }
-  if (init instanceof Headers) {
-    return init.toTuples();
-  }
-  const out = [];
-  if (isPlainObject(init)) {
-    return new Headers(init).toTuples();
-  }
-  if (isIterable(init)) {
-    for (const tuple of init) {
-      if (!tuple) {
-        continue;
-      }
-      const [name, value] = tuple;
-      out.push([name, value]);
-    }
-    return out;
-  }
-  return out;
+  return new Headers(init).toTuples();
 }
 function hasHeaderName(tuples, name) {
   if (!tuples) {
@@ -288,6 +269,24 @@ function hasHeaderName(tuples, name) {
   }
   return false;
 }
+function hasWebSocketProtocolHeader(headers) {
+  const protocolHeaderName = "Sec-WebSocket-Protocol";
+  if (!headers) {
+    return false;
+  }
+  return hasHeaderName(headersToTuples(headers), protocolHeaderName);
+}
+function assertNoManualWebSocketProtocolHeader(headers) {
+  if (hasWebSocketProtocolHeader(headers)) {
+    throw new RequestError("Do not set `Sec-WebSocket-Protocol` header manually; use the `protocols` option instead.");
+  }
+}
+function normalizeWebSocketProtocolList(protocols) {
+  if (protocols === void 0) {
+    return void 0;
+  }
+  return typeof protocols === "string" ? [protocols] : [...protocols];
+}
 function mergeHeaderTuples(defaults, overrides) {
   if (!defaults) {
     return overrides === void 0 ? void 0 : headersToTuples(overrides);
@@ -368,13 +367,16 @@ function createNativeBodyStream(handle) {
 }
 function wrapBodyStream(source, onFirstUse) {
   let started = false;
-  const reader = source.getReader();
+  let reader = null;
   return new ReadableStream({
     async pull(controller) {
       if (!started) {
         started = true;
         onFirstUse();
       }
+      if (!reader) {
+        reader = source.getReader();
+      }
       try {
         const { done, value } = await reader.read();
         if (done) {
@@ -387,6 +389,9 @@ function wrapBodyStream(source, onFirstUse) {
       }
     },
     cancel(reason) {
+      if (!reader) {
+        return source.cancel(reason);
+      }
       return reader.cancel(reason);
     }
   });
@@ -533,8 +538,22 @@ var Response = class _Response {
     const bytes = await this.consumeBody();
     return UTF8_DECODER.decode(bytes);
   }
+  async blob() {
+    const bytes = await this.consumeBody();
+    const contentType = this.headers.get("content-type") ?? "";
+    return new Blob([bytes], contentType ? { type: contentType } : void 0);
+  }
+  async formData() {
+    const bytes = await this.consumeBody();
+    const contentType = this.headers.get("content-type");
+    const response = new globalThis.Response(
+      bytes,
+      contentType ? { headers: { "content-type": contentType } } : void 0
+    );
+    return response.formData();
+  }
   clone() {
-    if (this.bodyUsed || this.bodyStream) {
+    if (this.bodyUsed) {
       throw new TypeError("Cannot clone a Response whose body is already used");
     }
     if (this.nativeHandleAvailable && this.payload.bodyHandle !== null) {
@@ -669,6 +688,36 @@ var Session = class {
       throw new RequestError(String(error));
     }
   }
+  async websocket(urlOrOptions, options) {
+    this.ensureActive();
+    const normalized = normalizeSessionWebSocketArgs(urlOrOptions, options);
+    validateWebSocketProtocols(normalized.options.protocols);
+    assertNoManualWebSocketProtocolHeader(normalized.options.headers);
+    const protocols = normalizeWebSocketProtocolList(normalized.options.protocols);
+    const transportId = this.defaults.transportId;
+    if (!transportId) {
+      throw new RequestError(
+        "Session has no transport. Create the session with browser/os options or pass a transport to use session.websocket()."
+      );
+    }
+    return WebSocket._connectWithInit({
+      _internal: true,
+      url: normalized.url,
+      options: normalized.options,
+      openDispatchMode: "deferred",
+      connect: (callbacks) => nativeBinding.websocketConnectSession({
+        url: normalized.url,
+        sessionId: this.id,
+        transportId,
+        headers: headersToTuples(normalized.options.headers ?? {}),
+        ...protocols && protocols.length > 0 && { protocols },
+        onMessage: callbacks.onMessage,
+        onClose: callbacks.onClose,
+        onError: callbacks.onError
+      }),
+      legacyCallbacks: normalized.legacyCallbacks
+    });
+  }
   async close() {
     if (this.disposed) {
       return;
@@ -749,7 +798,7 @@ function resolveTransportContext(config, sessionDefaults) {
     if (config.transport.closed) {
       throw new RequestError("Transport has been closed");
     }
-    const hasProxy = Object.hasOwn(config, "proxy");
+    const hasProxy = config.proxy !== void 0;
     if (config.browser !== void 0 || config.os !== void 0 || hasProxy || config.insecure !== void 0) {
       throw new RequestError("`transport` cannot be combined with browser/os/proxy/insecure options");
     }
@@ -849,7 +898,7 @@ function setupAbort(signal, cancelNative) {
   return { promise, cleanup };
 }
 function coerceUrlInput(input) {
-  if (typeof input !== "string") {
+  if (input instanceof URL) {
     return input.href;
   }
   if (input.length === 0) {
@@ -864,6 +913,41 @@ function coerceUrlInput(input) {
   }
   return trimmed;
 }
+function isRequestLike(input) {
+  if (!input || typeof input !== "object") {
+    return false;
+  }
+  if (typeof Request !== "undefined" && input instanceof Request) {
+    return true;
+  }
+  const candidate = input;
+  return typeof candidate.url === "string" && typeof candidate.method === "string" && typeof candidate.arrayBuffer === "function" && typeof candidate.redirect === "string";
+}
+async function resolveFetchArgs(input, init) {
+  if (!isRequestLike(input)) {
+    return { url: coerceUrlInput(input), init: init ?? {} };
+  }
+  const mergedInit = init ? { ...init } : {};
+  if (mergedInit.method === void 0) {
+    mergedInit.method = input.method;
+  }
+  if (mergedInit.headers === void 0) {
+    mergedInit.headers = input.headers;
+  }
+  if (mergedInit.redirect === void 0 && (input.redirect === "follow" || input.redirect === "manual" || input.redirect === "error")) {
+    mergedInit.redirect = input.redirect;
+  }
+  if (mergedInit.signal === void 0) {
+    mergedInit.signal = input.signal;
+  }
+  if (mergedInit.body === void 0 && input.body !== null) {
+    if (input.bodyUsed) {
+      throw new TypeError("Request body is already used");
+    }
+    mergedInit.body = Buffer.from(await input.arrayBuffer());
+  }
+  return { url: coerceUrlInput(input.url), init: mergedInit };
+}
 function normalizeUrlForComparison(value) {
   try {
     return new URL(value).toString();
@@ -939,17 +1023,23 @@ function ensureBodyAllowed(method, body) {
   }
 }
 function validateBrowserProfile(browser) {
-  if (!browser) {
+  if (browser === void 0) {
     return;
   }
+  if (typeof browser !== "string" || browser.trim().length === 0) {
+    throw new RequestError("Browser profile must not be empty");
+  }
   if (!getProfileSet().has(browser)) {
     throw new RequestError(`Invalid browser profile: ${browser}. Available profiles: ${getProfiles().join(", ")}`);
   }
 }
 function validateOperatingSystem(os) {
-  if (!os) {
+  if (os === void 0) {
     return;
   }
+  if (typeof os !== "string" || os.trim().length === 0) {
+    throw new RequestError("Operating system must not be empty");
+  }
   if (!getOperatingSystemSet().has(os)) {
     throw new RequestError(`Invalid operating system: ${os}. Available options: ${getOperatingSystems().join(", ")}`);
   }
@@ -961,8 +1051,8 @@ function validateTimeout(timeout) {
   if (typeof timeout !== "number" || !Number.isFinite(timeout)) {
     throw new RequestError("Timeout must be a finite number");
   }
-  if (timeout <= 0) {
-    throw new RequestError("Timeout must be greater than 0");
+  if (timeout < 0) {
+    throw new RequestError("Timeout must be 0 (no timeout) or a positive number");
   }
 }
 function validatePositiveNumber(value, label) {
@@ -1029,8 +1119,9 @@ async function dispatchRequest(options, requestUrl, signal) {
   return new Response(payload, requestUrl);
 }
 async function fetch(input, init) {
-  const url = coerceUrlInput(input);
-  const config = init ?? {};
+  const resolved = await resolveFetchArgs(input, init);
+  const url = resolved.url;
+  const config = resolved.init;
   const sessionContext = resolveSessionContext(config);
   const sessionDefaults = sessionContext.defaults;
   validateRedirectMode(config.redirect);
@@ -1049,7 +1140,7 @@ async function fetch(input, init) {
     headerTuples.push(["Content-Type", serializedBody.contentType]);
   }
   const transport = resolveTransportContext(config, sessionDefaults);
-  const timeout = config.timeout ?? sessionDefaults?.timeout;
+  const timeout = config.timeout ?? sessionDefaults?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const requestOptions = {
     url,
     method,
@@ -1071,9 +1162,7 @@ async function fetch(input, init) {
       requestOptions.insecure = transport.insecure;
     }
   }
-  if (timeout !== void 0) {
-    requestOptions.timeout = timeout;
-  }
+  requestOptions.timeout = timeout;
   if (config.redirect !== void 0) {
     requestOptions.redirect = config.redirect;
   }
@@ -1261,84 +1350,696 @@ async function post(url, body, init) {
   }
   return fetch(url, config);
 }
-var WebSocket = class {
+function normalizeWebSocketUrl(url) {
+  const normalized = String(url).trim();
+  if (!normalized) {
+    throw new RequestError("URL is required");
+  }
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch (error) {
+    throw new RequestError(String(error));
+  }
+  if (parsed.hash) {
+    throw new RequestError("WebSocket URL must not include a hash fragment");
+  }
+  if (parsed.protocol === "http:") {
+    parsed.protocol = "ws:";
+  } else if (parsed.protocol === "https:") {
+    parsed.protocol = "wss:";
+  }
+  if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+    throw new RequestError("expected a ws: or wss: url");
+  }
+  return parsed.toString();
+}
+function validateWebSocketProtocols(protocols) {
+  if (protocols === void 0) {
+    return;
+  }
+  const protocolList = typeof protocols === "string" ? [protocols] : protocols;
+  const seen = /* @__PURE__ */ new Set();
+  const validToken = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+  for (const protocol of protocolList) {
+    if (typeof protocol !== "string" || protocol.length === 0) {
+      throw new RequestError("WebSocket protocol values must be non-empty strings");
+    }
+    if (!validToken.test(protocol)) {
+      throw new RequestError(`Invalid WebSocket protocol value: ${protocol}`);
+    }
+    if (seen.has(protocol)) {
+      throw new RequestError(`Duplicate WebSocket protocol: ${protocol}`);
+    }
+    seen.add(protocol);
+  }
+}
+function normalizeStandaloneWebSocketOptions(options) {
+  const normalized = {};
+  if (!options) {
+    return normalized;
+  }
+  if (options.browser !== void 0) {
+    normalized.browser = options.browser;
+  }
+  if (options.os !== void 0) {
+    normalized.os = options.os;
+  }
+  if (options.headers !== void 0) {
+    normalized.headers = options.headers;
+  }
+  if (options.proxy !== void 0) {
+    normalized.proxy = options.proxy;
+  }
+  if (options.protocols !== void 0) {
+    normalized.protocols = options.protocols;
+  }
+  if (options.binaryType !== void 0) {
+    if (options.binaryType !== "nodebuffer" && options.binaryType !== "arraybuffer" && options.binaryType !== "blob") {
+      throw new RequestError("binaryType must be one of: 'nodebuffer', 'arraybuffer', 'blob'");
+    }
+    normalized.binaryType = options.binaryType;
+  }
+  return normalized;
+}
+function normalizeSessionWebSocketOptions(options) {
+  const normalized = {};
+  if (!options) {
+    return normalized;
+  }
+  const optionsWithOverrides = options;
+  if (optionsWithOverrides.browser !== void 0) {
+    throw new RequestError(
+      "`browser` is not supported in session.websocket(); the session controls browser emulation."
+    );
+  }
+  if (optionsWithOverrides.os !== void 0) {
+    throw new RequestError("`os` is not supported in session.websocket(); the session controls OS emulation.");
+  }
+  if (optionsWithOverrides.proxy !== void 0) {
+    throw new RequestError("`proxy` is not supported in session.websocket(); the session transport controls proxying.");
+  }
+  if (options.headers !== void 0) {
+    normalized.headers = options.headers;
+  }
+  if (options.protocols !== void 0) {
+    normalized.protocols = options.protocols;
+  }
+  if (options.binaryType !== void 0) {
+    if (options.binaryType !== "nodebuffer" && options.binaryType !== "arraybuffer" && options.binaryType !== "blob") {
+      throw new RequestError("binaryType must be one of: 'nodebuffer', 'arraybuffer', 'blob'");
+    }
+    normalized.binaryType = options.binaryType;
+  }
+  return normalized;
+}
+function extractLegacyWebSocketCallbacks(options) {
+  if (!isPlainObject(options)) {
+    return void 0;
+  }
+  const maybeCallbacks = options;
+  const callbacks = {};
+  if (typeof maybeCallbacks.onMessage === "function") {
+    callbacks.onMessage = maybeCallbacks.onMessage;
+  }
+  if (typeof maybeCallbacks.onClose === "function") {
+    callbacks.onClose = maybeCallbacks.onClose;
+  }
+  if (typeof maybeCallbacks.onError === "function") {
+    callbacks.onError = maybeCallbacks.onError;
+  }
+  return Object.keys(callbacks).length > 0 ? callbacks : void 0;
+}
+function normalizeWebSocketCloseOptions(code, reason) {
+  if (code === void 0 && reason === void 0) {
+    return void 0;
+  }
+  if (code === void 0) {
+    throw new RequestError("A close code is required when providing a close reason");
+  }
+  if (!Number.isInteger(code)) {
+    throw new RequestError("Close code must be an integer");
+  }
+  if (code !== 1e3 && (code < 3e3 || code > 4999)) {
+    throw new RequestError("Close code must be 1000 or in range 3000-4999");
+  }
+  const normalizedReason = reason ?? "";
+  if (Buffer.byteLength(normalizedReason, "utf8") > 123) {
+    throw new RequestError("Close reason must be 123 bytes or fewer");
+  }
+  return {
+    code,
+    reason: normalizedReason
+  };
+}
+function isWebSocketListenerType(type) {
+  return type === "open" || type === "message" || type === "close" || type === "error";
+}
+var WebSocket = class _WebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  url;
+  protocol = "";
+  extensions = "";
+  readyState = _WebSocket.CONNECTING;
+  _binaryType = "nodebuffer";
+  _bufferedAmount = 0;
+  _onopen = null;
+  _onmessage = null;
+  _onclose = null;
+  _onerror = null;
+  _onHandlerOrder = {
+    open: -1,
+    message: -1,
+    close: -1,
+    error: -1
+  };
+  _listenerOrderCounter = 0;
+  _listeners = {
+    open: /* @__PURE__ */ new Map(),
+    message: /* @__PURE__ */ new Map(),
+    close: /* @__PURE__ */ new Map(),
+    error: /* @__PURE__ */ new Map()
+  };
+  _legacyCallbacks;
+  _openDispatchMode;
   _connection;
+  _connectPromise;
+  _closeOptions;
   _finalizerToken;
-  _closed = false;
-  _closing;
-  constructor(connection) {
-    this._connection = connection;
-    if (websocketFinalizer) {
-      this._finalizerToken = connection;
-      websocketFinalizer.register(this, connection, connection);
-    }
-  }
-  /**
-   * Send a message (text or binary)
-   */
-  async send(data) {
-    const payload = typeof data === "string" ? data : Buffer.isBuffer(data) ? data : data instanceof ArrayBuffer ? Buffer.from(data) : ArrayBuffer.isView(data) ? Buffer.from(data.buffer, data.byteOffset, data.byteLength) : (() => {
-      throw new TypeError("WebSocket data must be a string, Buffer, ArrayBuffer, or ArrayBufferView");
-    })();
+  _openEventDispatched = false;
+  _openEventQueued = false;
+  _closeEventDispatched = false;
+  _nativeCloseStarted = false;
+  _pendingMessages = [];
+  _sendChain = Promise.resolve();
+  constructor(urlOrInit, protocolsOrOptions, maybeOptions) {
+    let init;
+    if (isInternalWebSocketInit(urlOrInit)) {
+      init = urlOrInit;
+    } else {
+      init = _WebSocket.buildStandaloneInit(urlOrInit, protocolsOrOptions, maybeOptions);
+    }
+    this.url = init.url;
+    this.binaryType = init.options.binaryType ?? "nodebuffer";
+    this._legacyCallbacks = init.legacyCallbacks;
+    this._openDispatchMode = init.openDispatchMode;
+    this._connectPromise = this.connect(init.connect);
+    void this._connectPromise.catch(() => void 0);
+  }
+  get binaryType() {
+    return this._binaryType;
+  }
+  set binaryType(value) {
+    if (value === "arraybuffer" || value === "blob" || value === "nodebuffer") {
+      this._binaryType = value;
+    }
+  }
+  get bufferedAmount() {
+    return this._bufferedAmount;
+  }
+  get onopen() {
+    return this._onopen;
+  }
+  set onopen(listener) {
+    this._onopen = listener;
+    this._onHandlerOrder.open = listener ? ++this._listenerOrderCounter : -1;
+  }
+  get onmessage() {
+    return this._onmessage;
+  }
+  set onmessage(listener) {
+    this._onmessage = listener;
+    this._onHandlerOrder.message = listener ? ++this._listenerOrderCounter : -1;
+  }
+  get onclose() {
+    return this._onclose;
+  }
+  set onclose(listener) {
+    this._onclose = listener;
+    this._onHandlerOrder.close = listener ? ++this._listenerOrderCounter : -1;
+  }
+  get onerror() {
+    return this._onerror;
+  }
+  set onerror(listener) {
+    this._onerror = listener;
+    this._onHandlerOrder.error = listener ? ++this._listenerOrderCounter : -1;
+  }
+  static async _connectWithInit(init) {
+    const ws = new _WebSocket(init);
+    await ws._waitUntilConnected();
+    ws.scheduleOpenEventAfterAwait();
+    return ws;
+  }
+  static buildStandaloneInit(url, protocolsOrOptions, maybeOptions) {
+    const optionsCandidate = typeof protocolsOrOptions === "string" || Array.isArray(protocolsOrOptions) ? maybeOptions : protocolsOrOptions ?? maybeOptions;
+    const normalizedOptions = normalizeStandaloneWebSocketOptions(optionsCandidate);
+    validateWebSocketProtocols(
+      typeof protocolsOrOptions === "string" || Array.isArray(protocolsOrOptions) ? protocolsOrOptions : normalizedOptions.protocols
+    );
+    assertNoManualWebSocketProtocolHeader(normalizedOptions.headers);
+    validateBrowserProfile(normalizedOptions.browser);
+    const os = normalizedOptions.os ?? DEFAULT_OS;
+    validateOperatingSystem(os);
+    const browser = normalizedOptions.browser ?? DEFAULT_BROWSER;
+    const protocols = normalizeWebSocketProtocolList(
+      typeof protocolsOrOptions === "string" || Array.isArray(protocolsOrOptions) ? protocolsOrOptions : normalizedOptions.protocols
+    );
+    return {
+      _internal: true,
+      url: normalizeWebSocketUrl(url),
+      options: normalizedOptions,
+      openDispatchMode: "automatic",
+      connect: (callbacks) => nativeBinding.websocketConnect({
+        url: normalizeWebSocketUrl(url),
+        browser,
+        os,
+        headers: headersToTuples(normalizedOptions.headers ?? {}),
+        ...protocols && protocols.length > 0 && { protocols },
+        ...normalizedOptions.proxy !== void 0 && { proxy: normalizedOptions.proxy },
+        onMessage: callbacks.onMessage,
+        onClose: callbacks.onClose,
+        onError: callbacks.onError
+      }),
+      legacyCallbacks: extractLegacyWebSocketCallbacks(optionsCandidate)
+    };
+  }
+  async connect(connectFn) {
     try {
-      await nativeBinding.websocketSend(this._connection, payload);
+      const connection = await connectFn({
+        onMessage: (data) => {
+          this.handleNativeMessage(data);
+        },
+        onClose: (event) => {
+          this.handleNativeClose(event);
+        },
+        onError: (message) => {
+          this.handleNativeError(message);
+        }
+      });
+      this._connection = connection;
+      this.protocol = connection.protocol ?? "";
+      this.extensions = connection.extensions ?? "";
+      if (websocketFinalizer) {
+        this._finalizerToken = connection;
+        websocketFinalizer.register(this, connection, connection);
+      }
+      if (this.readyState === _WebSocket.CLOSING) {
+        this.startNativeClose();
+        return;
+      }
+      this.readyState = _WebSocket.OPEN;
+      if (this._openDispatchMode === "automatic") {
+        this.scheduleOpenEventAfterConnect();
+      }
     } catch (error) {
+      this.handleNativeError(String(error));
+      this.finalizeClosed({ code: 1006, reason: "" }, false);
       throw new RequestError(String(error));
     }
   }
-  /**
-   * Close the WebSocket connection
-   */
-  async close() {
-    if (this._closed) {
+  _waitUntilConnected() {
+    return this._connectPromise;
+  }
+  scheduleOpenEventAfterConnect() {
+    this.scheduleOpenEventWithDepth(2);
+  }
+  scheduleOpenEventAfterAwait() {
+    this.scheduleOpenEventWithDepth(3);
+  }
+  scheduleOpenEventWithDepth(depth) {
+    if (this._openEventDispatched || this._openEventQueued || this.readyState !== _WebSocket.OPEN) {
+      return;
+    }
+    this._openEventQueued = true;
+    const queue = (remaining) => {
+      if (remaining === 0) {
+        this._openEventQueued = false;
+        if (this._openEventDispatched || this.readyState !== _WebSocket.OPEN) {
+          return;
+        }
+        this._openEventDispatched = true;
+        this.dispatchOpenEvent();
+        return;
+      }
+      queueMicrotask(() => {
+        queue(remaining - 1);
+      });
+    };
+    queue(depth);
+  }
+  releaseConnectionTracking() {
+    if (!this._finalizerToken || !websocketFinalizer) {
+      return;
+    }
+    websocketFinalizer.unregister(this._finalizerToken);
+    this._finalizerToken = void 0;
+  }
+  toMessageEventData(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (this._binaryType === "arraybuffer") {
+      const arrayBuffer = new ArrayBuffer(data.byteLength);
+      new Uint8Array(arrayBuffer).set(data);
+      return arrayBuffer;
+    }
+    if (this._binaryType === "blob") {
+      return new Blob([data]);
+    }
+    return data;
+  }
+  invokeListener(listener, event) {
+    try {
+      if (typeof listener === "function") {
+        listener.call(this, event);
+      } else {
+        listener.handleEvent(event);
+      }
+    } catch {
+    }
+  }
+  createBaseEvent(type) {
+    return {
+      type,
+      isTrusted: false,
+      timeStamp: Date.now(),
+      target: this,
+      currentTarget: this
+    };
+  }
+  getOnHandler(type) {
+    switch (type) {
+      case "open":
+        return this._onopen;
+      case "message":
+        return this._onmessage;
+      case "close":
+        return this._onclose;
+      case "error":
+        return this._onerror;
+      default:
+        return null;
+    }
+  }
+  getOnHandlerOrder(type) {
+    return this._onHandlerOrder[type];
+  }
+  getListenerMap(type) {
+    return this._listeners[type];
+  }
+  dispatchEvent(type, event) {
+    const listenerMap = this.getListenerMap(type);
+    const onHandler = this.getOnHandler(type);
+    if (listenerMap.size === 0 && !onHandler) {
+      return;
+    }
+    const ordered = [];
+    for (const descriptor of listenerMap.values()) {
+      ordered.push({
+        order: descriptor.order,
+        listener: descriptor.listener,
+        once: descriptor.once
+      });
+    }
+    if (onHandler) {
+      ordered.push({
+        order: this.getOnHandlerOrder(type),
+        listener: onHandler,
+        once: false
+      });
+    }
+    ordered.sort((a, b) => a.order - b.order);
+    for (const entry of ordered) {
+      if (entry.once) {
+        this.removeEventListener(type, entry.listener);
+      }
+      this.invokeListener(entry.listener, event);
+    }
+  }
+  dispatchOpenEvent() {
+    const event = this.createBaseEvent("open");
+    this.dispatchEvent("open", event);
+    if (!this._closeEventDispatched && this._pendingMessages.length > 0) {
+      const pending = this._pendingMessages;
+      this._pendingMessages = [];
+      for (const data of pending) {
+        this.dispatchMessageEvent(this.toMessageEventData(data));
+      }
+    }
+  }
+  dispatchMessageEvent(data) {
+    const event = {
+      ...this.createBaseEvent("message"),
+      data
+    };
+    this.dispatchEvent("message", event);
+  }
+  dispatchCloseEvent(event) {
+    this.dispatchEvent("close", event);
+  }
+  dispatchErrorEvent(message) {
+    const event = {
+      ...this.createBaseEvent("error"),
+      ...message !== void 0 && { message }
+    };
+    this.dispatchEvent("error", event);
+  }
+  handleNativeMessage(data) {
+    if (this._closeEventDispatched) {
+      return;
+    }
+    this._legacyCallbacks?.onMessage?.(data);
+    if (!this._openEventDispatched && this.readyState === _WebSocket.OPEN) {
+      this._pendingMessages.push(data);
+      return;
+    }
+    this.dispatchMessageEvent(this.toMessageEventData(data));
+  }
+  handleNativeError(message) {
+    this._legacyCallbacks?.onError?.(message);
+    this.dispatchErrorEvent(message);
+  }
+  handleNativeClose(event) {
+    const wasClean = this.readyState === _WebSocket.CLOSING || event.code === 1e3;
+    this.finalizeClosed(event, wasClean);
+  }
+  finalizeClosed(event, wasClean) {
+    if (this._closeEventDispatched) {
+      return;
+    }
+    this.readyState = _WebSocket.CLOSED;
+    this._closeEventDispatched = true;
+    this._pendingMessages = [];
+    this.releaseConnectionTracking();
+    const closeEvent = {
+      ...this.createBaseEvent("close"),
+      code: event.code,
+      reason: event.reason,
+      wasClean
+    };
+    this._legacyCallbacks?.onClose?.(closeEvent);
+    this.dispatchCloseEvent(closeEvent);
+  }
+  startNativeClose() {
+    if (this._nativeCloseStarted || !this._connection) {
       return;
     }
-    if (this._closing) {
-      return this._closing;
+    this._nativeCloseStarted = true;
+    const connection = this._connection;
+    const closeOptions = this._closeOptions;
+    void nativeBinding.websocketClose(connection, closeOptions).catch((error) => {
+      this.handleNativeError(String(error));
+      this.finalizeClosed({ code: 1006, reason: "" }, false);
+    });
+  }
+  addEventListener(type, listener, options) {
+    if (!listener || !isWebSocketListenerType(type)) {
+      return;
+    }
+    const normalizedListener = listener;
+    if (typeof normalizedListener !== "function" && (typeof normalizedListener !== "object" || normalizedListener === null || typeof normalizedListener.handleEvent !== "function")) {
+      return;
+    }
+    const listenerMap = this.getListenerMap(type);
+    if (listenerMap.has(normalizedListener)) {
+      return;
+    }
+    const parsedOptions = typeof options === "boolean" ? {} : options ?? {};
+    const once = parsedOptions.once === true;
+    const signal = parsedOptions.signal;
+    if (signal?.aborted) {
+      return;
+    }
+    const descriptor = {
+      listener: normalizedListener,
+      order: ++this._listenerOrderCounter,
+      once
+    };
+    if (signal) {
+      const onAbort = () => {
+        this.removeEventListener(type, normalizedListener);
+      };
+      descriptor.abortSignal = signal;
+      descriptor.abortHandler = onAbort;
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    listenerMap.set(normalizedListener, descriptor);
+  }
+  removeEventListener(type, listener) {
+    if (!listener || !isWebSocketListenerType(type)) {
+      return;
+    }
+    const normalizedListener = listener;
+    if (typeof normalizedListener !== "function" && typeof normalizedListener !== "object") {
+      return;
+    }
+    const listenerMap = this.getListenerMap(type);
+    const descriptor = listenerMap.get(normalizedListener);
+    if (!descriptor) {
+      return;
+    }
+    if (descriptor.abortSignal && descriptor.abortHandler) {
+      descriptor.abortSignal.removeEventListener("abort", descriptor.abortHandler);
+    }
+    listenerMap.delete(normalizedListener);
+  }
+  getSendByteLength(data) {
+    if (typeof data === "string") {
+      return Buffer.byteLength(data);
+    }
+    if (Buffer.isBuffer(data)) {
+      return data.byteLength;
+    }
+    if (data instanceof ArrayBuffer) {
+      return data.byteLength;
+    }
+    if (ArrayBuffer.isView(data)) {
+      return data.byteLength;
+    }
+    if (typeof Blob !== "undefined" && data instanceof Blob) {
+      return data.size;
     }
-    this._closing = (async () => {
+    throw new TypeError("WebSocket data must be a string, Buffer, ArrayBuffer, ArrayBufferView, or Blob");
+  }
+  async normalizeSendPayload(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof ArrayBuffer) {
+      return Buffer.from(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    if (typeof Blob !== "undefined" && data instanceof Blob) {
+      return Buffer.from(await data.arrayBuffer());
+    }
+    throw new TypeError("WebSocket data must be a string, Buffer, ArrayBuffer, ArrayBufferView, or Blob");
+  }
+  send(data) {
+    if (this.readyState !== _WebSocket.OPEN || !this._connection) {
+      throw new RequestError("WebSocket is not open");
+    }
+    const queuedBytes = this.getSendByteLength(data);
+    const connection = this._connection;
+    this._bufferedAmount += queuedBytes;
+    const sendTask = async () => {
       try {
-        await nativeBinding.websocketClose(this._connection);
-        this._closed = true;
-        if (this._finalizerToken && websocketFinalizer) {
-          websocketFinalizer.unregister(this._finalizerToken);
-          this._finalizerToken = void 0;
-        }
+        const payload = await this.normalizeSendPayload(data);
+        await nativeBinding.websocketSend(connection, payload);
       } catch (error) {
-        throw new RequestError(String(error));
+        this.handleNativeError(String(error));
+        this.finalizeClosed({ code: 1006, reason: "" }, false);
       } finally {
-        this._closing = void 0;
+        this._bufferedAmount = Math.max(0, this._bufferedAmount - queuedBytes);
       }
-    })();
-    return this._closing;
+    };
+    this._sendChain = this._sendChain.then(sendTask, sendTask);
+  }
+  close(code, reason) {
+    if (this.readyState === _WebSocket.CLOSING || this.readyState === _WebSocket.CLOSED) {
+      return;
+    }
+    this._closeOptions = normalizeWebSocketCloseOptions(code, reason);
+    this.readyState = _WebSocket.CLOSING;
+    this.startNativeClose();
   }
 };
-async function websocket(options) {
-  if (!options.url) {
-    throw new RequestError("URL is required");
+function isInternalWebSocketInit(value) {
+  if (!isPlainObject(value)) {
+    return false;
   }
-  if (!options.onMessage) {
-    throw new RequestError("onMessage callback is required");
+  const candidate = value;
+  return candidate._internal === true && typeof candidate.url === "string" && typeof candidate.connect === "function";
+}
+function normalizeStandaloneWebSocketArgs(urlOrOptions, options) {
+  if (typeof urlOrOptions === "string" || urlOrOptions instanceof URL) {
+    const normalizedOptions2 = normalizeStandaloneWebSocketOptions(options);
+    return {
+      url: normalizeWebSocketUrl(urlOrOptions),
+      options: normalizedOptions2,
+      legacyCallbacks: extractLegacyWebSocketCallbacks(options)
+    };
   }
-  validateBrowserProfile(options.browser);
-  const os = options.os ?? DEFAULT_OS;
+  const legacy = urlOrOptions;
+  const normalizedOptions = normalizeStandaloneWebSocketOptions(legacy);
+  return {
+    url: normalizeWebSocketUrl(legacy.url),
+    options: normalizedOptions,
+    legacyCallbacks: extractLegacyWebSocketCallbacks(legacy)
+  };
+}
+function normalizeSessionWebSocketArgs(urlOrOptions, options) {
+  if (typeof urlOrOptions === "string" || urlOrOptions instanceof URL) {
+    const normalizedOptions2 = normalizeSessionWebSocketOptions(options);
+    return {
+      url: normalizeWebSocketUrl(urlOrOptions),
+      options: normalizedOptions2,
+      legacyCallbacks: extractLegacyWebSocketCallbacks(options)
+    };
+  }
+  const legacy = urlOrOptions;
+  const normalizedOptions = normalizeSessionWebSocketOptions(legacy);
+  return {
+    url: normalizeWebSocketUrl(legacy.url),
+    options: normalizedOptions,
+    legacyCallbacks: extractLegacyWebSocketCallbacks(legacy)
+  };
+}
+async function websocket(urlOrOptions, options) {
+  const normalized = normalizeStandaloneWebSocketArgs(urlOrOptions, options);
+  validateWebSocketProtocols(normalized.options.protocols);
+  assertNoManualWebSocketProtocolHeader(normalized.options.headers);
+  validateBrowserProfile(normalized.options.browser);
+  const os = normalized.options.os ?? DEFAULT_OS;
   validateOperatingSystem(os);
-  const browser = options.browser ?? DEFAULT_BROWSER;
-  try {
-    const connection = await nativeBinding.websocketConnect({
-      url: options.url,
+  const browser = normalized.options.browser ?? DEFAULT_BROWSER;
+  const protocols = normalizeWebSocketProtocolList(normalized.options.protocols);
+  return WebSocket._connectWithInit({
+    _internal: true,
+    url: normalized.url,
+    options: normalized.options,
+    openDispatchMode: "deferred",
+    connect: (callbacks) => nativeBinding.websocketConnect({
+      url: normalized.url,
       browser,
       os,
-      headers: options.headers ?? {},
-      ...options.proxy !== void 0 && { proxy: options.proxy },
-      onMessage: options.onMessage,
-      ...options.onClose !== void 0 && { onClose: options.onClose },
-      ...options.onError !== void 0 && { onError: options.onError }
-    });
-    return new WebSocket(connection);
-  } catch (error) {
-    throw new RequestError(String(error));
-  }
+      headers: headersToTuples(normalized.options.headers ?? {}),
+      ...protocols && protocols.length > 0 && { protocols },
+      ...normalized.options.proxy !== void 0 && { proxy: normalized.options.proxy },
+      onMessage: callbacks.onMessage,
+      onClose: callbacks.onClose,
+      onError: callbacks.onError
+    }),
+    legacyCallbacks: normalized.legacyCallbacks
+  });
 }
 var wreq_js_default = {
   fetch,
@@ -1355,7 +2056,8 @@ var wreq_js_default = {
   Headers,
   Response,
   Transport,
-  Session
+  Session,
+  RequestError
 };
 export {
   Headers,