@gjsify/ws 0.2.0

package/lib/esm/websocket.js

@@ -0,0 +1,249 @@
+import { EventEmitter } from "@gjsify/events";
+import { Buffer } from "@gjsify/buffer";
+import { WebSocket as NativeWebSocket } from "@gjsify/websocket";
+import {
+  BINARY_TYPES,
+  CLOSED,
+  CLOSING,
+  CONNECTING,
+  OPEN
+} from "./constants.js";
+class WebSocket extends EventEmitter {
+  /** Static readyState constants — match the W3C and `ws` values. */
+  static CONNECTING = CONNECTING;
+  static OPEN = OPEN;
+  static CLOSING = CLOSING;
+  static CLOSED = CLOSED;
+  /** Instance-side copies for `ws.readyState === ws.OPEN` style code. */
+  CONNECTING = CONNECTING;
+  OPEN = OPEN;
+  CLOSING = CLOSING;
+  CLOSED = CLOSED;
+  /** Per-instance state. Populated from the underlying native WebSocket as
+   *  events arrive; exposed as properties so that ws-calling code like
+   *  `if (ws.readyState === ws.OPEN)` works identically to Node's `ws`. */
+  readyState = CONNECTING;
+  url = "";
+  protocol = "";
+  extensions = "";
+  bufferedAmount = 0;
+  binaryType = "nodebuffer";
+  /** The real WebSocket we delegate to. Typed as `any` because the W3C
+   *  ambient type comes from multiple realms depending on where this bundle
+   *  ends up (GJS browser-like globals vs. Node's undici). */
+  _native = null;
+  constructor(address, protocols, options = {}) {
+    super();
+    if (address === null) {
+      queueMicrotask(() => this._fail("Constructing ws.WebSocket with null address is not supported on Gjs"));
+      return;
+    }
+    this.url = typeof address === "string" ? address : String(address);
+    const protos = this._resolveProtocols(protocols, options);
+    this._openNative(this.url, protos, options);
+  }
+  /** Merge `protocols` arg and `options.protocols` / `options.protocol`. */
+  _resolveProtocols(protocols, options) {
+    if (protocols !== void 0) {
+      return Array.isArray(protocols) ? protocols : [protocols];
+    }
+    if (options.protocols !== void 0) {
+      return Array.isArray(options.protocols) ? options.protocols : [options.protocols];
+    }
+    if (options.protocol !== void 0) return [options.protocol];
+    return void 0;
+  }
+  /** Lazy-open the underlying native WebSocket. Separated from the constructor
+   *  so subclasses or future socket-adoption paths can bypass it. */
+  _openNative(url, protocols, options) {
+    if (typeof NativeWebSocket !== "function") {
+      queueMicrotask(() => this._fail(
+        "@gjsify/websocket provided no WebSocket constructor. On Node.js 22+ globalThis.WebSocket is native; on older Node install `ws` directly, or ensure globalThis.WebSocket is set before @gjsify/ws is imported."
+      ));
+      return;
+    }
+    const nativeOpts = {
+      perMessageDeflate: options.perMessageDeflate !== false,
+      headers: options.headers,
+      origin: options.origin,
+      handshakeTimeout: options.handshakeTimeout
+    };
+    try {
+      this._native = new NativeWebSocket(url, protocols, nativeOpts);
+    } catch (err) {
+      queueMicrotask(() => this._fail(err instanceof Error ? err : new Error(String(err))));
+      return;
+    }
+    this._native.binaryType = "arraybuffer";
+    this._native.addEventListener("open", () => this._onOpen());
+    this._native.addEventListener("message", (ev) => this._onMessage(ev));
+    this._native.addEventListener("close", (ev) => this._onClose(ev));
+    this._native.addEventListener("error", (ev) => this._onError(ev));
+  }
+  _fail(err) {
+    const error = typeof err === "string" ? new Error(err) : err;
+    this.readyState = CLOSED;
+    this.emit("error", error);
+    this._dispatchEvent("error", { error, message: error.message });
+    this.emit("close", 1006, Buffer.from(error.message));
+    this._dispatchEvent("close", { code: 1006, reason: error.message, wasClean: false });
+  }
+  _onOpen() {
+    this.readyState = OPEN;
+    if (typeof this._native.protocol === "string") this.protocol = this._native.protocol;
+    if (typeof this._native.extensions === "string") this.extensions = this._native.extensions;
+    this.emit("open");
+    this._dispatchEvent("open", {});
+  }
+  _onMessage(ev) {
+    const raw = ev?.data;
+    let data;
+    let isBinary = false;
+    if (typeof raw === "string") {
+      data = raw;
+      isBinary = false;
+    } else if (raw instanceof ArrayBuffer) {
+      isBinary = true;
+      data = this._decodeBinary(raw);
+    } else if (ArrayBuffer.isView(raw)) {
+      isBinary = true;
+      data = this._decodeBinary(raw.buffer);
+    } else {
+      data = raw;
+      isBinary = false;
+    }
+    this.emit("message", data, isBinary);
+    this._dispatchEvent("message", { data, type: isBinary ? "binary" : "text" });
+  }
+  /** Convert an ArrayBuffer to the Buffer flavor requested by `binaryType`. */
+  _decodeBinary(buf) {
+    switch (this.binaryType) {
+      case "arraybuffer":
+        return buf;
+      case "fragments":
+        return [Buffer.from(buf)];
+      // one-fragment approximation
+      case "blob": {
+        const BlobCtor = globalThis.Blob;
+        return BlobCtor ? new BlobCtor([new Uint8Array(buf)]) : Buffer.from(buf);
+      }
+      case "nodebuffer":
+      default:
+        return Buffer.from(buf);
+    }
+  }
+  _onClose(ev) {
+    const code = typeof ev?.code === "number" ? ev.code : 1006;
+    const reason = typeof ev?.reason === "string" ? ev.reason : "";
+    this.readyState = CLOSED;
+    this.emit("close", code, Buffer.from(reason));
+    this._dispatchEvent("close", { code, reason, wasClean: !!ev?.wasClean });
+  }
+  _onError(ev) {
+    const msg = ev?.message || "WebSocket error";
+    const err = ev?.error instanceof Error ? ev.error : new Error(msg);
+    this.emit("error", err);
+    this._dispatchEvent("error", { error: err, message: msg });
+  }
+  send(data, optionsOrCb, cb) {
+    const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
+    if (this.readyState === CONNECTING) {
+      throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+    }
+    if (this.readyState !== OPEN) {
+      const err = new Error("WebSocket is not open: readyState " + this.readyState);
+      if (callback) queueMicrotask(() => callback(err));
+      else queueMicrotask(() => this.emit("error", err));
+      return;
+    }
+    this._nativeSend(data, callback);
+  }
+  _nativeSend(data, cb) {
+    try {
+      let payload = data;
+      if (typeof data === "number" || typeof data === "boolean") {
+        payload = String(data);
+      } else if (Buffer.isBuffer(data)) {
+        const b = data;
+        payload = b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+      }
+      this._native.send(payload);
+      if (cb) queueMicrotask(() => cb());
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      if (cb) queueMicrotask(() => cb(e));
+      else queueMicrotask(() => this.emit("error", e));
+    }
+  }
+  _sizeOf(data) {
+    if (typeof data === "string") return data.length;
+    if (data instanceof ArrayBuffer) return data.byteLength;
+    if (ArrayBuffer.isView(data)) return data.byteLength;
+    return 0;
+  }
+  close(code, reason) {
+    if (this.readyState === CLOSED) return;
+    if (this.readyState === CLOSING) return;
+    this.readyState = CLOSING;
+    try {
+      const reasonStr = reason === void 0 ? void 0 : Buffer.isBuffer(reason) ? reason.toString("utf8") : String(reason);
+      if (code === void 0) this._native?.close();
+      else if (reasonStr === void 0) this._native?.close(code);
+      else this._native?.close(code, reasonStr);
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  /** ws-only: force-close without sending a Close frame. On Gjs we can't bypass
+   *  Soup's close handshake, so terminate is approximated as close(1006).
+   *  Known gap vs. ws semantics — documented. */
+  terminate() {
+    if (this.readyState === CLOSED) return;
+    this.readyState = CLOSING;
+    try {
+      this._native?.close(1006, "terminated");
+    } catch {
+    }
+  }
+  /** Convenience: returns true if the socket is closed or closing. Matches
+   *  ws.isPaused() / internal state checks that some consumers rely on. */
+  get isPaused() {
+    return this.readyState === CLOSING || this.readyState === CLOSED;
+  }
+  // --- W3C EventTarget compat surface -------------------------------------
+  // ws uses EventEmitter by default, but exposes addEventListener-style
+  // registration for consumers that prefer the W3C API. We mirror it to
+  // stay compat.
+  _eventTargetListeners = /* @__PURE__ */ new Map();
+  addEventListener(type, listener) {
+    let set = this._eventTargetListeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this._eventTargetListeners.set(type, set);
+    }
+    set.add(listener);
+  }
+  removeEventListener(type, listener) {
+    this._eventTargetListeners.get(type)?.delete(listener);
+  }
+  _dispatchEvent(type, detail) {
+    const set = this._eventTargetListeners.get(type);
+    if (!set || set.size === 0) return;
+    const ev = Object.assign({ type, target: this }, detail);
+    for (const listener of set) {
+      try {
+        listener(ev);
+      } catch (err) {
+        queueMicrotask(() => this.emit("error", err));
+      }
+    }
+  }
+  // Static list of accepted binary types — exposed for parity with ws.
+  static get BINARY_TYPES() {
+    return BINARY_TYPES;
+  }
+}
+WebSocket.WebSocket = WebSocket;
+export {
+  WebSocket
+};

package/lib/types/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const BINARY_TYPES: readonly ["nodebuffer", "arraybuffer", "fragments"];
+export declare const EMPTY_BUFFER: Uint8Array<ArrayBuffer>;
+export declare const CONNECTING = 0;
+export declare const OPEN = 1;
+export declare const CLOSING = 2;
+export declare const CLOSED = 3;
+/** Internal marker for native `globalThis.WebSocket` instances handed in via
+ *  `{ socket }` option (not currently supported but reserved). */
+export declare const kWebSocket: unique symbol;

package/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+import { WebSocket } from './websocket.js';
+import { WebSocketServer } from './websocket-server.js';
+import { createWebSocketStream } from './stream.js';
+export { WebSocket, WebSocketServer, createWebSocketStream };
+export { WebSocketServer as Server };
+export default WebSocket;

package/lib/types/index.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/stream.d.ts

@@ -0,0 +1,2 @@
+import { Duplex } from 'node:stream';
+export declare function createWebSocketStream(ws: any, options?: Record<string, unknown>): Duplex;

package/lib/types/stream.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/websocket-server.d.ts

@@ -0,0 +1,119 @@
+import { EventEmitter } from '@gjsify/events';
+import { Buffer } from '@gjsify/buffer';
+import Soup from '@girs/soup-3.0';
+/** Structural duck-type for @gjsify/http Server — avoids a hard dep on @gjsify/http. */
+interface HttpServer {
+    soupServer: Soup.Server | null;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    } | null;
+}
+export interface VerifyClientInfo {
+    /** Value of the HTTP Origin request header (empty string if absent). */
+    origin: string;
+    /** Whether the connection uses TLS. Always false on Gjs (Soup plain text). */
+    secure: boolean;
+    /** Minimal HTTP request object populated from Soup.ServerMessage. */
+    req: {
+        method: string;
+        url: string;
+        headers: Record<string, string | string[]>;
+        socket: {
+            remoteAddress: string;
+            remotePort: number;
+        };
+    };
+}
+export type VerifyClientSync = (info: VerifyClientInfo) => boolean;
+export type VerifyClientAsync = (info: VerifyClientInfo, cb: (result: boolean, code?: number, message?: string, headers?: Record<string, string>) => void) => void;
+export interface ServerOptions {
+    host?: string;
+    port?: number;
+    backlog?: number;
+    /** Attach to an existing @gjsify/http Server instead of creating a new one. */
+    server?: HttpServer;
+    /** Pre-upgrade access control hook. Sync: return boolean. Async: call cb(result, code?). */
+    verifyClient?: VerifyClientSync | VerifyClientAsync;
+    /** Subprotocol selection hook. Receives the Set of client-offered protocols and
+     *  a minimal request object; return the selected protocol string or false to
+     *  use none. Server-side ws.protocol is set correctly; client-visible protocol
+     *  negotiation requires Phase 3 (manual handshake). */
+    handleProtocols?: (protocols: Set<string>, req: VerifyClientInfo['req']) => string | false;
+    path?: string;
+    noServer?: boolean;
+    clientTracking?: boolean;
+    perMessageDeflate?: boolean | object;
+    maxPayload?: number;
+    skipUTF8Validation?: boolean;
+    allowSynchronousEvents?: boolean;
+}
+/** Wraps an accepted Soup.WebsocketConnection in a `ws.WebSocket`-shaped
+ *  EventEmitter. Kept private to this file: the WebSocket class in
+ *  ./websocket.ts targets the CLIENT constructor path. Server-accepted
+ *  connections have different semantics (no URL reconnect, different
+ *  lifecycle) so we expose a narrower surface. */
+declare class ServerSideWebSocket extends EventEmitter {
+    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;
+    readyState: number;
+    protocol: string;
+    extensions: string;
+    url: string;
+    private _conn;
+    constructor(conn: Soup.WebsocketConnection, url: string);
+    send(data: string | Buffer | ArrayBuffer | ArrayBufferView, optionsOrCb?: ((err?: Error) => void) | object, cb?: (err?: Error) => void): void;
+    close(code?: number, reason?: string | Buffer): void;
+    terminate(): void;
+}
+/** `ws.WebSocketServer` — listens on a TCP port (or attaches to an existing
+ *  @gjsify/http Server) and emits 'connection' events wrapping
+ *  Soup.WebsocketConnection as ws.WebSocket-shaped objects. */
+export declare class WebSocketServer extends EventEmitter {
+    readonly options: ServerOptions;
+    readonly clients: Set<ServerSideWebSocket>;
+    readonly path: string;
+    private _server;
+    private _address;
+    constructor(options?: ServerOptions, callback?: () => void);
+    private _buildVerifyClientInfo;
+    /** Register add_handler (verifyClient) + add_websocket_handler on soupServer.
+     *  The verifyClient add_handler MUST be registered before add_websocket_handler —
+     *  Soup processes normal handlers before websocket handlers; setting a status code
+     *  in add_handler prevents the websocket handler from firing (HTTP-level rejection).
+     *  Only register add_handler when verifyClient is provided — a no-op handler on the
+     *  same path as an existing http.Server catch-all can interfere with Soup's routing. */
+    private _setupHandlers;
+    private _start;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    } | null;
+    close(callback?: (err?: Error) => void): void;
+    /** Manual WebSocket upgrade — matches npm ws semantics exactly.
+     *  The caller intercepts 'upgrade' on an http.Server (typically with
+     *  { noServer: true } on this WebSocketServer) and passes the raw
+     *  IncomingMessage + net.Socket + head buffer here.
+     *
+     *  Internally: validates headers, runs verifyClient, computes
+     *  Sec-WebSocket-Accept, emits 'headers' (mutable array), writes the 101
+     *  response via socket.write(), then creates Soup.WebsocketConnection from
+     *  the underlying IOStream and calls cb(ws, req). */
+    handleUpgrade(req: any, socket: any, _head: Buffer, cb: (ws: ServerSideWebSocket, req: any) => void): void;
+    shouldHandle(req: {
+        url?: string;
+    }): boolean;
+    private _validateUpgradeHeaders;
+    private _completeUpgrade;
+    private _abortHandshake;
+    private _buildVerifyClientInfoFromReq;
+}
+export {};

package/lib/types/websocket-server.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/websocket.d.ts

@@ -0,0 +1,99 @@
+import { EventEmitter } from '@gjsify/events';
+import { Buffer } from '@gjsify/buffer';
+export type BinaryType = 'nodebuffer' | 'arraybuffer' | 'fragments' | 'blob';
+/** Options accepted by the ws constructor. Only a subset is honored on Gjs —
+ *  see README for the support matrix. Unknown options are silently ignored
+ *  to preserve drop-in compatibility with `ws`-calling code. */
+export interface ClientOptions {
+    protocol?: string;
+    protocols?: string | string[];
+    origin?: string;
+    headers?: Record<string, string | string[]>;
+    handshakeTimeout?: number;
+    /** Enable permessage-deflate (RFC 7692). Defaults to true, matching the real
+     *  ws npm package. Set to false to disable deflate negotiation (useful when
+     *  the remote server has buggy deflate handling). */
+    perMessageDeflate?: boolean;
+}
+/** `ws.WebSocket` — EventEmitter-based WebSocket client.
+ *
+ *  Events (ws-compatible):
+ *    - 'open'                          → ()
+ *    - 'message'                       → (data: Buffer | ArrayBuffer | string, isBinary: boolean)
+ *    - 'close'                         → (code: number, reason: Buffer)
+ *    - 'error'                         → (error: Error)
+ *    - 'ping' / 'pong'                 → NOT EMITTED on Gjs (Soup handles control
+ *                                        frames internally; no JS hook exposed).
+ *                                        Consumers that rely on 'ping'/'pong' for
+ *                                        keep-alive application logic need to use
+ *                                        data messages instead. Tracked as a
+ *                                        known limitation in STATUS.md.
+ *    - 'upgrade' / 'unexpected-response' / 'redirect'
+ *                                      → NOT EMITTED on Gjs (Soup does not expose
+ *                                        the raw HTTP upgrade response). Code
+ *                                        that only branches on `open` vs `error`
+ *                                        still works.
+ *
+ *  Also implements W3C DOM `EventTarget` methods (addEventListener /
+ *  removeEventListener) so `ws` users who follow W3C-style handlers via the
+ *  `ws.EventTarget` flag still work without special-casing the Gjs path.
+ */
+export declare class WebSocket extends EventEmitter {
+    /** Static readyState constants — match the W3C and `ws` values. */
+    static readonly CONNECTING = 0;
+    static readonly OPEN = 1;
+    static readonly CLOSING = 2;
+    static readonly CLOSED = 3;
+    /** Instance-side copies for `ws.readyState === ws.OPEN` style code. */
+    readonly CONNECTING = 0;
+    readonly OPEN = 1;
+    readonly CLOSING = 2;
+    readonly CLOSED = 3;
+    /** Per-instance state. Populated from the underlying native WebSocket as
+     *  events arrive; exposed as properties so that ws-calling code like
+     *  `if (ws.readyState === ws.OPEN)` works identically to Node's `ws`. */
+    readyState: number;
+    url: string;
+    protocol: string;
+    extensions: string;
+    bufferedAmount: number;
+    binaryType: BinaryType;
+    /** The real WebSocket we delegate to. Typed as `any` because the W3C
+     *  ambient type comes from multiple realms depending on where this bundle
+     *  ends up (GJS browser-like globals vs. Node's undici). */
+    private _native;
+    constructor(address: string | URL | null, protocols?: string | string[], options?: ClientOptions);
+    /** Merge `protocols` arg and `options.protocols` / `options.protocol`. */
+    private _resolveProtocols;
+    /** Lazy-open the underlying native WebSocket. Separated from the constructor
+     *  so subclasses or future socket-adoption paths can bypass it. */
+    private _openNative;
+    private _fail;
+    private _onOpen;
+    private _onMessage;
+    /** Convert an ArrayBuffer to the Buffer flavor requested by `binaryType`. */
+    private _decodeBinary;
+    private _onClose;
+    private _onError;
+    send(data: string | Buffer | ArrayBuffer | ArrayBufferView | Blob | number | boolean, optionsOrCb?: ((err?: Error) => void) | {
+        mask?: boolean;
+        binary?: boolean;
+        compress?: boolean;
+        fin?: boolean;
+    }, cb?: (err?: Error) => void): void;
+    private _nativeSend;
+    private _sizeOf;
+    close(code?: number, reason?: string | Buffer): void;
+    /** ws-only: force-close without sending a Close frame. On Gjs we can't bypass
+     *  Soup's close handshake, so terminate is approximated as close(1006).
+     *  Known gap vs. ws semantics — documented. */
+    terminate(): void;
+    /** Convenience: returns true if the socket is closed or closing. Matches
+     *  ws.isPaused() / internal state checks that some consumers rely on. */
+    get isPaused(): boolean;
+    private _eventTargetListeners;
+    addEventListener(type: string, listener: (ev: any) => void): void;
+    removeEventListener(type: string, listener: (ev: any) => void): void;
+    private _dispatchEvent;
+    static get BINARY_TYPES(): readonly ["nodebuffer", "arraybuffer", "fragments"];
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@gjsify/ws",
+  "version": "0.2.0",
+  "description": "Drop-in replacement for the `ws` npm package on Gjs — wraps globalThis.WebSocket (Soup.WebsocketConnection) and Soup.Server for the WebSocketServer side",
+  "type": "module",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc",
+    "build:test": "yarn build:test:gjs && yarn build:test:node",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test:gjs": "gjsify run test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "ws",
+    "websocket"
+  ],
+  "dependencies": {
+    "@girs/gio-2.0": "^2.88.0-4.0.0-rc.9",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-rc.9",
+    "@girs/soup-3.0": "^3.6.6-4.0.0-rc.9",
+    "@gjsify/buffer": "^0.2.0",
+    "@gjsify/crypto": "^0.2.0",
+    "@gjsify/events": "^0.2.0",
+    "@gjsify/utils": "^0.2.0",
+    "@gjsify/websocket": "^0.2.0"
+  },
+  "devDependencies": {
+    "@gjsify/cli": "^0.2.0",
+    "@gjsify/unit": "^0.2.0",
+    "@types/node": "^25.6.0",
+    "typescript": "^6.0.3"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,15 @@
+// Constants shared between WebSocket and WebSocketServer.
+// Values chosen to match the `ws` npm package where observable.
+
+export const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'] as const;
+export const EMPTY_BUFFER = new Uint8Array(0);
+
+// WebSocket readyState values — identical to the W3C spec and `ws` npm pkg.
+export const CONNECTING = 0;
+export const OPEN = 1;
+export const CLOSING = 2;
+export const CLOSED = 3;
+
+/** Internal marker for native `globalThis.WebSocket` instances handed in via
+ *  `{ socket }` option (not currently supported but reserved). */
+export const kWebSocket = Symbol('ws:kWebSocket');