@peers-app/peers-device 0.15.0 → 0.15.2

package/dist/persistent-vars.test.js

@@ -32,7 +32,7 @@ describe("Persistent Variables - Update Loop Bug", () => {
     async function createTestUserContext() {
         const userId = (0, peers_sdk_1.newid)();
         const deviceId = (0, peers_sdk_1.newid)();
-        const db = new local_data_source_1.DBLocal(':memory:');
+        const db = new local_data_source_1.DBLocal(":memory:");
         const dataSourceFactory = (metaData, schema, groupId) => {
             const sqlDataSource = new peers_sdk_1.SQLDataSource(db, metaData, schema);
             return sqlDataSource;
@@ -45,47 +45,47 @@ describe("Persistent Variables - Update Loop Bug", () => {
     describe("pvar basic functionality", () => {
         it("should create and persist a pvar value", async () => {
             const userContext = await createTestUserContext();
-            const pvar = (0, peers_sdk_1.deviceVar)('basicTestVar', {
-                defaultValue: 'initial',
-                userContext
+            const pvar = (0, peers_sdk_1.deviceVar)("basicTestVar", {
+                defaultValue: "initial",
+                userContext,
             });
             await pvar.loadingPromise;
-            expect(pvar()).toBe('initial');
-            pvar('updated');
+            expect(pvar()).toBe("initial");
+            pvar("updated");
             await (0, peers_sdk_1.sleep)(100);
-            expect(pvar()).toBe('updated');
+            expect(pvar()).toBe("updated");
         });
         it("should sync value between two pvar instances (without rapid updates)", async () => {
             const userContext = await createTestUserContext();
-            const pvar1 = (0, peers_sdk_1.deviceVar)('syncTestVar', {
-                defaultValue: 'initial',
-                userContext
+            const pvar1 = (0, peers_sdk_1.deviceVar)("syncTestVar", {
+                defaultValue: "initial",
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('syncTestVar', {
-                defaultValue: 'initial',
-                userContext
+            const pvar2 = (0, peers_sdk_1.deviceVar)("syncTestVar", {
+                defaultValue: "initial",
+                userContext,
             });
             await pvar2.loadingPromise;
             // Single update with enough time to settle
-            pvar1('updated-value');
+            pvar1("updated-value");
             await (0, peers_sdk_1.sleep)(200);
             // Both should have the same value
-            expect(pvar1()).toBe('updated-value');
-            expect(pvar2()).toBe('updated-value');
+            expect(pvar1()).toBe("updated-value");
+            expect(pvar2()).toBe("updated-value");
         });
     });
     describe("bug documentation", () => {
         it("confirms same pvar instance is returned for same name (singleton pattern)", async () => {
             const userContext = await createTestUserContext();
-            const pvar1 = (0, peers_sdk_1.deviceVar)('instanceTestVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar1 = (0, peers_sdk_1.deviceVar)("instanceTestVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('instanceTestVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar2 = (0, peers_sdk_1.deviceVar)("instanceTestVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar2.loadingPromise;
             // Singleton pattern: these ARE the same instance
@@ -99,20 +99,20 @@ describe("Persistent Variables - Update Loop Bug", () => {
             let localEventCount = 0;
             let remoteEventCount = 0;
             // Subscribe to events before creating the pvar
-            userContext.subscribeToDataChangedAcrossAllGroups('PersistentVars', (evt) => {
-                if (evt.data.source === 'local') {
+            userContext.subscribeToDataChangedAcrossAllGroups("PersistentVars", (evt) => {
+                if (evt.data.source === "local") {
                     localEventCount++;
                 }
                 else {
                     remoteEventCount++;
                 }
             });
-            const pvar = (0, peers_sdk_1.deviceVar)('eventTestVar', {
-                defaultValue: 'initial',
-                userContext
+            const pvar = (0, peers_sdk_1.deviceVar)("eventTestVar", {
+                defaultValue: "initial",
+                userContext,
             });
             await pvar.loadingPromise;
-            pvar('test-value');
+            pvar("test-value");
             await (0, peers_sdk_1.sleep)(200);
             // Document that local events ARE received (this contributes to the bug)
             // WHEN FIXED: Local events should either be filtered out OR the pvar
@@ -125,14 +125,14 @@ describe("Persistent Variables - Update Loop Bug", () => {
             const userContext = await createTestUserContext();
             let updateCount = 0;
             const maxUpdates = 20;
-            const pvar1 = (0, peers_sdk_1.deviceVar)('debugBugVar', {
+            const pvar1 = (0, peers_sdk_1.deviceVar)("debugBugVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('debugBugVar', {
+            const pvar2 = (0, peers_sdk_1.deviceVar)("debugBugVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar2.loadingPromise;
             pvar1.subscribe(() => {
@@ -158,14 +158,14 @@ describe("Persistent Variables - Update Loop Bug", () => {
         });
         it("singleton pattern returns same instance for same name/scope", async () => {
             const userContext = await createTestUserContext();
-            const pvar1 = (0, peers_sdk_1.deviceVar)('singletonVerifyVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar1 = (0, peers_sdk_1.deviceVar)("singletonVerifyVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('singletonVerifyVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar2 = (0, peers_sdk_1.deviceVar)("singletonVerifyVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar2.loadingPromise;
             // Singleton pattern is now implemented - same instance should be returned
@@ -173,14 +173,14 @@ describe("Persistent Variables - Update Loop Bug", () => {
         });
         it("different pvar names return different instances", async () => {
             const userContext = await createTestUserContext();
-            const pvar1 = (0, peers_sdk_1.deviceVar)('singletonVarA', {
-                defaultValue: 'default',
-                userContext
+            const pvar1 = (0, peers_sdk_1.deviceVar)("singletonVarA", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('singletonVarB', {
-                defaultValue: 'default',
-                userContext
+            const pvar2 = (0, peers_sdk_1.deviceVar)("singletonVarB", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar2.loadingPromise;
             // Different names should be different instances
@@ -189,24 +189,24 @@ describe("Persistent Variables - Update Loop Bug", () => {
         it("different userContexts return different instances (test isolation)", async () => {
             const userContext1 = await createTestUserContext();
             const userContext2 = await createTestUserContext();
-            const pvar1 = (0, peers_sdk_1.deviceVar)('isolationTestVar', {
-                defaultValue: 'default',
-                userContext: userContext1
+            const pvar1 = (0, peers_sdk_1.deviceVar)("isolationTestVar", {
+                defaultValue: "default",
+                userContext: userContext1,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('isolationTestVar', {
-                defaultValue: 'default',
-                userContext: userContext2
+            const pvar2 = (0, peers_sdk_1.deviceVar)("isolationTestVar", {
+                defaultValue: "default",
+                userContext: userContext2,
             });
             await pvar2.loadingPromise;
             // Different userContexts should have different instances (important for test isolation)
             expect(pvar1).not.toBe(pvar2);
             // They should work independently
-            pvar1('value1');
-            pvar2('value2');
+            pvar1("value1");
+            pvar2("value2");
             await (0, peers_sdk_1.sleep)(100);
-            expect(pvar1()).toBe('value1');
-            expect(pvar2()).toBe('value2');
+            expect(pvar1()).toBe("value1");
+            expect(pvar2()).toBe("value2");
         });
     });
     /**
@@ -218,14 +218,14 @@ describe("Persistent Variables - Update Loop Bug", () => {
         it("rapid sequential updates should not cause infinite loop", async () => {
             const userContext = await createTestUserContext();
             let updateCount = 0;
-            const pvar1 = (0, peers_sdk_1.deviceVar)('rapidBugVar', {
+            const pvar1 = (0, peers_sdk_1.deviceVar)("rapidBugVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('rapidBugVar', {
+            const pvar2 = (0, peers_sdk_1.deviceVar)("rapidBugVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar2.loadingPromise;
             pvar1.subscribe(() => updateCount++);
@@ -241,21 +241,21 @@ describe("Persistent Variables - Update Loop Bug", () => {
         it("alternating updates between instances should not cause infinite loop", async () => {
             const userContext = await createTestUserContext();
             let updateCount = 0;
-            const pvar1 = (0, peers_sdk_1.deviceVar)('alternateBugVar', {
-                defaultValue: 'initial',
-                userContext
+            const pvar1 = (0, peers_sdk_1.deviceVar)("alternateBugVar", {
+                defaultValue: "initial",
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('alternateBugVar', {
-                defaultValue: 'initial',
-                userContext
+            const pvar2 = (0, peers_sdk_1.deviceVar)("alternateBugVar", {
+                defaultValue: "initial",
+                userContext,
             });
             await pvar2.loadingPromise;
             pvar1.subscribe(() => updateCount++);
             pvar2.subscribe(() => updateCount++);
             // Alternating updates between instances
-            pvar1('from-1');
-            pvar2('from-2');
+            pvar1("from-1");
+            pvar2("from-2");
             await (0, peers_sdk_1.sleep)(1000);
             // Should not cause infinite loop - expect reasonable update count
             expect(updateCount).toBeLessThan(10);
@@ -269,14 +269,14 @@ describe("Persistent Variables - Update Loop Bug", () => {
             const userContext = await createTestUserContext();
             let updateCount = 0;
             let loopDetected = false;
-            const pvar1 = (0, peers_sdk_1.deviceVar)('seqPropagationVar', {
+            const pvar1 = (0, peers_sdk_1.deviceVar)("seqPropagationVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('seqPropagationVar', {
+            const pvar2 = (0, peers_sdk_1.deviceVar)("seqPropagationVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar2.loadingPromise;
             // Set up subscribers that count updates and detect loops
@@ -319,29 +319,29 @@ describe("Persistent Variables - Update Loop Bug", () => {
             const userContext = await createTestUserContext();
             const updates = [];
             const MAX_UPDATES = 30;
-            const pvar1 = (0, peers_sdk_1.deviceVar)('crossSyncVar', {
-                defaultValue: 'start',
-                userContext
+            const pvar1 = (0, peers_sdk_1.deviceVar)("crossSyncVar", {
+                defaultValue: "start",
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('crossSyncVar', {
-                defaultValue: 'start',
-                userContext
+            const pvar2 = (0, peers_sdk_1.deviceVar)("crossSyncVar", {
+                defaultValue: "start",
+                userContext,
             });
             await pvar2.loadingPromise;
             // Track all updates
-            pvar1.subscribe(v => {
+            pvar1.subscribe((v) => {
                 if (updates.length < MAX_UPDATES) {
                     updates.push(`pvar1:${v}`);
                 }
             });
-            pvar2.subscribe(v => {
+            pvar2.subscribe((v) => {
                 if (updates.length < MAX_UPDATES) {
                     updates.push(`pvar2:${v}`);
                 }
             });
             // Single update
-            pvar1('changed');
+            pvar1("changed");
             // Wait for sync
             await (0, peers_sdk_1.sleep)(500);
             const updatesAfterSync = updates.length;
@@ -351,8 +351,8 @@ describe("Persistent Variables - Update Loop Bug", () => {
             // Should have stabilized - no new updates
             expect(updatesAfterWait - updatesAfterSync).toBe(0);
             // Both should have the same value
-            expect(pvar1()).toBe('changed');
-            expect(pvar2()).toBe('changed');
+            expect(pvar1()).toBe("changed");
+            expect(pvar2()).toBe("changed");
             // Total updates should be reasonable (pvar1 update + pvar2 sync = ~2-4 updates)
             expect(updates.length).toBeLessThan(10);
         });
@@ -367,9 +367,9 @@ describe("Persistent Variables - Update Loop Bug", () => {
          */
         it("rapid updates should result in final value being persisted, not stale values", async () => {
             const userContext = await createTestUserContext();
-            const pvar1 = (0, peers_sdk_1.deviceVar)('staleValueVar', {
+            const pvar1 = (0, peers_sdk_1.deviceVar)("staleValueVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar1.loadingPromise;
             // Make rapid updates - all synchronous, before any async processing
@@ -382,9 +382,9 @@ describe("Persistent Variables - Update Loop Bug", () => {
             await pvar1.loadingPromise;
             await (0, peers_sdk_1.sleep)(500);
             // Create a new pvar instance to read fresh from DB
-            const pvar2 = (0, peers_sdk_1.deviceVar)('staleValueVar', {
+            const pvar2 = (0, peers_sdk_1.deviceVar)("staleValueVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar2.loadingPromise;
             // The DB should have the final value (5), not any intermediate value
@@ -399,13 +399,13 @@ describe("Persistent Variables - Update Loop Bug", () => {
         it("value should not regress during rapid updates", async () => {
             const userContext = await createTestUserContext();
             const valuesObserved = [];
-            const pvar1 = (0, peers_sdk_1.deviceVar)('regressionVar', {
+            const pvar1 = (0, peers_sdk_1.deviceVar)("regressionVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar1.loadingPromise;
             // Track all values observed
-            pvar1.subscribe(v => {
+            pvar1.subscribe((v) => {
                 valuesObserved.push(v);
             });
             // Rapid sequential updates
@@ -421,7 +421,7 @@ describe("Persistent Variables - Update Loop Bug", () => {
             for (const v of valuesObserved) {
                 if (v < maxSeen) {
                     // Value regressed - this indicates the bug
-                    fail(`Value regressed from ${maxSeen} to ${v}. All values: ${valuesObserved.join(', ')}`);
+                    fail(`Value regressed from ${maxSeen} to ${v}. All values: ${valuesObserved.join(", ")}`);
                 }
                 maxSeen = Math.max(maxSeen, v);
             }
@@ -455,24 +455,24 @@ describe("Persistent Variables - Update Loop Bug", () => {
             const pvar1Values = [];
             const pvar2Values = [];
             const MAX_UPDATES = 50; // If we exceed this, it's an infinite loop
-            const pvar1 = (0, peers_sdk_1.deviceVar)('raceConditionVar', {
+            const pvar1 = (0, peers_sdk_1.deviceVar)("raceConditionVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar1.loadingPromise;
-            const pvar2 = (0, peers_sdk_1.deviceVar)('raceConditionVar', {
+            const pvar2 = (0, peers_sdk_1.deviceVar)("raceConditionVar", {
                 defaultValue: 0,
-                userContext
+                userContext,
             });
             await pvar2.loadingPromise;
             // Track observable updates and THROW if infinite loop detected
-            pvar1.subscribe(v => {
+            pvar1.subscribe((v) => {
                 pvar1Values.push(v);
                 if (pvar1Values.length + pvar2Values.length > MAX_UPDATES) {
                     throw new Error(`INFINITE LOOP DETECTED: ${pvar1Values.length + pvar2Values.length} updates`);
                 }
             });
-            pvar2.subscribe(v => {
+            pvar2.subscribe((v) => {
                 pvar2Values.push(v);
                 if (pvar1Values.length + pvar2Values.length > MAX_UPDATES) {
                     throw new Error(`INFINITE LOOP DETECTED: ${pvar1Values.length + pvar2Values.length} updates`);
@@ -493,14 +493,14 @@ describe("Persistent Variables - Update Loop Bug", () => {
             let pvar1Max = 0;
             for (const v of pvar1Values) {
                 if (v < pvar1Max) {
-                    fail(`pvar1 regressed from ${pvar1Max} to ${v}. Values: ${pvar1Values.join(', ')}`);
+                    fail(`pvar1 regressed from ${pvar1Max} to ${v}. Values: ${pvar1Values.join(", ")}`);
                 }
                 pvar1Max = Math.max(pvar1Max, v);
             }
             let pvar2Max = 0;
             for (const v of pvar2Values) {
                 if (v < pvar2Max) {
-                    fail(`pvar2 regressed from ${pvar2Max} to ${v}. Values: ${pvar2Values.join(', ')}`);
+                    fail(`pvar2 regressed from ${pvar2Max} to ${v}. Values: ${pvar2Values.join(", ")}`);
                 }
                 pvar2Max = Math.max(pvar2Max, v);
             }
@@ -509,138 +509,138 @@ describe("Persistent Variables - Update Loop Bug", () => {
     describe("explicit delete functionality", () => {
         it("should not auto-delete when value equals default", async () => {
             const userContext = await createTestUserContext();
-            const pvar = (0, peers_sdk_1.deviceVar)('noAutoDeleteVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar = (0, peers_sdk_1.deviceVar)("noAutoDeleteVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar.loadingPromise;
             // Change to a non-default value and persist
-            pvar('changed');
+            pvar("changed");
             await pvar.loadingPromise;
             await (0, peers_sdk_1.sleep)(100);
             // Verify it was persisted
-            expect(pvar()).toBe('changed');
+            expect(pvar()).toBe("changed");
             // Set back to the default value
-            pvar('default');
+            pvar("default");
             await pvar.loadingPromise;
             await (0, peers_sdk_1.sleep)(100);
             // Value should still be persisted (not auto-deleted)
             // We verify by creating a new pvar instance to read fresh from DB
-            const pvar2 = (0, peers_sdk_1.deviceVar)('noAutoDeleteVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar2 = (0, peers_sdk_1.deviceVar)("noAutoDeleteVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar2.loadingPromise;
             // The value in DB should be 'default' (explicitly set), not missing
-            expect(pvar2()).toBe('default');
+            expect(pvar2()).toBe("default");
         });
         it("delete() should remove pvar from database and reset to default", async () => {
             const userContext = await createTestUserContext();
-            const pvar = (0, peers_sdk_1.deviceVar)('deleteTestVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar = (0, peers_sdk_1.deviceVar)("deleteTestVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar.loadingPromise;
             // Set a non-default value
-            pvar('stored-value');
+            pvar("stored-value");
             await pvar.loadingPromise;
             await (0, peers_sdk_1.sleep)(100);
-            expect(pvar()).toBe('stored-value');
+            expect(pvar()).toBe("stored-value");
             // Call delete
             await pvar.delete();
             await (0, peers_sdk_1.sleep)(100);
             // Value should be reset to default
-            expect(pvar()).toBe('default');
+            expect(pvar()).toBe("default");
             // Verify it's actually deleted from DB by creating a new pvar instance
             // The new pvar should get the default value (not 'stored-value')
-            const pvar2 = (0, peers_sdk_1.deviceVar)('deleteTestVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar2 = (0, peers_sdk_1.deviceVar)("deleteTestVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar2.loadingPromise;
-            expect(pvar2()).toBe('default');
+            expect(pvar2()).toBe("default");
         });
         it("delete() on unsaved pvar should just reset to default", async () => {
             const userContext = await createTestUserContext();
             // Create a pvar but don't change it from default
-            const pvar = (0, peers_sdk_1.deviceVar)('neverSavedVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar = (0, peers_sdk_1.deviceVar)("neverSavedVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar.loadingPromise;
             // Call delete (should not error even though nothing to delete)
             await pvar.delete();
             // Should still have the default value
-            expect(pvar()).toBe('default');
+            expect(pvar()).toBe("default");
         });
         it("delete() should be awaitable", async () => {
             const userContext = await createTestUserContext();
-            const pvar = (0, peers_sdk_1.deviceVar)('awaitDeleteVar', {
-                defaultValue: 'default',
-                userContext
+            const pvar = (0, peers_sdk_1.deviceVar)("awaitDeleteVar", {
+                defaultValue: "default",
+                userContext,
             });
             await pvar.loadingPromise;
-            pvar('value');
+            pvar("value");
             await pvar.loadingPromise;
             // delete() should return a promise that resolves
             const deleteResult = pvar.delete();
             expect(deleteResult).toBeInstanceOf(Promise);
             await deleteResult;
-            expect(pvar()).toBe('default');
+            expect(pvar()).toBe("default");
         });
         it("should support auto-delete pattern via subscription and recreate on new value", async () => {
             const userContext = await createTestUserContext();
             // Create a pvar with auto-delete behavior (like message drafts)
-            const pvar = (0, peers_sdk_1.deviceVar)('autoDeletePatternVar', {
-                defaultValue: '',
-                userContext
+            const pvar = (0, peers_sdk_1.deviceVar)("autoDeletePatternVar", {
+                defaultValue: "",
+                userContext,
             });
             await pvar.loadingPromise;
             // Set up auto-delete subscription (this mimics what message-compose does)
-            pvar.subscribe(value => {
+            pvar.subscribe((value) => {
                 if (!value) {
                     pvar.delete();
                 }
             });
             // Step 1: Add some content
-            pvar('draft content');
+            pvar("draft content");
             await pvar.loadingPromise;
             await (0, peers_sdk_1.sleep)(100);
             // Verify content is persisted
-            expect(pvar()).toBe('draft content');
+            expect(pvar()).toBe("draft content");
             // Create a fresh pvar to verify it's in DB
-            const pvar2 = (0, peers_sdk_1.deviceVar)('autoDeletePatternVar', {
-                defaultValue: '',
-                userContext
+            const pvar2 = (0, peers_sdk_1.deviceVar)("autoDeletePatternVar", {
+                defaultValue: "",
+                userContext,
             });
             await pvar2.loadingPromise;
-            expect(pvar2()).toBe('draft content');
+            expect(pvar2()).toBe("draft content");
             // Step 2: Clear content (simulates sending message or clearing editor)
-            pvar('');
+            pvar("");
             await pvar.loadingPromise;
             await (0, peers_sdk_1.sleep)(200); // Give time for delete to complete
             // Value should be empty (default)
-            expect(pvar()).toBe('');
+            expect(pvar()).toBe("");
             // Verify it's deleted from DB by creating another fresh instance
-            const pvar3 = (0, peers_sdk_1.deviceVar)('autoDeletePatternVar', {
-                defaultValue: '',
-                userContext
+            const pvar3 = (0, peers_sdk_1.deviceVar)("autoDeletePatternVar", {
+                defaultValue: "",
+                userContext,
             });
             await pvar3.loadingPromise;
-            expect(pvar3()).toBe(''); // Should be default, not persisted
+            expect(pvar3()).toBe(""); // Should be default, not persisted
             // Step 3: Add new content (should recreate the pvar in DB)
-            pvar('new draft content');
+            pvar("new draft content");
             await pvar.loadingPromise;
             await (0, peers_sdk_1.sleep)(100);
             // Verify the new content is persisted
-            expect(pvar()).toBe('new draft content');
+            expect(pvar()).toBe("new draft content");
             // Create yet another fresh instance to verify recreation in DB
-            const pvar4 = (0, peers_sdk_1.deviceVar)('autoDeletePatternVar', {
-                defaultValue: '',
-                userContext
+            const pvar4 = (0, peers_sdk_1.deviceVar)("autoDeletePatternVar", {
+                defaultValue: "",
+                userContext,
             });
             await pvar4.loadingPromise;
-            expect(pvar4()).toBe('new draft content');
+            expect(pvar4()).toBe("new draft content");
         });
     });
 });