@peers-app/peers-sdk 0.8.10 → 0.8.11

package/dist/device/binary-peer-connection.js

@@ -132,80 +132,36 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
     const transportType = protocol === 'wrtc' ? 'wrtc' :
         protocol === 'libp2p' ? 'libp2p' :
             protocol === 'ws' ? 'ws' : 'unknown';
-    // WebRTC SCTP has ~256KB max message size, use 64KB to be safe
-    const WRTC_MAX_CHUNK = 64 * 1024;
-    // Backpressure thresholds
-    const HIGH_WATER_MARK = transportType === 'wrtc' ? 64 * 1024 : 4 * 1024 * 1024;
-    const LOW_WATER_MARK = transportType === 'wrtc' ? 16 * 1024 : 2 * 1024 * 1024;
-    // Helper to wait for buffer to drain
-    const waitForDrain = async () => {
-        if (!peer.getBufferedAmount)
-            return;
-        const buffered = peer.getBufferedAmount();
-        if (buffered <= HIGH_WATER_MARK)
-            return;
-        await new Promise(resolve => {
-            const checkDrain = () => {
-                const currentBuffered = peer.getBufferedAmount ? peer.getBufferedAmount() : 0;
-                if (!peer.getBufferedAmount || currentBuffered < LOW_WATER_MARK) {
-                    resolve();
-                }
-                else {
-                    setTimeout(checkDrain, 5);
-                }
-            };
-            peer.on('drain', resolve);
-            checkDrain();
-        });
-    };
-    // Helper to send a single raw bytes packet
-    const sendRawBytesPacket = async (streamIdBytes, payload) => {
-        const packet = new Uint8Array(1 + 2 + streamIdBytes.length + payload.length);
+    // Core sendRawBytes implementation - defined early so sendRPCData can use it
+    const sendRawBytesImpl = async (streamId, data) => {
+        const streamIdBytes = new TextEncoder().encode(streamId);
+        const packet = new Uint8Array(1 + 2 + streamIdBytes.length + data.length);
         packet[0] = PROTOCOL_RAW_BYTES;
         const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
         view.setUint16(1, streamIdBytes.length, false);
         packet.set(streamIdBytes, 3);
-        packet.set(payload, 3 + streamIdBytes.length);
-        await waitForDrain();
+        packet.set(data, 3 + streamIdBytes.length);
+        // Use transport-specific thresholds for backpressure
+        const HIGH_WATER_MARK = transportType === 'wrtc' ? 128 * 1024 : 4 * 1024 * 1024;
+        const LOW_WATER_MARK = transportType === 'wrtc' ? 32 * 1024 : 2 * 1024 * 1024;
+        if (peer.getBufferedAmount && peer.getBufferedAmount() > HIGH_WATER_MARK) {
+            await new Promise(resolve => {
+                const checkDrain = () => {
+                    if (!peer.getBufferedAmount || peer.getBufferedAmount() < LOW_WATER_MARK) {
+                        resolve();
+                    }
+                    else {
+                        setTimeout(checkDrain, 5);
+                    }
+                };
+                peer.on('drain', resolve);
+                checkDrain();
+            });
+        }
         stats.bytesSent += packet.length;
         stats.messagesSent++;
         peer.send(packet);
     };
-    // Core sendRawBytes implementation
-    // For WebRTC: chunks large data to fit under SCTP message size limit
-    // For RPC_STREAM_ID: also prepends 4-byte length for reassembly
-    const sendRawBytesImpl = async (streamId, data) => {
-        const streamIdBytes = new TextEncoder().encode(streamId);
-        const headerOverhead = 1 + 2 + streamIdBytes.length; // PROTOCOL + streamIdLen + streamId
-        const maxPayloadSize = WRTC_MAX_CHUNK - headerOverhead;
-        // For WebRTC with large data
-        if (transportType === 'wrtc' && data.length > maxPayloadSize) {
-            // RPC_STREAM_ID needs length prefix for reassembly (receiver must reconstruct complete message)
-            if (streamId === RPC_STREAM_ID) {
-                // Prepend 4-byte total length to data
-                const withLength = new Uint8Array(4 + data.length);
-                new DataView(withLength.buffer).setUint32(0, data.length, false);
-                withLength.set(data, 4);
-                // Send in chunks
-                for (let offset = 0; offset < withLength.length; offset += maxPayloadSize) {
-                    const chunk = withLength.subarray(offset, Math.min(offset + maxPayloadSize, withLength.length));
-                    await sendRawBytesPacket(streamIdBytes, chunk);
-                }
-            }
-            else {
-                // Other streams: just chunk without length prefix
-                // Handlers receive smaller pieces but that's OK (e.g., file transfers stream to disk)
-                for (let offset = 0; offset < data.length; offset += maxPayloadSize) {
-                    const chunk = data.subarray(offset, Math.min(offset + maxPayloadSize, data.length));
-                    await sendRawBytesPacket(streamIdBytes, chunk);
-                }
-            }
-        }
-        else {
-            // Small data or non-WebRTC: send directly
-            await sendRawBytesPacket(streamIdBytes, data);
-        }
-    };
     // Helper to send RPC messages - routes large messages through raw bytes streaming
     const sendRPCData = async (encoded) => {
         if (encoded.length > LARGE_MESSAGE_THRESHOLD) {
@@ -222,9 +178,6 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
             peer.send(withProtocol);
         }
     };
-    // Buffer for RPC stream reassembly (large RPC messages sent via raw bytes are length-prefixed)
-    let rpcStreamBuffer = null;
-    let rpcStreamExpectedLength = null;
     // Handle incoming data
     peer.on('data', async (data) => {
         try {
@@ -245,52 +198,17 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
                 const streamIdBytes = bytes.subarray(3, 3 + streamIdLength);
                 const streamId = new TextDecoder().decode(streamIdBytes);
                 const payload = bytes.subarray(3 + streamIdLength);
-                // Handle RPC stream with reassembly (large RPC messages are length-prefixed)
+                // Check if this is an RPC message sent via raw bytes (for large payloads)
                 if (streamId === RPC_STREAM_ID) {
-                    // Append to buffer
-                    if (rpcStreamBuffer === null) {
-                        rpcStreamBuffer = payload;
-                    }
-                    else {
-                        const combined = new Uint8Array(rpcStreamBuffer.length + payload.length);
-                        combined.set(rpcStreamBuffer, 0);
-                        combined.set(payload, rpcStreamBuffer.length);
-                        rpcStreamBuffer = combined;
-                    }
-                    // Process complete messages from buffer
-                    while (rpcStreamBuffer && rpcStreamBuffer.length >= 4) {
-                        // Read expected length if not yet known
-                        if (rpcStreamExpectedLength === null) {
-                            const lenView = new DataView(rpcStreamBuffer.buffer, rpcStreamBuffer.byteOffset, rpcStreamBuffer.byteLength);
-                            rpcStreamExpectedLength = lenView.getUint32(0, false);
-                        }
-                        // Check if we have the complete message
-                        if (rpcStreamBuffer.length >= 4 + rpcStreamExpectedLength) {
-                            const rpcData = rpcStreamBuffer.subarray(4, 4 + rpcStreamExpectedLength);
-                            handleRPCMessage(rpcData, handlers, callbacks, sendRPCData);
-                            // Remove processed data from buffer
-                            if (rpcStreamBuffer.length === 4 + rpcStreamExpectedLength) {
-                                rpcStreamBuffer = null;
-                            }
-                            else {
-                                rpcStreamBuffer = rpcStreamBuffer.subarray(4 + rpcStreamExpectedLength);
-                            }
-                            rpcStreamExpectedLength = null;
-                        }
-                        else {
-                            // Need more data
-                            break;
-                        }
-                    }
+                    handleRPCMessage(payload, handlers, callbacks, sendRPCData);
                     return;
                 }
-                // Other streams: pass through to handler
                 const handler = rawBytesHandlers[streamId];
                 if (handler)
                     handler(payload);
                 return;
             }
-            // Handle RPC messages (small, sent directly)
+            // Handle RPC messages
             if (protocolType === PROTOCOL_RPC) {
                 const rpcBytes = bytes.subarray(1);
                 handleRPCMessage(rpcBytes, handlers, callbacks, sendRPCData);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.8.10",
+  "version": "0.8.11",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"