@adventurelabs/scout-core 1.4.84 → 1.4.85

package/dist/api_keys/actions.d.ts

@@ -1,6 +1,7 @@
 import { IApiKeyScout } from "../types/db";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function test_api_key_loading(device_id: number): Promise<boolean>;
 export declare function server_list_api_keys(device_id: number): Promise<IApiKeyScout[]>;
-export declare function server_list_api_keys_batch(device_ids: number[]): Promise<{
+export declare function server_list_api_keys_batch(device_ids: number[], client?: SupabaseClient): Promise<{
     [device_id: number]: IApiKeyScout[];
 }>;

package/dist/api_keys/actions.js

@@ -31,8 +31,8 @@ export async function server_list_api_keys(device_id) {
     }
     return data_to_return;
 }
-export async function server_list_api_keys_batch(device_ids) {
-    const supabase = await newServerClient();
+export async function server_list_api_keys_batch(device_ids, client) {
+    const supabase = client || (await newServerClient());
     // Check if the batch function exists by trying a simple call
     try {
         const { data, error } = await supabase.rpc("load_api_keys_batch", {

package/dist/helpers/herds.js

@@ -1,7 +1,18 @@
 "use server";
+import { createHash } from "crypto";
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { HerdModule, } from "../types/herd_module";
+import { LABELS } from "../constants/annotator";
+import { get_devices_by_herd } from "./devices";
+import { server_get_plans_by_herd_ids } from "./plans";
+import { server_get_layers_by_herd_ids } from "./layers";
+import { server_get_providers_by_herd_ids } from "./providers";
+import { server_get_users_with_herd_access_batch } from "./users";
+import { get_parts_by_herd_ids } from "./parts";
+import { server_get_more_zones_and_actions_for_herd } from "./zones";
+import { server_list_api_keys_batch } from "../api_keys/actions";
+import { server_get_session_summaries_by_herd } from "./session_summaries";
+import { server_get_session_usage_over_time_by_herd } from "./sessions";
 export async function get_herds(client) {
     const { data: herds } = await client.from("herds").select();
     if (!herds) {
@@ -71,12 +82,17 @@ export async function createHerd(newHerd) {
         return IWebResponse.success(true).to_compatible();
     }
 }
+// Stable hash of modules (queries return rows in a deterministic DB order), minus
+// the per-fetch timestamp, so the client can skip no-op updates without a deep walk.
+function hashHerdModules(modules) {
+    const stable = modules.map(({ timestamp_last_refreshed: _ts, ...rest }) => rest);
+    return createHash("sha1").update(JSON.stringify(stable)).digest("hex");
+}
 export async function server_load_herd_modules() {
     const startTime = Date.now();
-    const client_supabase = await newServerClient();
-    const herdsResult = await get_herds_with_location(client_supabase);
-    if (herdsResult.status !== EnumWebResponse.SUCCESS ||
-        !herdsResult.data) {
+    const client = await newServerClient();
+    const herdsResult = await get_herds_with_location(client);
+    if (herdsResult.status !== EnumWebResponse.SUCCESS || !herdsResult.data) {
         return {
             status: EnumWebResponse.ERROR,
             msg: herdsResult.msg ?? "Failed to load herds",
@@ -84,26 +100,88 @@ export async function server_load_herd_modules() {
             time_finished: Date.now(),
             time_sent: Date.now(),
             server_processing_time_ms: Date.now() - startTime,
+            content_hash: "",
         };
     }
     const herds = herdsResult.data.filter((h) => h.id != null);
-    const endTime = Date.now();
-    const totalLoadTime = endTime - startTime;
     if (herds.length === 0) {
-        console.log(`[server_load_herd_modules] No accessible herds (${totalLoadTime}ms)`);
+        const endTime = Date.now();
+        console.log(`[server_load_herd_modules] No accessible herds (${endTime - startTime}ms)`);
         return {
             status: EnumWebResponse.SUCCESS,
             msg: "No herds accessible",
             data: [],
             time_finished: endTime,
             time_sent: endTime,
-            server_processing_time_ms: totalLoadTime,
+            server_processing_time_ms: endTime - startTime,
+            content_hash: hashHerdModules([]),
         };
     }
-    const herdModulePromises = herds.map((herd) => HerdModule.from_herd(herd, client_supabase));
-    const new_herd_modules = await Promise.all(herdModulePromises);
-    const serialized_herd_modules = new_herd_modules.map((herd_module) => herd_module.to_serializable());
-    console.log(`[server_load_herd_modules] Loaded ${herds.length} herds in ${totalLoadTime}ms (parallel processing)`);
+    const herdIds = herds.map((h) => h.id);
+    // Run a per-herd RPC across all herds in parallel, tolerating individual failures.
+    const perHerd = (fn) => Promise.all(herds.map((h) => fn(h.id).catch(() => ({
+        status: EnumWebResponse.ERROR,
+        msg: "",
+        data: null,
+    }))));
+    const grouped = (p) => p.then((r) => r.data ?? {}).catch(() => ({}));
+    const [plansByHerd, layersByHerd, providersByHerd, usersByHerd, partsByDevice, devicesResults, zonesResults, summariesResults, usageResults,] = await Promise.all([
+        grouped(server_get_plans_by_herd_ids(herdIds, client)),
+        grouped(server_get_layers_by_herd_ids(herdIds, client)),
+        grouped(server_get_providers_by_herd_ids(herdIds, client)),
+        server_get_users_with_herd_access_batch(herdIds, client)
+            .then((r) => (r.status === EnumWebResponse.SUCCESS ? r.data : null))
+            .catch(() => null),
+        grouped(get_parts_by_herd_ids(client, herdIds)),
+        perHerd((id) => get_devices_by_herd(id, client)),
+        perHerd((id) => server_get_more_zones_and_actions_for_herd(id, 0, 10, client)),
+        perHerd((id) => server_get_session_summaries_by_herd(id, client)),
+        perHerd((id) => server_get_session_usage_over_time_by_herd(id, client)),
+    ]);
+    const devicesByHerdIndex = devicesResults.map((res) => res.status === EnumWebResponse.SUCCESS && res.data ? res.data : []);
+    const allDevices = devicesByHerdIndex.flat();
+    const allDeviceIds = allDevices.map((device) => device.id ?? 0);
+    let apiKeysByDevice = {};
+    if (allDeviceIds.length > 0) {
+        try {
+            apiKeysByDevice = await server_list_api_keys_batch(allDeviceIds, client);
+        }
+        catch (error) {
+            console.error(`[server_load_herd_modules] Failed to load API keys:`, error);
+        }
+    }
+    for (const device of allDevices) {
+        const deviceId = device.id ?? 0;
+        device.api_keys_scout = apiKeysByDevice[deviceId] || [];
+        device.parts = partsByDevice[deviceId] || [];
+    }
+    const serialized_herd_modules = herds.map((herd, index) => {
+        const zonesRes = zonesResults[index];
+        const summariesRes = summariesResults[index];
+        const usageRes = usageResults[index];
+        return {
+            herd,
+            devices: devicesByHerdIndex[index],
+            timestamp_last_refreshed: Date.now(),
+            user_roles: usersByHerd ? usersByHerd[herd.id] ?? [] : null,
+            labels: LABELS,
+            plans: plansByHerd[herd.id] ?? [],
+            zones: zonesRes.status === EnumWebResponse.SUCCESS && zonesRes.data
+                ? zonesRes.data
+                : [],
+            layers: layersByHerd[herd.id] ?? [],
+            providers: providersByHerd[herd.id] ?? [],
+            session_summaries: summariesRes.status === EnumWebResponse.SUCCESS && summariesRes.data
+                ? summariesRes.data
+                : null,
+            session_usage: usageRes.status === EnumWebResponse.SUCCESS && usageRes.data
+                ? usageRes.data
+                : null,
+        };
+    });
+    const endTime = Date.now();
+    const totalLoadTime = endTime - startTime;
+    console.log(`[server_load_herd_modules] Loaded ${herds.length} herds in ${totalLoadTime}ms (batched queries)`);
     return {
         status: EnumWebResponse.SUCCESS,
         msg: "Herd modules loaded successfully",
@@ -111,5 +189,6 @@ export async function server_load_herd_modules() {
         time_finished: endTime,
         time_sent: endTime,
         server_processing_time_ms: totalLoadTime,
+        content_hash: hashHerdModules(serialized_herd_modules),
     };
 }

package/dist/helpers/index.d.ts

@@ -3,7 +3,6 @@ export * from "./auth";
 export * from "./bounding_boxes";
 export * from "./chat";
 export * from "./certificates";
-export * from "./credentials";
 export * from "./user_credentials";
 export * from "./herd_credentials";
 export * from "./db";

package/dist/helpers/index.js

@@ -3,7 +3,6 @@ export * from "./auth";
 export * from "./bounding_boxes";
 export * from "./chat";
 export * from "./certificates";
-export * from "./credentials";
 export * from "./user_credentials";
 export * from "./herd_credentials";
 export * from "./db";

package/dist/helpers/layers.d.ts

@@ -1,3 +1,6 @@
+import { Database } from "../types/supabase";
 import { ILayer } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_layers_by_herd(herd_id: number): Promise<IWebResponseCompatible<ILayer[]>>;
+export declare function server_get_layers_by_herd_ids(herd_ids: number[], client: SupabaseClient<Database>): Promise<IWebResponseCompatible<Record<number, ILayer[]>>>;

package/dist/helpers/layers.js

@@ -19,3 +19,23 @@ export async function server_get_layers_by_herd(herd_id) {
         return IWebResponse.success(data).to_compatible();
     }
 }
+// Fetches layers for many herds in one query, grouped by herd_id.
+export async function server_get_layers_by_herd_ids(herd_ids, client) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("layers")
+        .select("*")
+        .in("herd_id", herd_ids)
+        .order("id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const row of data ?? []) {
+        (grouped[_a = row.herd_id] ?? (grouped[_a] = [])).push(row);
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}

package/dist/helpers/parts.d.ts

@@ -75,6 +75,13 @@ export declare function get_parts_by_certificate_id(client: SupabaseClient<Datab
  * @param herd_id - ID of the herd to get parts for
  */
 export declare function get_parts_by_herd_id(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IPart[]>>;
+/**
+ * Retrieves active parts for all devices across many herds in one query,
+ * grouped by device_id.
+ * @param client - Supabase client instance
+ * @param herd_ids - IDs of the herds to get parts for
+ */
+export declare function get_parts_by_herd_ids(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IPart[]>>>;
 /**
  * Restores a deleted part to active lifecycle
  * @param client - Supabase client instance

package/dist/helpers/parts.js

@@ -238,6 +238,38 @@ export async function get_parts_by_herd_id(client, herd_id) {
     }
     return IWebResponse.success(data).to_compatible();
 }
+/**
+ * Retrieves active parts for all devices across many herds in one query,
+ * grouped by device_id.
+ * @param client - Supabase client instance
+ * @param herd_ids - IDs of the herds to get parts for
+ */
+export async function get_parts_by_herd_ids(client, herd_ids) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("parts")
+        .select(`
+      *,
+      devices!parts_device_id_fkey(herd_id)
+    `)
+        .in("devices.herd_id", herd_ids)
+        .eq("lifecycle", "active")
+        .order("created_at", { ascending: false })
+        .order("id", { ascending: true });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    const grouped = {};
+    for (const row of data ?? []) {
+        if (row.device_id == null)
+            continue;
+        (grouped[_a = row.device_id] ?? (grouped[_a] = [])).push(row);
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}
 /**
  * Restores a deleted part to active lifecycle
  * @param client - Supabase client instance

package/dist/helpers/plans.d.ts

@@ -1,5 +1,8 @@
+import { Database } from "../types/supabase";
 import { IPlan } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_plans_by_herd(herd_id: number): Promise<IWebResponseCompatible<IPlan[]>>;
+export declare function server_get_plans_by_herd_ids(herd_ids: number[], client: SupabaseClient<Database>): Promise<IWebResponseCompatible<Record<number, IPlan[]>>>;
 export declare function server_create_plans(plans: IPlan[]): Promise<IWebResponseCompatible<IPlan[]>>;
 export declare function server_delete_plans_by_ids(plan_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/plans.js

@@ -19,6 +19,26 @@ export async function server_get_plans_by_herd(herd_id) {
         return IWebResponse.success(data).to_compatible();
     }
 }
+// Fetches plans for many herds in one query, grouped by herd_id.
+export async function server_get_plans_by_herd_ids(herd_ids, client) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("plans")
+        .select("*")
+        .in("herd_id", herd_ids)
+        .order("id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const row of data ?? []) {
+        (grouped[_a = row.herd_id] ?? (grouped[_a] = [])).push(row);
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}
 // function that uploads plan to our db
 export async function server_create_plans(plans) {
     // loop through plans and format

package/dist/helpers/providers.d.ts

@@ -1,6 +1,9 @@
+import { Database } from "../types/supabase";
 import { IProvider } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_providers_by_herd(herd_id: number): Promise<IWebResponseCompatible<IProvider[]>>;
+export declare function server_get_providers_by_herd_ids(herd_ids: number[], client: SupabaseClient<Database>): Promise<IWebResponseCompatible<Record<number, IProvider[]>>>;
 export declare function server_create_provider(provider: Omit<IProvider, "id" | "created_at">): Promise<IWebResponseCompatible<IProvider>>;
 export declare function server_update_provider(provider_id: number, updates: Partial<Omit<IProvider, "id" | "created_at">>): Promise<IWebResponseCompatible<IProvider>>;
 export declare function server_delete_providers_by_ids(provider_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/providers.js

@@ -19,6 +19,26 @@ export async function server_get_providers_by_herd(herd_id) {
         return IWebResponse.success(data).to_compatible();
     }
 }
+// Fetches providers for many herds in one query, grouped by herd_id.
+export async function server_get_providers_by_herd_ids(herd_ids, client) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("providers")
+        .select("*")
+        .in("herd_id", herd_ids)
+        .order("id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const row of data ?? []) {
+        (grouped[_a = row.herd_id] ?? (grouped[_a] = [])).push(row);
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}
 // function that creates a new provider in our db
 export async function server_create_provider(provider) {
     const supabase = await newServerClient();

package/dist/helpers/users.d.ts

@@ -5,6 +5,7 @@ import { Database } from "../types/supabase";
 export declare function server_get_user_roles(herd_id: number): Promise<IWebResponseCompatible<IUserRolePerHerd[]>>;
 export declare function server_get_user(): Promise<IWebResponseCompatible<IUser | null>>;
 export declare function server_get_users_with_herd_access(herd_id: number, supabaseClient?: SupabaseClient): Promise<IWebResponseCompatible<IUserAndRole[]>>;
+export declare function server_get_users_with_herd_access_batch(herd_ids: number[], client: SupabaseClient): Promise<IWebResponseCompatible<Record<number, IUserAndRole[]>>>;
 export declare function server_upsert_user_herd_role(herd_id: number, username: string, herd_role_id: number): Promise<IWebResponseCompatible<IUserAndRole | null>>;
 export type UserProfileUpdate = Database["public"]["Tables"]["users"]["Update"];
 export declare function update_user_profile(client: SupabaseClient<Database>, user_id: string, patch: UserProfileUpdate): Promise<IWebResponseCompatible<IUserProfileRow | null>>;

package/dist/helpers/users.js

@@ -49,6 +49,36 @@ export async function server_get_users_with_herd_access(herd_id, supabaseClient)
     }));
     return IWebResponse.success(transformedData).to_compatible();
 }
+// Fetches users-with-role for many herds in one query, grouped by herd_id.
+export async function server_get_users_with_herd_access_batch(herd_ids, client) {
+    var _a;
+    if (herd_ids.length === 0) {
+        return IWebResponse.success({}).to_compatible();
+    }
+    const { data, error } = await client
+        .from("users_roles_per_herd")
+        .select(`
+      herd_id,
+      herd_role_id,
+      herd_roles (*),
+      users!users_roles_per_herd_user_id_fkey (*)
+    `)
+        .in("herd_id", herd_ids)
+        .order("herd_id", { ascending: true })
+        .order("user_id", { ascending: true });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const grouped = {};
+    for (const item of (data ?? [])) {
+        (grouped[_a = item.herd_id] ?? (grouped[_a] = [])).push({
+            user: item.users,
+            herd_role_id: item.herd_role_id,
+            herd_role: item.herd_roles,
+        });
+    }
+    return IWebResponse.success(grouped).to_compatible();
+}
 export async function server_upsert_user_herd_role(herd_id, username, herd_role_id) {
     const supabase = await newServerClient();
     const { data: user, error: user_error } = await supabase

package/dist/helpers/zones.d.ts

@@ -1,5 +1,6 @@
 import { IZoneWithActions } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 /**
  * Get more zones and actions for a herd
  * @param herd_id - The ID of the herd to get zones and actions for
@@ -8,7 +9,7 @@ import { IWebResponseCompatible } from "../types/requests";
  * @returns A list of zones and actions
  * @throws An error if the zones or actions are not fetched
  */
-export declare function server_get_more_zones_and_actions_for_herd(herd_id: number, offset: number, page_count?: number): Promise<IWebResponseCompatible<IZoneWithActions[]>>;
+export declare function server_get_more_zones_and_actions_for_herd(herd_id: number, offset: number, page_count?: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IZoneWithActions[]>>;
 /**
  * Create zones and actions for a herd
  * @param zones - The zones to create

package/dist/helpers/zones.js

@@ -8,10 +8,10 @@ import { EnumWebResponse, IWebResponse, } from "../types/requests";
  * @returns A list of zones and actions
  * @throws An error if the zones or actions are not fetched
  */
-export async function server_get_more_zones_and_actions_for_herd(herd_id, offset, page_count = 10) {
+export async function server_get_more_zones_and_actions_for_herd(herd_id, offset, page_count = 10, client) {
     const from = offset * page_count;
     const to = from + page_count - 1;
-    const supabase = await newServerClient();
+    const supabase = client || (await newServerClient());
     // make rpc call to get_events_with_tags_for_herd(herd_id, offset, limit)
     const { data, error } = await supabase.rpc("get_zones_and_actions_for_herd", {
         herd_id_caller: herd_id,

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,6 @@ 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"];
@@ -102,8 +101,6 @@ 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"];

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);
-        }
-    }
-}

package/dist/types/supabase.d.ts

@@ -514,47 +514,6 @@ export type Database = {
                     }
                 ];
             };
-            credentials: {
-                Row: {
-                    created_at: string;
-                    expiration: string | null;
-                    id: number;
-                    issuer: string;
-                    tracking_number: string | null;
-                    type: string;
-                    updated_at: string | null;
-                    user_id: string;
-                };
-                Insert: {
-                    created_at?: string;
-                    expiration?: string | null;
-                    id?: number;
-                    issuer: string;
-                    tracking_number?: string | null;
-                    type: string;
-                    updated_at?: string | null;
-                    user_id: string;
-                };
-                Update: {
-                    created_at?: string;
-                    expiration?: string | null;
-                    id?: number;
-                    issuer?: string;
-                    tracking_number?: string | null;
-                    type?: string;
-                    updated_at?: string | null;
-                    user_id?: string;
-                };
-                Relationships: [
-                    {
-                        foreignKeyName: "credentials_user_id_fkey";
-                        columns: ["user_id"];
-                        isOneToOne: false;
-                        referencedRelation: "users";
-                        referencedColumns: ["id"];
-                    }
-                ];
-            };
             devices: {
                 Row: {
                     altitude: number | null;
@@ -1126,46 +1085,31 @@ export type Database = {
                     auto_delete_media_with_humans: boolean | null;
                     auto_delete_media_with_no_tracks: boolean | null;
                     description: string;
-                    earthranger_domain: string | null;
-                    earthranger_token: string | null;
                     id: number;
                     inserted_at: string;
                     is_public: boolean;
                     location: unknown;
                     slug: string;
-                    video_publisher_token: string | null;
-                    video_server_url: string | null;
-                    video_subscriber_token: string | null;
                 };
                 Insert: {
                     auto_delete_media_with_humans?: boolean | null;
                     auto_delete_media_with_no_tracks?: boolean | null;
                     description: string;
-                    earthranger_domain?: string | null;
-                    earthranger_token?: string | null;
                     id?: number;
                     inserted_at?: string;
                     is_public?: boolean;
                     location?: unknown;
                     slug: string;
-                    video_publisher_token?: string | null;
-                    video_server_url?: string | null;
-                    video_subscriber_token?: string | null;
                 };
                 Update: {
                     auto_delete_media_with_humans?: boolean | null;
                     auto_delete_media_with_no_tracks?: boolean | null;
                     description?: string;
-                    earthranger_domain?: string | null;
-                    earthranger_token?: string | null;
                     id?: number;
                     inserted_at?: string;
                     is_public?: boolean;
                     location?: unknown;
                     slug?: string;
-                    video_publisher_token?: string | null;
-                    video_server_url?: string | null;
-                    video_subscriber_token?: string | null;
                 };
                 Relationships: [];
             };
@@ -1640,7 +1584,9 @@ export type Database = {
                     herd_id: number;
                     id: number;
                     key: string | null;
+                    sensitivity_tier: number | null;
                     source: string;
+                    timestamp_expiration: string | null;
                     type: string;
                 };
                 Insert: {
@@ -1648,7 +1594,9 @@ export type Database = {
                     herd_id: number;
                     id?: number;
                     key?: string | null;
+                    sensitivity_tier?: number | null;
                     source: string;
+                    timestamp_expiration?: string | null;
                     type: string;
                 };
                 Update: {
@@ -1656,7 +1604,9 @@ export type Database = {
                     herd_id?: number;
                     id?: number;
                     key?: string | null;
+                    sensitivity_tier?: number | null;
                     source?: string;
+                    timestamp_expiration?: string | null;
                     type?: string;
                 };
                 Relationships: [
@@ -4014,11 +3964,6 @@ export type Database = {
                 slug: string | null;
                 description: string | null;
                 is_public: boolean | null;
-                earthranger_domain: string | null;
-                earthranger_token: string | null;
-                video_publisher_token: string | null;
-                video_subscriber_token: string | null;
-                video_server_url: string | null;
                 location: string | null;
                 latitude: number | null;
                 longitude: number | null;

package/package.json

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