@adventurelabs/scout-core 1.1.1 → 1.2.2

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

@@ -6,6 +6,5 @@ export declare function get_versions_software(client: SupabaseClient<Database>):
 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")
@@ -39,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) {
@@ -67,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")
@@ -121,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/index.d.ts

@@ -2,3 +2,7 @@ export { useScoutRefresh, type UseScoutRefreshOptions, } from "./useScoutRefresh
 export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
 export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";
 export { useScoutRealtimeVersionsSoftware } from "./useScoutRealtimeVersionsSoftware";
+export { useScoutRealtimeEvents } from "./useScoutRealtimeEvents";
+export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
+export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
+export { useScoutRealtimePlans } from "./useScoutRealtimePlans";

package/dist/hooks/index.js

@@ -2,3 +2,7 @@ export { useScoutRefresh, } from "./useScoutRefresh";
 export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
 export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";
 export { useScoutRealtimeVersionsSoftware } from "./useScoutRealtimeVersionsSoftware";
+export { useScoutRealtimeEvents } from "./useScoutRealtimeEvents";
+export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
+export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
+export { useScoutRealtimePlans } from "./useScoutRealtimePlans";

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/useScoutRealtimeEvents.d.ts

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

package/dist/hooks/useScoutRealtimeEvents.js

@@ -0,0 +1,96 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { updateEventValuesForHerdModule } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeEvents(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [newEventItems, setNewEventItems] = useState([]);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Event broadcast handler
+    const handleEventBroadcast = useCallback((payload) => {
+        console.log("[Events] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const eventData = data.record || data.old_record;
+        if (!eventData)
+            return;
+        let operation;
+        // TODO: UNCOMMENT GLOBAL STORE OPERATIONS IF OKAY WITH FREQUENT
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record && activeHerdId && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Events] New event received:", data.record);
+                    // For events, we need to update the event values in the herd module
+                    dispatch(updateEventValuesForHerdModule({
+                        herd_id: activeHerdId,
+                        events: [data.record],
+                    }));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record && activeHerdId && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Events] Event updated:", data.record);
+                    dispatch(updateEventValuesForHerdModule({
+                        herd_id: activeHerdId,
+                        events: [data.record],
+                    }));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record &&
+                    activeHerdId &&
+                    shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Events] Event deleted:", data.old_record);
+                    // TODO: WRITE DELETION STORE ACTION
+                    console.log("[Events] Event deletion detected - manual refresh may be needed");
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: eventData,
+            operation,
+        };
+        console.log(`[scout-core realtime] EVENT ${data.operation} received:`, JSON.stringify(realtimeData));
+        setNewEventItems((prev) => [realtimeData, ...prev]);
+    }, [dispatch, activeHerdId]);
+    // Clear new items when herd changes
+    const clearNewItems = useCallback(() => {
+        setNewEventItems([]);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createEventsChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-events`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleEventBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Events] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Events] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous items when switching herds
+        clearNewItems();
+        // Create events channel for active herd
+        if (activeHerdId) {
+            const channel = createEventsChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearNewItems]);
+    return newEventItems;
+}

package/dist/hooks/useScoutRealtimePlans.d.ts

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

package/dist/hooks/useScoutRealtimePlans.js

@@ -0,0 +1,83 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { addPlan, deletePlan, updatePlan } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimePlans(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [newPlanItems, setNewPlanItems] = useState([]);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Plan broadcast handler
+    const handlePlanBroadcast = useCallback((payload) => {
+        console.log("[Plans] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const planData = data.record || data.old_record;
+        if (!planData)
+            return;
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Plans] New plan received:", data.record);
+                    dispatch(addPlan(data.record));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    dispatch(updatePlan(data.record));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
+                    dispatch(deletePlan(data.old_record));
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: planData,
+            operation,
+        };
+        console.log(`[scout-core realtime] PLAN ${data.operation} received:`, JSON.stringify(realtimeData));
+        setNewPlanItems((prev) => [realtimeData, ...prev]);
+    }, [dispatch]);
+    // Clear new items when herd changes
+    const clearNewItems = useCallback(() => {
+        setNewPlanItems([]);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createPlansChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-plans`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handlePlanBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Plans] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Plans] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous items when switching herds
+        clearNewItems();
+        // Create plans channel for active herd
+        if (activeHerdId) {
+            const channel = createPlansChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearNewItems]);
+    return newPlanItems;
+}

package/dist/hooks/useScoutRealtimeSessions.d.ts

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

package/dist/hooks/useScoutRealtimeSessions.js

@@ -0,0 +1,83 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { addSessionToStore, deleteSessionFromStore, updateSessionInStore, } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeSessions(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [newSessionItems, setNewSessionItems] = useState([]);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Session broadcast handler
+    const handleSessionBroadcast = useCallback((payload) => {
+        console.log("[Sessions] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const sessionData = data.record || data.old_record;
+        if (!sessionData)
+            return;
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Sessions] New session received:", data.record);
+                    dispatch(addSessionToStore(data.record));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    dispatch(updateSessionInStore(data.record));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
+                    dispatch(deleteSessionFromStore(data.old_record));
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: sessionData,
+            operation,
+        };
+        console.log(`[scout-core realtime] SESSION ${data.operation} received:`, JSON.stringify(realtimeData));
+        setNewSessionItems((prev) => [realtimeData, ...prev]);
+    }, [dispatch]);
+    // Clear new items when herd changes
+    const clearNewItems = useCallback(() => {
+        setNewSessionItems([]);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createSessionsChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-sessions`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleSessionBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Sessions] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Sessions] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous items when switching herds
+        clearNewItems();
+        // Create sessions channel for active herd
+        if (activeHerdId) {
+            const channel = createSessionsChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearNewItems]);
+    return newSessionItems;
+}

package/dist/hooks/useScoutRealtimeTags.d.ts

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

package/dist/hooks/useScoutRealtimeTags.js

@@ -0,0 +1,85 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { addTag, deleteTag, updateTag } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeTags(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [newTagItems, setNewTagItems] = useState([]);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Tag broadcast handler
+    const handleTagBroadcast = useCallback((payload) => {
+        console.log("[Tags] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const tagData = data.record || data.old_record;
+        if (!tagData)
+            return;
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Tags] New tag received:", data.record);
+                    dispatch(addTag(data.record));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Tags] Tag updated:", data.record);
+                    dispatch(updateTag(data.record));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Tags] Tag deleted:", data.old_record);
+                    dispatch(deleteTag(data.old_record));
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: tagData,
+            operation,
+        };
+        console.log(`[scout-core realtime] TAG ${data.operation} received:`, JSON.stringify(realtimeData));
+        setNewTagItems((prev) => [realtimeData, ...prev]);
+    }, [dispatch]);
+    // Clear new items when herd changes
+    const clearNewItems = useCallback(() => {
+        setNewTagItems([]);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createTagsChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-tags`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleTagBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Tags] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Tags] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous items when switching herds
+        clearNewItems();
+        // Create tags channel for active herd
+        if (activeHerdId) {
+            const channel = createTagsChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearNewItems]);
+    return newTagItems;
+}

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 { 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,19 +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 immediately 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 {
-                                    console.log("[useScoutRefresh] Starting background parallel API calls: herd modules, user, software versions");
                                     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();
@@ -146,45 +136,25 @@ export function useScoutRefresh(options = {}) {
                                             dispatch(setUserApiDuration(duration));
                                             return { data: data.user, status: "success" };
                                         })(),
-                                        (async () => {
-                                            const start = Date.now();
-                                            const result = await get_versions_software(supabase);
-                                            const duration = Date.now() - start;
-                                            return { ...result, duration };
-                                        })(),
                                     ]);
                                     const backgroundDuration = Date.now() - backgroundStartTime;
-                                    console.log(`[useScoutRefresh] Background parallel API calls completed in ${backgroundDuration}ms (herd modules, user, software versions)`);
                                     // Validate background responses
-                                    if (backgroundHerdModulesResult.status === "success" &&
-                                        backgroundHerdModulesResult.data &&
+                                    if (backgroundHerdModulesResult.data &&
                                         Array.isArray(backgroundHerdModulesResult.data) &&
                                         backgroundUserResult &&
                                         backgroundUserResult.data) {
-                                        // Update cache with fresh herd modules data
+                                        // Update cache with fresh data
                                         try {
                                             await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
                                         }
                                         catch (cacheError) {
-                                            console.warn("[useScoutRefresh] Background herd modules cache save failed:", cacheError);
+                                            console.warn("[useScoutRefresh] Background cache save failed:", cacheError);
                                             await handleIndexedDbError(cacheError, "background cache save", async () => {
                                                 if (backgroundHerdModulesResult.data) {
                                                     await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
                                                 }
                                             });
                                         }
-                                        // Update cache with fresh software versions separately
-                                        if (backgroundVersionsResult &&
-                                            backgroundVersionsResult.status === "success" &&
-                                            backgroundVersionsResult.data) {
-                                            try {
-                                                await scoutCache.setVersionsSoftware(backgroundVersionsResult.data, cacheTtlMs);
-                                                console.log(`[useScoutRefresh] Background cached ${backgroundVersionsResult.data.length} software versions`);
-                                            }
-                                            catch (versionsCacheError) {
-                                                console.warn("[useScoutRefresh] Background software versions cache save failed:", versionsCacheError);
-                                            }
-                                        }
                                         // Update store with fresh data from background request
                                         console.log(`[useScoutRefresh] Updating store with background herd modules`);
                                         dispatch(setHerdModules(backgroundHerdModulesResult.data));
@@ -192,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({
@@ -230,10 +193,9 @@ export function useScoutRefresh(options = {}) {
                     // Continue with API call
                 }
             }
-            // Step 2: Load fresh data from API (herd modules, user, and software versions in parallel)
-            console.log("[useScoutRefresh] Starting parallel API calls: herd modules, user, software versions");
+            // 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();
@@ -251,19 +213,9 @@ export function useScoutRefresh(options = {}) {
                         start,
                     };
                 })(),
-                (async () => {
-                    const start = Date.now();
-                    const result = await get_versions_software(supabase);
-                    const duration = Date.now() - start;
-                    return {
-                        result,
-                        duration,
-                        start,
-                    };
-                })(),
             ]);
             const parallelDuration = Date.now() - parallelStartTime;
-            console.log(`[useScoutRefresh] Parallel API calls completed in ${parallelDuration}ms (herd modules, user, software versions)`);
+            console.log(`[useScoutRefresh] Parallel API requests completed in ${parallelDuration}ms`);
             // Extract results and timing
             const herdModulesResponse = herdModulesResult.result;
             const res_new_user = userResult.result;
@@ -305,23 +257,12 @@ export function useScoutRefresh(options = {}) {
             const cacheSaveStartTime = Date.now();
             try {
                 await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
-                // Cache software versions separately
-                if (versionsResult.result.status === "success" &&
-                    versionsResult.result.data) {
-                    try {
-                        await scoutCache.setVersionsSoftware(versionsResult.result.data, cacheTtlMs);
-                        console.log(`[useScoutRefresh] Cached ${versionsResult.result.data.length} software versions`);
-                    }
-                    catch (versionsCacheError) {
-                        console.warn("[useScoutRefresh] Failed to cache software versions:", versionsCacheError);
-                    }
-                }
                 const cacheSaveDuration = Date.now() - cacheSaveStartTime;
                 timingRefs.current.cacheSaveDuration = cacheSaveDuration;
                 console.log(`[useScoutRefresh] Cache updated in ${cacheSaveDuration}ms with TTL: ${Math.round(cacheTtlMs / 1000)}s`);
             }
             catch (cacheError) {
-                console.warn("[useScoutRefresh] Herd modules cache save failed:", cacheError);
+                console.warn("[useScoutRefresh] Cache save failed:", cacheError);
                 await handleIndexedDbError(cacheError, "cache save", async () => {
                     await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
                 });
@@ -333,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/index.d.ts

@@ -41,6 +41,10 @@ export * from "./helpers/components";
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
 export * from "./hooks/useScoutRealtimeVersionsSoftware";
+export * from "./hooks/useScoutRealtimeEvents";
+export * from "./hooks/useScoutRealtimeTags";
+export * from "./hooks/useScoutRealtimeSessions";
+export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRefresh";
 export * from "./providers";
 export * from "./store/scout";

package/dist/index.js

@@ -45,6 +45,10 @@ export * from "./helpers/components";
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
 export * from "./hooks/useScoutRealtimeVersionsSoftware";
+export * from "./hooks/useScoutRealtimeEvents";
+export * from "./hooks/useScoutRealtimeTags";
+export * from "./hooks/useScoutRealtimeSessions";
+export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRefresh";
 // Providers
 export * from "./providers";

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