@peers-app/peers-sdk 0.8.0 → 0.8.2

package/dist/device/streamed-socket.js

@@ -1,11 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamedSocket = void 0;
+exports.createSocketStats = createSocketStats;
 const lodash_1 = require("lodash");
 const utils_1 = require("../utils");
 const socket_type_1 = require("./socket.type");
 const tx_encoding_1 = require("./tx-encoding");
 const msgpack_1 = require("@msgpack/msgpack");
+/** Creates a new stats object for tracking socket throughput */
+function createSocketStats() {
+    const now = Date.now();
+    return {
+        bytesSent: 0,
+        bytesReceived: 0,
+        messagesSent: 0,
+        messagesReceived: 0,
+        startTime: now,
+        // For calculating recent rates
+        lastSampleTime: now,
+        lastSampleBytesSent: 0,
+        lastSampleBytesReceived: 0,
+    };
+}
 // Encode chunk metadata + data into a single Uint8Array
 function encodeChunk(chunk) {
     // Encode metadata using msgpack
@@ -30,14 +46,24 @@ function encodeChunk(chunk) {
 }
 // Decode binary chunk back into IMessageChunk
 function decodeChunk(bytes) {
+    // Ensure we have a proper Uint8Array with a valid ArrayBuffer
+    // Socket.io might send data that doesn't have a proper buffer property
+    let normalizedBytes;
+    if (bytes.buffer instanceof ArrayBuffer) {
+        normalizedBytes = bytes;
+    }
+    else {
+        // Create a new Uint8Array copy which will have a proper buffer
+        normalizedBytes = new Uint8Array(bytes);
+    }
     // Read metadata length
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const view = new DataView(normalizedBytes.buffer, normalizedBytes.byteOffset, normalizedBytes.byteLength);
     const metadataLength = view.getUint32(0, false); // big-endian
     // Extract metadata
-    const metadataBytes = bytes.subarray(4, 4 + metadataLength);
+    const metadataBytes = normalizedBytes.subarray(4, 4 + metadataLength);
     const metadata = (0, msgpack_1.decode)(metadataBytes);
     // Extract data
-    const data = bytes.subarray(4 + metadataLength);
+    const data = normalizedBytes.subarray(4 + metadataLength);
     return {
         messageId: metadata.messageId,
         chunkIndex: metadata.chunkIndex,
@@ -51,10 +77,13 @@ class StreamedSocket {
     maxChunkSize;
     safeSocketChunkEventName = '__streamed-socket-chunk';
     safeSocketResponseEventName = '__streamed-socket-response';
+    stats = createSocketStats();
     constructor(socket, maxChunkSize = socket_type_1.DEFAULT_MAX_CHUNK_SIZE) {
         this.socket = socket;
         this.maxChunkSize = maxChunkSize;
         socket.on(this.safeSocketChunkEventName, (encodedChunk) => {
+            // Track received bytes
+            this.stats.bytesReceived += encodedChunk.length;
             const chunk = decodeChunk(encodedChunk);
             this.handleChunk(chunk);
         });
@@ -103,13 +132,18 @@ class StreamedSocket {
         if (chunks.length > 1) {
             console.debug(`Sending ${chunks.length} chunks for event ${eventName} with messageId ${messageId}`);
         }
+        let totalBytesSent = 0;
         for (const chunk of chunks) {
             // Encode chunk with metadata into single Uint8Array
             const encodedChunk = encodeChunk(chunk);
+            totalBytesSent += encodedChunk.length;
             // TODO on error or timeout retry
             // TODO respond to backpressure from socket
             this.socket.emit(this.safeSocketChunkEventName, encodedChunk, lodash_1.noop);
         }
+        // Track stats
+        this.stats.bytesSent += totalBytesSent;
+        this.stats.messagesSent++;
     }
     handlers = {};
     on(eventName, handler) {
@@ -159,6 +193,8 @@ class StreamedSocket {
                 reassembled.set(chunk.data, offset);
                 offset += chunk.data.length;
             }
+            // Track message received
+            this.stats.messagesReceived++;
             delete this.chunkBuffers[chunkZero.messageId];
             const eventName = chunkZero.eventName;
             const args = (0, tx_encoding_1.txDecode)(reassembled);
@@ -190,7 +226,12 @@ class StreamedSocket {
             }, lodash_1.noop);
         }
         catch (error) {
-            console.error(`Error handling chunked request:`, error);
+            if (String(error).includes('No handler registered for event')) {
+                console.warn(String(error));
+            }
+            else {
+                console.error(`Error handling chunked request:`, error);
+            }
             return;
         }
     }

package/dist/device/tx-encoding.js

@@ -5,16 +5,34 @@ exports.txDecode = txDecode;
 const msgpack_1 = require("@msgpack/msgpack");
 const fflate_1 = require("fflate");
 const serial_json_1 = require("../serial-json");
+// Minimum size before attempting compression (bytes)
+// Small payloads don't benefit much from compression
+const COMPRESSION_THRESHOLD = 8 * 1024; // 8KB
+// Minimum compression ratio to justify the CPU cost
+// If compressed isn't at least 20% smaller, skip it
+const MIN_COMPRESSION_RATIO = 0.8;
+// Compression level: 1 (fastest) to 9 (best compression)
+// Level 1 is ~5-10x faster than level 6 with reasonable compression
+const COMPRESSION_LEVEL = 1;
 function txEncode(data) {
     const noCycles = (0, serial_json_1.toJSON)(data); // remove cycles and encode dates, etc.
     // First encode to msgpack
     const encoded = (0, msgpack_1.encode)(noCycles);
     let body;
     let flag;
-    if (encoded.length > 1024) {
-        // Compress big payloads
-        body = (0, fflate_1.compressSync)(encoded);
-        flag = 1; // compressed
+    if (encoded.length > COMPRESSION_THRESHOLD) {
+        // Try to compress - use fast compression level
+        const compressed = (0, fflate_1.compressSync)(encoded, { level: COMPRESSION_LEVEL });
+        // Only use compression if it actually helps significantly
+        if (compressed.length < encoded.length * MIN_COMPRESSION_RATIO) {
+            body = compressed;
+            flag = 1; // compressed
+        }
+        else {
+            // Compression didn't help much, skip it
+            body = encoded;
+            flag = 0; // not compressed
+        }
     }
     else {
         body = encoded;

package/dist/device/tx-encoding.test.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tx_encoding_1 = require("./tx-encoding");
+const msgpack_1 = require("@msgpack/msgpack");
+const serial_json_1 = require("../serial-json");
 describe('tx-encode-decode', () => {
     describe('txEncode and txDecode', () => {
         it('should encode and decode simple objects', () => {
@@ -88,14 +90,22 @@ describe('tx-encode-decode', () => {
             expect(encoded[0]).toBe(0); // flag = 0 means not compressed
         });
         it('should compress large payloads (> 1024 bytes)', () => {
-            // Create an object that will exceed 1024 bytes when encoded
+            // Create an object that will exceed 8KB when msgpack-encoded
+            // msgpack is more compact than JSON, so we need significantly more data
+            // A string of 20,000 chars is roughly 20KB in JSON, but msgpack uses length prefix + bytes
+            // So we need even more to ensure msgpack encoding exceeds 8KB
             const largeObj = {
-                data: 'x'.repeat(2000),
-                array: Array.from({ length: 100 }, (_, i) => ({ id: i, value: `item ${i}` }))
+                data: 'x'.repeat(30000),
+                array: Array.from({ length: 1000 }, (_, i) => ({
+                    id: i,
+                    value: `item ${i} with some extra text to make it larger and ensure we exceed the threshold`,
+                    nested: { prop: `nested value ${i}` }
+                }))
             };
-            const jsonStr = JSON.stringify(largeObj);
-            expect(jsonStr.length).toBeGreaterThan(1024);
             const encoded = (0, tx_encoding_1.txEncode)(largeObj);
+            // Verify the encoded size (without flag byte) exceeds 8KB threshold
+            const encodedSize = encoded.length - 1; // subtract flag byte
+            expect(encodedSize).toBeGreaterThan(8 * 1024);
             // First byte is the flag
             expect(encoded[0]).toBe(1); // flag = 1 means compressed
             // Verify it can still be decoded correctly
@@ -103,14 +113,22 @@ describe('tx-encode-decode', () => {
             expect(decoded).toEqual(largeObj);
         });
         it('should have smaller encoded size for large compressible data', () => {
+            // Create data that exceeds 8KB when msgpack-encoded and compresses well
+            // Use data with some repetition but also enough variety to ensure msgpack size is large
             const largeRepetitiveObj = {
-                data: 'repeat '.repeat(500),
-                values: Array.from({ length: 200 }, () => 'same string')
+                data: 'repeat '.repeat(10000), // Highly repetitive string - will compress well
+                values: Array.from({ length: 5000 }, (_, i) => `item ${i} with some text that repeats to create compressible data pattern`)
             };
+            // First, verify the msgpack-encoded size exceeds 8KB threshold
+            const noCycles = (0, serial_json_1.toJSON)(largeRepetitiveObj);
+            const msgpackEncoded = (0, msgpack_1.encode)(noCycles);
+            expect(msgpackEncoded.length).toBeGreaterThan(8 * 1024);
             const encoded = (0, tx_encoding_1.txEncode)(largeRepetitiveObj);
-            // Compressed size should be significantly smaller than the raw data
-            const rawDataSize = JSON.stringify(largeRepetitiveObj).length;
-            expect(encoded.length).toBeLessThan(rawDataSize / 2);
+            // Verify compression flag is set (means compression was applied)
+            expect(encoded[0]).toBe(1); // flag = 1 means compressed
+            // Compressed size should be significantly smaller than the raw msgpack data
+            const compressedSize = encoded.length - 1; // subtract flag byte
+            expect(compressedSize).toBeLessThan(msgpackEncoded.length * 0.8); // Should be at least 20% smaller
             // Verify correctness
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(largeRepetitiveObj);

package/dist/index.d.ts

@@ -12,6 +12,8 @@ export * from "./types/workflow";
 export * from "./types/workflow-logger";
 export * from "./types/workflow-run-context";
 export * from "./types/zod-types";
+export * from "./device/binary-peer-connection";
+export * from "./device/socket-io-binary-peer";
 export * from "./device/connection";
 export * from "./device/device";
 export * from "./device/device-election";

package/dist/index.js

@@ -29,6 +29,8 @@ __exportStar(require("./types/workflow"), exports);
 __exportStar(require("./types/workflow-logger"), exports);
 __exportStar(require("./types/workflow-run-context"), exports);
 __exportStar(require("./types/zod-types"), exports);
+__exportStar(require("./device/binary-peer-connection"), exports);
+__exportStar(require("./device/socket-io-binary-peer"), exports);
 __exportStar(require("./device/connection"), exports);
 __exportStar(require("./device/device"), exports);
 __exportStar(require("./device/device-election"), exports);

package/dist/package-loader/package-loader.d.ts

@@ -3,6 +3,8 @@ import type { IPeersPackage } from "../types/peers-package";
 import { IPackage } from "../data/packages";
 export declare class PackageLoader {
     readonly dataContext: DataContext;
+    static PeersSDK: any;
+    static Zod: any;
     private packageInstances;
     require: (<T>(module: string) => T) | undefined;
     constructor(dataContext: DataContext);

package/dist/package-loader/package-loader.js

@@ -8,6 +8,8 @@ const packages_1 = require("../data/packages");
 const tools_2 = require("../data/tools");
 class PackageLoader {
     dataContext;
+    static PeersSDK;
+    static Zod;
     packageInstances = {};
     require = undefined;
     constructor(dataContext) {
@@ -59,9 +61,9 @@ class PackageLoader {
                     case 'PeersSDK':
                         // Import all peers-sdk exports
                         // return _require('peers-sdk');
-                        return _require('../index');
+                        return PackageLoader.PeersSDK || _require('../index');
                     case 'zod':
-                        return _require('zod');
+                        return PackageLoader.Zod || _require('zod');
                     default:
                         // For other modules, use the standard require
                         console.warn(`Package ${pkg.name} is requiring a module ${moduleId}, which is not provided by the package loader.`);

package/dist/rpc-types.d.ts

@@ -18,6 +18,7 @@ export declare const rpcServerCalls: {
     encryptData: ((value: string, groupId?: string) => Promise<string>);
     tableMethodCall: ((dataContextId: string, tableName: string, methodName: string, ...args: any[]) => Promise<any>);
     getFileContents: ((fileId: string, encoding?: BufferEncoding) => Promise<string>);
+    injectUIBundle: ((uiBundleFileId: string) => Promise<void>);
     resetAllDeviceSyncInfo: (() => Promise<void>);
     importGroupShare: ((groupShareJson: string) => Promise<string>);
 };

package/dist/rpc-types.js

@@ -19,6 +19,8 @@ exports.rpcServerCalls = {
     tableMethodCall: rpcStub('tableMethodCall'),
     // TODO lock this down so not all code can get any file contents
     getFileContents: rpcStub('getFileContents'),
+    // Inject UI bundle directly into WebView (bypasses slow postMessage for large strings)
+    injectUIBundle: rpcStub('injectUIBundle'),
     resetAllDeviceSyncInfo: rpcStub('resetAllDeviceSyncInfo'),
     importGroupShare: rpcStub('importGroupShare'),
     // TODO try to get rid of this and rely on the client-side table and server-side table individually emitting events
@@ -33,7 +35,9 @@ exports.rpcClientCalls = {
     setClientPath: rpcStub('setClientPath'),
     openThread: rpcStub('openThread'),
 };
-exports.isClient = typeof window !== 'undefined';
+// Check if we're in a web browser or webview (not React Native or Node.js)
+// React Native has window but not document, so we check for both
+exports.isClient = typeof window !== 'undefined' && typeof document !== 'undefined';
 if (exports.isClient) {
     // @ts-ignore
     const _window = window;

package/package.json

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