@adventurelabs/scout-core 1.0.133 → 1.2.1

package/dist/helpers/cache.d.ts

@@ -1,5 +1,4 @@
 import { IHerdModule } from "../types/herd_module";
-import { IVersionsSoftware } from "../types/db";
 export interface CacheMetadata {
     key: string;
     timestamp: number;
@@ -46,7 +45,6 @@ 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>;
@@ -60,8 +58,5 @@ 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,11 +1,9 @@
 const DB_NAME = "ScoutCache";
-const DB_VERSION = 3; // Increment to invalidate old cache versions
-const CACHE_VERSION = "3.0.0"; // Cache metadata version string
+const DB_VERSION = 4; // Increment to invalidate old cache versions
 const HERD_MODULES_STORE = "herd_modules";
 const CACHE_METADATA_STORE = "cache_metadata";
-const VERSIONS_SOFTWARE_STORE = "versions_software";
-// Default TTL: 24 hours (2 days)
-const DEFAULT_TTL_MS = 2 * 24 * 60 * 60 * 1000;
+// Default TTL: 24 hours (1 day)
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 export class ScoutCache {
     constructor() {
         this.db = null;
@@ -63,17 +61,6 @@ 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) {
@@ -92,17 +79,13 @@ 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");
         }
-        if (!hasVersionsSoftwareStore) {
-            console.error("[ScoutCache] Missing versions_software object store");
-        }
-        return hasHerdModulesStore && hasMetadataStore && hasVersionsSoftwareStore;
+        return hasHerdModulesStore && hasMetadataStore;
     }
     async setHerdModules(herdModules, ttlMs = DEFAULT_TTL_MS, etag) {
         await this.init();
@@ -118,7 +101,7 @@ export class ScoutCache {
             const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
             const timestamp = Date.now();
-            const version = CACHE_VERSION;
+            const version = "2.0.0";
             // Store each herd module (contains all nested data - devices, events, zones, etc.)
             herdModules.forEach((herdModule) => {
                 const cacheEntry = {
@@ -238,21 +221,6 @@ 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;
@@ -397,135 +365,6 @@ 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,10 +3,8 @@ 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,5 +1,4 @@
 import { IWebResponse } from "../types/requests";
-import { scoutCache } from "./cache";
 export async function get_versions_software(client) {
     const { data, error } = await client
         .from("versions_software")
@@ -13,35 +12,6 @@ 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")
@@ -68,14 +38,6 @@ 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) {
@@ -96,47 +58,8 @@ 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")
@@ -150,14 +73,6 @@ 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/useScoutRealtimeConnectivity.js

@@ -44,7 +44,7 @@ export function useScoutRealtimeConnectivity(scoutSupabase) {
             default:
                 return;
         }
-        console.log(`[CONNECTIVITY] ${data.operation} received for device ${connectivityData.device_id}:`, JSON.stringify(connectivityData));
+        console.log(`[scout-core realtime] CONNECTIVITY ${data.operation} received for device ${connectivityData.device_id}:`, JSON.stringify(connectivityData));
         const realtimeData = {
             data: connectivityData,
             operation,

package/dist/hooks/useScoutRealtimeDevices.js

@@ -28,14 +28,12 @@ export function useScoutRealtimeDevices(scoutSupabase) {
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
                 if (data.record) {
-                    console.log("[Devices] Device updated:", data.record);
                     dispatch(updateDevice(data.record));
                 }
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
                 if (data.old_record) {
-                    console.log("[Devices] Device deleted:", data.old_record);
                     dispatch(deleteDevice(data.old_record));
                 }
                 break;
@@ -46,6 +44,7 @@ export function useScoutRealtimeDevices(scoutSupabase) {
             data: deviceData,
             operation,
         };
+        console.log(`[scout-core realtime] DEVICE ${data.operation} received:`, JSON.stringify(realtimeData));
         setNewDeviceItems((prev) => [realtimeData, ...prev]);
     }, [dispatch]);
     // Clear new items when herd changes

package/dist/hooks/useScoutRealtimeVersionsSoftware.js

@@ -1,52 +1,37 @@
 "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 { event, payload: data } = payload;
         const versionData = data.record || data.old_record;
-        if (!versionData)
+        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) {
-                    console.log("[VersionsSoftware] Version updated:", data.record);
-                    dispatch(upsertVersionSoftware(data.record));
-                }
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record) {
-                    console.log("[VersionsSoftware] Version deleted:", 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));
+        console.log(`[scout-core realtime] 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([]);

package/dist/hooks/useScoutRefresh.js

@@ -1,10 +1,9 @@
 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, setVersionsSoftware, } from "../store/scout";
+import { EnumScoutStateStatus, setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiServerProcessingDuration, setHerdModulesApiTotalRequestDuration, setUserApiDuration, setDataProcessingDuration, setCacheLoadDuration, setUser, setDataSource, setDataSourceInfo, } 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";
@@ -88,10 +87,7 @@ export function useScoutRefresh(options = {}) {
             if (cacheFirst) {
                 const cacheStartTime = Date.now();
                 try {
-                    const [cacheResult, versionsCacheResult] = await Promise.all([
-                        scoutCache.getHerdModules(),
-                        scoutCache.getVersionsSoftware(),
-                    ]);
+                    const cacheResult = await scoutCache.getHerdModules();
                     cacheLoadDuration = Date.now() - cacheStartTime;
                     timingRefs.current.cacheLoadDuration = cacheLoadDuration;
                     dispatch(setCacheLoadDuration(cacheLoadDuration));
@@ -110,18 +106,13 @@ export function useScoutRefresh(options = {}) {
                         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) {
                             // Background fetch fresh data without blocking
                             (async () => {
                                 try {
                                     const backgroundStartTime = Date.now();
-                                    const [backgroundHerdModulesResult, backgroundUserResult, backgroundVersionsResult,] = await Promise.all([
+                                    const [backgroundHerdModulesResult, backgroundUserResult] = await Promise.all([
                                         (async () => {
                                             const start = Date.now();
                                             const result = await server_load_herd_modules();
@@ -145,45 +136,22 @@ 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.status === "success" &&
-                                        backgroundHerdModulesResult.data &&
+                                    if (backgroundHerdModulesResult.data &&
                                         Array.isArray(backgroundHerdModulesResult.data) &&
                                         backgroundUserResult &&
                                         backgroundUserResult.data) {
                                         // Update cache with fresh data
                                         try {
-                                            await Promise.all([
-                                                scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs),
-                                                backgroundVersionsResult &&
-                                                    backgroundVersionsResult.status === "success" &&
-                                                    backgroundVersionsResult.data
-                                                    ? scoutCache.setVersionsSoftware(backgroundVersionsResult.data, cacheTtlMs)
-                                                    : Promise.resolve(),
-                                            ]);
+                                            await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
                                         }
                                         catch (cacheError) {
                                             console.warn("[useScoutRefresh] Background cache save failed:", cacheError);
                                             await handleIndexedDbError(cacheError, "background cache save", async () => {
-                                                const promises = [];
                                                 if (backgroundHerdModulesResult.data) {
-                                                    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);
+                                                    await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
                                                 }
                                             });
                                         }
@@ -194,13 +162,6 @@ export function useScoutRefresh(options = {}) {
                                             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));
                                         dispatch(setDataSourceInfo({
@@ -234,7 +195,7 @@ export function useScoutRefresh(options = {}) {
             }
             // Step 2: Load fresh data from API
             const parallelStartTime = Date.now();
-            const [herdModulesResult, userResult, versionsResult] = await Promise.all([
+            const [herdModulesResult, userResult] = await Promise.all([
                 (async () => {
                     const start = Date.now();
                     const result = await server_load_herd_modules();
@@ -252,16 +213,6 @@ 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`);
@@ -305,15 +256,7 @@ export function useScoutRefresh(options = {}) {
             // Step 3: Update cache with fresh data
             const cacheSaveStartTime = Date.now();
             try {
-                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);
+                await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
                 const cacheSaveDuration = Date.now() - cacheSaveStartTime;
                 timingRefs.current.cacheSaveDuration = cacheSaveDuration;
                 console.log(`[useScoutRefresh] Cache updated in ${cacheSaveDuration}ms with TTL: ${Math.round(cacheTtlMs / 1000)}s`);
@@ -321,14 +264,7 @@ export function useScoutRefresh(options = {}) {
             catch (cacheError) {
                 console.warn("[useScoutRefresh] Cache save failed:", cacheError);
                 await handleIndexedDbError(cacheError, "cache save", async () => {
-                    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);
+                    await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
                 });
             }
             // Step 4: Conditionally update store with fresh data, skip timestamp-only changes
@@ -338,12 +274,6 @@ export function useScoutRefresh(options = {}) {
             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;

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -1389,6 +1389,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
             frequency_hz: number | null;
             bandwidth_hz: number | null;
             associated_station: string | null;
+            mode: string | null;
         };
         device_heartbeat_analysis: {
             device_id: number | null;

package/dist/store/scout.d.ts

@@ -1,4 +1,4 @@
-import { IUser, IVersionsSoftware } from "../types/db";
+import { IUser } from "../types/db";
 import { IHerdModule, EnumHerdModulesLoadingState } from "../types/herd_module";
 import { EnumDataSource, IDataSourceInfo } from "../types/data_source";
 import { MapDeviceIdToConnectivity } from "../types/connectivity";
@@ -23,7 +23,6 @@ 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;
@@ -173,19 +172,7 @@ 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">, setVersionsSoftware: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setVersionsSoftware">, upsertVersionSoftware: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/upsertVersionSoftware">, deleteVersionSoftwareById: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteVersionSoftwareById">;
+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">;
 declare const _default: import("redux").Reducer<ScoutState>;
 export default _default;

package/dist/store/scout.js

@@ -25,7 +25,6 @@ const initialState = {
     data_source: EnumDataSource.UNKNOWN,
     data_source_info: null,
     active_herd_gps_trackers_connectivity: {},
-    versions_software: [],
 };
 export const scoutSlice = createSlice({
     name: "scout",
@@ -285,27 +284,8 @@ 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, setVersionsSoftware, upsertVersionSoftware, deleteVersionSoftwareById, } = 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, } = scoutSlice.actions;
 export default scoutSlice.reducer;

package/dist/types/supabase.d.ts

@@ -1441,6 +1441,7 @@ export type Database = {
                 frequency_hz: number | null;
                 bandwidth_hz: number | null;
                 associated_station: string | null;
+                mode: string | null;
             };
             device_heartbeat_analysis: {
                 device_id: number | null;

package/package.json

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