@adventurelabs/scout-core 1.0.84 → 1.0.86

package/dist/helpers/cache.d.ts

@@ -4,6 +4,7 @@ export interface CacheMetadata {
     timestamp: number;
     ttl: number;
     version: string;
+    dbVersion: number;
     etag?: string;
     lastModified?: number;
 }
@@ -30,11 +31,16 @@ export interface TimingStats {
     dataProcessing: number;
     localStorage: number;
 }
+export interface DatabaseHealth {
+    healthy: boolean;
+    issues: string[];
+}
 export declare class ScoutCache {
     private db;
     private initPromise;
     private stats;
     private init;
+    private validateDatabaseSchema;
     setHerdModules(herdModules: IHerdModule[], ttlMs?: number, etag?: string): Promise<void>;
     getHerdModules(): Promise<CacheResult<IHerdModule[]>>;
     clearHerdModules(): Promise<void>;
@@ -48,5 +54,9 @@ export declare class ScoutCache {
     }>;
     preloadCache(loadFunction: () => Promise<IHerdModule[]>, ttlMs?: number): Promise<void>;
     getDefaultTtl(): number;
+    getCurrentDbVersion(): number;
+    isCacheVersionCompatible(): Promise<boolean>;
+    resetDatabase(): Promise<void>;
+    checkDatabaseHealth(): Promise<DatabaseHealth>;
 }
 export declare const scoutCache: ScoutCache;

package/dist/helpers/cache.js

@@ -1,5 +1,5 @@
 const DB_NAME = "ScoutCache";
-const DB_VERSION = 1;
+const DB_VERSION = 2; // Increment to invalidate old cache versions
 const HERD_MODULES_STORE = "herd_modules";
 const CACHE_METADATA_STORE = "cache_metadata";
 // Default TTL: 24 hours (1 day)
@@ -22,39 +22,78 @@ export class ScoutCache {
             const request = indexedDB.open(DB_NAME, DB_VERSION);
             request.onerror = () => {
                 console.error("[ScoutCache] Failed to open IndexedDB:", request.error);
+                this.db = null;
+                this.initPromise = null;
                 reject(request.error);
             };
             request.onsuccess = () => {
                 this.db = request.result;
                 console.log("[ScoutCache] IndexedDB initialized successfully");
+                // Add error handler for runtime database errors
+                this.db.onerror = (event) => {
+                    console.error("[ScoutCache] Database error:", event);
+                };
                 resolve();
             };
             request.onupgradeneeded = (event) => {
                 const db = event.target.result;
-                // Create herd modules store
-                if (!db.objectStoreNames.contains(HERD_MODULES_STORE)) {
+                try {
+                    console.log(`[ScoutCache] Upgrading database to version ${DB_VERSION}`);
+                    // Remove all existing object stores to ensure clean slate
+                    const existingStores = Array.from(db.objectStoreNames);
+                    for (const storeName of existingStores) {
+                        console.log(`[ScoutCache] Removing existing object store: ${storeName}`);
+                        db.deleteObjectStore(storeName);
+                    }
+                    // Create herd modules store (unified storage for all herd data)
                     const herdModulesStore = db.createObjectStore(HERD_MODULES_STORE, {
                         keyPath: "herdId",
                     });
                     herdModulesStore.createIndex("timestamp", "timestamp", {
                         unique: false,
                     });
-                }
-                // Create cache metadata store
-                if (!db.objectStoreNames.contains(CACHE_METADATA_STORE)) {
+                    herdModulesStore.createIndex("dbVersion", "dbVersion", {
+                        unique: false,
+                    });
+                    console.log("[ScoutCache] Created herd_modules object store");
+                    // Create cache metadata store
                     const metadataStore = db.createObjectStore(CACHE_METADATA_STORE, {
                         keyPath: "key",
                     });
+                    console.log("[ScoutCache] Created cache_metadata object store");
+                    console.log(`[ScoutCache] Database schema upgrade to version ${DB_VERSION} completed`);
+                }
+                catch (error) {
+                    console.error("[ScoutCache] Error during database upgrade:", error);
+                    reject(error);
                 }
-                console.log("[ScoutCache] Database schema upgraded");
+            };
+            request.onblocked = () => {
+                console.warn("[ScoutCache] Database upgrade blocked - other connections may need to be closed");
             };
         });
         return this.initPromise;
     }
+    validateDatabaseSchema() {
+        if (!this.db)
+            return false;
+        const hasHerdModulesStore = this.db.objectStoreNames.contains(HERD_MODULES_STORE);
+        const hasMetadataStore = this.db.objectStoreNames.contains(CACHE_METADATA_STORE);
+        if (!hasHerdModulesStore) {
+            console.error("[ScoutCache] Missing herd_modules object store");
+        }
+        if (!hasMetadataStore) {
+            console.error("[ScoutCache] Missing cache_metadata object store");
+        }
+        return hasHerdModulesStore && hasMetadataStore;
+    }
     async setHerdModules(herdModules, 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([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
@@ -62,13 +101,14 @@ export class ScoutCache {
             const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
             const timestamp = Date.now();
-            const version = "1.0.0";
-            // Store each herd module
+            const version = "2.0.0";
+            // Store each herd module (contains all nested data - devices, events, zones, etc.)
             herdModules.forEach((herdModule) => {
                 const cacheEntry = {
                     herdId: herdModule.herd.id.toString(),
                     data: herdModule,
                     timestamp,
+                    dbVersion: DB_VERSION,
                 };
                 herdModulesStore.put(cacheEntry);
             });
@@ -78,6 +118,7 @@ export class ScoutCache {
                 timestamp,
                 ttl: ttlMs,
                 version,
+                dbVersion: DB_VERSION,
                 etag,
                 lastModified: timestamp,
             };
@@ -88,6 +129,9 @@ export class ScoutCache {
         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([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readonly");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
@@ -103,6 +147,17 @@ export class ScoutCache {
                     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] Cache from incompatible DB version (${metadata.dbVersion || "unknown"} !== ${DB_VERSION}), invalidating`);
+                    this.stats.misses++;
+                    // Clear old cache asynchronously
+                    this.clearHerdModules().catch((error) => {
+                        console.warn("[ScoutCache] Failed to clear old cache:", error);
+                    });
+                    resolve({ data: null, isStale: true, age: 0, metadata: null });
+                    return;
+                }
                 const age = now - metadata.timestamp;
                 const isStale = age > metadata.ttl;
                 // Get all herd modules
@@ -110,7 +165,10 @@ export class ScoutCache {
                 getAllRequest.onsuccess = () => {
                     const cacheEntries = getAllRequest.result;
                     const herdModules = cacheEntries
-                        .filter((entry) => entry.data && entry.data.herd && entry.data.herd.slug)
+                        .filter((entry) => entry.data &&
+                        entry.data.herd &&
+                        entry.data.herd.slug &&
+                        entry.dbVersion === DB_VERSION)
                         .map((entry) => entry.data)
                         .sort((a, b) => (a.herd?.slug || "").localeCompare(b.herd?.slug || ""));
                     // Update stats
@@ -134,6 +192,9 @@ export class ScoutCache {
         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([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
@@ -148,12 +209,16 @@ export class ScoutCache {
         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("herd_modules");
+            metadataStore.delete("providers");
         });
     }
     async getCacheStats() {
@@ -180,7 +245,6 @@ export class ScoutCache {
         const result = await this.getHerdModules();
         return result.age;
     }
-    // Method to check if we should refresh based on various conditions
     async shouldRefresh(maxAgeMs, forceRefresh) {
         if (forceRefresh) {
             return { shouldRefresh: true, reason: "Force refresh requested" };
@@ -189,6 +253,15 @@ export class ScoutCache {
         if (!result.data || result.data.length === 0) {
             return { shouldRefresh: true, reason: "No cached data" };
         }
+        // Check for DB version mismatch
+        if (!result.metadata ||
+            !result.metadata.dbVersion ||
+            result.metadata.dbVersion !== DB_VERSION) {
+            return {
+                shouldRefresh: true,
+                reason: `Cache from incompatible DB version (${result.metadata?.dbVersion || "unknown"} !== ${DB_VERSION})`,
+            };
+        }
         if (result.isStale) {
             return { shouldRefresh: true, reason: "Cache is stale" };
         }
@@ -200,7 +273,6 @@ export class ScoutCache {
         }
         return { shouldRefresh: false, reason: "Cache is valid and fresh" };
     }
-    // Method to preload cache with background refresh
     async preloadCache(loadFunction, ttlMs = DEFAULT_TTL_MS) {
         try {
             console.log("[ScoutCache] Starting background cache preload...");
@@ -214,10 +286,85 @@ export class ScoutCache {
             console.warn("[ScoutCache] Background preload failed:", error);
         }
     }
-    // Get the default TTL value
     getDefaultTtl() {
         return DEFAULT_TTL_MS;
     }
+    getCurrentDbVersion() {
+        return DB_VERSION;
+    }
+    async isCacheVersionCompatible() {
+        try {
+            const result = await this.getHerdModules();
+            if (!result.metadata)
+                return false;
+            return (result.metadata.dbVersion !== undefined &&
+                result.metadata.dbVersion === DB_VERSION);
+        }
+        catch (error) {
+            console.warn("[ScoutCache] Version compatibility check failed:", error);
+            return false;
+        }
+    }
+    async resetDatabase() {
+        console.log("[ScoutCache] Resetting database...");
+        // Close existing connection
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+        this.initPromise = null;
+        // Delete the database
+        return new Promise((resolve, reject) => {
+            const deleteRequest = indexedDB.deleteDatabase(DB_NAME);
+            deleteRequest.onsuccess = () => {
+                console.log("[ScoutCache] Database reset successfully");
+                resolve();
+            };
+            deleteRequest.onerror = () => {
+                console.error("[ScoutCache] Failed to reset database:", deleteRequest.error);
+                reject(deleteRequest.error);
+            };
+            deleteRequest.onblocked = () => {
+                console.warn("[ScoutCache] Database reset blocked - close all other tabs");
+                // Continue anyway, it will resolve when unblocked
+            };
+        });
+    }
+    async checkDatabaseHealth() {
+        const issues = [];
+        try {
+            await this.init();
+            if (!this.db) {
+                issues.push("Database connection not established");
+                return { healthy: false, issues };
+            }
+            if (!this.validateDatabaseSchema()) {
+                issues.push("Database schema validation failed");
+            }
+            // Check version compatibility
+            const isVersionCompatible = await this.isCacheVersionCompatible();
+            if (!isVersionCompatible) {
+                issues.push(`Cache version incompatible (current: ${DB_VERSION})`);
+            }
+            // Try a simple read operation
+            try {
+                const result = await this.getHerdModules();
+                if (result.data === null && result.age === 0) {
+                    // This is expected for empty cache, not an error
+                }
+            }
+            catch (error) {
+                issues.push(`Read operation failed: ${error}`);
+            }
+        }
+        catch (error) {
+            issues.push(`Database initialization failed: ${error}`);
+        }
+        return {
+            healthy: issues.length === 0,
+            issues,
+        };
+    }
 }
 // Singleton instance
 export const scoutCache = new ScoutCache();

package/dist/hooks/useScoutRefresh.d.ts

@@ -1,4 +1,4 @@
-import { CacheStats, TimingStats } from "../helpers/cache";
+import { CacheStats, TimingStats, DatabaseHealth } from "../helpers/cache";
 export interface UseScoutRefreshOptions {
     autoRefresh?: boolean;
     onRefreshComplete?: () => void;
@@ -41,4 +41,8 @@ export declare function useScoutRefresh(options?: UseScoutRefreshOptions): {
     getTimingStats: () => TimingStats;
     clearCache: () => Promise<void>;
     getCacheStats: () => Promise<CacheStats>;
+    checkDatabaseHealth: () => Promise<DatabaseHealth>;
+    resetDatabase: () => Promise<void>;
+    isCacheVersionCompatible: () => Promise<boolean>;
+    getCurrentDbVersion: () => number;
 };

package/dist/hooks/useScoutRefresh.js

@@ -4,7 +4,7 @@ import { EnumScoutStateStatus, setActiveHerdId, setHerdModules, setStatus, setHe
 import { EnumHerdModulesLoadingState } from "../types/herd_module";
 import { server_load_herd_modules } from "../helpers/herds";
 import { server_get_user } from "../helpers/users";
-import { scoutCache } from "../helpers/cache";
+import { scoutCache, } from "../helpers/cache";
 import { EnumDataSource } from "../types/data_source";
 /**
  * Hook for refreshing scout data with detailed timing measurements and cache-first loading
@@ -107,7 +107,7 @@ export function useScoutRefresh(options = {}) {
                                     const backgroundStartTime = Date.now();
                                     const [backgroundHerdModulesResult, backgroundUserResult] = await Promise.all([
                                         server_load_herd_modules(),
-                                        server_get_user()
+                                        server_get_user(),
                                     ]);
                                     const backgroundDuration = Date.now() - backgroundStartTime;
                                     console.log(`[useScoutRefresh] Background fetch completed in ${backgroundDuration}ms`);
@@ -123,6 +123,21 @@ export function useScoutRefresh(options = {}) {
                                         }
                                         catch (cacheError) {
                                             console.warn("[useScoutRefresh] Background cache save failed:", cacheError);
+                                            // If it's an IndexedDB object store error, try to reset the database
+                                            if (cacheError instanceof Error &&
+                                                (cacheError.message.includes("object store") ||
+                                                    cacheError.message.includes("NotFoundError"))) {
+                                                console.log("[useScoutRefresh] Attempting database reset due to schema error...");
+                                                try {
+                                                    await scoutCache.resetDatabase();
+                                                    console.log("[useScoutRefresh] Database reset successful, retrying cache save...");
+                                                    await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
+                                                    console.log("[useScoutRefresh] Cache save successful after database reset");
+                                                }
+                                                catch (resetError) {
+                                                    console.error("[useScoutRefresh] Database reset and retry failed:", resetError);
+                                                }
+                                            }
                                         }
                                         // Update store with fresh data
                                         dispatch(setHerdModules(backgroundHerdModulesResult.data));
@@ -157,6 +172,19 @@ export function useScoutRefresh(options = {}) {
                 }
                 catch (cacheError) {
                     console.warn("[useScoutRefresh] Cache load failed:", cacheError);
+                    // If it's an IndexedDB object store error, try to reset the database
+                    if (cacheError instanceof Error &&
+                        (cacheError.message.includes("object store") ||
+                            cacheError.message.includes("NotFoundError"))) {
+                        console.log("[useScoutRefresh] Attempting database reset due to cache load error...");
+                        try {
+                            await scoutCache.resetDatabase();
+                            console.log("[useScoutRefresh] Database reset successful");
+                        }
+                        catch (resetError) {
+                            console.error("[useScoutRefresh] Database reset failed:", resetError);
+                        }
+                    }
                     // Continue with API call
                 }
             }
@@ -223,6 +251,21 @@ export function useScoutRefresh(options = {}) {
             }
             catch (cacheError) {
                 console.warn("[useScoutRefresh] Cache save failed:", cacheError);
+                // If it's an IndexedDB object store error, try to reset the database
+                if (cacheError instanceof Error &&
+                    (cacheError.message.includes("object store") ||
+                        cacheError.message.includes("NotFoundError"))) {
+                    console.log("[useScoutRefresh] Attempting database reset due to cache save error...");
+                    try {
+                        await scoutCache.resetDatabase();
+                        console.log("[useScoutRefresh] Database reset successful, retrying cache save...");
+                        await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
+                        console.log("[useScoutRefresh] Cache save successful after database reset");
+                    }
+                    catch (resetError) {
+                        console.error("[useScoutRefresh] Database reset and retry failed:", resetError);
+                    }
+                }
             }
             // Step 4: Update store with fresh data
             const dataProcessingStartTime = Date.now();
@@ -345,10 +388,52 @@ export function useScoutRefresh(options = {}) {
             };
         }
     }, []);
+    // Utility function to check database health
+    const checkDatabaseHealth = useCallback(async () => {
+        try {
+            return await scoutCache.checkDatabaseHealth();
+        }
+        catch (error) {
+            console.error("[useScoutRefresh] Failed to check database health:", error);
+            return {
+                healthy: false,
+                issues: [`Health check failed: ${error}`],
+            };
+        }
+    }, []);
+    // Utility function to reset database
+    const resetDatabase = useCallback(async () => {
+        try {
+            await scoutCache.resetDatabase();
+            console.log("[useScoutRefresh] Database reset successfully");
+        }
+        catch (error) {
+            console.error("[useScoutRefresh] Failed to reset database:", error);
+            throw error;
+        }
+    }, []);
+    // Utility function to check cache version compatibility
+    const isCacheVersionCompatible = useCallback(async () => {
+        try {
+            return await scoutCache.isCacheVersionCompatible();
+        }
+        catch (error) {
+            console.error("[useScoutRefresh] Failed to check cache version compatibility:", error);
+            return false;
+        }
+    }, []);
+    // Utility function to get current DB version
+    const getCurrentDbVersion = useCallback(() => {
+        return scoutCache.getCurrentDbVersion();
+    }, []);
     return {
         handleRefresh,
         getTimingStats,
         clearCache,
         getCacheStats,
+        checkDatabaseHealth,
+        resetDatabase,
+        isCacheVersionCompatible,
+        getCurrentDbVersion,
     };
 }

package/dist/index.d.ts

@@ -30,6 +30,7 @@ export * from "./helpers/web";
 export * from "./helpers/zones";
 export * from "./helpers/storage";
 export * from "./helpers/eventUtils";
+export * from "./helpers/cache";
 export * from "./hooks/useScoutDbListener";
 export * from "./hooks/useScoutRefresh";
 export * from "./providers";

package/dist/index.js

@@ -33,6 +33,7 @@ export * from "./helpers/web";
 export * from "./helpers/zones";
 export * from "./helpers/storage";
 export * from "./helpers/eventUtils";
+export * from "./helpers/cache";
 // Hooks
 export * from "./hooks/useScoutDbListener";
 export * from "./hooks/useScoutRefresh";

package/dist/types/db.d.ts

@@ -22,6 +22,7 @@ export type IHerd = Database["public"]["Tables"]["herds"]["Row"];
 export type ISession = Database["public"]["Tables"]["sessions"]["Row"];
 export type IConnectivity = Database["public"]["Tables"]["connectivity"]["Row"];
 export type IHeartbeat = Database["public"]["Tables"]["heartbeats"]["Row"];
+export type IProvider = Database["public"]["Tables"]["providers"]["Row"];
 export type IEventWithTags = Database["public"]["CompositeTypes"]["event_with_tags"] & {
     earthranger_url: string | null;
     file_path: string | null;

package/dist/types/herd_module.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
+import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IProvider, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
 import { EnumWebResponse } from "./requests";
 export declare enum EnumHerdModulesLoadingState {
     NOT_LOADING = "NOT_LOADING",
@@ -21,7 +21,8 @@ export declare class HerdModule {
     labels: string[];
     plans: IPlan[];
     layers: ILayer[];
-    constructor(herd: IHerd, devices: IDevice[], events: IEventWithTags[], timestamp_last_refreshed: number, user_roles?: IUserAndRole[] | null, events_page_index?: number, total_events?: number, total_events_with_filters?: number, labels?: string[], plans?: IPlan[], zones?: IZoneWithActions[], sessions?: ISessionWithCoordinates[], layers?: ILayer[]);
+    providers: IProvider[];
+    constructor(herd: IHerd, devices: IDevice[], events: IEventWithTags[], timestamp_last_refreshed: number, user_roles?: IUserAndRole[] | null, events_page_index?: number, total_events?: number, total_events_with_filters?: number, labels?: string[], plans?: IPlan[], zones?: IZoneWithActions[], sessions?: ISessionWithCoordinates[], layers?: ILayer[], providers?: IProvider[]);
     to_serializable(): IHerdModule;
     static from_herd(herd: IHerd, client: SupabaseClient): Promise<HerdModule>;
 }
@@ -39,6 +40,7 @@ export interface IHerdModule {
     zones: IZoneWithActions[];
     sessions: ISessionWithCoordinates[];
     layers: ILayer[];
+    providers: IProvider[];
 }
 export interface IHerdModulesResponse {
     data: IHerdModule[];

package/dist/types/herd_module.js

@@ -4,6 +4,7 @@ import { server_get_total_events_by_herd } from "../helpers/events";
 import { EnumSessionsVisibility } from "./events";
 import { server_get_plans_by_herd } from "../helpers/plans";
 import { server_get_layers_by_herd } from "../helpers/layers";
+import { server_get_providers_by_herd } from "../helpers/providers";
 import { server_get_events_and_tags_for_devices_batch } from "../helpers/tags";
 import { server_get_users_with_herd_access } from "../helpers/users";
 import { EnumWebResponse } from "./requests";
@@ -18,7 +19,7 @@ export var EnumHerdModulesLoadingState;
     EnumHerdModulesLoadingState["UNSUCCESSFULLY_LOADED"] = "UNSUCCESSFULLY_LOADED";
 })(EnumHerdModulesLoadingState || (EnumHerdModulesLoadingState = {}));
 export class HerdModule {
-    constructor(herd, devices, events, timestamp_last_refreshed, user_roles = null, events_page_index = 0, total_events = 0, total_events_with_filters = 0, labels = [], plans = [], zones = [], sessions = [], layers = []) {
+    constructor(herd, devices, events, timestamp_last_refreshed, user_roles = null, events_page_index = 0, total_events = 0, total_events_with_filters = 0, labels = [], plans = [], zones = [], sessions = [], layers = [], providers = []) {
         this.user_roles = null;
         this.events_page_index = 0;
         this.total_events = 0;
@@ -26,6 +27,7 @@ export class HerdModule {
         this.labels = [];
         this.plans = [];
         this.layers = [];
+        this.providers = [];
         this.herd = herd;
         this.devices = devices;
         this.events = events;
@@ -39,6 +41,7 @@ export class HerdModule {
         this.zones = zones;
         this.sessions = sessions;
         this.layers = layers;
+        this.providers = providers;
     }
     to_serializable() {
         return {
@@ -55,6 +58,7 @@ export class HerdModule {
             zones: this.zones,
             sessions: this.sessions,
             layers: this.layers,
+            providers: this.providers,
         };
     }
     static async from_herd(herd, client) {
@@ -95,7 +99,7 @@ export class HerdModule {
                 }
             }
             // Run all remaining requests in parallel with individual error handling
-            const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions, res_layers,] = await Promise.allSettled([
+            const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions, res_layers, res_providers,] = await Promise.allSettled([
                 server_get_more_zones_and_actions_for_herd(herd.id, 0, 10).catch((error) => {
                     console.warn(`[HerdModule] Failed to get zones and actions:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
@@ -114,12 +118,20 @@ export class HerdModule {
                 }),
                 server_get_sessions_by_herd_id(herd.id).catch((error) => {
                     console.warn(`[HerdModule] Failed to get sessions:`, error);
-                    return { status: EnumWebResponse.ERROR, data: [], msg: error.message };
+                    return {
+                        status: EnumWebResponse.ERROR,
+                        data: [],
+                        msg: error.message,
+                    };
                 }),
                 server_get_layers_by_herd(herd.id).catch((error) => {
                     console.warn(`[HerdModule] Failed to get layers:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
+                server_get_providers_by_herd(herd.id).catch((error) => {
+                    console.warn(`[HerdModule] Failed to get providers:`, error);
+                    return { status: EnumWebResponse.ERROR, data: null };
+                }),
             ]);
             // Assign recent events to devices from batch results
             for (let i = 0; i < new_devices.length; i++) {
@@ -148,23 +160,28 @@ export class HerdModule {
             const plans = res_plans.status === "fulfilled" && res_plans.value?.data
                 ? res_plans.value.data
                 : [];
-            const sessions = res_sessions.status === "fulfilled" && res_sessions.value?.data ? res_sessions.value.data : [];
+            const sessions = res_sessions.status === "fulfilled" && res_sessions.value?.data
+                ? res_sessions.value.data
+                : [];
             const layers = res_layers.status === "fulfilled" && res_layers.value?.data
                 ? res_layers.value.data
                 : [];
+            const providers = res_providers.status === "fulfilled" && res_providers.value?.data
+                ? res_providers.value.data
+                : [];
             // TODO: store in DB and retrieve on load?
             const newLabels = LABELS;
             const endTime = Date.now();
             const loadTime = endTime - startTime;
             console.log(`[HerdModule] Loaded herd ${herd.slug} in ${loadTime}ms (${new_devices.length} devices)`);
-            return new HerdModule(herd, new_devices, [], Date.now(), user_roles, 0, total_events, total_events, newLabels, plans, zones, sessions, layers);
+            return new HerdModule(herd, new_devices, [], Date.now(), user_roles, 0, total_events, total_events, newLabels, plans, zones, sessions, layers, providers);
         }
         catch (error) {
             const endTime = Date.now();
             const loadTime = endTime - startTime;
             console.error(`[HerdModule] Critical error in HerdModule.from_herd (${loadTime}ms):`, error);
             // Return a minimal but valid HerdModule instance to prevent complete failure
-            return new HerdModule(herd, [], [], Date.now(), null, 0, 0, 0, [], [], [], [], []);
+            return new HerdModule(herd, [], [], Date.now(), null, 0, 0, 0, [], [], [], [], [], []);
         }
     }
 }

package/package.json

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