@adventurelabs/scout-core 1.4.83 → 1.4.85

package/dist/hooks/useDeviceDisplayName.js

@@ -0,0 +1,49 @@
+"use client";
+import { useEffect, useState } from "react";
+import { formatDeviceDisplayName } from "../helpers/ui";
+const labelByDeviceId = new Map();
+function rememberDevice(device) {
+    if (device.id == null)
+        return;
+    labelByDeviceId.set(device.id, formatDeviceDisplayName(device));
+}
+export function primeDeviceDisplayNameCache(devices) {
+    for (const device of devices)
+        rememberDevice(device);
+}
+export function useDeviceDisplayName(deviceId, options = {}) {
+    const [, setTick] = useState(0);
+    const bump = () => setTick(t => t + 1);
+    useEffect(() => {
+        if (!options.herdModules?.length)
+            return;
+        for (const hm of options.herdModules) {
+            for (const device of hm.devices ?? [])
+                rememberDevice(device);
+        }
+        bump();
+    }, [options.herdModules]);
+    useEffect(() => {
+        if (deviceId == null || labelByDeviceId.has(deviceId) || !options.supabase) {
+            return;
+        }
+        let cancelled = false;
+        options.supabase
+            .from("devices")
+            .select("id, name, domain_name, description")
+            .eq("id", deviceId)
+            .maybeSingle()
+            .then(({ data }) => {
+            if (cancelled || !data)
+                return;
+            rememberDevice(data);
+            bump();
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [deviceId, options.supabase]);
+    if (deviceId == null)
+        return null;
+    return labelByDeviceId.get(deviceId) ?? `Device ${deviceId}`;
+}

package/dist/hooks/useScoutRefresh.js

@@ -136,6 +136,7 @@ export function useScoutRefresh(options = {}) {
             dispatch(setStatus(EnumScoutStateStatus.LOADING));
             dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.LOADING));
             let cachedHerdModules = null;
+            let cachedContentHash;
             let cacheLoadDuration = 0;
             // Step 1: Load from cache first if enabled
             if (cacheFirst) {
@@ -147,6 +148,7 @@ export function useScoutRefresh(options = {}) {
                     dispatch(setCacheLoadDuration(cacheLoadDuration));
                     if (cacheResult.data && cacheResult.data.length > 0) {
                         cachedHerdModules = cacheResult.data;
+                        cachedContentHash = cacheResult.metadata?.etag;
                         console.log(`[useScoutRefresh] Loaded ${cachedHerdModules.length} herd modules from cache in ${cacheLoadDuration}ms (age: ${Math.round(cacheResult.age / 1000)}s, stale: ${cacheResult.isStale})`);
                         // Set data source to CACHE initially
                         dispatch(setDataSource(EnumDataSource.CACHE));
@@ -158,7 +160,10 @@ export function useScoutRefresh(options = {}) {
                         }));
                         // Update the store with cached data
                         console.log(`[useScoutRefresh] Updating store with cached herd modules`);
-                        dispatchInTransition(dispatch, setHerdModules(cachedHerdModules));
+                        dispatchInTransition(dispatch, setHerdModules({
+                            modules: cachedHerdModules,
+                            contentHash: cachedContentHash,
+                        }));
                         dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
                         // If cache is fresh, we still background fetch but don't wait (only when online)
                         if (!cacheResult.isStale) {
@@ -193,21 +198,25 @@ export function useScoutRefresh(options = {}) {
                                             EnumWebResponse.SUCCESS &&
                                             Array.isArray(backgroundHerdModulesResult.data) &&
                                             backgroundUserResult) {
+                                            const backgroundContentHash = backgroundHerdModulesResult.content_hash;
                                             // Update cache with fresh data
                                             try {
-                                                await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
+                                                await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs, backgroundContentHash);
                                             }
                                             catch (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);
+                                                        await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs, backgroundContentHash);
                                                     }
                                                 });
                                             }
                                             // Update store with fresh data from background request
                                             console.log(`[useScoutRefresh] Updating store with background herd modules`);
-                                            dispatchInTransition(dispatch, setHerdModules(backgroundHerdModulesResult.data));
+                                            dispatchInTransition(dispatch, setHerdModules({
+                                                modules: backgroundHerdModulesResult.data,
+                                                contentHash: backgroundContentHash,
+                                            }));
                                             // Update data source to DATABASE
                                             dispatch(setDataSource(EnumDataSource.DATABASE));
                                             dispatch(setDataSourceInfo({
@@ -248,7 +257,10 @@ export function useScoutRefresh(options = {}) {
                         source: EnumDataSource.CACHE,
                         timestamp: Date.now(),
                     }));
-                    dispatchInTransition(dispatch, setHerdModules(cachedHerdModules));
+                    dispatchInTransition(dispatch, setHerdModules({
+                        modules: cachedHerdModules,
+                        contentHash: cachedContentHash,
+                    }));
                     dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
                 }
                 else {
@@ -310,6 +322,7 @@ export function useScoutRefresh(options = {}) {
             console.log(`[useScoutRefresh] Data validation took: ${validationDuration}ms`);
             // Use the validated data
             const compatible_new_herd_modules = herdModulesResponse.data;
+            const freshContentHash = herdModulesResponse.content_hash;
             // Set data source to DATABASE
             dispatch(setDataSource(EnumDataSource.DATABASE));
             dispatch(setDataSourceInfo({
@@ -319,7 +332,7 @@ export function useScoutRefresh(options = {}) {
             // Step 3: Update cache with fresh data
             const cacheSaveStartTime = Date.now();
             try {
-                await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
+                await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs, freshContentHash);
                 const cacheSaveDuration = Date.now() - cacheSaveStartTime;
                 timingRefs.current.cacheSaveDuration = cacheSaveDuration;
                 console.log(`[useScoutRefresh] Cache updated in ${cacheSaveDuration}ms with TTL: ${Math.round(cacheTtlMs / 1000)}s`);
@@ -327,14 +340,17 @@ export function useScoutRefresh(options = {}) {
             catch (cacheError) {
                 console.warn("[useScoutRefresh] Cache save failed:", cacheError);
                 await handleIndexedDbError(cacheError, "cache save", async () => {
-                    await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
+                    await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs, freshContentHash);
                 });
             }
             // Step 4: Update store with fresh data (reducer skips no-op updates)
             const dataProcessingStartTime = Date.now();
             // Update store with new data
             console.log(`[useScoutRefresh] Updating store with fresh herd modules`);
-            dispatchInTransition(dispatch, setHerdModules(compatible_new_herd_modules));
+            dispatchInTransition(dispatch, setHerdModules({
+                modules: compatible_new_herd_modules,
+                contentHash: freshContentHash,
+            }));
             dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
             const dataProcessingDuration = Date.now() - dataProcessingStartTime;
             timingRefs.current.dataProcessingDuration = dataProcessingDuration;

package/dist/index.d.ts

@@ -20,7 +20,8 @@ export * from "./helpers/bounding_boxes";
 export * from "./helpers/chat";
 export * from "./helpers/certificates";
 export * from "./helpers/connectivity";
-export * from "./helpers/credentials";
+export * from "./helpers/user_credentials";
+export * from "./helpers/herd_credentials";
 export * from "./helpers/db";
 export * from "./helpers/devices";
 export * from "./helpers/email";
@@ -82,6 +83,6 @@ export * from "./store/api";
 export * from "./supabase/middleware";
 export * from "./supabase/server";
 export * from "./api_keys/actions";
-export type { HerdModule, IHerdModule } from "./types/herd_module";
-export type { IDevice, IEvent, IUser, IHerd, IHerdPrettyLocation, IEventWithTags, IZoneWithActions, ICredential, CredentialInsert, CredentialUpdate, IPointsForUser, PointsForUserInsert, PointsForUserUpdate, ICertificate, CertificateInsert, CertificateUpdate, IUserAndRole, IUserProfileRow, IHerdInvitation, IHerdInvitationWithHerdSlug, IHerdAllowedDomain, IUserRolePerHerd, IAbility, IHerdRole, IHerdRoleWithAbilities, HerdRoleSystemName, HerdInvitationStatus, IApiKeyScout, ILayer, IHeartbeat, IProvider, IConnectivity, ISession, ISessionWithCoordinates, IConnectivityWithCoordinates, IObservation, ObservationInsert, ObservationUpdate, IAnalysisJob, IAnalysisTask, AnalysisWorkStatus, } from "./types/db";
+export type { IHerdModule } from "./types/herd_module";
+export type { IDevice, IEvent, IUser, IHerd, IHerdPrettyLocation, IEventWithTags, IZoneWithActions, IPointsForUser, PointsForUserInsert, PointsForUserUpdate, ICertificate, CertificateInsert, CertificateUpdate, IUserAndRole, IUserProfileRow, IHerdInvitation, IHerdInvitationWithHerdSlug, IHerdAllowedDomain, IUserRolePerHerd, IAbility, IHerdRole, IHerdRoleWithAbilities, HerdRoleSystemName, HerdInvitationStatus, IApiKeyScout, ILayer, IHeartbeat, IProvider, IConnectivity, ISession, ISessionWithCoordinates, IConnectivityWithCoordinates, IObservation, ObservationInsert, ObservationUpdate, IAnalysisJob, IAnalysisTask, AnalysisWorkStatus, } from "./types/db";
 export { EnumSessionsVisibility } from "./types/events";

package/dist/index.js

@@ -23,7 +23,8 @@ export * from "./helpers/bounding_boxes";
 export * from "./helpers/chat";
 export * from "./helpers/certificates";
 export * from "./helpers/connectivity";
-export * from "./helpers/credentials";
+export * from "./helpers/user_credentials";
+export * from "./helpers/herd_credentials";
 export * from "./helpers/db";
 export * from "./helpers/devices";
 export * from "./helpers/email";

package/dist/store/scout.d.ts

@@ -17,6 +17,7 @@ export interface LoadingPerformance {
 }
 export interface ScoutState {
     herd_modules: IHerdModule[];
+    herd_modules_content_hash: string | null;
     status: EnumScoutStateStatus;
     herd_modules_loading_state: EnumHerdModulesLoadingState;
     loading_performance: LoadingPerformance;

package/dist/store/scout.js

@@ -9,6 +9,7 @@ export var EnumScoutStateStatus;
 })(EnumScoutStateStatus || (EnumScoutStateStatus = {}));
 const initialState = {
     herd_modules: [],
+    herd_modules_content_hash: null,
     status: EnumScoutStateStatus.LOADING,
     herd_modules_loading_state: EnumHerdModulesLoadingState.NOT_LOADING,
     loading_performance: {
@@ -33,10 +34,25 @@ export const scoutSlice = createSlice({
     initialState,
     reducers: {
         setHerdModules: (state, action) => {
-            if (herdModulesSemanticallyEqual(current(state.herd_modules), action.payload)) {
+            // Payload is the modules array (legacy) or { modules, contentHash }.
+            const payload = action.payload;
+            const modules = Array.isArray(payload)
+                ? payload
+                : payload.modules;
+            const contentHash = Array.isArray(payload)
+                ? null
+                : payload.contentHash ?? null;
+            // Prefer the cheap hash check; fall back to deep compare when absent.
+            if (contentHash != null) {
+                if (state.herd_modules_content_hash === contentHash) {
+                    return;
+                }
+            }
+            else if (herdModulesSemanticallyEqual(current(state.herd_modules), modules)) {
                 return;
             }
-            state.herd_modules = action.payload;
+            state.herd_modules = modules;
+            state.herd_modules_content_hash = contentHash;
             state.lastRefreshed = Date.now();
         },
         setStatus: (state, action) => {

package/dist/types/db.d.ts

@@ -58,7 +58,8 @@ export type IOperator = Database["public"]["Tables"]["operators"]["Row"];
 export type IObservation = Database["public"]["Tables"]["observations"]["Row"];
 export type IProvider = Database["public"]["Tables"]["providers"]["Row"];
 export type IPart = Database["public"]["Tables"]["parts"]["Row"];
-export type ICredential = Database["public"]["Tables"]["credentials"]["Row"];
+export type IUserCredential = Database["public"]["Tables"]["user_credentials"]["Row"];
+export type IHerdCredential = Database["public"]["Tables"]["herd_credentials"]["Row"];
 export type IPointsForUser = Database["public"]["Tables"]["points_for_user"]["Row"];
 export type ICertificate = Database["public"]["Tables"]["certificates"]["Row"];
 export type IVersionsSoftware = Database["public"]["Tables"]["versions_software"]["Row"];
@@ -100,8 +101,13 @@ export interface ISessionSummary {
 }
 export type ISessionUsageOverTime = Database["public"]["Functions"]["get_session_usage_over_time"]["Returns"];
 export type PartInsert = Database["public"]["Tables"]["parts"]["Insert"];
-export type CredentialInsert = Database["public"]["Tables"]["credentials"]["Insert"];
-export type CredentialUpdate = Database["public"]["Tables"]["credentials"]["Update"];
+export type UserCredentialInsert = Database["public"]["Tables"]["user_credentials"]["Insert"];
+export type UserCredentialUpdate = Database["public"]["Tables"]["user_credentials"]["Update"];
+export type HerdCredentialInsert = Database["public"]["Tables"]["herd_credentials"]["Insert"];
+export type HerdCredentialUpdate = Database["public"]["Tables"]["herd_credentials"]["Update"];
+export interface CredentialQueryArgs {
+    type?: string;
+}
 export type PointsForUserInsert = Database["public"]["Tables"]["points_for_user"]["Insert"];
 export type PointsForUserUpdate = Database["public"]["Tables"]["points_for_user"]["Update"];
 export type CertificateInsert = Database["public"]["Tables"]["certificates"]["Insert"];

package/dist/types/herd_module.d.ts

@@ -1,4 +1,3 @@
-import { SupabaseClient } from "@supabase/supabase-js";
 import { IDevice, IHerdPrettyLocation, IPlan, ILayer, IProvider, IUserAndRole, IZoneWithActions, ISessionSummary, ISessionUsageOverTime } from "../types/db";
 import { EnumWebResponse } from "./requests";
 export declare enum EnumHerdModulesLoadingState {
@@ -7,22 +6,6 @@ export declare enum EnumHerdModulesLoadingState {
     SUCCESSFULLY_LOADED = "SUCCESSFULLY_LOADED",
     UNSUCCESSFULLY_LOADED = "UNSUCCESSFULLY_LOADED"
 }
-export declare class HerdModule {
-    herd: IHerdPrettyLocation;
-    devices: IDevice[];
-    zones: IZoneWithActions[];
-    timestamp_last_refreshed: number;
-    user_roles: IUserAndRole[] | null;
-    labels: string[];
-    plans: IPlan[];
-    layers: ILayer[];
-    providers: IProvider[];
-    session_summaries: ISessionSummary | null;
-    session_usage: ISessionUsageOverTime | null;
-    constructor(herd: IHerdPrettyLocation, devices: IDevice[], timestamp_last_refreshed: number, user_roles?: IUserAndRole[] | null, labels?: string[], plans?: IPlan[], zones?: IZoneWithActions[], layers?: ILayer[], providers?: IProvider[], session_summaries?: ISessionSummary | null, session_usage?: ISessionUsageOverTime | null);
-    to_serializable(): IHerdModule;
-    static from_herd(herd: IHerdPrettyLocation, client: SupabaseClient): Promise<HerdModule>;
-}
 export interface IHerdModule {
     herd: IHerdPrettyLocation;
     devices: IDevice[];
@@ -40,6 +23,7 @@ export interface IHerdModulesResponse {
     data: IHerdModule[];
     time_finished: number;
     server_processing_time_ms: number;
+    content_hash: string;
 }
 export interface IHerdModulesResponseWithStatus {
     status: EnumWebResponse;
@@ -48,4 +32,5 @@ export interface IHerdModulesResponseWithStatus {
     time_finished: number;
     time_sent: number;
     server_processing_time_ms: number;
+    content_hash: string;
 }

package/dist/types/herd_module.js

@@ -1,15 +1,3 @@
-import { LABELS } from "../constants/annotator";
-import { get_devices_by_herd } from "../helpers/devices";
-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_users_with_herd_access } from "../helpers/users";
-import { get_parts_by_herd_id } from "../helpers/parts";
-import { EnumWebResponse } from "./requests";
-import { server_get_more_zones_and_actions_for_herd } from "../helpers/zones";
-import { server_list_api_keys_batch } from "../api_keys/actions";
-import { server_get_session_summaries_by_herd } from "../helpers/session_summaries";
-import { server_get_session_usage_over_time_by_herd } from "../helpers/sessions";
 export var EnumHerdModulesLoadingState;
 (function (EnumHerdModulesLoadingState) {
     EnumHerdModulesLoadingState["NOT_LOADING"] = "NOT_LOADING";
@@ -17,157 +5,3 @@ export var EnumHerdModulesLoadingState;
     EnumHerdModulesLoadingState["SUCCESSFULLY_LOADED"] = "SUCCESSFULLY_LOADED";
     EnumHerdModulesLoadingState["UNSUCCESSFULLY_LOADED"] = "UNSUCCESSFULLY_LOADED";
 })(EnumHerdModulesLoadingState || (EnumHerdModulesLoadingState = {}));
-export class HerdModule {
-    constructor(herd, devices, timestamp_last_refreshed, user_roles = null, labels = [], plans = [], zones = [], layers = [], providers = [], session_summaries = null, session_usage = null) {
-        this.user_roles = null;
-        this.labels = [];
-        this.plans = [];
-        this.layers = [];
-        this.providers = [];
-        this.session_summaries = null;
-        this.session_usage = null;
-        this.herd = herd;
-        this.devices = devices;
-        this.timestamp_last_refreshed = timestamp_last_refreshed;
-        this.user_roles = user_roles;
-        this.labels = labels;
-        this.plans = plans;
-        this.zones = zones;
-        this.layers = layers;
-        this.providers = providers;
-        this.session_summaries = session_summaries;
-        this.session_usage = session_usage;
-    }
-    to_serializable() {
-        return {
-            herd: this.herd,
-            devices: this.devices,
-            timestamp_last_refreshed: this.timestamp_last_refreshed,
-            user_roles: this.user_roles,
-            labels: this.labels,
-            plans: this.plans,
-            zones: this.zones,
-            layers: this.layers,
-            providers: this.providers,
-            session_summaries: this.session_summaries,
-            session_usage: this.session_usage,
-        };
-    }
-    static async from_herd(herd, client) {
-        const startTime = Date.now();
-        try {
-            // Start loading herd-level data in parallel with devices
-            const herdLevelPromises = 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 };
-                }),
-                server_get_users_with_herd_access(herd.id, client).catch((error) => {
-                    console.warn(`[HerdModule] Failed to get user roles:`, error);
-                    return { status: EnumWebResponse.ERROR, data: null };
-                }),
-                server_get_plans_by_herd(herd.id).catch((error) => {
-                    console.warn(`[HerdModule] Failed to get plans:`, error);
-                    return { status: EnumWebResponse.ERROR, data: null };
-                }),
-                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 };
-                }),
-                server_get_session_summaries_by_herd(herd.id, client).catch((error) => {
-                    console.warn(`[HerdModule] Failed to get session summaries:`, error);
-                    return { status: EnumWebResponse.ERROR, data: null };
-                }),
-                server_get_session_usage_over_time_by_herd(herd.id, client).catch((error) => {
-                    console.warn(`[HerdModule] Failed to get session usage:`, error);
-                    return { status: EnumWebResponse.ERROR, data: null };
-                }),
-            ]);
-            // Load devices and parts in parallel
-            const devicesPromise = get_devices_by_herd(herd.id, client);
-            const partsPromise = get_parts_by_herd_id(client, herd.id);
-            // Wait for devices, parts, and herd-level data
-            const [deviceResponse, partsResponse, herdLevelResults] = await Promise.all([devicesPromise, partsPromise, herdLevelPromises]);
-            // Check devices response
-            if (deviceResponse.status == EnumWebResponse.ERROR ||
-                !deviceResponse.data) {
-                console.warn(`[HerdModule] No devices found for herd ${herd.id}`);
-                return new HerdModule(herd, [], Date.now());
-            }
-            const new_devices = deviceResponse.data;
-            // Get parts data (optional - don't fail if parts can't be loaded)
-            let parts_data = [];
-            if (partsResponse.status !== EnumWebResponse.ERROR &&
-                partsResponse.data) {
-                parts_data = partsResponse.data;
-            }
-            else {
-                console.warn(`[HerdModule] Failed to load parts for herd ${herd.id}:`, partsResponse.status);
-            }
-            // Load API keys for devices if we have any
-            if (new_devices.length > 0) {
-                try {
-                    const device_ids = new_devices.map((device) => device.id ?? 0);
-                    const api_keys_batch = await server_list_api_keys_batch(device_ids);
-                    // Assign API keys to devices
-                    for (let i = 0; i < new_devices.length; i++) {
-                        const device_id = new_devices[i].id ?? 0;
-                        new_devices[i].api_keys_scout = api_keys_batch[device_id] || [];
-                    }
-                }
-                catch (error) {
-                    console.error(`[HerdModule] Failed to load API keys:`, error);
-                    // Continue without API keys
-                }
-            }
-            // Associate parts with devices
-            if (parts_data.length > 0) {
-                for (const device of new_devices) {
-                    device.parts = parts_data.filter((part) => part.device_id === device.id);
-                }
-            }
-            // Extract herd-level data with safe fallbacks
-            const [res_zones, res_user_roles, res_plans, res_layers, res_providers, session_summaries_result, session_usage_result,] = herdLevelResults;
-            const zones = res_zones.status === "fulfilled" && res_zones.value?.data
-                ? res_zones.value.data
-                : [];
-            const user_roles = res_user_roles.status === "fulfilled" && res_user_roles.value?.data
-                ? res_user_roles.value.data
-                : null;
-            const plans = res_plans.status === "fulfilled" && res_plans.value?.data
-                ? res_plans.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
-                : [];
-            const session_summaries = session_summaries_result.status === "fulfilled" &&
-                session_summaries_result.value?.data
-                ? session_summaries_result.value.data
-                : null;
-            const session_usage = session_usage_result.status === "fulfilled" &&
-                session_usage_result.value?.data
-                ? session_usage_result.value.data
-                : null;
-            // 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, newLabels, plans, zones, layers, providers, session_summaries, session_usage);
-        }
-        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, [], [], [], [], [], null, null);
-        }
-    }
-}