@adventurelabs/scout-core 1.0.130 → 1.0.131

package/dist/helpers/cache.d.ts

@@ -1,4 +1,5 @@
 import { IHerdModule } from "../types/herd_module";
+import { IVersionsSoftware } from "../types/db";
 export interface CacheMetadata {
     key: string;
     timestamp: number;
@@ -45,6 +46,7 @@ export declare class ScoutCache {
     getHerdModules(): Promise<CacheResult<IHerdModule[]>>;
     clearHerdModules(): Promise<void>;
     invalidateHerdModules(): Promise<void>;
+    invalidateVersionsSoftware(): Promise<void>;
     getCacheStats(): Promise<CacheStats>;
     isCacheValid(ttlMs?: number): Promise<boolean>;
     getCacheAge(): Promise<number>;
@@ -58,5 +60,8 @@ export declare class ScoutCache {
     isCacheVersionCompatible(): Promise<boolean>;
     resetDatabase(): Promise<void>;
     checkDatabaseHealth(): Promise<DatabaseHealth>;
+    setVersionsSoftware(versionsSoftware: IVersionsSoftware[], ttlMs?: number, etag?: string): Promise<void>;
+    getVersionsSoftware(): Promise<CacheResult<IVersionsSoftware[]>>;
+    clearVersionsSoftware(): Promise<void>;
 }
 export declare const scoutCache: ScoutCache;

package/dist/helpers/cache.js

@@ -1,9 +1,11 @@
 const DB_NAME = "ScoutCache";
-const DB_VERSION = 2; // Increment to invalidate old cache versions
+const DB_VERSION = 3; // Increment to invalidate old cache versions
+const CACHE_VERSION = "3.0.0"; // Cache metadata version string
 const HERD_MODULES_STORE = "herd_modules";
 const CACHE_METADATA_STORE = "cache_metadata";
-// Default TTL: 24 hours (1 day)
-const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const VERSIONS_SOFTWARE_STORE = "versions_software";
+// Default TTL: 24 hours (2 days)
+const DEFAULT_TTL_MS = 2 * 24 * 60 * 60 * 1000;
 export class ScoutCache {
     constructor() {
         this.db = null;
@@ -61,6 +63,17 @@ export class ScoutCache {
                         keyPath: "key",
                     });
                     console.log("[ScoutCache] Created cache_metadata object store");
+                    // Create versions_software store
+                    const versionsSoftwareStore = db.createObjectStore(VERSIONS_SOFTWARE_STORE, {
+                        keyPath: "id",
+                    });
+                    versionsSoftwareStore.createIndex("system", "system", {
+                        unique: false,
+                    });
+                    versionsSoftwareStore.createIndex("timestamp", "timestamp", {
+                        unique: false,
+                    });
+                    console.log("[ScoutCache] Created versions_software object store");
                     console.log(`[ScoutCache] Database schema upgrade to version ${DB_VERSION} completed`);
                 }
                 catch (error) {
@@ -79,13 +92,17 @@ export class ScoutCache {
             return false;
         const hasHerdModulesStore = this.db.objectStoreNames.contains(HERD_MODULES_STORE);
         const hasMetadataStore = this.db.objectStoreNames.contains(CACHE_METADATA_STORE);
+        const hasVersionsSoftwareStore = this.db.objectStoreNames.contains(VERSIONS_SOFTWARE_STORE);
         if (!hasHerdModulesStore) {
             console.error("[ScoutCache] Missing herd_modules object store");
         }
         if (!hasMetadataStore) {
             console.error("[ScoutCache] Missing cache_metadata object store");
         }
-        return hasHerdModulesStore && hasMetadataStore;
+        if (!hasVersionsSoftwareStore) {
+            console.error("[ScoutCache] Missing versions_software object store");
+        }
+        return hasHerdModulesStore && hasMetadataStore && hasVersionsSoftwareStore;
     }
     async setHerdModules(herdModules, ttlMs = DEFAULT_TTL_MS, etag) {
         await this.init();
@@ -101,7 +118,7 @@ export class ScoutCache {
             const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
             const timestamp = Date.now();
-            const version = "2.0.0";
+            const version = CACHE_VERSION;
             // Store each herd module (contains all nested data - devices, events, zones, etc.)
             herdModules.forEach((herdModule) => {
                 const cacheEntry = {
@@ -221,6 +238,21 @@ export class ScoutCache {
             metadataStore.delete("providers");
         });
     }
+    async invalidateVersionsSoftware() {
+        await this.init();
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (!this.validateDatabaseSchema()) {
+            throw new Error("Database schema validation failed - required object stores not found");
+        }
+        const transaction = this.db.transaction([CACHE_METADATA_STORE], "readwrite");
+        return new Promise((resolve, reject) => {
+            transaction.onerror = () => reject(transaction.error);
+            transaction.oncomplete = () => resolve();
+            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
+            metadataStore.delete("versions_software");
+        });
+    }
     async getCacheStats() {
         const result = await this.getHerdModules();
         const totalRequests = this.stats.hits + this.stats.misses;
@@ -365,6 +397,135 @@ export class ScoutCache {
             issues,
         };
     }
+    async setVersionsSoftware(versionsSoftware, ttlMs = DEFAULT_TTL_MS, etag) {
+        await this.init();
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (!this.validateDatabaseSchema()) {
+            throw new Error("Database schema validation failed - required object stores not found");
+        }
+        const transaction = this.db.transaction([VERSIONS_SOFTWARE_STORE, CACHE_METADATA_STORE], "readwrite");
+        return new Promise((resolve, reject) => {
+            transaction.onerror = () => reject(transaction.error);
+            transaction.oncomplete = () => resolve();
+            const versionsSoftwareStore = transaction.objectStore(VERSIONS_SOFTWARE_STORE);
+            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
+            const timestamp = Date.now();
+            const version = CACHE_VERSION;
+            // Clear existing versions_software data first
+            versionsSoftwareStore.clear();
+            // Store each software version with timestamp
+            versionsSoftware.forEach((version) => {
+                const cacheEntry = {
+                    ...version,
+                    timestamp,
+                    dbVersion: DB_VERSION,
+                };
+                versionsSoftwareStore.put(cacheEntry);
+            });
+            // Store cache metadata
+            const metadata = {
+                key: "versions_software",
+                timestamp,
+                ttl: ttlMs,
+                version,
+                dbVersion: DB_VERSION,
+                etag,
+                lastModified: timestamp,
+            };
+            metadataStore.put(metadata);
+        });
+    }
+    async getVersionsSoftware() {
+        await this.init();
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (!this.validateDatabaseSchema()) {
+            throw new Error("Database schema validation failed - required object stores not found");
+        }
+        const transaction = this.db.transaction([VERSIONS_SOFTWARE_STORE, CACHE_METADATA_STORE], "readonly");
+        return new Promise((resolve, reject) => {
+            transaction.onerror = () => reject(transaction.error);
+            const versionsSoftwareStore = transaction.objectStore(VERSIONS_SOFTWARE_STORE);
+            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
+            // Get metadata first
+            const metadataRequest = metadataStore.get("versions_software");
+            metadataRequest.onsuccess = () => {
+                const metadata = metadataRequest.result;
+                const now = Date.now();
+                if (!metadata) {
+                    this.stats.misses++;
+                    resolve({ data: null, isStale: true, age: 0, metadata: null });
+                    return;
+                }
+                // Check if cache is from an incompatible DB version
+                if (!metadata.dbVersion || metadata.dbVersion !== DB_VERSION) {
+                    console.log(`[ScoutCache] Versions software cache from incompatible DB version (${metadata.dbVersion || "unknown"} !== ${DB_VERSION}), invalidating`);
+                    this.stats.misses++;
+                    resolve({ data: null, isStale: true, age: 0, metadata });
+                    return;
+                }
+                const age = now - metadata.timestamp;
+                const isStale = age > metadata.ttl;
+                if (isStale) {
+                    this.stats.misses++;
+                    console.log(`[ScoutCache] Versions software cache is stale (${Math.round(age / 1000)}s old, TTL: ${Math.round(metadata.ttl / 1000)}s)`);
+                    resolve({ data: null, isStale: true, age, metadata });
+                    return;
+                }
+                // Get all versions_software
+                const getAllRequest = versionsSoftwareStore.getAll();
+                getAllRequest.onsuccess = () => {
+                    const cacheEntries = getAllRequest.result;
+                    if (!cacheEntries || cacheEntries.length === 0) {
+                        this.stats.misses++;
+                        resolve({ data: null, isStale: false, age, metadata });
+                        return;
+                    }
+                    // Extract versions_software data and remove cache metadata
+                    const versionsSoftware = cacheEntries.map((entry) => {
+                        const { timestamp, dbVersion, ...versionData } = entry;
+                        return versionData;
+                    });
+                    this.stats.hits++;
+                    console.log(`[ScoutCache] Found ${versionsSoftware.length} cached software versions (${Math.round(age / 1000)}s old)`);
+                    resolve({
+                        data: versionsSoftware,
+                        isStale: false,
+                        age,
+                        metadata,
+                    });
+                };
+                getAllRequest.onerror = () => {
+                    this.stats.misses++;
+                    console.error("[ScoutCache] Failed to get versions software:", getAllRequest.error);
+                    resolve({ data: null, isStale: true, age, metadata });
+                };
+            };
+            metadataRequest.onerror = () => {
+                this.stats.misses++;
+                console.error("[ScoutCache] Failed to get versions software metadata:", metadataRequest.error);
+                resolve({ data: null, isStale: true, age: 0, metadata: null });
+            };
+        });
+    }
+    async clearVersionsSoftware() {
+        await this.init();
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (!this.validateDatabaseSchema()) {
+            throw new Error("Database schema validation failed - required object stores not found");
+        }
+        const transaction = this.db.transaction([VERSIONS_SOFTWARE_STORE, CACHE_METADATA_STORE], "readwrite");
+        return new Promise((resolve, reject) => {
+            transaction.onerror = () => reject(transaction.error);
+            transaction.oncomplete = () => resolve();
+            const versionsSoftwareStore = transaction.objectStore(VERSIONS_SOFTWARE_STORE);
+            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
+            versionsSoftwareStore.clear();
+            metadataStore.delete("versions_software");
+        });
+    }
 }
 // Singleton instance
 export const scoutCache = new ScoutCache();

package/dist/helpers/versions_software.d.ts

@@ -3,8 +3,10 @@ import { IVersionsSoftware, VersionsSoftwareInsert } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
 export declare function get_versions_software(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;
+export declare function get_versions_software_with_cache(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;
 export declare function get_versions_software_by_system(client: SupabaseClient<Database>, system: string): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;
 export declare function create_version_software(client: SupabaseClient<Database>, newVersionSoftware: VersionsSoftwareInsert): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;
 export declare function update_version_software(client: SupabaseClient<Database>, version_id: number, updatedVersionSoftware: Partial<VersionsSoftwareInsert>): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;
+export declare function server_get_versions_software(): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;
 export declare function delete_version_software(client: SupabaseClient<Database>, version_id: number): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;
 export declare function get_versions_software_by_created_by(client: SupabaseClient<Database>, user_id: string): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;

package/dist/helpers/versions_software.js

@@ -1,4 +1,5 @@
 import { IWebResponse } from "../types/requests";
+import { scoutCache } from "./cache";
 export async function get_versions_software(client) {
     const { data, error } = await client
         .from("versions_software")
@@ -12,6 +13,35 @@ export async function get_versions_software(client) {
     }
     return IWebResponse.success(data).to_compatible();
 }
+export async function get_versions_software_with_cache(client) {
+    try {
+        // Try to get from cache first
+        const cacheResult = await scoutCache.getVersionsSoftware();
+        if (cacheResult.data && !cacheResult.isStale) {
+            console.log(`[VersionsSoftware] Using cached data (${Math.round(cacheResult.age / 1000)}s old)`);
+            return IWebResponse.success(cacheResult.data).to_compatible();
+        }
+        // Cache miss or stale data - fetch from API
+        console.log("[VersionsSoftware] Cache miss or stale, fetching from API");
+        const apiResponse = await get_versions_software(client);
+        // If API request was successful, cache the result
+        if (apiResponse.status === "success" && apiResponse.data) {
+            try {
+                await scoutCache.setVersionsSoftware(apiResponse.data);
+                console.log(`[VersionsSoftware] Cached ${apiResponse.data.length} software versions`);
+            }
+            catch (cacheError) {
+                console.warn("[VersionsSoftware] Failed to cache data:", cacheError);
+                // Continue anyway, we still have the API data
+            }
+        }
+        return apiResponse;
+    }
+    catch (cacheError) {
+        console.warn("[VersionsSoftware] Cache error, falling back to API:", cacheError);
+        return get_versions_software(client);
+    }
+}
 export async function get_versions_software_by_system(client, system) {
     const { data, error } = await client
         .from("versions_software")
@@ -38,6 +68,14 @@ export async function create_version_software(client, newVersionSoftware) {
     if (!data) {
         return IWebResponse.error("Failed to create software version").to_compatible();
     }
+    // Invalidate cache after successful creation
+    try {
+        await scoutCache.invalidateVersionsSoftware();
+        console.log("[VersionsSoftware] Cache invalidated after creation");
+    }
+    catch (cacheError) {
+        console.warn("[VersionsSoftware] Failed to invalidate cache:", cacheError);
+    }
     return IWebResponse.success(data).to_compatible();
 }
 export async function update_version_software(client, version_id, updatedVersionSoftware) {
@@ -58,8 +96,47 @@ export async function update_version_software(client, version_id, updatedVersion
     if (!data) {
         return IWebResponse.error("Software version not found or update failed").to_compatible();
     }
+    // Invalidate cache after successful update
+    try {
+        await scoutCache.invalidateVersionsSoftware();
+        console.log("[VersionsSoftware] Cache invalidated after update");
+    }
+    catch (cacheError) {
+        console.warn("[VersionsSoftware] Failed to invalidate cache:", cacheError);
+    }
     return IWebResponse.success(data).to_compatible();
 }
+export async function server_get_versions_software() {
+    const { newServerClient } = await import("../supabase/server");
+    const client = await newServerClient();
+    try {
+        // Try to get from cache first
+        const cacheResult = await scoutCache.getVersionsSoftware();
+        if (cacheResult.data && !cacheResult.isStale) {
+            console.log(`[VersionsSoftware] Server using cached data (${Math.round(cacheResult.age / 1000)}s old)`);
+            return IWebResponse.success(cacheResult.data).to_compatible();
+        }
+        // Cache miss or stale data - fetch from API
+        console.log("[VersionsSoftware] Server cache miss or stale, fetching from API");
+        const apiResponse = await get_versions_software(client);
+        // If API request was successful, cache the result
+        if (apiResponse.status === "success" && apiResponse.data) {
+            try {
+                await scoutCache.setVersionsSoftware(apiResponse.data);
+                console.log(`[VersionsSoftware] Server cached ${apiResponse.data.length} software versions`);
+            }
+            catch (cacheError) {
+                console.warn("[VersionsSoftware] Server failed to cache data:", cacheError);
+                // Continue anyway, we still have the API data
+            }
+        }
+        return apiResponse;
+    }
+    catch (cacheError) {
+        console.warn("[VersionsSoftware] Server cache error, falling back to API:", cacheError);
+        return get_versions_software(client);
+    }
+}
 export async function delete_version_software(client, version_id) {
     const { data, error } = await client
         .from("versions_software")
@@ -73,6 +150,14 @@ export async function delete_version_software(client, version_id) {
     if (!data) {
         return IWebResponse.error("Software version not found or deletion failed").to_compatible();
     }
+    // Invalidate cache after successful deletion
+    try {
+        await scoutCache.invalidateVersionsSoftware();
+        console.log("[VersionsSoftware] Cache invalidated after deletion");
+    }
+    catch (cacheError) {
+        console.warn("[VersionsSoftware] Failed to invalidate cache:", cacheError);
+    }
     return IWebResponse.success(data).to_compatible();
 }
 export async function get_versions_software_by_created_by(client, user_id) {

package/dist/hooks/index.d.ts

@@ -1,3 +1,4 @@
 export { useScoutRefresh, type UseScoutRefreshOptions, } from "./useScoutRefresh";
 export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
 export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";
+export { useScoutRealtimeVersionsSoftware } from "./useScoutRealtimeVersionsSoftware";

package/dist/hooks/index.js

@@ -1,3 +1,4 @@
 export { useScoutRefresh, } from "./useScoutRefresh";
 export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
 export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";
+export { useScoutRealtimeVersionsSoftware } from "./useScoutRealtimeVersionsSoftware";

package/dist/hooks/useScoutRealtimeVersionsSoftware.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { IVersionsSoftware } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimeVersionsSoftware(scoutSupabase: SupabaseClient<Database>): RealtimeData<IVersionsSoftware>[];

package/dist/hooks/useScoutRealtimeVersionsSoftware.js

@@ -0,0 +1,66 @@
+"use client";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeVersionsSoftware(scoutSupabase) {
+    const channels = useRef([]);
+    const [newVersionsItems, setNewVersionsItems] = useState([]);
+    // Handle versions software broadcasts
+    const handleVersionsSoftwareBroadcast = useCallback((payload) => {
+        const { event, payload: data } = payload;
+        const versionData = data.record || data.old_record;
+        if (!versionData) {
+            return;
+        }
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                break;
+            default:
+                return;
+        }
+        console.log(`[VERSIONS_SOFTWARE] ${data.operation} received for version ${versionData.system}@${versionData.version}:`, JSON.stringify(versionData));
+        const realtimeData = {
+            data: versionData,
+            operation,
+        };
+        setNewVersionsItems((prev) => [realtimeData, ...prev]);
+    }, []);
+    // Clear new items
+    const clearNewItems = useCallback(() => {
+        setNewVersionsItems([]);
+    }, []);
+    useEffect(() => {
+        if (!scoutSupabase)
+            return;
+        // Clean up existing channels
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+        // Clear previous items when setting up
+        clearNewItems();
+        // Create versions_software channel
+        const channel = scoutSupabase
+            .channel("versions_software_changes", { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleVersionsSoftwareBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log("[VERSIONS_SOFTWARE] ✅ Connected to software versions broadcasts");
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn("[VERSIONS_SOFTWARE] 🟡 Failed to connect to software versions broadcasts");
+            }
+        });
+        channels.current.push(channel);
+        return () => {
+            channels.current.forEach((ch) => scoutSupabase.removeChannel(ch));
+            channels.current = [];
+        };
+    }, [scoutSupabase, handleVersionsSoftwareBroadcast, clearNewItems]);
+    return newVersionsItems;
+}

package/dist/hooks/useScoutRefresh.js

@@ -50,158 +50,6 @@ export function useScoutRefresh(options = {}) {
         cacheSaveDuration: 0,
     });
     // Helper function for deep comparison of objects
-    const deepEqual = useCallback((obj1, obj2, visited = new WeakMap()) => {
-        if (obj1 === obj2)
-            return true;
-        if (obj1 == null || obj2 == null)
-            return obj1 === obj2;
-        if (typeof obj1 !== typeof obj2)
-            return false;
-        if (typeof obj1 !== "object")
-            return obj1 === obj2;
-        // Handle circular references
-        if (visited.has(obj1)) {
-            return visited.get(obj1) === obj2;
-        }
-        visited.set(obj1, obj2);
-        // Handle Date objects
-        if (obj1 instanceof Date && obj2 instanceof Date) {
-            return obj1.getTime() === obj2.getTime();
-        }
-        if (Array.isArray(obj1) !== Array.isArray(obj2))
-            return false;
-        if (Array.isArray(obj1)) {
-            if (obj1.length !== obj2.length)
-                return false;
-            for (let i = 0; i < obj1.length; i++) {
-                if (!deepEqual(obj1[i], obj2[i], visited))
-                    return false;
-            }
-            return true;
-        }
-        const keys1 = Object.keys(obj1);
-        const keys2 = Object.keys(obj2);
-        if (keys1.length !== keys2.length)
-            return false;
-        for (const key of keys1) {
-            if (!keys2.includes(key))
-                return false;
-            if (!deepEqual(obj1[key], obj2[key], visited))
-                return false;
-        }
-        return true;
-    }, []);
-    // Helper function to sort herd modules consistently by ID
-    const sortHerdModulesById = useCallback((herdModules) => {
-        if (!Array.isArray(herdModules))
-            return herdModules;
-        return [...herdModules].sort((a, b) => {
-            const aId = a?.herd?.id || 0;
-            const bId = b?.herd?.id || 0;
-            return aId - bId;
-        });
-    }, []);
-    // Helper function to normalize herd modules for comparison (excludes timestamp metadata)
-    const normalizeHerdModulesForComparison = useCallback((herdModules) => {
-        if (!Array.isArray(herdModules))
-            return herdModules;
-        return herdModules.map((hm) => {
-            if (!hm || typeof hm !== "object")
-                return hm;
-            // Create a copy without timestamp metadata that doesn't represent business data changes
-            const { timestamp_last_refreshed, ...businessData } = hm;
-            return businessData;
-        });
-    }, []);
-    // Helper function to find what specifically changed for debugging
-    const findBusinessDataChanges = useCallback((newData, currentData) => {
-        if (!Array.isArray(newData) || !Array.isArray(currentData)) {
-            return `Array type mismatch: new=${Array.isArray(newData)}, current=${Array.isArray(currentData)}`;
-        }
-        if (newData.length !== currentData.length) {
-            return `Array length: ${currentData.length} → ${newData.length}`;
-        }
-        // Sort and normalize both for consistent comparison
-        const sortedNew = normalizeHerdModulesForComparison(sortHerdModulesById(newData));
-        const sortedCurrent = normalizeHerdModulesForComparison(sortHerdModulesById(currentData));
-        const changes = [];
-        for (let i = 0; i < sortedNew.length; i++) {
-            const newHerd = sortedNew[i];
-            const currentHerd = sortedCurrent[i];
-            if (!newHerd || !currentHerd)
-                continue;
-            const herdName = newHerd.herd?.name || newHerd.name || `herd-${newHerd.herd?.id || i}`;
-            // Check key business fields
-            const businessFields = [
-                "total_events",
-                "total_events_with_filters",
-                "events_page_index",
-            ];
-            businessFields.forEach((field) => {
-                if (newHerd[field] !== currentHerd[field]) {
-                    changes.push(`${herdName}.${field}: ${currentHerd[field]} → ${newHerd[field]}`);
-                }
-            });
-            // Check array lengths
-            const arrayFields = [
-                "devices",
-                "events",
-                "plans",
-                "zones",
-                "sessions",
-                "layers",
-                "providers",
-            ];
-            arrayFields.forEach((field) => {
-                const newArray = newHerd[field];
-                const currentArray = currentHerd[field];
-                if (Array.isArray(newArray) && Array.isArray(currentArray)) {
-                    if (newArray.length !== currentArray.length) {
-                        changes.push(`${herdName}.${field}[]: ${currentArray.length} → ${newArray.length}`);
-                    }
-                }
-            });
-        }
-        return changes.length > 0
-            ? changes.join(", ")
-            : "No specific changes identified";
-    }, [normalizeHerdModulesForComparison, sortHerdModulesById]);
-    // Helper function to conditionally dispatch only if business data has changed
-    const conditionalDispatch = useCallback((newData, currentData, actionCreator, dataType, skipTimestampOnlyUpdates = true) => {
-        // For herd modules, sort both datasets by ID before comparison
-        let dataToCompare = newData;
-        let currentToCompare = currentData;
-        if (dataType.includes("Herd modules")) {
-            dataToCompare = sortHerdModulesById(newData);
-            currentToCompare = sortHerdModulesById(currentData);
-            // If we want to skip timestamp-only updates, normalize the data for comparison
-            if (skipTimestampOnlyUpdates) {
-                dataToCompare = normalizeHerdModulesForComparison(dataToCompare);
-                currentToCompare =
-                    normalizeHerdModulesForComparison(currentToCompare);
-            }
-        }
-        if (!deepEqual(dataToCompare, currentToCompare)) {
-            console.log(`[useScoutRefresh] ${dataType} business data changed, updating store`);
-            // Add debugging for unexpected business changes
-            if (skipTimestampOnlyUpdates && dataType.includes("Herd modules")) {
-                const changes = findBusinessDataChanges(dataToCompare, currentToCompare);
-                console.log(`[useScoutRefresh] ${dataType} changes: ${changes}`);
-            }
-            dispatch(actionCreator(newData)); // Always dispatch original unsorted data
-            return true;
-        }
-        else {
-            console.log(`[useScoutRefresh] ${dataType} business data unchanged, skipping store update`);
-            return false;
-        }
-    }, [
-        dispatch,
-        deepEqual,
-        sortHerdModulesById,
-        normalizeHerdModulesForComparison,
-        findBusinessDataChanges,
-    ]);
     // Helper function to handle IndexedDB errors - memoized for stability
     const handleIndexedDbError = useCallback(async (error, operation, retryFn) => {
         if (error instanceof Error &&
@@ -254,13 +102,10 @@ export function useScoutRefresh(options = {}) {
                             cacheAge: cacheResult.age,
                             isStale: cacheResult.isStale,
                         }));
-                        // Conditionally update the store with cached data if business data is different
-                        // Get current state at execution time to avoid dependency issues
-                        const currentHerdModules = store.getState().scout.herd_modules;
-                        const herdModulesChanged = conditionalDispatch(cachedHerdModules, currentHerdModules, setHerdModules, "Herd modules (cache)", true);
-                        if (herdModulesChanged) {
-                            dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
-                        }
+                        // Update the store with cached data
+                        console.log(`[useScoutRefresh] Updating store with cached herd modules`);
+                        dispatch(setHerdModules(cachedHerdModules));
+                        dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
                         // If cache is fresh, we still background fetch but don't wait
                         if (!cacheResult.isStale) {
                             // Background fetch fresh data without blocking
@@ -310,12 +155,12 @@ export function useScoutRefresh(options = {}) {
                                                 }
                                             });
                                         }
-                                        // Conditionally update store with fresh background data, skip timestamp-only changes
-                                        const currentHerdModules = store.getState().scout.herd_modules;
-                                        const currentUser = store.getState().scout.user;
-                                        conditionalDispatch(backgroundHerdModulesResult.data, currentHerdModules, setHerdModules, "Herd modules (background)", true);
+                                        // Update store with fresh data from background request
+                                        console.log(`[useScoutRefresh] Updating store with background herd modules`);
+                                        dispatch(setHerdModules(backgroundHerdModulesResult.data));
                                         if (backgroundUserResult && backgroundUserResult.data) {
-                                            conditionalDispatch(backgroundUserResult.data, currentUser, setUser, "User (background)");
+                                            console.log(`[useScoutRefresh] Updating store with background user data`);
+                                            dispatch(setUser(backgroundUserResult.data));
                                         }
                                         // Update data source to DATABASE
                                         dispatch(setDataSource(EnumDataSource.DATABASE));
@@ -424,13 +269,12 @@ export function useScoutRefresh(options = {}) {
             }
             // Step 4: Conditionally update store with fresh data, skip timestamp-only changes
             const dataProcessingStartTime = Date.now();
-            const currentHerdModules = store.getState().scout.herd_modules;
-            const currentUser = store.getState().scout.user;
-            const herdModulesChanged = conditionalDispatch(compatible_new_herd_modules, currentHerdModules, setHerdModules, "Herd modules (fresh API)", true);
-            const userChanged = conditionalDispatch(res_new_user.data, currentUser, setUser, "User (fresh API)");
-            if (herdModulesChanged) {
-                dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
-            }
+            // Update store with new data
+            console.log(`[useScoutRefresh] Updating store with fresh herd modules`);
+            dispatch(setHerdModules(compatible_new_herd_modules));
+            console.log(`[useScoutRefresh] Updating store with fresh user data`);
+            dispatch(setUser(res_new_user.data));
+            dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
             const dataProcessingDuration = Date.now() - dataProcessingStartTime;
             timingRefs.current.dataProcessingDuration = dataProcessingDuration;
             dispatch(setDataProcessingDuration(dataProcessingDuration));
@@ -469,7 +313,6 @@ export function useScoutRefresh(options = {}) {
         onRefreshComplete,
         cacheFirst,
         cacheTtlMs,
-        conditionalDispatch,
         handleIndexedDbError,
     ]);
     useEffect(() => {

package/dist/index.d.ts

@@ -40,6 +40,7 @@ export * from "./helpers/versions_software";
 export * from "./helpers/components";
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
+export * from "./hooks/useScoutRealtimeVersionsSoftware";
 export * from "./hooks/useScoutRefresh";
 export * from "./providers";
 export * from "./store/scout";

package/dist/index.js

@@ -44,6 +44,7 @@ export * from "./helpers/components";
 // Hooks
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
+export * from "./hooks/useScoutRealtimeVersionsSoftware";
 export * from "./hooks/useScoutRefresh";
 // Providers
 export * from "./providers";

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -221,6 +221,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 id: number;
                 inserted_at: string;
                 location: unknown;
+                mode: string | null;
                 noise: number;
                 session_id: number | null;
                 signal: number;
@@ -241,6 +242,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 id?: number;
                 inserted_at?: string;
                 location: unknown;
+                mode?: string | null;
                 noise: number;
                 session_id?: number | null;
                 signal: number;
@@ -261,6 +263,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 id?: number;
                 inserted_at?: string;
                 location?: unknown;
+                mode?: string | null;
                 noise?: number;
                 session_id?: number | null;
                 signal?: number;

package/dist/types/supabase.d.ts

@@ -230,6 +230,7 @@ export type Database = {
                     id: number;
                     inserted_at: string;
                     location: unknown;
+                    mode: string | null;
                     noise: number;
                     session_id: number | null;
                     signal: number;
@@ -250,6 +251,7 @@ export type Database = {
                     id?: number;
                     inserted_at?: string;
                     location: unknown;
+                    mode?: string | null;
                     noise: number;
                     session_id?: number | null;
                     signal: number;
@@ -270,6 +272,7 @@ export type Database = {
                     id?: number;
                     inserted_at?: string;
                     location?: unknown;
+                    mode?: string | null;
                     noise?: number;
                     session_id?: number | null;
                     signal?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adventurelabs/scout-core",
-  "version": "1.0.130",
+  "version": "1.0.131",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",