@peers-app/peers-sdk 0.8.10 → 0.8.12

package/dist/data/persistent-vars.d.ts

@@ -60,6 +60,8 @@ export declare class PersistentVarsTable extends Table<IPersistentVar> {
 export declare function PersistentVars(dataContext?: DataContext): PersistentVarsTable;
 export type PersistentVar<T> = Observable<T> & {
     loadingPromise: Promise<PersistentVar<T>>;
+    /** Delete the persistent variable from the database and reset to default value */
+    delete: () => Promise<void>;
 };
 export declare function getPersistentVar(name: string, dataContext?: DataContext): Promise<IPersistentVar | undefined>;
 interface IPersistentVarOptionsBase {

package/dist/data/persistent-vars.js

@@ -155,6 +155,14 @@ function persistentVarFactory(name, opts) {
     pvarCache.set(cacheKey, persistentVar);
     let isSecret = opts.isSecret;
     let rec = undefined;
+    let deleteVarImpl = undefined;
+    // Assign the delete method - it will wait for loading and then call the implementation
+    persistentVar.delete = async () => {
+        await persistentVar.loadingPromise;
+        if (deleteVarImpl) {
+            await deleteVarImpl();
+        }
+    };
     persistentVar.loadingPromise = new Promise(async (resolve) => {
         try {
             const userContext = opts?.userContext || await (0, user_context_singleton_1.getUserContext)();
@@ -224,37 +232,36 @@ function persistentVarFactory(name, opts) {
                 rec.value.value = value;
                 const dc = getDataContext();
                 const table = PersistentVars(dc);
-                // delete if value equals default value
-                if ((0, lodash_1.isEqual)(rec.value.value, defaultValue)) {
-                    if (rec.persistentVarId) {
-                        if (name === 'colorModePreference') {
-                            console.log(`deleted persistent var ${name} from db:`, rec.value.value);
-                        }
-                        await table.delete(rec);
+                try {
+                    rec = await table.save(rec);
+                    if (name === 'colorModePreference') {
+                        console.log(`Saved var ${name} to db:`, rec.value.value);
                     }
-                    rec = undefined;
                 }
-                else {
-                    try {
-                        rec = await table.save(rec);
-                        if (name === 'colorModePreference') {
-                            console.log(`Saved var ${name} to db:`, rec.value.value);
-                        }
+                catch (err) {
+                    const errMsg = err?.message || String(err) || '';
+                    if (errMsg.includes('UNIQUE constraint failed')) {
+                        console.warn(`Detected UNIQUE constraint failed error when saving persistent var, reloading and retrying: ${name}`);
+                        rec = await loadRecFromDb();
+                        persistentVar(rec.value.value);
                     }
-                    catch (err) {
-                        const errMsg = err?.message || String(err) || '';
-                        if (errMsg.includes('UNIQUE constraint failed')) {
-                            console.warn(`Detected UNIQUE constraint failed error when saving persistent var, reloading and retrying: ${name}`);
-                            rec = await loadRecFromDb();
-                            persistentVar(rec.value.value);
-                        }
-                        else {
-                            console.error('Error saving persistent var', { name, value, rec, err });
-                            throw err;
-                        }
+                    else {
+                        console.error('Error saving persistent var', { name, value, rec, err });
+                        throw err;
                     }
                 }
             }
+            deleteVarImpl = async () => {
+                const dc = getDataContext();
+                const table = PersistentVars(dc);
+                if (rec?.persistentVarId) {
+                    await table.delete(rec);
+                    rec = undefined;
+                }
+                if (defaultValue !== undefined) {
+                    persistentVar(defaultValue);
+                }
+            };
             // subscribe to db changes
             userContext.subscribeToDataChangedAcrossAllGroups(exports.persistentVarsMetaData.name, async (evt) => {
                 const dbRec = evt.data.dataObject;

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/dist/rpc-types.d.ts

@@ -93,6 +93,19 @@ export declare const rpcServerCalls: {
         success: boolean;
         error?: string;
     }>);
+    voiceGetState: (() => Promise<{
+        state: "disabled" | "idle" | "listening" | "recording" | "processing" | "speaking";
+    }>);
+    voiceStartRecording: (() => Promise<void>);
+    voiceStopRecording: (() => Promise<void>);
+    voiceSetTargetChannel: ((channelId: string) => Promise<void>);
+    voiceGetAudioDevices: (() => Promise<string[]>);
+    voiceTestTTS: ((text: string) => Promise<void>);
+    voiceNotifyPlaybackComplete: (() => Promise<void>);
+    voiceStopPlayback: (() => Promise<void>);
+    voiceGetThreadId: (() => Promise<string | null>);
+    voiceSetThreadId: ((threadId: string | null) => Promise<void>);
+    voiceNotifyTextActivity: (() => Promise<void>);
 };
 export declare const rpcClientCalls: {
     ping: (msg: string) => Promise<string>;

package/dist/rpc-types.js

@@ -39,6 +39,18 @@ exports.rpcServerCalls = {
     uiClick: rpcStub('uiClick'),
     uiSet: rpcStub('uiSet'),
     uiScroll: rpcStub('uiScroll'),
+    // Voice control (settings managed via voiceSettings pvar, keys via secret pvars)
+    voiceGetState: rpcStub('voiceGetState'),
+    voiceStartRecording: rpcStub('voiceStartRecording'),
+    voiceStopRecording: rpcStub('voiceStopRecording'),
+    voiceSetTargetChannel: rpcStub('voiceSetTargetChannel'),
+    voiceGetAudioDevices: rpcStub('voiceGetAudioDevices'),
+    voiceTestTTS: rpcStub('voiceTestTTS'),
+    voiceNotifyPlaybackComplete: rpcStub('voiceNotifyPlaybackComplete'),
+    voiceStopPlayback: rpcStub('voiceStopPlayback'),
+    voiceGetThreadId: rpcStub('voiceGetThreadId'),
+    voiceSetThreadId: rpcStub('voiceSetThreadId'),
+    voiceNotifyTextActivity: rpcStub('voiceNotifyTextActivity'),
     // TODO try to get rid of this and rely on the client-side table and server-side table individually emitting events
     // TODO TODO before deleting this, check if we can stop client-side tables from emitting events and rely solely on server-side tables
     //           propagating events with rpcClientCalls.emitEvent.  It's very likely we're currently seeing two events for every one write originating from the UI

package/package.json

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