@sigx/lynx-websocket 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Andreas Ekdahl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,147 @@
+# @sigx/lynx-websocket
+
+Browser-standard `WebSocket` client for sigx-lynx. Wraps
+`URLSessionWebSocketTask` on iOS and OkHttp `WebSocket` on Android, and
+installs a global `WebSocket` class that matches the WHATWG / MDN API so
+portable web code works unchanged.
+
+> Note: this is **only for WebSockets**. Plain HTTP works out of the box —
+> Lynx already ships a global `fetch()`. See [Networking](#networking)
+> below.
+
+## Install
+
+```bash
+pnpm add @sigx/lynx-websocket
+```
+
+```ts
+// sigx.lynx.config.ts
+export default defineLynxConfig({
+    modules: ['@sigx/lynx-websocket'],
+});
+```
+
+Then run `sigx-lynx prebuild` to regenerate the iOS / Android projects.
+No permissions are required on either platform (OkHttp piggy-backs on
+the app's standard `INTERNET` permission, which the host app already
+declares).
+
+## Usage
+
+Listing the package in `modules:` registers a global `WebSocket` — you don't
+need to `import` anything to use it:
+
+```ts
+const ws = new WebSocket('wss://ws.postman-echo.com/raw');
+
+ws.onopen = () => ws.send('hello');
+ws.onmessage = (event) => {
+    console.log('received', event.data);
+};
+ws.onclose = (event) => {
+    console.log('closed', event.code, event.reason);
+};
+```
+
+If you prefer an explicit import (e.g. for TypeScript clarity, or to use
+inside a library that shouldn't assume the global is set):
+
+```ts
+import { WebSocket } from '@sigx/lynx-websocket';
+
+const ws = new WebSocket('wss://example.com/socket');
+```
+
+### Binary frames
+
+`binaryType` is fixed to `'arraybuffer'` — `'blob'` is not supported (Lynx
+doesn't ship a `Blob` polyfill, matching upstream's `fetch` constraints).
+Send `ArrayBuffer` / typed arrays directly:
+
+```ts
+const ws = new WebSocket('wss://example.com/socket');
+ws.binaryType = 'arraybuffer';
+
+ws.onmessage = (event) => {
+    if (event.data instanceof ArrayBuffer) {
+        const bytes = new Uint8Array(event.data);
+        // ...
+    }
+};
+
+ws.onopen = () => {
+    ws.send(new Uint8Array([0x01, 0x02, 0x03]));
+};
+```
+
+### Subprotocols
+
+Pass a string or array of strings as the second arg to the constructor —
+the negotiated value is available on `ws.protocol` after `open`:
+
+```ts
+const ws = new WebSocket('wss://example.com/chat', ['v2.chat', 'v1.chat']);
+ws.onopen = () => console.log('negotiated', ws.protocol);
+```
+
+## API
+
+Matches [`WebSocket` on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket):
+
+| Member | Type | Notes |
+|---|---|---|
+| `new WebSocket(url, protocols?)` | constructor | `url` must be `ws:` / `wss:` (http/https accepted, normalised by native). |
+| `readyState` | `0 \| 1 \| 2 \| 3` | `CONNECTING / OPEN / CLOSING / CLOSED`. |
+| `url` | `string` | The URL passed to the constructor. |
+| `protocol` | `string` | Negotiated subprotocol; `''` until `open`. |
+| `extensions` | `string` | Negotiated `Sec-WebSocket-Extensions`. |
+| `bufferedAmount` | `number` | Bytes handed to native, not yet acked. Approximate; updated on `send`. |
+| `binaryType` | `'arraybuffer'` | Fixed — `'blob'` is unsupported. |
+| `send(data)` | method | `string \| ArrayBuffer \| ArrayBufferView`. Throws if `CONNECTING`. |
+| `close(code?, reason?)` | method | Browser semantics: `1000` or `3000–4999`; reason ≤123 UTF-8 bytes. |
+| `onopen / onmessage / onerror / onclose` | listener slot | Standard WHATWG event shape. |
+| `addEventListener(type, fn)` / `removeEventListener` / `dispatchEvent` | EventTarget | Multiple listeners per event. |
+| Class constants | `CONNECTING (0) / OPEN (1) / CLOSING (2) / CLOSED (3)` | On both class and instance. |
+| `isWebSocketAvailable()` | export | Whether the native module is registered (useful in tests / SSR). |
+
+## Caveats vs the browser
+
+- **No `Blob`** binary type — use `ArrayBuffer`.
+- **`bufferedAmount`** is a JS-side approximation (bytes handed off to
+  native), not the OS socket buffer level. Sufficient for backpressure
+  hinting; don't use it for exact accounting.
+- **`Sec-WebSocket-Extensions`** negotiation is whatever URLSession (iOS)
+  or OkHttp (Android) offers — neither advertises `permessage-deflate` by
+  default. If you need it, configure the server to live without it or open
+  an issue.
+- **No `Sec-WebSocket-Key` access** — handshake headers other than
+  `Sec-WebSocket-Protocol` aren't customizable from JS in this version.
+
+## How it works
+
+JS → native is a 3-method bridge (`create / send / close`). Native → JS is
+a single `__sigxWebSocketEvent` global event multiplexed by a monotonic
+numeric id; the shim demultiplexes per-instance. A per-`LynxView`
+publisher pumps events from a process-wide `WebSocketEventBus` into
+`LynxView.sendGlobalEvent`. Sockets outlive any single LynxView so a
+template reload doesn't drop in-flight connections that JS is
+re-attaching to.
+
+## Related
+
+- **HTTP**: just call `fetch()` — it's a built-in Lynx global. No package
+  needed. See [upstream Lynx fetch docs](https://lynxjs.org/api/lynx-api/global/fetch.html)
+  for the Lynx subset (no CORS / redirect / keepalive / FormData / Blob).
+- **Connectivity**: [`@sigx/lynx-network`](../lynx-network) for online /
+  offline and connection-type state.
+
+## Reference app
+
+Once wired in, point it at an echo service to smoke-test:
+
+```ts
+const ws = new WebSocket('wss://ws.postman-echo.com/raw');
+ws.onopen = () => ws.send('ping');
+ws.onmessage = (e) => console.log(e.data); // → 'ping'
+```

package/android/com/sigx/websocket/WebSocketEventBus.kt

@@ -0,0 +1,104 @@
+package com.sigx.websocket
+
+import com.lynx.react.bridge.JavaOnlyMap
+import java.util.UUID
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Process-wide pub/sub bus that owns the conversion of native WebSocket
+ * callbacks into JS-side event payloads. OkHttp listeners write here;
+ * per-LynxView [WebSocketPublisher] instances read.
+ *
+ * Mirrors the publisher pattern used elsewhere in the repo
+ * (`LinkingState`, `SafeAreaPublisher`, …): native lifecycle is decoupled
+ * from any specific LynxView so events survive view recreation and
+ * per-view subscribers can fan out without holding onto the WS task.
+ *
+ * Payload keys match the `NativeEvent` interface in `src/websocket.ts`.
+ */
+internal object WebSocketEventBus {
+
+    private val listeners = CopyOnWriteArrayList<Pair<UUID, (JavaOnlyMap) -> Unit>>()
+
+    fun addListener(fn: (JavaOnlyMap) -> Unit): UUID {
+        val token = UUID.randomUUID()
+        listeners.add(token to fn)
+        return token
+    }
+
+    fun removeListener(token: UUID) {
+        listeners.removeAll { it.first == token }
+    }
+
+    fun publishOpen(id: Int, protocol: String, extensions: String) {
+        emit(
+            mapOf(
+                "id" to id,
+                "type" to "open",
+                "protocol" to protocol,
+                "extensions" to extensions,
+            )
+        )
+    }
+
+    fun publishMessageText(id: Int, text: String) {
+        emit(
+            mapOf(
+                "id" to id,
+                "type" to "message",
+                "data" to text,
+                "isBinary" to false,
+            )
+        )
+    }
+
+    fun publishMessageBinary(id: Int, base64: String) {
+        emit(
+            mapOf(
+                "id" to id,
+                "type" to "message",
+                "binary" to base64,
+                "isBinary" to true,
+            )
+        )
+    }
+
+    fun publishError(id: Int, message: String) {
+        emit(
+            mapOf(
+                "id" to id,
+                "type" to "error",
+                "data" to message,
+            )
+        )
+    }
+
+    fun publishClose(id: Int, code: Int, reason: String, wasClean: Boolean) {
+        emit(
+            mapOf(
+                "id" to id,
+                "type" to "close",
+                "code" to code,
+                "reason" to reason,
+                "wasClean" to wasClean,
+            )
+        )
+    }
+
+    private fun emit(payload: Map<String, Any>) {
+        // JavaOnlyMap doesn't ship a `from(Map)` overload that handles
+        // mixed value types on every host, so build it explicitly to keep
+        // the bridge happy.
+        val map = JavaOnlyMap()
+        for ((k, v) in payload) {
+            when (v) {
+                is String -> map.putString(k, v)
+                is Int -> map.putInt(k, v)
+                is Double -> map.putDouble(k, v)
+                is Boolean -> map.putBoolean(k, v)
+                else -> map.putString(k, v.toString())
+            }
+        }
+        for ((_, fn) in listeners) fn(map)
+    }
+}

package/android/com/sigx/websocket/WebSocketModule.kt

@@ -0,0 +1,78 @@
+package com.sigx.websocket
+
+import android.content.Context
+import android.util.Log
+import com.lynx.jsbridge.LynxMethod
+import com.lynx.jsbridge.LynxModule
+import com.lynx.react.bridge.Callback
+import com.lynx.react.bridge.JavaOnlyMap
+import com.lynx.react.bridge.ReadableArray
+
+/**
+ * Native WebSocket bridge — JS-callable side.
+ *
+ * JS usage (via the `@sigx/lynx-websocket` shim, not directly):
+ *
+ *   NativeModules.WebSocket.create(id, url, protocols, cb)
+ *   NativeModules.WebSocket.send(id, payload, isBinary, cb)
+ *   NativeModules.WebSocket.close(id, code, reason, cb)
+ *
+ * Async lifecycle events (`open`, `message`, `error`, `close`) are pushed
+ * back via [WebSocketEventBus], which a per-LynxView [WebSocketPublisher]
+ * forwards to JS through `LynxView.sendGlobalEvent("__sigxWebSocketEvent",
+ * [...])`.
+ *
+ * Implemented with OkHttp's WebSocket. Each socket is stored in
+ * [WebSocketTaskStore] keyed by the JS-supplied numeric id; the same id is
+ * echoed back in every event so the JS shim can demultiplex.
+ */
+class WebSocketModule(context: Context) : LynxModule(context) {
+
+    @LynxMethod
+    fun create(id: Int, url: String?, protocols: ReadableArray?, callback: Callback?) {
+        if (url.isNullOrEmpty()) {
+            WebSocketEventBus.publishError(id, "Invalid URL")
+            WebSocketEventBus.publishClose(id, 1006, "Invalid URL", wasClean = false)
+            callback?.invoke(JavaOnlyMap.from(emptyMap<String, Any>()))
+            return
+        }
+
+        val protoList = mutableListOf<String>()
+        if (protocols != null) {
+            for (i in 0 until protocols.size()) {
+                val v = protocols.getString(i)
+                if (!v.isNullOrEmpty()) protoList.add(v)
+            }
+        }
+
+        try {
+            WebSocketTaskStore.create(id, url, protoList)
+            callback?.invoke(JavaOnlyMap.from(emptyMap<String, Any>()))
+        } catch (e: Exception) {
+            Log.e(TAG, "create($id) failed: ${e.message}")
+            WebSocketEventBus.publishError(id, e.message ?: "create failed")
+            WebSocketEventBus.publishClose(id, 1006, e.message ?: "", wasClean = false)
+            callback?.invoke(JavaOnlyMap.from(mapOf("error" to (e.message ?: "create failed"))))
+        }
+    }
+
+    @LynxMethod
+    fun send(id: Int, payload: String?, isBinary: Boolean, callback: Callback?) {
+        val ok = WebSocketTaskStore.send(id, payload ?: "", isBinary)
+        if (!ok) {
+            callback?.invoke(JavaOnlyMap.from(mapOf("error" to "WebSocket $id not found or not open")))
+            return
+        }
+        callback?.invoke(JavaOnlyMap.from(emptyMap<String, Any>()))
+    }
+
+    @LynxMethod
+    fun close(id: Int, code: Int, reason: String?, callback: Callback?) {
+        WebSocketTaskStore.close(id, code, reason ?: "")
+        callback?.invoke(JavaOnlyMap.from(emptyMap<String, Any>()))
+    }
+
+    private companion object {
+        const val TAG = "SigxWebSocketModule"
+    }
+}

package/android/com/sigx/websocket/WebSocketPublisher.kt

@@ -0,0 +1,44 @@
+package com.sigx.websocket
+
+import android.util.Log
+import com.lynx.react.bridge.JavaOnlyArray
+import com.lynx.tasm.LynxView
+import java.util.UUID
+
+/**
+ * Per-[LynxView] publisher that pumps [WebSocketEventBus] payloads into JS
+ * via `LynxView.sendGlobalEvent("__sigxWebSocketEvent", [...])`.
+ *
+ * One instance per LynxView; instantiated by the generated
+ * `GeneratedLifecyclePublishers.attachAll(lynxView)` and retained for the
+ * LynxView's lifetime. The bus is global so opening a socket from one
+ * LynxView and reading it from another (via the JS shim) works, but in
+ * practice each LynxView holds its own JS heap so events are delivered to
+ * the matching view only.
+ */
+class WebSocketPublisher(private val lynxView: LynxView) {
+
+    private var token: UUID? = null
+
+    fun attach() {
+        token = WebSocketEventBus.addListener { payload ->
+            try {
+                val params = JavaOnlyArray()
+                params.pushMap(payload)
+                lynxView.sendGlobalEvent(EVENT_NAME, params)
+            } catch (e: Throwable) {
+                Log.w(TAG, "publish failed: ${e.message}")
+            }
+        }
+    }
+
+    fun detach() {
+        token?.let { WebSocketEventBus.removeListener(it) }
+        token = null
+    }
+
+    private companion object {
+        const val TAG = "SigxWebSocketPublisher"
+        const val EVENT_NAME = "__sigxWebSocketEvent"
+    }
+}

package/android/com/sigx/websocket/WebSocketTaskStore.kt

@@ -0,0 +1,115 @@
+package com.sigx.websocket
+
+import android.util.Base64
+import android.util.Log
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import okio.ByteString
+import okio.ByteString.Companion.toByteString
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+
+/**
+ * Process-wide registry of live OkHttp [WebSocket] instances keyed by the
+ * JS-supplied numeric id. Sockets outlive any single LynxView (a page
+ * reload should not drop in-flight sockets that the JS bundle is
+ * re-attaching to).
+ */
+internal object WebSocketTaskStore {
+
+    private const val TAG = "SigxWebSocketStore"
+
+    private val sockets = ConcurrentHashMap<Int, WebSocket>()
+
+    private val client: OkHttpClient by lazy {
+        OkHttpClient.Builder()
+            // No read timeout on established sockets — close frames drive teardown.
+            .readTimeout(0, TimeUnit.MILLISECONDS)
+            .pingInterval(0, TimeUnit.MILLISECONDS)
+            .build()
+    }
+
+    fun create(id: Int, url: String, protocols: List<String>) {
+        // If JS re-uses an id (shouldn't — ids are monotonic), tear down
+        // the prior socket first to avoid leaks.
+        sockets.remove(id)?.cancel()
+
+        val builder = Request.Builder().url(url)
+        if (protocols.isNotEmpty()) {
+            builder.addHeader("Sec-WebSocket-Protocol", protocols.joinToString(", "))
+        }
+        val request = builder.build()
+        val ws = client.newWebSocket(request, Listener(id))
+        sockets[id] = ws
+    }
+
+    fun send(id: Int, payload: String, isBinary: Boolean): Boolean {
+        val ws = sockets[id] ?: return false
+        return if (isBinary) {
+            // Payload is base64-encoded on the JS side — decode to raw bytes.
+            val bytes = try {
+                Base64.decode(payload, Base64.DEFAULT)
+            } catch (e: IllegalArgumentException) {
+                Log.w(TAG, "send($id) invalid base64: ${e.message}")
+                return false
+            }
+            ws.send(bytes.toByteString())
+        } else {
+            ws.send(payload)
+        }
+    }
+
+    fun close(id: Int, code: Int, reason: String) {
+        val ws = sockets[id] ?: return
+        // OkHttp returns false if the socket is already closing/closed —
+        // either way the listener will fire and we'll clean up.
+        ws.close(code, reason)
+    }
+
+    private fun forget(id: Int) {
+        sockets.remove(id)
+    }
+
+    /**
+     * OkHttp WebSocketListener — converts OkHttp callbacks into
+     * [WebSocketEventBus] publishes. One listener per socket so we can
+     * capture the id in the closure.
+     */
+    private class Listener(private val id: Int) : WebSocketListener() {
+
+        override fun onOpen(webSocket: WebSocket, response: Response) {
+            val protocol = response.header("Sec-WebSocket-Protocol") ?: ""
+            val extensions = response.header("Sec-WebSocket-Extensions") ?: ""
+            WebSocketEventBus.publishOpen(id, protocol, extensions)
+        }
+
+        override fun onMessage(webSocket: WebSocket, text: String) {
+            WebSocketEventBus.publishMessageText(id, text)
+        }
+
+        override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+            val b64 = Base64.encodeToString(bytes.toByteArray(), Base64.NO_WRAP)
+            WebSocketEventBus.publishMessageBinary(id, b64)
+        }
+
+        override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
+            // Echo the peer's close back — OkHttp does the responding close
+            // for us automatically here.
+            webSocket.close(code, reason)
+        }
+
+        override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+            forget(id)
+            WebSocketEventBus.publishClose(id, code, reason, wasClean = true)
+        }
+
+        override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+            forget(id)
+            WebSocketEventBus.publishError(id, t.message ?: t.javaClass.simpleName)
+            WebSocketEventBus.publishClose(id, 1006, t.message ?: "", wasClean = false)
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { WebSocket, isWebSocketAvailable } from './websocket.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * `@sigx/lynx-websocket` — browser-standard `WebSocket` for sigx-lynx.
+ *
+ * Importing this module (or listing `@sigx/lynx-websocket` in
+ * `sigx.lynx.config.ts → modules:`) installs a global `WebSocket` class on
+ * `globalThis`, so portable web code that does `new WebSocket(url)` works
+ * unchanged.
+ */
+import { WebSocket as SigxWebSocket } from './websocket.js';
+export { WebSocket, isWebSocketAvailable } from './websocket.js';
+// Side-effect: register on the global so consumers don't need an import
+// site to call `new WebSocket(...)`. Mirrors the CLI plugin's auto-import
+// behavior for native modules — listing the package in `modules: [...]`
+// already causes this file to run at bundle init time.
+{
+    const g = globalThis;
+    if (typeof g.WebSocket === 'undefined') {
+        g.WebSocket = SigxWebSocket;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE5D,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEjE,wEAAwE;AACxE,0EAA0E;AAC1E,wEAAwE;AACxE,uDAAuD;AACvD,CAAC;IACG,MAAM,CAAC,GAAG,UAAgD,CAAC;IAC3D,IAAI,OAAO,CAAC,CAAC,SAAS,KAAK,WAAW,EAAE,CAAC;QACrC,CAAC,CAAC,SAAS,GAAG,aAAa,CAAC;IAChC,CAAC;AACL,CAAC"}

package/dist/websocket.d.ts

@@ -0,0 +1,91 @@
+/** Bridge to lynx's `GlobalEventEmitter` for native → JS events. */
+interface GlobalEventEmitterLike {
+    addListener: (name: string, fn: (...a: unknown[]) => void) => void;
+    removeListener: (name: string, fn: (...a: unknown[]) => void) => void;
+}
+/** Wire payload pushed by the native side. */
+interface NativeEvent {
+    id: number;
+    type: 'open' | 'message' | 'error' | 'close';
+    /** Text body for message events, error message for error events. */
+    data?: string;
+    /** Base64-encoded binary payload (set when isBinary === true). */
+    binary?: string;
+    isBinary?: boolean;
+    /** Negotiated subprotocol — populated on the open event. */
+    protocol?: string;
+    /** Negotiated extensions — populated on the open event. */
+    extensions?: string;
+    /** Close frame fields. */
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+}
+type ReadyState = 0 | 1 | 2 | 3;
+type BinaryType = 'arraybuffer';
+type EventListenerLike = ((ev: WebSocketEventLike) => void) | {
+    handleEvent(ev: WebSocketEventLike): void;
+};
+/** Minimal WHATWG `Event` shape — enough for portable WS code. */
+interface WebSocketEventLike {
+    type: string;
+    target: WebSocket;
+    currentTarget: WebSocket;
+    data?: unknown;
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+    message?: string;
+}
+/**
+ * WHATWG-compatible WebSocket. Drop-in for browser code.
+ *
+ * @example
+ * ```ts
+ * const ws = new WebSocket('wss://ws.postman-echo.com/raw');
+ * ws.onopen = () => ws.send('hello');
+ * ws.onmessage = e => console.log(e.data);
+ * ```
+ */
+export declare class WebSocket {
+    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;
+    protocol: string;
+    extensions: string;
+    bufferedAmount: number;
+    binaryType: BinaryType;
+    onopen: ((ev: WebSocketEventLike) => void) | null;
+    onmessage: ((ev: WebSocketEventLike) => void) | null;
+    onerror: ((ev: WebSocketEventLike) => void) | null;
+    onclose: ((ev: WebSocketEventLike) => void) | null;
+    private _readyState;
+    private readonly _id;
+    private readonly _listeners;
+    get readyState(): ReadyState;
+    constructor(url: string, protocols?: string | string[]);
+    send(data: string | ArrayBuffer | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: string, listener: EventListenerLike): void;
+    removeEventListener(type: string, listener: EventListenerLike): void;
+    dispatchEvent(event: WebSocketEventLike): boolean;
+    /** @internal — called by the shared global-event subscriber. */
+    private _dispatch;
+    private _invoke;
+}
+/** Whether the native WebSocket module is registered in this build. */
+export declare function isWebSocketAvailable(): boolean;
+/** @internal */
+export declare const __internal: {
+    deliver(evt: NativeEvent): void;
+    reset(): void;
+    readonly cachedEmitter: GlobalEventEmitterLike | null;
+};
+export {};
+//# sourceMappingURL=websocket.d.ts.map

package/dist/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../src/websocket.ts"],"names":[],"mappings":"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"}