react-native-nitro-websockets 0.1.0-beta.5 → 1.0.0

package/NitroFetchWebsockets.podspec

@@ -34,7 +34,7 @@ Pod::Spec.new do |s|
   ]
 
   current_xcconfig = s.attributes_hash['pod_target_xcconfig'] || {}
-  s.pod_target_xcconfig = current_xcconfig.merge({
+  merged_xcconfig = {
     'HEADER_SEARCH_PATHS' => [
       '$(inherited)',
       '"${PODS_TARGET_SRCROOT}/cpp"',
@@ -43,7 +43,12 @@ Pod::Spec.new do |s|
       '"$(PODS_CONFIGURATION_BUILD_DIR)/NitroFetchWebsockets"',
     ].join(' '),
     'OTHER_LDFLAGS' => '-lc++',
-  })
+  }
+  if ENV['NITRO_WS_TRACING'] == '1'
+    existing_cxx_flags = current_xcconfig['OTHER_CPLUSPLUSFLAGS'] || '$(inherited)'
+    merged_xcconfig['OTHER_CPLUSPLUSFLAGS'] = "#{existing_cxx_flags} -DNITRO_WS_TRACING=1"
+  end
+  s.pod_target_xcconfig = current_xcconfig.merge(merged_xcconfig)
 
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'

package/android/CMakeLists.txt

@@ -77,6 +77,11 @@ add_library(${PACKAGE_NAME} SHARED
 # Add Nitrogen specs
 include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroFetchWebsockets+autolinking.cmake)
 
+# ── Tracing (Perfetto / systrace) ─────────────────────────────────────────────
+if(NITRO_WS_TRACING)
+  target_compile_definitions(${PACKAGE_NAME} PRIVATE NITRO_WS_TRACING=1)
+endif()
+
 # Include directories
 include_directories(
   "src/main/cpp"

package/android/build.gradle

@@ -31,6 +31,8 @@ def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroFetchWebsockets_" + name]
 }
 
+def enableTracing = (getExtOrDefault("enableTracing") ?: "false").toString().toBoolean()
+
 def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroFetchWebsockets_" + name]).toInteger()
 }
@@ -45,11 +47,16 @@ android {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    buildConfigField "boolean", "NITRO_WS_TRACING", enableTracing.toString()
 
     externalNativeBuild {
       cmake {
         cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
-        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        def cmakeArgs = ["-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"]
+        if (enableTracing) {
+          cmakeArgs.add("-DNITRO_WS_TRACING=ON")
+        }
+        arguments(*cmakeArgs)
         abiFilters (*reactNativeArchitectures())
 
         buildTypes {

package/android/src/main/cpp/WebSocketConnection.cpp

@@ -13,6 +13,10 @@
 #include <stdexcept>
 #include <algorithm>
 
+#if defined(NITRO_WS_TRACING)
+#include <android/trace.h>
+#endif
+
 namespace margelo::nitro::nitrofetchwebsockets {
 
 
@@ -66,7 +70,7 @@ int nitroWsCallback(lws* wsi, enum lws_callback_reasons reason,
       break;
 
     case LWS_CALLBACK_CLIENT_RECEIVE:
-      if (conn) conn->handleReceive(in, len, lws_frame_is_binary(wsi) != 0);
+      if (conn) conn->handleReceiveFragment(wsi, in, len);
       break;
 
     case LWS_CALLBACK_CLIENT_WRITEABLE:
@@ -132,6 +136,10 @@ void WebSocketConnection::connect(
   _url   = url;
   _state = State::CONNECTING;
 
+#if defined(NITRO_WS_TRACING)
+  ATrace_beginSection(("NitroWS connect " + url).c_str());
+#endif
+
   ParsedUrl parsed;
   try {
     parsed = parseUrl(url);
@@ -181,6 +189,9 @@ void WebSocketConnection::connect(
       self->_wsi = wsi;
     }
   });
+#if defined(NITRO_WS_TRACING)
+  ATrace_endSection();
+#endif
 }
 
 
@@ -203,6 +214,9 @@ void WebSocketConnection::close(int code, const std::string& reason) {
 
 
 void WebSocketConnection::send(const std::string& data) {
+#if defined(NITRO_WS_TRACING)
+  ATrace_beginSection("NitroWS send text");
+#endif
   std::vector<uint8_t> buf(LWS_PRE + data.size());
   std::memcpy(buf.data() + LWS_PRE, data.c_str(), data.size());
   {
@@ -211,9 +225,15 @@ void WebSocketConnection::send(const std::string& data) {
     _bufferedAmount += data.size();
   }
   requestWrite();
+#if defined(NITRO_WS_TRACING)
+  ATrace_endSection();
+#endif
 }
 
 void WebSocketConnection::sendBinary(const uint8_t* data, size_t len) {
+#if defined(NITRO_WS_TRACING)
+  ATrace_beginSection("NitroWS send binary");
+#endif
   std::vector<uint8_t> buf(LWS_PRE + len);
   std::memcpy(buf.data() + LWS_PRE, data, len);
   {
@@ -222,6 +242,9 @@ void WebSocketConnection::sendBinary(const uint8_t* data, size_t len) {
     _bufferedAmount += len;
   }
   requestWrite();
+#if defined(NITRO_WS_TRACING)
+  ATrace_endSection();
+#endif
 }
 
 void WebSocketConnection::requestWrite() {
@@ -266,6 +289,9 @@ void WebSocketConnection::setOnError(OnError cb) {
 
 
 void WebSocketConnection::handleEstablished(lws* wsi) {
+#if defined(NITRO_WS_TRACING)
+  ATrace_beginSection("NitroWS established");
+#endif
   _wsi   = wsi;
   _state = State::OPEN;
   _redirectCount = 0;
@@ -278,6 +304,9 @@ void WebSocketConnection::handleEstablished(lws* wsi) {
   } else {
     _openFired = true;
   }
+#if defined(NITRO_WS_TRACING)
+  ATrace_endSection();
+#endif
 }
 
 void WebSocketConnection::handleReceive(const void* in, size_t len, bool isBinary) {
@@ -291,6 +320,50 @@ void WebSocketConnection::handleReceive(const void* in, size_t len, bool isBinar
   }
 }
 
+void WebSocketConnection::handleReceiveFragment(lws* wsi, const void* in, size_t len) {
+#if defined(NITRO_WS_TRACING)
+  ATrace_beginSection("NitroWS receive");
+#endif
+  bool isBinary = lws_frame_is_binary(wsi) != 0;
+  bool isFirst  = lws_is_first_fragment(wsi) != 0;
+  bool isFinal  = lws_is_final_fragment(wsi) != 0;
+
+  // Fast path: single-frame message (most common case)
+  if (isFirst && isFinal) {
+    handleReceive(in, len, isBinary);
+#if defined(NITRO_WS_TRACING)
+    ATrace_endSection();
+#endif
+    return;
+  }
+
+  // Multi-frame: accumulate fragments
+  if (isFirst) {
+    _rxBuf.clear();
+    _rxBinary = isBinary;
+  }
+
+  // Max message size guard — close with 1009 (Message Too Big)
+  if (_rxBuf.size() + len > kMaxMessageSize) {
+    _rxBuf.clear();
+    _rxBuf.shrink_to_fit();
+    close(1009, "message too large");
+    return;
+  }
+
+  const uint8_t* data = static_cast<const uint8_t*>(in);
+  _rxBuf.insert(_rxBuf.end(), data, data + len);
+
+  if (isFinal) {
+    handleReceive(_rxBuf.data(), _rxBuf.size(), _rxBinary);
+    _rxBuf.clear();
+    _rxBuf.shrink_to_fit();
+  }
+#if defined(NITRO_WS_TRACING)
+  ATrace_endSection();
+#endif
+}
+
 int WebSocketConnection::handleWriteable(lws* wsi) {
   OutMessage msg;
   {
@@ -319,18 +392,30 @@ int WebSocketConnection::handleWriteable(lws* wsi) {
 }
 
 void WebSocketConnection::handleClose(int code, const char* reason, size_t len) {
+#if defined(NITRO_WS_TRACING)
+  ATrace_beginSection("NitroWS close");
+#endif
   _state = State::CLOSED;
   _wsi   = nullptr;
   if (_onClose) {
     std::string r = (reason && len > 0) ? std::string(reason, len) : "";
     _onClose(code > 0 ? code : 1000, r, true);
   }
+#if defined(NITRO_WS_TRACING)
+  ATrace_endSection();
+#endif
 }
 
 void WebSocketConnection::handleError(const char* msg) {
+#if defined(NITRO_WS_TRACING)
+  ATrace_beginSection("NitroWS error");
+#endif
   _state = State::CLOSED;
   _wsi   = nullptr;
   if (_onError) _onError(msg ? std::string(msg) : "WebSocket error");
+#if defined(NITRO_WS_TRACING)
+  ATrace_endSection();
+#endif
 }
 
 void WebSocketConnection::handleRedirect(const std::string& location) {

package/android/src/main/cpp/WebSocketConnection.hpp

@@ -47,6 +47,7 @@ public:
   // lws callback handlers (internal, not part of the base interface)
   void handleEstablished(lws* wsi);
   void handleReceive(const void* in, size_t len, bool isBinary);
+  void handleReceiveFragment(lws* wsi, const void* in, size_t len);
   int  handleWriteable(lws* wsi);
   void handleClose(int code, const char* reason, size_t len);
   void handleError(const char* msg);
@@ -72,6 +73,7 @@ private:
   std::atomic<bool> _isRedirecting{false};
   std::atomic<int>  _redirectCount{0};
   static constexpr int kMaxRedirects = 5;
+  static constexpr size_t kMaxMessageSize = 16 * 1024 * 1024; // 16 MB
 
   struct BufferedMessage { std::vector<uint8_t> data; bool isBinary; };
   std::deque<BufferedMessage> _msgBuffer;
@@ -93,6 +95,9 @@ private:
   };
   std::optional<PendingConnect> _pendingConnect;
   std::mutex _pendingConnectMu;
+
+  std::vector<uint8_t> _rxBuf;
+  bool _rxBinary = false;
 };
 
 } // namespace margelo::nitro::nitrofetchwebsockets

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./expo/plugins/dist/index.js').default

package/cpp/WsTrace.hpp

@@ -0,0 +1,55 @@
+//
+//  WsTrace.hpp
+//  Pods
+//
+//  Created by Ritesh Shukla on 03.04.26.
+//
+
+#if defined(NITRO_WS_TRACING)
+
+#if defined(__ANDROID__)
+
+#include <android/trace.h>
+#include <string>
+
+#define WS_TRACE_BEGIN(label) ATrace_beginSection(label)
+#define WS_TRACE_END()        ATrace_endSection()
+
+#define WS_TRACE_ASYNC_BEGIN(label, cookie) ATrace_beginAsyncSection(label, cookie)
+#define WS_TRACE_ASYNC_END(label, cookie)   ATrace_endAsyncSection(label, cookie)
+
+#define WS_TRACE_INT(label, value) ATrace_setCounter(label, value)
+
+#elif defined(__APPLE__)
+
+#include <os/log.h>
+#include <os/signpost.h>
+
+// Shared log handle — defined in NWWebSocketConnection.mm
+namespace margelo::nitro::nitrofetchwebsockets {
+  os_log_t wsTraceLog();
+}
+
+#define WS_TRACE_BEGIN(label) \
+  os_signpost_interval_begin(margelo::nitro::nitrofetchwebsockets::wsTraceLog(), \
+    os_signpost_id_generate(margelo::nitro::nitrofetchwebsockets::wsTraceLog()), \
+    "NitroWS", "%s", label)
+
+#define WS_TRACE_END() ((void)0)
+
+// iOS async tracing uses signpost IDs
+#define WS_TRACE_ASYNC_BEGIN(label, cookie) ((void)0)
+#define WS_TRACE_ASYNC_END(label, cookie)   ((void)0)
+#define WS_TRACE_INT(label, value)          ((void)0)
+
+#endif // __ANDROID__ / __APPLE__
+
+#else // !NITRO_WS_TRACING
+
+#define WS_TRACE_BEGIN(label)               ((void)0)
+#define WS_TRACE_END()                      ((void)0)
+#define WS_TRACE_ASYNC_BEGIN(label, cookie) ((void)0)
+#define WS_TRACE_ASYNC_END(label, cookie)   ((void)0)
+#define WS_TRACE_INT(label, value)          ((void)0)
+
+#endif

package/ios/NWWebSocketConnection.hpp

@@ -67,6 +67,10 @@ private:
   void scheduleReceive();
   void fireClose(int code, const std::string& reason, bool wasClean);
   void fireError(const std::string& msg);
+
+#if defined(NITRO_WS_TRACING)
+  uint64_t _signpostId = 0;
+#endif
 };
 
 std::shared_ptr<WebSocketConnectionBase> createNWConnection();

package/ios/NWWebSocketConnection.mm

@@ -10,6 +10,16 @@
 
 #include <cstring>
 
+#if defined(NITRO_WS_TRACING)
+#include <os/log.h>
+#include <os/signpost.h>
+
+static os_log_t nitroWsLog() {
+  static os_log_t log = os_log_create("com.margelo.nitro.websockets", "NitroWS");
+  return log;
+}
+#endif
+
 // ── ObjC delegate bridging NSURLSession events to C++ via blocks ────────
 
 @interface NWWSDelegate : NSObject <NSURLSessionWebSocketDelegate, NSURLSessionTaskDelegate>
@@ -93,6 +103,13 @@ void NWWebSocketConnection::connect(
     _negotiatedProtocol.clear();
   }
   _state.store(State::CONNECTING, std::memory_order_release);
+
+#if defined(NITRO_WS_TRACING)
+  os_signpost_id_t spid = os_signpost_id_generate(nitroWsLog());
+  _signpostId = spid;
+  os_signpost_interval_begin(nitroWsLog(), spid, "NitroWS",
+                              "%{public}s", url.c_str());
+#endif
   _closeFired = false;
   _openFired = false;
   _receivedCloseCode = 1005;
@@ -155,6 +172,12 @@ void NWWebSocketConnection::connect(
 
     conn->_state.store(State::OPEN, std::memory_order_release);
 
+#if defined(NITRO_WS_TRACING)
+    os_signpost_interval_end(nitroWsLog(),
+      static_cast<os_signpost_id_t>(conn->_signpostId),
+      "NitroWS", "connected");
+#endif
+
     if (protocol.length > 0) {
       std::lock_guard<std::mutex> lock(conn->_strMu);
       conn->_negotiatedProtocol = [protocol UTF8String];
@@ -255,6 +278,12 @@ void NWWebSocketConnection::send(const std::string& data) {
   if (_state.load(std::memory_order_acquire) != State::OPEN) return;
   if (!_impl->task) return;
 
+#if defined(NITRO_WS_TRACING)
+  os_signpost_event_emit(nitroWsLog(),
+    static_cast<os_signpost_id_t>(_signpostId),
+    "NitroWS", "send text %zu bytes", data.size());
+#endif
+
   size_t len = data.size();
   _bufferedAmount.fetch_add(len, std::memory_order_relaxed);
 
@@ -284,6 +313,12 @@ void NWWebSocketConnection::sendBinary(const uint8_t* data, size_t len) {
   if (_state.load(std::memory_order_acquire) != State::OPEN) return;
   if (!_impl->task) return;
 
+#if defined(NITRO_WS_TRACING)
+  os_signpost_event_emit(nitroWsLog(),
+    static_cast<os_signpost_id_t>(_signpostId),
+    "NitroWS", "send binary %zu bytes", len);
+#endif
+
   _bufferedAmount.fetch_add(len, std::memory_order_relaxed);
 
   NSData* nsData = [NSData dataWithBytes:data length:len];
@@ -336,6 +371,13 @@ void NWWebSocketConnection::scheduleReceive() {
         onMsg = conn->_onMessage;
       }
 
+#if defined(NITRO_WS_TRACING)
+      os_signpost_event_emit(nitroWsLog(),
+        static_cast<os_signpost_id_t>(conn->_signpostId),
+        "NitroWS", "receive %s",
+        message.type == NSURLSessionWebSocketMessageTypeString ? "text" : "binary");
+#endif
+
       switch (message.type) {
         case NSURLSessionWebSocketMessageTypeString: {
           NSData* utf8 =
@@ -446,6 +488,12 @@ void NWWebSocketConnection::fireClose(
   if (_closeFired.exchange(true, std::memory_order_acq_rel)) return;
   _state.store(State::CLOSED, std::memory_order_release);
 
+#if defined(NITRO_WS_TRACING)
+  os_signpost_event_emit(nitroWsLog(),
+    static_cast<os_signpost_id_t>(_signpostId),
+    "NitroWS", "close code=%d clean=%d", code, wasClean ? 1 : 0);
+#endif
+
   OnClose cb;
   {
     std::lock_guard<std::mutex> lock(_cbMu);
@@ -457,6 +505,12 @@ void NWWebSocketConnection::fireClose(
 void NWWebSocketConnection::fireError(const std::string& msg) {
   _state.store(State::CLOSED, std::memory_order_release);
 
+#if defined(NITRO_WS_TRACING)
+  os_signpost_event_emit(nitroWsLog(),
+    static_cast<os_signpost_id_t>(_signpostId),
+    "NitroWS", "error %{public}s", msg.c_str());
+#endif
+
   OnError cb;
   {
     std::lock_guard<std::mutex> lock(_cbMu);

package/lib/index.d.ts

@@ -13,6 +13,7 @@ export { prewarmOnAppStart, removeFromPrewarmQueue, clearPrewarmQueue, } from '.
  */
 export declare class NitroWebSocket {
     private _ws;
+    private _inspectorId;
     constructor(url: string, protocols?: string | string[], headers?: Record<string, string>);
     get readyState(): import("./NitroWebSocket.nitro").WebSocketReadyState;
     get url(): string;

package/lib/index.js

@@ -3,12 +3,22 @@ import { TextDecoder } from 'react-native-nitro-text-decoder';
 export { createWebSocket } from './NitroWebSocket.nitro';
 export { prewarmOnAppStart, removeFromPrewarmQueue, clearPrewarmQueue, } from './prewarm';
 const utf8Decoder = new TextDecoder('utf-8', { fatal: false, ignoreBOM: true });
+// Try-import NetworkInspector from fetch package (optional peer dep)
+let _inspector = null;
+try {
+    _inspector = require('react-native-nitro-fetch').NetworkInspector;
+}
+catch { }
+function generateWsId() {
+    return 'ws-' + String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
+}
 /**
  * Browser-compatible WebSocket wrapper backed by a Nitro HybridObject
  * using libwebsockets + mbedTLS under the hood.
  */
 export class NitroWebSocket {
     _ws;
+    _inspectorId;
     constructor(url, protocols, headers) {
         this._ws = NitroModules.createHybridObject('WebSocket');
         const protocolList = protocols
@@ -16,6 +26,14 @@ export class NitroWebSocket {
                 ? protocols
                 : [protocols]
             : [];
+        const headerPairs = headers
+            ? Object.entries(headers).map(([key, value]) => ({ key, value }))
+            : [];
+        // Record WS open in inspector
+        if (_inspector?.isEnabled()) {
+            this._inspectorId = generateWsId();
+            _inspector._recordWsOpen(this._inspectorId, url, protocolList, headerPairs);
+        }
         this._ws.connect(url, protocolList, headers ?? {});
     }
     get readyState() {
@@ -34,15 +52,30 @@ export class NitroWebSocket {
         return this._ws.extensions;
     }
     set onopen(fn) {
-        this._ws.onOpen = fn ?? undefined;
+        if (fn == null) {
+            this._ws.onOpen = undefined;
+            return;
+        }
+        const inspectorId = this._inspectorId;
+        this._ws.onOpen = () => {
+            if (inspectorId && _inspector?.isEnabled()) {
+                _inspector._recordWsConnected(inspectorId);
+            }
+            fn();
+        };
     }
     set onmessage(fn) {
         if (fn == null) {
             this._ws.onMessage = undefined;
             return;
         }
+        const inspectorId = this._inspectorId;
         this._ws.onMessage = (native) => {
             if (native.isBinary) {
+                const size = native.data.byteLength;
+                if (inspectorId && _inspector?.isEnabled()) {
+                    _inspector._recordWsMessage(inspectorId, 'received', `[binary ${size} bytes]`, size, true);
+                }
                 fn({
                     data: '',
                     isBinary: true,
@@ -51,26 +84,55 @@ export class NitroWebSocket {
             }
             else {
                 const buf = native.data;
+                const text = buf.byteLength === 0 ? '' : utf8Decoder.decode(buf, { stream: false });
+                const size = buf.byteLength;
+                if (inspectorId && _inspector?.isEnabled()) {
+                    _inspector._recordWsMessage(inspectorId, 'received', text, size, false);
+                }
                 fn({
-                    data: buf.byteLength === 0
-                        ? ''
-                        : utf8Decoder.decode(buf, { stream: false }),
+                    data: text,
                     isBinary: false,
                 });
             }
         };
     }
     set onclose(fn) {
-        this._ws.onClose = fn ?? undefined;
+        if (fn == null) {
+            this._ws.onClose = undefined;
+            return;
+        }
+        const inspectorId = this._inspectorId;
+        this._ws.onClose = (e) => {
+            if (inspectorId && _inspector?.isEnabled()) {
+                _inspector._recordWsClose(inspectorId, e.code, e.reason);
+            }
+            fn(e);
+        };
     }
     set onerror(fn) {
-        this._ws.onError = fn ?? undefined;
+        if (fn == null) {
+            this._ws.onError = undefined;
+            return;
+        }
+        const inspectorId = this._inspectorId;
+        this._ws.onError = (error) => {
+            if (inspectorId && _inspector?.isEnabled()) {
+                _inspector._recordWsError(inspectorId, error);
+            }
+            fn(error);
+        };
     }
     send(data) {
         if (typeof data === 'string') {
+            if (this._inspectorId && _inspector?.isEnabled()) {
+                _inspector._recordWsMessage(this._inspectorId, 'sent', data, data.length, false);
+            }
             this._ws.send(data);
         }
         else {
+            if (this._inspectorId && _inspector?.isEnabled()) {
+                _inspector._recordWsMessage(this._inspectorId, 'sent', `[binary ${data.byteLength} bytes]`, data.byteLength, true);
+            }
             this._ws.sendBinary(data);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-websockets",
-  "version": "0.1.0-beta.5",
+  "version": "1.0.0",
   "description": "react-native-nitro-websockets",
   "main": "lib/index",
   "module": "lib/index",
@@ -25,6 +25,7 @@
     "ios/**/*.cpp",
     "ios/**/*.swift",
     "app.plugin.js",
+    "expo/plugins/dist",
     "nitro.json",
     "*.podspec",
     "README.md",
@@ -58,12 +59,23 @@
     "thirdparty/mbedtls/CMakeLists.txt",
     "thirdparty/mbedtls/LICENSE"
   ],
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json",
+    "./app.plugin.js": "./app.plugin.js"
+  },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf android/build node_modules/**/android/build lib",
+    "clean": "rm -rf android/build node_modules/**/android/build lib expo/plugins/dist",
     "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
     "lint-ci": "eslint \"**/*.{js,ts,tsx}\" -f @jamesacarr/github-actions",
     "typescript": "tsc",
+    "build:plugin": "cd expo/plugins && npx tsc",
+    "release": "npm run build:plugin && release-it --only-version",
     "specs": "tsc --noEmit false && nitrogen --logLevel=\"debug\""
   },
   "keywords": [
@@ -89,7 +101,9 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
+    "@expo/config-plugins": "^9.0.0",
     "@release-it/conventional-changelog": "^9.0.2",
+    "expo-module-scripts": "^5.0.8",
     "@react-native/eslint-config": "^0.85.0-rc.0",
     "@types/react": "^19.2.0",
     "eslint": "^9.22.0",
@@ -108,7 +122,13 @@
     "react": "*",
     "react-native": "*",
     "react-native-nitro-modules": "*",
-    "react-native-nitro-text-decoder": ">=0.1.0"
+    "react-native-nitro-text-decoder": ">=0.1.0",
+    "react-native-nitro-fetch": "*"
+  },
+  "peerDependenciesMeta": {
+    "react-native-nitro-fetch": {
+      "optional": true
+    }
   },
   "release-it": {
     "git": false,

package/src/index.ts

@@ -28,12 +28,23 @@ export {
 
 const utf8Decoder = new TextDecoder('utf-8', { fatal: false, ignoreBOM: true })
 
+// Try-import NetworkInspector from fetch package (optional peer dep)
+let _inspector: any = null
+try {
+  _inspector = require('react-native-nitro-fetch').NetworkInspector
+} catch {}
+
+function generateWsId(): string {
+  return 'ws-' + String(Date.now()) + '-' + String(Math.random()).slice(2, 8)
+}
+
 /**
  * Browser-compatible WebSocket wrapper backed by a Nitro HybridObject
  * using libwebsockets + mbedTLS under the hood.
  */
 export class NitroWebSocket {
   private _ws: HybridWebSocket
+  private _inspectorId: string | undefined
 
   constructor(
     url: string,
@@ -46,6 +57,21 @@ export class NitroWebSocket {
         ? protocols
         : [protocols]
       : []
+    const headerPairs = headers
+      ? Object.entries(headers).map(([key, value]) => ({ key, value }))
+      : []
+
+    // Record WS open in inspector
+    if (_inspector?.isEnabled()) {
+      this._inspectorId = generateWsId()
+      _inspector._recordWsOpen(
+        this._inspectorId,
+        url,
+        protocolList,
+        headerPairs
+      )
+    }
+
     this._ws.connect(url, protocolList, headers ?? {})
   }
 
@@ -66,15 +92,36 @@ export class NitroWebSocket {
   }
 
   set onopen(fn: (() => void) | null) {
-    this._ws.onOpen = fn ?? undefined
+    if (fn == null) {
+      this._ws.onOpen = undefined
+      return
+    }
+    const inspectorId = this._inspectorId
+    this._ws.onOpen = () => {
+      if (inspectorId && _inspector?.isEnabled()) {
+        _inspector._recordWsConnected(inspectorId)
+      }
+      fn()
+    }
   }
   set onmessage(fn: ((e: WebSocketMessageEvent) => void) | null) {
     if (fn == null) {
       this._ws.onMessage = undefined
       return
     }
+    const inspectorId = this._inspectorId
     this._ws.onMessage = (native: HybridWebSocketMessageEvent) => {
       if (native.isBinary) {
+        const size = native.data.byteLength
+        if (inspectorId && _inspector?.isEnabled()) {
+          _inspector._recordWsMessage(
+            inspectorId,
+            'received',
+            `[binary ${size} bytes]`,
+            size,
+            true
+          )
+        }
         fn({
           data: '',
           isBinary: true,
@@ -82,27 +129,74 @@ export class NitroWebSocket {
         })
       } else {
         const buf = native.data
+        const text =
+          buf.byteLength === 0 ? '' : utf8Decoder.decode(buf, { stream: false })
+        const size = buf.byteLength
+        if (inspectorId && _inspector?.isEnabled()) {
+          _inspector._recordWsMessage(
+            inspectorId,
+            'received',
+            text,
+            size,
+            false
+          )
+        }
         fn({
-          data:
-            buf.byteLength === 0
-              ? ''
-              : utf8Decoder.decode(buf, { stream: false }),
+          data: text,
           isBinary: false,
         })
       }
     }
   }
   set onclose(fn: ((e: NitroWSCloseEvent) => void) | null) {
-    this._ws.onClose = fn ?? undefined
+    if (fn == null) {
+      this._ws.onClose = undefined
+      return
+    }
+    const inspectorId = this._inspectorId
+    this._ws.onClose = (e: NitroWSCloseEvent) => {
+      if (inspectorId && _inspector?.isEnabled()) {
+        _inspector._recordWsClose(inspectorId, e.code, e.reason)
+      }
+      fn(e)
+    }
   }
   set onerror(fn: ((error: string) => void) | null) {
-    this._ws.onError = fn ?? undefined
+    if (fn == null) {
+      this._ws.onError = undefined
+      return
+    }
+    const inspectorId = this._inspectorId
+    this._ws.onError = (error: string) => {
+      if (inspectorId && _inspector?.isEnabled()) {
+        _inspector._recordWsError(inspectorId, error)
+      }
+      fn(error)
+    }
   }
 
   send(data: string | ArrayBuffer) {
     if (typeof data === 'string') {
+      if (this._inspectorId && _inspector?.isEnabled()) {
+        _inspector._recordWsMessage(
+          this._inspectorId,
+          'sent',
+          data,
+          data.length,
+          false
+        )
+      }
       this._ws.send(data)
     } else {
+      if (this._inspectorId && _inspector?.isEnabled()) {
+        _inspector._recordWsMessage(
+          this._inspectorId,
+          'sent',
+          `[binary ${data.byteLength} bytes]`,
+          data.byteLength,
+          true
+        )
+      }
       this._ws.sendBinary(data)
     }
   }