@peers-app/peers-sdk 0.8.11 → 0.8.17

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-v2.d.ts

@@ -0,0 +1,69 @@
+/**
+ * binary-peer-connection-v2.ts
+ *
+ * Unified binary transport layer that replaces both binary-peer-connection.ts
+ * and streamed-socket.ts. Provides two cleanly separated modes:
+ *
+ * 1. **RPC mode** (emit/on): request/response interactions with automatic
+ *    encoding (txEncode for objects, passthrough for Uint8Array) and transparent
+ *    chunking for large payloads.
+ *
+ * 2. **Stream mode** (sendRawBytes/onRawBytes): continuous byte transfer for
+ *    file syncing, database downloads, log streaming, etc. Each sendRawBytes
+ *    call = exactly one onRawBytes callback (atomic delivery after reassembly).
+ *
+ * Both modes share a single sendFrame() function that handles backpressure
+ * and event-loop yielding (critical for Go sidecar WebRTC pipeline).
+ */
+import { Connection } from "./connection";
+import { Device } from "./device";
+import { ISocket } from "./socket.type";
+type ITrustLevelFn = Connection['getTrustLevel'];
+/**
+ * Generic binary peer interface supporting WebRTC, libp2p, and WebSocket transports.
+ * Provides a unified abstraction for binary data channel communication.
+ */
+export interface IBinaryPeer {
+    on(event: 'data', handler: (data: Buffer | Uint8Array) => void): void;
+    on(event: 'close', handler: () => void): void;
+    on(event: 'drain', handler: () => void): void;
+    send(data: string | Uint8Array | Buffer): void;
+    destroy(): void;
+    /**
+     * Returns the number of bytes currently buffered waiting to be sent.
+     * Used for backpressure detection. Returns 0 if not supported.
+     */
+    getBufferedAmount?(): number;
+}
+export type IWebRTCPeer = IBinaryPeer;
+export type ILibp2pPeer = IBinaryPeer;
+export interface WrapBinaryPeerOptions {
+    /** Protocol identifier used for server address (e.g., 'wrtc', 'libp2p', or 'ws') */
+    protocol: 'wrtc' | 'libp2p' | 'ws';
+    /**
+     * Mark the transport as already secure (encrypted at transport layer).
+     * When true, sets secureLocal and secureRemote to skip application-level encryption.
+     */
+    markTransportSecure?: boolean;
+}
+/**
+ * Creates an ISocket from a binary peer. This is the core v2 factory function.
+ * Replaces both createBinaryPeerSocket (v1) and StreamedSocket.
+ */
+export declare function createBinaryPeerSocket(connectionId: string, peer: IBinaryPeer, protocol?: string): ISocket;
+/**
+ * Wraps a binary peer (WebRTC, libp2p, or WebSocket) into a Connection.
+ * This is the main implementation that handles all binary protocols.
+ */
+export declare function wrapBinaryPeer(connectionId: string, peer: IBinaryPeer, localDevice: Device, initiator: boolean, options: WrapBinaryPeerOptions, getTrustLevel?: ITrustLevelFn): Connection;
+/**
+ * Wraps a WebRTC peer into a Connection.
+ * WebRTC is encrypted at the transport layer (DTLS-SRTP).
+ */
+export declare function wrapWrtc(connectionId: string, peer: IWebRTCPeer, localDevice: Device, initiator: boolean, getTrustLevel?: ITrustLevelFn): Connection;
+/**
+ * Wraps a libp2p peer into a Connection.
+ * libp2p is encrypted at the transport layer (noise protocol).
+ */
+export declare function wrapLibp2p(connectionId: string, peer: ILibp2pPeer, localDevice: Device, initiator: boolean, getTrustLevel?: ITrustLevelFn): Connection;
+export {};