@peers-app/peers-sdk 0.8.8 → 0.8.10

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

@@ -132,36 +132,80 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
     const transportType = protocol === 'wrtc' ? 'wrtc' :
         protocol === 'libp2p' ? 'libp2p' :
             protocol === 'ws' ? 'ws' : 'unknown';
-    // 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);
+    // 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);
         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(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();
-            });
-        }
+        packet.set(payload, 3 + streamIdBytes.length);
+        await waitForDrain();
         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) {
@@ -178,6 +222,9 @@ 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 {
@@ -198,17 +245,52 @@ 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);
-                // Check if this is an RPC message sent via raw bytes (for large payloads)
+                // Handle RPC stream with reassembly (large RPC messages are length-prefixed)
                 if (streamId === RPC_STREAM_ID) {
-                    handleRPCMessage(payload, handlers, callbacks, sendRPCData);
+                    // 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;
+                        }
+                    }
                     return;
                 }
+                // Other streams: pass through to handler
                 const handler = rawBytesHandlers[streamId];
                 if (handler)
                     handler(payload);
                 return;
             }
-            // Handle RPC messages
+            // Handle RPC messages (small, sent directly)
             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.8",
+  "version": "0.8.10",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"