@adventurelabs/scout-core 1.0.130 → 1.0.132

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,79 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { upsertVersionSoftware, deleteVersionSoftwareById, } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeVersionsSoftware(scoutSupabase) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [newVersionsItems, setNewVersionsItems] = useState([]);
+    // Handle versions software broadcasts
+    const handleVersionsSoftwareBroadcast = useCallback((payload) => {
+        console.log("[VersionsSoftware] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const versionData = data.record || data.old_record;
+        if (!versionData)
+            return;
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record) {
+                    console.log("[VersionsSoftware] New version received:", data.record);
+                    dispatch(upsertVersionSoftware(data.record));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record) {
+                    dispatch(upsertVersionSoftware(data.record));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record) {
+                    dispatch(deleteVersionSoftwareById(data.old_record.id));
+                }
+                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]);
+    }, [dispatch]);
+    // 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

@@ -1,9 +1,10 @@
 import { useEffect, useCallback, useRef, useMemo } from "react";
 import { useAppDispatch } from "../store/hooks";
 import { useStore } from "react-redux";
-import { EnumScoutStateStatus, setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiServerProcessingDuration, setHerdModulesApiTotalRequestDuration, setUserApiDuration, setDataProcessingDuration, setCacheLoadDuration, setUser, setDataSource, setDataSourceInfo, } from "../store/scout";
+import { EnumScoutStateStatus, setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiServerProcessingDuration, setHerdModulesApiTotalRequestDuration, setUserApiDuration, setDataProcessingDuration, setCacheLoadDuration, setUser, setDataSource, setDataSourceInfo, setVersionsSoftware, } from "../store/scout";
 import { EnumHerdModulesLoadingState } from "../types/herd_module";
 import { server_load_herd_modules } from "../helpers/herds";
+import { server_get_versions_software } from "../helpers/versions_software";
 import { scoutCache } from "../helpers/cache";
 import { EnumDataSource } from "../types/data_source";
 import { createBrowserClient } from "@supabase/ssr";
@@ -50,158 +51,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 &&
@@ -239,7 +88,10 @@ export function useScoutRefresh(options = {}) {
             if (cacheFirst) {
                 const cacheStartTime = Date.now();
                 try {
-                    const cacheResult = await scoutCache.getHerdModules();
+                    const [cacheResult, versionsCacheResult] = await Promise.all([
+                        scoutCache.getHerdModules(),
+                        scoutCache.getVersionsSoftware(),
+                    ]);
                     cacheLoadDuration = Date.now() - cacheStartTime;
                     timingRefs.current.cacheLoadDuration = cacheLoadDuration;
                     dispatch(setCacheLoadDuration(cacheLoadDuration));
@@ -254,12 +106,14 @@ 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));
+                        // Load cached software versions if available
+                        if (versionsCacheResult.data && !versionsCacheResult.isStale) {
+                            console.log(`[useScoutRefresh] Loaded ${versionsCacheResult.data.length} software versions from cache`);
+                            dispatch(setVersionsSoftware(versionsCacheResult.data));
                         }
                         // If cache is fresh, we still background fetch but don't wait
                         if (!cacheResult.isStale) {
@@ -267,7 +121,7 @@ export function useScoutRefresh(options = {}) {
                             (async () => {
                                 try {
                                     const backgroundStartTime = Date.now();
-                                    const [backgroundHerdModulesResult, backgroundUserResult] = await Promise.all([
+                                    const [backgroundHerdModulesResult, backgroundUserResult, backgroundVersionsResult,] = await Promise.all([
                                         (async () => {
                                             const start = Date.now();
                                             const result = await server_load_herd_modules();
@@ -291,31 +145,61 @@ export function useScoutRefresh(options = {}) {
                                             dispatch(setUserApiDuration(duration));
                                             return { data: data.user, status: "success" };
                                         })(),
+                                        (async () => {
+                                            const start = Date.now();
+                                            const result = await server_get_versions_software();
+                                            const duration = Date.now() - start;
+                                            return { ...result, duration };
+                                        })(),
                                     ]);
                                     const backgroundDuration = Date.now() - backgroundStartTime;
                                     // Validate background responses
-                                    if (backgroundHerdModulesResult.data &&
+                                    if (backgroundHerdModulesResult.status === "success" &&
+                                        backgroundHerdModulesResult.data &&
                                         Array.isArray(backgroundHerdModulesResult.data) &&
                                         backgroundUserResult &&
                                         backgroundUserResult.data) {
                                         // Update cache with fresh data
                                         try {
-                                            await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
+                                            await Promise.all([
+                                                scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs),
+                                                backgroundVersionsResult &&
+                                                    backgroundVersionsResult.status === "success" &&
+                                                    backgroundVersionsResult.data
+                                                    ? scoutCache.setVersionsSoftware(backgroundVersionsResult.data, cacheTtlMs)
+                                                    : Promise.resolve(),
+                                            ]);
                                         }
                                         catch (cacheError) {
                                             console.warn("[useScoutRefresh] Background cache save failed:", cacheError);
                                             await handleIndexedDbError(cacheError, "background cache save", async () => {
+                                                const promises = [];
                                                 if (backgroundHerdModulesResult.data) {
-                                                    await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
+                                                    promises.push(scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs));
+                                                }
+                                                if (backgroundVersionsResult &&
+                                                    backgroundVersionsResult.status === "success" &&
+                                                    backgroundVersionsResult.data) {
+                                                    promises.push(scoutCache.setVersionsSoftware(backgroundVersionsResult.data, cacheTtlMs));
+                                                }
+                                                if (promises.length > 0) {
+                                                    await Promise.all(promises);
                                                 }
                                             });
                                         }
-                                        // 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 software versions if successful
+                                        if (backgroundVersionsResult &&
+                                            backgroundVersionsResult.status === "success" &&
+                                            backgroundVersionsResult.data) {
+                                            console.log(`[useScoutRefresh] Updating store with background software versions`);
+                                            dispatch(setVersionsSoftware(backgroundVersionsResult.data));
                                         }
                                         // Update data source to DATABASE
                                         dispatch(setDataSource(EnumDataSource.DATABASE));
@@ -350,7 +234,7 @@ export function useScoutRefresh(options = {}) {
             }
             // Step 2: Load fresh data from API
             const parallelStartTime = Date.now();
-            const [herdModulesResult, userResult] = await Promise.all([
+            const [herdModulesResult, userResult, versionsResult] = await Promise.all([
                 (async () => {
                     const start = Date.now();
                     const result = await server_load_herd_modules();
@@ -368,6 +252,16 @@ export function useScoutRefresh(options = {}) {
                         start,
                     };
                 })(),
+                (async () => {
+                    const start = Date.now();
+                    const result = await server_get_versions_software();
+                    const duration = Date.now() - start;
+                    return {
+                        result,
+                        duration,
+                        start,
+                    };
+                })(),
             ]);
             const parallelDuration = Date.now() - parallelStartTime;
             console.log(`[useScoutRefresh] Parallel API requests completed in ${parallelDuration}ms`);
@@ -411,7 +305,15 @@ export function useScoutRefresh(options = {}) {
             // Step 3: Update cache with fresh data
             const cacheSaveStartTime = Date.now();
             try {
-                await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
+                const cachePromises = [
+                    scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs),
+                ];
+                // Cache software versions if available
+                if (versionsResult.result.status === "success" &&
+                    versionsResult.result.data) {
+                    cachePromises.push(scoutCache.setVersionsSoftware(versionsResult.result.data, cacheTtlMs));
+                }
+                await Promise.all(cachePromises);
                 const cacheSaveDuration = Date.now() - cacheSaveStartTime;
                 timingRefs.current.cacheSaveDuration = cacheSaveDuration;
                 console.log(`[useScoutRefresh] Cache updated in ${cacheSaveDuration}ms with TTL: ${Math.round(cacheTtlMs / 1000)}s`);
@@ -419,18 +321,30 @@ export function useScoutRefresh(options = {}) {
             catch (cacheError) {
                 console.warn("[useScoutRefresh] Cache save failed:", cacheError);
                 await handleIndexedDbError(cacheError, "cache save", async () => {
-                    await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
+                    const retryPromises = [
+                        scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs),
+                    ];
+                    if (versionsResult.result.status === "success" &&
+                        versionsResult.result.data) {
+                        retryPromises.push(scoutCache.setVersionsSoftware(versionsResult.result.data, cacheTtlMs));
+                    }
+                    await Promise.all(retryPromises);
                 });
             }
             // 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));
+            // Update software versions
+            if (versionsResult.result.status === "success" &&
+                versionsResult.result.data) {
+                console.log(`[useScoutRefresh] Updating store with fresh software versions`);
+                dispatch(setVersionsSoftware(versionsResult.result.data));
             }
+            dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
             const dataProcessingDuration = Date.now() - dataProcessingStartTime;
             timingRefs.current.dataProcessingDuration = dataProcessingDuration;
             dispatch(setDataProcessingDuration(dataProcessingDuration));
@@ -469,7 +383,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/store/scout.d.ts

@@ -1,4 +1,4 @@
-import { IUser } from "../types/db";
+import { IUser, IVersionsSoftware } from "../types/db";
 import { IHerdModule, EnumHerdModulesLoadingState } from "../types/herd_module";
 import { EnumDataSource, IDataSourceInfo } from "../types/data_source";
 import { MapDeviceIdToConnectivity } from "../types/connectivity";
@@ -23,6 +23,7 @@ export interface ScoutState {
     data_source: EnumDataSource;
     data_source_info: IDataSourceInfo | null;
     active_herd_gps_trackers_connectivity: MapDeviceIdToConnectivity;
+    versions_software: IVersionsSoftware[];
 }
 export interface RootState {
     scout: ScoutState;
@@ -172,7 +173,19 @@ export declare const scoutSlice: import("@reduxjs/toolkit").Slice<ScoutState, {
         payload: any;
         type: string;
     }) => void;
+    setVersionsSoftware: (state: import("immer").WritableDraft<ScoutState>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+    upsertVersionSoftware: (state: import("immer").WritableDraft<ScoutState>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+    deleteVersionSoftwareById: (state: import("immer").WritableDraft<ScoutState>, action: {
+        payload: any;
+        type: string;
+    }) => void;
 }, "scout", "scout", import("@reduxjs/toolkit").SliceSelectors<ScoutState>>;
-export declare const setHerdModules: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModules">, setStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setStatus">, setHerdModulesLoadingState: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesLoadingState">, setHerdModulesLoadedInMs: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesLoadedInMs">, setHerdModulesApiServerProcessingDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesApiServerProcessingDuration">, setHerdModulesApiTotalRequestDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesApiTotalRequestDuration">, setUserApiDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setUserApiDuration">, setDataProcessingDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setDataProcessingDuration">, setCacheLoadDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setCacheLoadDuration">, setActiveHerdId: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveHerdId">, setActiveDeviceId: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveDeviceId">, setDataSource: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setDataSource">, setDataSourceInfo: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setDataSourceInfo">, appendEventsToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendEventsToHerdModule">, replaceEventsForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/replaceEventsForHerdModule">, appendArtifactsToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendArtifactsToHerdModule">, replaceArtifactsForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/replaceArtifactsForHerdModule">, updateEventValuesForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateEventValuesForHerdModule">, updatePageIndexForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updatePageIndexForHerdModule">, appendPlansToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendPlansToHerdModule">, setUser: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setUser">, addTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addTag">, deleteTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteTag">, updateTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateTag">, addNewDeviceToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addNewDeviceToHerdModule">, updateDeviceForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateDeviceForHerdModule">, addDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addDevice">, deleteDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteDevice">, updateDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateDevice">, addPlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addPlan">, deletePlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deletePlan">, updatePlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updatePlan">, addSessionToStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addSessionToStore">, deleteSessionFromStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteSessionFromStore">, updateSessionInStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateSessionInStore">, setActiveHerdGpsTrackersConnectivity: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveHerdGpsTrackersConnectivity">;
+export declare const setHerdModules: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModules">, setStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setStatus">, setHerdModulesLoadingState: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesLoadingState">, setHerdModulesLoadedInMs: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesLoadedInMs">, setHerdModulesApiServerProcessingDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesApiServerProcessingDuration">, setHerdModulesApiTotalRequestDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesApiTotalRequestDuration">, setUserApiDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setUserApiDuration">, setDataProcessingDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setDataProcessingDuration">, setCacheLoadDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setCacheLoadDuration">, setActiveHerdId: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveHerdId">, setActiveDeviceId: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveDeviceId">, setDataSource: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setDataSource">, setDataSourceInfo: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setDataSourceInfo">, appendEventsToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendEventsToHerdModule">, replaceEventsForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/replaceEventsForHerdModule">, appendArtifactsToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendArtifactsToHerdModule">, replaceArtifactsForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/replaceArtifactsForHerdModule">, updateEventValuesForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateEventValuesForHerdModule">, updatePageIndexForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updatePageIndexForHerdModule">, appendPlansToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendPlansToHerdModule">, setUser: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setUser">, addTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addTag">, deleteTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteTag">, updateTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateTag">, addNewDeviceToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addNewDeviceToHerdModule">, updateDeviceForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateDeviceForHerdModule">, addDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addDevice">, deleteDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteDevice">, updateDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateDevice">, addPlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addPlan">, deletePlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deletePlan">, updatePlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updatePlan">, addSessionToStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addSessionToStore">, deleteSessionFromStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteSessionFromStore">, updateSessionInStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateSessionInStore">, setActiveHerdGpsTrackersConnectivity: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveHerdGpsTrackersConnectivity">, setVersionsSoftware: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setVersionsSoftware">, upsertVersionSoftware: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/upsertVersionSoftware">, deleteVersionSoftwareById: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteVersionSoftwareById">;
 declare const _default: import("redux").Reducer<ScoutState>;
 export default _default;

package/dist/store/scout.js

@@ -25,6 +25,7 @@ const initialState = {
     data_source: EnumDataSource.UNKNOWN,
     data_source_info: null,
     active_herd_gps_trackers_connectivity: {},
+    versions_software: [],
 };
 export const scoutSlice = createSlice({
     name: "scout",
@@ -284,8 +285,27 @@ export const scoutSlice = createSlice({
         setActiveHerdGpsTrackersConnectivity: (state, action) => {
             state.active_herd_gps_trackers_connectivity = action.payload;
         },
+        setVersionsSoftware: (state, action) => {
+            state.versions_software = action.payload;
+        },
+        upsertVersionSoftware: (state, action) => {
+            const version = action.payload;
+            const existingIndex = state.versions_software.findIndex((v) => v.id === version.id);
+            if (existingIndex !== -1) {
+                // Update existing version
+                state.versions_software[existingIndex] = version;
+            }
+            else {
+                // Add new version
+                state.versions_software = [version, ...state.versions_software];
+            }
+        },
+        deleteVersionSoftwareById: (state, action) => {
+            const versionId = action.payload;
+            state.versions_software = state.versions_software.filter((version) => version.id !== versionId);
+        },
     },
 });
 // Action creators are generated for each case reducer function
-export const { setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiServerProcessingDuration, setHerdModulesApiTotalRequestDuration, setUserApiDuration, setDataProcessingDuration, setCacheLoadDuration, setActiveHerdId, setActiveDeviceId, setDataSource, setDataSourceInfo, appendEventsToHerdModule, replaceEventsForHerdModule, appendArtifactsToHerdModule, replaceArtifactsForHerdModule, updateEventValuesForHerdModule, updatePageIndexForHerdModule, appendPlansToHerdModule, setUser, addTag, deleteTag, updateTag, addNewDeviceToHerdModule, updateDeviceForHerdModule, addDevice, deleteDevice, updateDevice, addPlan, deletePlan, updatePlan, addSessionToStore, deleteSessionFromStore, updateSessionInStore, setActiveHerdGpsTrackersConnectivity, } = scoutSlice.actions;
+export const { setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiServerProcessingDuration, setHerdModulesApiTotalRequestDuration, setUserApiDuration, setDataProcessingDuration, setCacheLoadDuration, setActiveHerdId, setActiveDeviceId, setDataSource, setDataSourceInfo, appendEventsToHerdModule, replaceEventsForHerdModule, appendArtifactsToHerdModule, replaceArtifactsForHerdModule, updateEventValuesForHerdModule, updatePageIndexForHerdModule, appendPlansToHerdModule, setUser, addTag, deleteTag, updateTag, addNewDeviceToHerdModule, updateDeviceForHerdModule, addDevice, deleteDevice, updateDevice, addPlan, deletePlan, updatePlan, addSessionToStore, deleteSessionFromStore, updateSessionInStore, setActiveHerdGpsTrackersConnectivity, setVersionsSoftware, upsertVersionSoftware, deleteVersionSoftwareById, } = scoutSlice.actions;
 export default scoutSlice.reducer;

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.132",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",