@peers-app/peers-sdk 0.14.0 → 0.15.0

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

@@ -1,16 +1,16 @@
 "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', () => {
+const tx_encoding_1 = require("./tx-encoding");
+describe("tx-encode-decode", () => {
+    describe("txEncode and txDecode", () => {
+        it("should encode and decode simple objects", () => {
             const testObj = {
-                name: 'test',
+                name: "test",
                 number: 42,
                 bool: true,
-                str: 'hello world'
+                str: "hello world",
             };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             expect(encoded).toBeInstanceOf(Uint8Array);
@@ -18,51 +18,51 @@ describe('tx-encode-decode', () => {
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(testObj);
         });
-        it('should encode and decode arrays', () => {
-            const testArray = [1, 2, 3, 'four', { five: 5 }];
+        it("should encode and decode arrays", () => {
+            const testArray = [1, 2, 3, "four", { five: 5 }];
             const encoded = (0, tx_encoding_1.txEncode)(testArray);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(testArray);
         });
-        it('should encode and decode nested objects', () => {
+        it("should encode and decode nested objects", () => {
             const testObj = {
                 level1: {
                     level2: {
                         level3: {
-                            value: 'deep nested value',
-                            number: 123
+                            value: "deep nested value",
+                            number: 123,
                         },
-                        array: [1, 2, 3]
-                    }
-                }
+                        array: [1, 2, 3],
+                    },
+                },
             };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(testObj);
         });
-        it('should encode and decode special types (dates, etc.)', () => {
+        it("should encode and decode special types (dates, etc.)", () => {
             const testObj = {
-                date: new Date('2023-01-01T00:00:00.000Z'),
+                date: new Date("2023-01-01T00:00:00.000Z"),
                 nan: NaN,
                 infinity: Infinity,
                 negInfinity: -Infinity,
                 undef: undefined,
-                nullVal: null
+                nullVal: null,
             };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded.date).toBeInstanceOf(Date);
-            expect(decoded.date.toISOString()).toBe('2023-01-01T00:00:00.000Z');
+            expect(decoded.date.toISOString()).toBe("2023-01-01T00:00:00.000Z");
             expect(Number.isNaN(decoded.nan)).toBe(true);
             expect(decoded.infinity).toBe(Infinity);
             expect(decoded.negInfinity).toBe(-Infinity);
             expect(decoded.undef).toBeUndefined();
             expect(decoded.nullVal).toBeNull();
         });
-        it('should encode and decode Uint8Array', () => {
+        it("should encode and decode Uint8Array", () => {
             const testObj = {
                 data: new Uint8Array([72, 101, 108, 108, 111]),
-                metadata: { size: 5 }
+                metadata: { size: 5 },
             };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
@@ -70,37 +70,37 @@ describe('tx-encode-decode', () => {
             expect(decoded.data).toEqual(testObj.data);
             expect(decoded.metadata).toEqual(testObj.metadata);
         });
-        it('should encode and decode Buffer', () => {
+        it("should encode and decode Buffer", () => {
             const testObj = {
-                buffer: Buffer.from('Hello Buffer'),
-                name: 'test'
+                buffer: Buffer.from("Hello Buffer"),
+                name: "test",
             };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(Buffer.isBuffer(decoded.buffer)).toBe(true);
             expect(decoded.buffer).toEqual(testObj.buffer);
-            expect(decoded.name).toBe('test');
+            expect(decoded.name).toBe("test");
         });
     });
-    describe('compression threshold', () => {
-        it('should not compress small payloads (< 1024 bytes)', () => {
-            const smallObj = { message: 'small' };
+    describe("compression threshold", () => {
+        it("should not compress small payloads (< 1024 bytes)", () => {
+            const smallObj = { message: "small" };
             const encoded = (0, tx_encoding_1.txEncode)(smallObj);
             // First byte is the flag
             expect(encoded[0]).toBe(0); // flag = 0 means not compressed
         });
-        it('should compress large payloads (> 1024 bytes)', () => {
+        it("should compress large payloads (> 1024 bytes)", () => {
             // 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(30000),
+                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}` }
-                }))
+                    nested: { prop: `nested value ${i}` },
+                })),
             };
             const encoded = (0, tx_encoding_1.txEncode)(largeObj);
             // Verify the encoded size (without flag byte) exceeds 8KB threshold
@@ -112,12 +112,12 @@ describe('tx-encode-decode', () => {
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(largeObj);
         });
-        it('should have smaller encoded size for large compressible data', () => {
+        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(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`)
+                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);
@@ -134,98 +134,98 @@ describe('tx-encode-decode', () => {
             expect(decoded).toEqual(largeRepetitiveObj);
         });
     });
-    describe('error handling', () => {
-        it('should throw error on empty payload', () => {
+    describe("error handling", () => {
+        it("should throw error on empty payload", () => {
             const emptyPayload = new Uint8Array(0);
-            expect(() => (0, tx_encoding_1.txDecode)(emptyPayload)).toThrow('Empty payload');
+            expect(() => (0, tx_encoding_1.txDecode)(emptyPayload)).toThrow("Empty payload");
         });
-        it('should throw error on unknown flag', () => {
+        it("should throw error on unknown flag", () => {
             // Create a payload with an invalid flag (2)
             const invalidPayload = new Uint8Array([2, 0, 0, 0]);
-            expect(() => (0, tx_encoding_1.txDecode)(invalidPayload)).toThrow('Unknown tx flag: 2');
+            expect(() => (0, tx_encoding_1.txDecode)(invalidPayload)).toThrow("Unknown tx flag: 2");
         });
-        it('should throw error on unknown flag (255)', () => {
+        it("should throw error on unknown flag (255)", () => {
             const invalidPayload = new Uint8Array([255, 0, 0, 0]);
-            expect(() => (0, tx_encoding_1.txDecode)(invalidPayload)).toThrow('Unknown tx flag: 255');
+            expect(() => (0, tx_encoding_1.txDecode)(invalidPayload)).toThrow("Unknown tx flag: 255");
         });
     });
-    describe('round-trip consistency', () => {
-        it('should handle empty objects', () => {
+    describe("round-trip consistency", () => {
+        it("should handle empty objects", () => {
             const emptyObj = {};
             const encoded = (0, tx_encoding_1.txEncode)(emptyObj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(emptyObj);
         });
-        it('should handle empty arrays', () => {
+        it("should handle empty arrays", () => {
             const emptyArray = [];
             const encoded = (0, tx_encoding_1.txEncode)(emptyArray);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(emptyArray);
         });
-        it('should handle strings with special characters', () => {
+        it("should handle strings with special characters", () => {
             const testObj = {
-                emoji: '🚀🎉',
-                unicode: 'Hello 世界',
-                special: 'line1\nline2\ttab',
-                quotes: 'He said "hello"'
+                emoji: "🚀🎉",
+                unicode: "Hello 世界",
+                special: "line1\nline2\ttab",
+                quotes: 'He said "hello"',
             };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(testObj);
         });
-        it('should handle very large numbers', () => {
+        it("should handle very large numbers", () => {
             const testObj = {
                 maxSafeInt: Number.MAX_SAFE_INTEGER,
                 minSafeInt: Number.MIN_SAFE_INTEGER,
                 large: 9007199254740991,
-                small: -9007199254740991
+                small: -9007199254740991,
             };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(testObj);
         });
-        it('should handle mixed type arrays', () => {
+        it("should handle mixed type arrays", () => {
             const testArray = [
                 1,
-                'string',
+                "string",
                 true,
                 null,
                 undefined,
-                { obj: 'value' },
+                { obj: "value" },
                 [1, 2, 3],
-                new Date('2023-01-01'),
-                new Uint8Array([1, 2, 3])
+                new Date("2023-01-01"),
+                new Uint8Array([1, 2, 3]),
             ];
             const encoded = (0, tx_encoding_1.txEncode)(testArray);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded[0]).toBe(1);
-            expect(decoded[1]).toBe('string');
+            expect(decoded[1]).toBe("string");
             expect(decoded[2]).toBe(true);
             expect(decoded[3]).toBeNull();
             expect(decoded[4]).toBeUndefined();
-            expect(decoded[5]).toEqual({ obj: 'value' });
+            expect(decoded[5]).toEqual({ obj: "value" });
             expect(decoded[6]).toEqual([1, 2, 3]);
             expect(decoded[7]).toBeInstanceOf(Date);
             expect(decoded[8]).toBeInstanceOf(Uint8Array);
             expect(decoded[8]).toEqual(new Uint8Array([1, 2, 3]));
         });
-        it('should handle objects with circular references removed by toJSON', () => {
+        it("should handle objects with circular references removed by toJSON", () => {
             // toJSON handles circular references, so this should work
-            const obj = { name: 'test' };
+            const obj = { name: "test" };
             obj.self = obj; // circular reference
             const encoded = (0, tx_encoding_1.txEncode)(obj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             // The circular reference should be handled by toJSON/fromJSON
-            expect(decoded).toHaveProperty('name', 'test');
-            expect(decoded).toHaveProperty('self');
+            expect(decoded).toHaveProperty("name", "test");
+            expect(decoded).toHaveProperty("self");
             expect(decoded.self).toBe(decoded); // self-reference restored
         });
-        it('should preserve data integrity across multiple encode/decode cycles', () => {
+        it("should preserve data integrity across multiple encode/decode cycles", () => {
             const original = {
                 id: 123,
-                name: 'multi-cycle test',
+                name: "multi-cycle test",
                 data: new Uint8Array([1, 2, 3, 4, 5]),
-                timestamp: new Date('2023-06-15T12:00:00.000Z')
+                timestamp: new Date("2023-06-15T12:00:00.000Z"),
             };
             // Encode and decode multiple times
             let current = original;
@@ -239,43 +239,43 @@ describe('tx-encode-decode', () => {
             expect(current.timestamp).toEqual(original.timestamp);
         });
     });
-    describe('payload structure', () => {
-        it('should have flag byte as first byte', () => {
-            const testObj = { test: 'value' };
+    describe("payload structure", () => {
+        it("should have flag byte as first byte", () => {
+            const testObj = { test: "value" };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             // First byte should be 0 or 1
             expect(encoded[0]).toBeGreaterThanOrEqual(0);
             expect(encoded[0]).toBeLessThanOrEqual(1);
         });
-        it('should have body after flag byte', () => {
-            const testObj = { test: 'value' };
+        it("should have body after flag byte", () => {
+            const testObj = { test: "value" };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             // Should have at least 2 bytes (flag + body)
             expect(encoded.length).toBeGreaterThan(1);
         });
     });
-    describe('edge cases', () => {
-        it('should handle objects at exactly 1024 bytes threshold', () => {
+    describe("edge cases", () => {
+        it("should handle objects at exactly 1024 bytes threshold", () => {
             // Create an object that when msgpack-encoded is very close to 1024 bytes
             // This is tricky to get exact, so we just verify it works
             const testObj = {
-                data: 'x'.repeat(1000)
+                data: "x".repeat(1000),
             };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);
             expect(decoded).toEqual(testObj);
         });
-        it('should handle primitive values', () => {
+        it("should handle primitive values", () => {
             expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(42))).toBe(42);
-            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)('string'))).toBe('string');
+            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)("string"))).toBe("string");
             expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(true))).toBe(true);
             expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(false))).toBe(false);
             expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(null))).toBe(null);
         });
-        it('should handle objects with only undefined values', () => {
+        it("should handle objects with only undefined values", () => {
             const testObj = {
                 a: undefined,
-                b: undefined
+                b: undefined,
             };
             const encoded = (0, tx_encoding_1.txEncode)(testObj);
             const decoded = (0, tx_encoding_1.txDecode)(encoded);

package/dist/events.d.ts

@@ -1,4 +1,4 @@
-import { IEventData } from "./rpc-types";
+import { type IEventData } from "./rpc-types";
 export type IEventFilter = (event: IEventData) => boolean;
 export type IEventHandler<T = any> = (eventData: IEventData<T>) => boolean | void | Promise<boolean> | Promise<void>;
 export interface ISubscription {

package/dist/events.js

@@ -6,7 +6,7 @@ exports.subscribeDebounce = subscribeDebounce;
 exports.emit = emit;
 exports.unionEvents = unionEvents;
 const rpc_types_1 = require("./rpc-types");
-const unitTests = process.env.NODE_ENV === 'test';
+const unitTests = process.env.NODE_ENV === "test";
 const subscriptions = [];
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function subscribe(nameOrFilter, handler) {
@@ -65,7 +65,10 @@ async function emit(event, dontPropagate) {
     //   );
     // }
     if (!(dontPropagate || unitTests)) {
-        matchedHandlerPromises.push(rpc_types_1.rpcClientCalls.emitEvent(event).catch((err) => { console.error(`Error while propagating event to client`, err); return false; }));
+        matchedHandlerPromises.push(rpc_types_1.rpcClientCalls.emitEvent(event).catch((err) => {
+            console.error(`Error while propagating event to client`, err);
+            return false;
+        }));
     }
     const results = await Promise.all(matchedHandlerPromises);
     // if any handlers returned false (or errored), return false, otherwise return true

package/dist/group-invite/group-invite.js

@@ -21,19 +21,110 @@ const keys_1 = require("../keys");
  * Using common, easy-to-spell words.
  */
 const WORD_LIST = [
-    'apple', 'banana', 'cherry', 'date', 'elder', 'fig', 'grape', 'honey',
-    'iris', 'jade', 'kiwi', 'lemon', 'mango', 'nectar', 'olive', 'peach',
-    'quince', 'rose', 'sugar', 'tulip', 'umber', 'violet', 'willow', 'yarrow',
-    'zebra', 'amber', 'blaze', 'coral', 'dusk', 'ember', 'frost', 'glow',
-    'haze', 'ivory', 'jewel', 'karma', 'lunar', 'maple', 'nova', 'opal',
-    'prism', 'quest', 'river', 'storm', 'terra', 'ultra', 'vivid', 'winter',
-    'azure', 'brave', 'calm', 'dawn', 'echo', 'fern', 'gentle', 'harbor',
-    'island', 'jungle', 'kindle', 'light', 'meadow', 'night', 'ocean', 'piano',
-    'quiet', 'rain', 'silk', 'tide', 'unity', 'velvet', 'wave', 'zenith',
-    'arch', 'beam', 'cloud', 'drift', 'earth', 'flame', 'green', 'hill',
-    'ink', 'jazz', 'keen', 'lake', 'moon', 'nest', 'oak', 'peak',
-    'ruby', 'sand', 'tree', 'vine', 'wind', 'year', 'zone', 'bold',
-    'crisp', 'deep', 'fair', 'glad', 'warm', 'pure', 'safe', 'true'
+    "apple",
+    "banana",
+    "cherry",
+    "date",
+    "elder",
+    "fig",
+    "grape",
+    "honey",
+    "iris",
+    "jade",
+    "kiwi",
+    "lemon",
+    "mango",
+    "nectar",
+    "olive",
+    "peach",
+    "quince",
+    "rose",
+    "sugar",
+    "tulip",
+    "umber",
+    "violet",
+    "willow",
+    "yarrow",
+    "zebra",
+    "amber",
+    "blaze",
+    "coral",
+    "dusk",
+    "ember",
+    "frost",
+    "glow",
+    "haze",
+    "ivory",
+    "jewel",
+    "karma",
+    "lunar",
+    "maple",
+    "nova",
+    "opal",
+    "prism",
+    "quest",
+    "river",
+    "storm",
+    "terra",
+    "ultra",
+    "vivid",
+    "winter",
+    "azure",
+    "brave",
+    "calm",
+    "dawn",
+    "echo",
+    "fern",
+    "gentle",
+    "harbor",
+    "island",
+    "jungle",
+    "kindle",
+    "light",
+    "meadow",
+    "night",
+    "ocean",
+    "piano",
+    "quiet",
+    "rain",
+    "silk",
+    "tide",
+    "unity",
+    "velvet",
+    "wave",
+    "zenith",
+    "arch",
+    "beam",
+    "cloud",
+    "drift",
+    "earth",
+    "flame",
+    "green",
+    "hill",
+    "ink",
+    "jazz",
+    "keen",
+    "lake",
+    "moon",
+    "nest",
+    "oak",
+    "peak",
+    "ruby",
+    "sand",
+    "tree",
+    "vine",
+    "wind",
+    "year",
+    "zone",
+    "bold",
+    "crisp",
+    "deep",
+    "fair",
+    "glad",
+    "warm",
+    "pure",
+    "safe",
+    "true",
 ];
 /**
  * Generate a random memorable passphrase.
@@ -49,7 +140,7 @@ function generateInvitePassword(wordCount = 4) {
         const index = bytes[i] % WORD_LIST.length;
         words.push(WORD_LIST[index]);
     }
-    return words.join('-');
+    return words.join("-");
 }
 /**
  * Derive a network alias from a password.
@@ -63,8 +154,8 @@ function deriveAliasFromPassword(password) {
     const hash = (0, sha2_1.sha256)(new TextEncoder().encode(normalized));
     // Convert first 4 bytes to 8-char hex string
     const hexChars = Array.from(hash.slice(0, 4))
-        .map(b => b.toString(16).padStart(2, '0'))
-        .join('')
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("")
         .toUpperCase();
     return hexChars;
 }
@@ -112,7 +203,7 @@ function decryptWithPassword(encrypted, password) {
     const ciphertext = combined.slice(24);
     const decrypted = nacl.secretbox.open(ciphertext, nonce, key);
     if (!decrypted) {
-        throw new Error('Decryption failed - invalid password or corrupted data');
+        throw new Error("Decryption failed - invalid password or corrupted data");
     }
     return (0, tx_encoding_1.txDecode)(decrypted);
 }
@@ -135,6 +226,6 @@ function isValidInvitePassword(password) {
 function generateRequestId() {
     const bytes = nacl.randomBytes(8);
     return Array.from(bytes)
-        .map(b => b.toString(16).padStart(2, '0'))
-        .join('');
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
 }

package/dist/group-invite/group-invite.pvars.d.ts

@@ -7,8 +7,8 @@
  * - Status messages for UI feedback
  * - Action triggers (UI sets these, device layer reacts)
  */
-import type { IGroupInviteListener, IGroupJoinRequest, IGroupInviteListenerInfo, IGroupJoinResult } from './group-invite.types';
-import { GroupMemberRole } from '../data/group-member-roles';
+import type { GroupMemberRole } from "../data/group-member-roles";
+import type { IGroupInviteListener, IGroupInviteListenerInfo, IGroupJoinRequest, IGroupJoinResult } from "./group-invite.types";
 /**
  * Active group invitation listeners.
  * Key is groupId, value contains the password and alias being listened for.

package/dist/group-invite/group-invite.pvars.js

@@ -20,40 +20,44 @@ const persistent_vars_1 = require("../data/persistent-vars");
  *
  * Used by admins who are waiting for join requests.
  */
-exports.groupInviteListeners = (0, persistent_vars_1.deviceVar)('groupInviteListeners', { defaultValue: {} });
+exports.groupInviteListeners = (0, persistent_vars_1.deviceVar)("groupInviteListeners", { defaultValue: {} });
 /**
  * Pending join requests that need admin approval.
  * Array of requests waiting to be approved or denied.
  *
  * These are shown to the admin in the group details UI.
  */
-exports.groupInviteRequests = (0, persistent_vars_1.deviceVar)('groupInviteRequests', { defaultValue: [] });
+exports.groupInviteRequests = (0, persistent_vars_1.deviceVar)("groupInviteRequests", {
+    defaultValue: [],
+});
 /**
  * Status message for the group invite UI (admin side).
  * Used to show success/error messages to the user.
  */
-exports.groupInviteStatus = (0, persistent_vars_1.deviceVar)('groupInviteStatus', { defaultValue: '' });
+exports.groupInviteStatus = (0, persistent_vars_1.deviceVar)("groupInviteStatus", { defaultValue: "" });
 /**
  * Status message for the join group UI (joiner side).
  * Used to show discovery/join status to the user.
  */
-exports.groupJoinStatus = (0, persistent_vars_1.deviceVar)('groupJoinStatus', { defaultValue: '' });
+exports.groupJoinStatus = (0, persistent_vars_1.deviceVar)("groupJoinStatus", { defaultValue: "" });
 /**
  * Results from discovering group listeners.
  * Updated by the device layer after discovery completes.
  */
-exports.groupInviteDiscoveryResult = (0, persistent_vars_1.deviceVar)('groupInviteDiscoveryResult', { defaultValue: [] });
+exports.groupInviteDiscoveryResult = (0, persistent_vars_1.deviceVar)("groupInviteDiscoveryResult", { defaultValue: [] });
 /**
  * Result of joining a group.
  * Updated by the device layer after join completes.
  */
-exports.groupInviteJoinResult = (0, persistent_vars_1.deviceVar)('groupInviteJoinResult', { defaultValue: null });
+exports.groupInviteJoinResult = (0, persistent_vars_1.deviceVar)("groupInviteJoinResult", {
+    defaultValue: null,
+});
 /**
  * Responses to join requests, keyed by requestId.
  * Written by processJoinRequest, read by handleJoinRequest.
  * Entries are cleaned up after being read.
  */
-exports.groupInviteResponses = (0, persistent_vars_1.deviceVar)('groupInviteResponses', { defaultValue: {} });
+exports.groupInviteResponses = (0, persistent_vars_1.deviceVar)("groupInviteResponses", { defaultValue: {} });
 // ============================================================================
 // ACTION TRIGGERS (UI sets these, device layer reacts)
 // ============================================================================
@@ -62,31 +66,35 @@ exports.groupInviteResponses = (0, persistent_vars_1.deviceVar)('groupInviteResp
  * Set by UI: { groupId, password }
  * Device layer clears after processing.
  */
-exports.groupInviteStartListening = (0, persistent_vars_1.deviceVar)('groupInviteStartListening', { defaultValue: null });
+exports.groupInviteStartListening = (0, persistent_vars_1.deviceVar)("groupInviteStartListening", { defaultValue: null });
 /**
  * Trigger to stop listening for invitations.
  * Set by UI: groupId
  * Device layer clears after processing.
  */
-exports.groupInviteStopListening = (0, persistent_vars_1.deviceVar)('groupInviteStopListening', { defaultValue: null });
+exports.groupInviteStopListening = (0, persistent_vars_1.deviceVar)("groupInviteStopListening", {
+    defaultValue: null,
+});
 /**
  * Trigger to discover groups with a password.
  * Set by UI: password
  * Device layer updates groupInviteDiscoveryResult and clears this.
  */
-exports.groupInviteDiscover = (0, persistent_vars_1.deviceVar)('groupInviteDiscover', { defaultValue: null });
+exports.groupInviteDiscover = (0, persistent_vars_1.deviceVar)("groupInviteDiscover", {
+    defaultValue: null,
+});
 /**
  * Trigger to send a join request.
  * Set by UI: { listener, password }
  * Device layer updates groupInviteJoinResult and clears this.
  */
-exports.groupInviteSendRequest = (0, persistent_vars_1.deviceVar)('groupInviteSendRequest', { defaultValue: null });
+exports.groupInviteSendRequest = (0, persistent_vars_1.deviceVar)("groupInviteSendRequest", { defaultValue: null });
 /**
  * Trigger to process (approve/deny) a join request.
  * Set by UI: { requestId, approved, role }
  * Device layer processes and clears this.
  */
-exports.groupInviteProcessRequest = (0, persistent_vars_1.deviceVar)('groupInviteProcessRequest', { defaultValue: null });
+exports.groupInviteProcessRequest = (0, persistent_vars_1.deviceVar)("groupInviteProcessRequest", { defaultValue: null });
 // ============================================================================
 // AUTO-CLEANUP
 // ============================================================================
@@ -119,7 +127,7 @@ exports.groupInviteRequests.loadingPromise.then(() => {
     setInterval(() => {
         const requests = (0, exports.groupInviteRequests)();
         const now = Date.now();
-        const validRequests = requests.filter(req => {
+        const validRequests = requests.filter((req) => {
             const receivedAt = new Date(req.receivedAt).getTime();
             const elapsed = now - receivedAt;
             return elapsed < 600_000; // Keep for 10 minutes

package/dist/group-invite/group-invite.types.d.ts

@@ -4,7 +4,7 @@
  * This flow allows admins to invite new members to a group using a simple
  * password. Multiple admins can listen for the same password simultaneously.
  */
-import { GroupMemberRole } from '../data/group-member-roles';
+import type { GroupMemberRole } from "../data/group-member-roles";
 /**
  * Information about a group shared during the invitation flow.
  */