@adventurelabs/scout-core 1.0.101 → 1.0.103

package/dist/helpers/operator.d.ts

@@ -0,0 +1,5 @@
+import { IWebResponseCompatible } from "../types/requests";
+import { IOperator } from "../types/db";
+export declare function server_get_operators_by_session_id(sessionId: number): Promise<IWebResponseCompatible<IOperator[]>>;
+export declare function server_get_operators_by_user_id(userId: string): Promise<IWebResponseCompatible<IOperator[]>>;
+export declare function server_get_operators_by_session_id_filtered(sessionId: number, action?: string, timestampAfter?: string): Promise<IWebResponseCompatible<IOperator[]>>;

package/dist/helpers/operator.js

@@ -0,0 +1,64 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+// Get operators by session id (server id)
+export async function server_get_operators_by_session_id(sessionId) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("operators")
+        .select("*")
+        .eq("session_id", sessionId)
+        .order("created_at", { ascending: false });
+    if (error) {
+        console.warn("Error fetching operators by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+// Get all operators for a specific user
+export async function server_get_operators_by_user_id(userId) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("operators")
+        .select("*")
+        .eq("user_id", userId)
+        .order("created_at", { ascending: false });
+    if (error) {
+        console.warn("Error fetching operators by user id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+// Get operators by session id with additional filters
+export async function server_get_operators_by_session_id_filtered(sessionId, action, timestampAfter) {
+    const supabase = await newServerClient();
+    let query = supabase
+        .from("operators")
+        .select("*")
+        .eq("session_id", sessionId);
+    // Apply optional filters
+    if (action) {
+        query = query.eq("action", action);
+    }
+    if (timestampAfter) {
+        query = query.gte("timestamp", timestampAfter);
+    }
+    const { data, error } = await query.order("timestamp", { ascending: false });
+    if (error) {
+        console.warn("Error fetching filtered operators by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}

package/dist/hooks/useScoutRealtimeConnectivity copy.d.ts

@@ -0,0 +1,3 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+export declare function useScoutRealtimeConnectivity(scoutSupabase: SupabaseClient<Database>): void;

package/dist/hooks/useScoutRealtimeConnectivity copy.js

@@ -0,0 +1,159 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useMemo } from "react";
+import { setActiveHerdGpsTrackersConnectivity } from "../store/scout";
+import { server_get_connectivity_by_device_id } from "../helpers/connectivity";
+import { EnumWebResponse } from "../types/requests";
+import { getHoursAgoTimestamp } from "../helpers/time";
+export function useScoutRealtimeConnectivity(scoutSupabase) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    const connectivity = useSelector((state) => state.scout.active_herd_gps_trackers_connectivity);
+    const herdModules = useSelector((state) => state.scout.herd_modules);
+    // Create stable reference for GPS device IDs to prevent unnecessary refetching
+    const gpsDeviceIds = useMemo(() => {
+        if (!activeHerdId)
+            return "";
+        const activeHerdModule = herdModules.find((hm) => hm.herd.id.toString() === activeHerdId);
+        if (!activeHerdModule)
+            return "";
+        const gpsDevices = activeHerdModule.devices.filter((device) => device.device_type &&
+            ["gps_tracker", "gps_tracker_vehicle", "gps_tracker_person"].includes(device.device_type));
+        return gpsDevices
+            .map((d) => d.id)
+            .filter(Boolean)
+            .sort()
+            .join(",");
+    }, [activeHerdId, herdModules]);
+    // Handle connectivity broadcasts
+    const handleConnectivityBroadcast = useCallback((payload) => {
+        const { event, payload: data } = payload;
+        const connectivityData = data.record || data.old_record;
+        // Only process GPS tracker data (no session_id)
+        if (!connectivityData?.device_id || connectivityData.session_id) {
+            return;
+        }
+        const deviceId = connectivityData.device_id;
+        const updatedConnectivity = { ...connectivity };
+        switch (data.operation) {
+            case "INSERT":
+                console.log(`[CONNECTIVITY] INSERT for ${deviceId}, ${JSON.stringify(connectivityData)}`);
+                if (!updatedConnectivity[deviceId]) {
+                    updatedConnectivity[deviceId] = {
+                        most_recent: connectivityData,
+                        history: [],
+                    };
+                }
+                else {
+                    const newHistory = [
+                        updatedConnectivity[deviceId].most_recent,
+                        ...updatedConnectivity[deviceId].history,
+                    ].slice(0, 99);
+                    updatedConnectivity[deviceId] = {
+                        most_recent: connectivityData,
+                        history: newHistory,
+                    };
+                }
+                break;
+            case "UPDATE":
+                if (updatedConnectivity[deviceId]) {
+                    if (updatedConnectivity[deviceId].most_recent.id ===
+                        connectivityData.id) {
+                        updatedConnectivity[deviceId] = {
+                            ...updatedConnectivity[deviceId],
+                            most_recent: connectivityData,
+                        };
+                    }
+                    else {
+                        const historyIndex = updatedConnectivity[deviceId].history.findIndex((c) => c.id === connectivityData.id);
+                        if (historyIndex >= 0) {
+                            const newHistory = [...updatedConnectivity[deviceId].history];
+                            newHistory[historyIndex] = connectivityData;
+                            updatedConnectivity[deviceId] = {
+                                ...updatedConnectivity[deviceId],
+                                history: newHistory,
+                            };
+                        }
+                    }
+                }
+                break;
+            case "DELETE":
+                if (updatedConnectivity[deviceId]) {
+                    if (updatedConnectivity[deviceId].most_recent.id ===
+                        connectivityData.id) {
+                        if (updatedConnectivity[deviceId].history.length === 0) {
+                            delete updatedConnectivity[deviceId];
+                        }
+                        else {
+                            updatedConnectivity[deviceId] = {
+                                most_recent: updatedConnectivity[deviceId].history[0],
+                                history: updatedConnectivity[deviceId].history.slice(1),
+                            };
+                        }
+                    }
+                    else {
+                        updatedConnectivity[deviceId] = {
+                            ...updatedConnectivity[deviceId],
+                            history: updatedConnectivity[deviceId].history.filter((c) => c.id !== connectivityData.id),
+                        };
+                    }
+                }
+                break;
+        }
+        dispatch(setActiveHerdGpsTrackersConnectivity(updatedConnectivity));
+    }, [connectivity, dispatch]);
+    // Fetch initial connectivity data
+    const fetchInitialData = useCallback(async () => {
+        if (!gpsDeviceIds)
+            return;
+        const deviceIds = gpsDeviceIds.split(",").filter(Boolean).map(Number);
+        if (deviceIds.length === 0) {
+            return;
+        }
+        const timestampFilter = getHoursAgoTimestamp(1);
+        const connectivityData = {};
+        await Promise.all(deviceIds.map(async (deviceId) => {
+            try {
+                const response = await server_get_connectivity_by_device_id(deviceId, timestampFilter);
+                if (response.status === EnumWebResponse.SUCCESS && response.data) {
+                    const trackerData = response.data.filter((conn) => !conn.session_id);
+                    if (trackerData.length > 0) {
+                        const sortedData = trackerData
+                            .sort((a, b) => new Date(b.timestamp_start || 0).getTime() -
+                            new Date(a.timestamp_start || 0).getTime())
+                            .slice(0, 100);
+                        connectivityData[deviceId] = {
+                            most_recent: sortedData[0],
+                            history: sortedData.slice(1), // Exclude the most recent item
+                        };
+                    }
+                }
+            }
+            catch (error) {
+                // Silent error handling
+            }
+        }));
+        dispatch(setActiveHerdGpsTrackersConnectivity(connectivityData));
+    }, [gpsDeviceIds, dispatch]);
+    useEffect(() => {
+        if (!scoutSupabase || gpsDeviceIds === "")
+            return;
+        // Clean up existing channels
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+        // Create connectivity channel
+        const channel = scoutSupabase
+            .channel(`${activeHerdId}-connectivity`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleConnectivityBroadcast)
+            .subscribe();
+        channels.current.push(channel);
+        // Fetch initial data
+        fetchInitialData();
+        return () => {
+            channels.current.forEach((ch) => scoutSupabase.removeChannel(ch));
+            channels.current = [];
+        };
+    }, [scoutSupabase, gpsDeviceIds, activeHerdId, handleConnectivityBroadcast]);
+}

package/dist/hooks/useScoutRealtimeConnectivity.d.ts

@@ -1,3 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
-export declare function useScoutRealtimeConnectivity(scoutSupabase: SupabaseClient<Database>): void;
+import { IConnectivityWithCoordinates } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimeConnectivity(scoutSupabase: SupabaseClient<Database>): RealtimeData<IConnectivityWithCoordinates>[];

package/dist/hooks/useScoutRealtimeConnectivity.js

@@ -1,16 +1,11 @@
 "use client";
-import { useAppDispatch } from "../store/hooks";
 import { useSelector } from "react-redux";
-import { useEffect, useRef, useCallback, useMemo } from "react";
-import { setActiveHerdGpsTrackersConnectivity } from "../store/scout";
-import { server_get_connectivity_by_device_id } from "../helpers/connectivity";
-import { EnumWebResponse } from "../types/requests";
-import { getHoursAgoTimestamp } from "../helpers/time";
+import { useEffect, useRef, useCallback, useState, useMemo } from "react";
+import { EnumRealtimeOperation } from "../types/realtime";
 export function useScoutRealtimeConnectivity(scoutSupabase) {
     const channels = useRef([]);
-    const dispatch = useAppDispatch();
+    const [newConnectivityItems, setNewConnectivityItems] = useState([]);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    const connectivity = useSelector((state) => state.scout.active_herd_gps_trackers_connectivity);
     const herdModules = useSelector((state) => state.scout.herd_modules);
     // Create stable reference for GPS device IDs to prevent unnecessary refetching
     const gpsDeviceIds = useMemo(() => {
@@ -35,125 +30,55 @@ export function useScoutRealtimeConnectivity(scoutSupabase) {
         if (!connectivityData?.device_id || connectivityData.session_id) {
             return;
         }
-        const deviceId = connectivityData.device_id;
-        const updatedConnectivity = { ...connectivity };
+        let operation;
         switch (data.operation) {
             case "INSERT":
-                console.log(`[CONNECTIVITY] INSERT for ${deviceId}, ${JSON.stringify(connectivityData)}`);
-                if (!updatedConnectivity[deviceId]) {
-                    updatedConnectivity[deviceId] = {
-                        most_recent: connectivityData,
-                        history: [],
-                    };
-                }
-                else {
-                    const newHistory = [
-                        updatedConnectivity[deviceId].most_recent,
-                        ...updatedConnectivity[deviceId].history,
-                    ].slice(0, 99);
-                    updatedConnectivity[deviceId] = {
-                        most_recent: connectivityData,
-                        history: newHistory,
-                    };
-                }
+                operation = EnumRealtimeOperation.INSERT;
                 break;
             case "UPDATE":
-                if (updatedConnectivity[deviceId]) {
-                    if (updatedConnectivity[deviceId].most_recent.id ===
-                        connectivityData.id) {
-                        updatedConnectivity[deviceId] = {
-                            ...updatedConnectivity[deviceId],
-                            most_recent: connectivityData,
-                        };
-                    }
-                    else {
-                        const historyIndex = updatedConnectivity[deviceId].history.findIndex((c) => c.id === connectivityData.id);
-                        if (historyIndex >= 0) {
-                            const newHistory = [...updatedConnectivity[deviceId].history];
-                            newHistory[historyIndex] = connectivityData;
-                            updatedConnectivity[deviceId] = {
-                                ...updatedConnectivity[deviceId],
-                                history: newHistory,
-                            };
-                        }
-                    }
-                }
+                operation = EnumRealtimeOperation.UPDATE;
                 break;
             case "DELETE":
-                if (updatedConnectivity[deviceId]) {
-                    if (updatedConnectivity[deviceId].most_recent.id ===
-                        connectivityData.id) {
-                        if (updatedConnectivity[deviceId].history.length === 0) {
-                            delete updatedConnectivity[deviceId];
-                        }
-                        else {
-                            updatedConnectivity[deviceId] = {
-                                most_recent: updatedConnectivity[deviceId].history[0],
-                                history: updatedConnectivity[deviceId].history.slice(1),
-                            };
-                        }
-                    }
-                    else {
-                        updatedConnectivity[deviceId] = {
-                            ...updatedConnectivity[deviceId],
-                            history: updatedConnectivity[deviceId].history.filter((c) => c.id !== connectivityData.id),
-                        };
-                    }
-                }
+                operation = EnumRealtimeOperation.DELETE;
                 break;
+            default:
+                return;
         }
-        dispatch(setActiveHerdGpsTrackersConnectivity(updatedConnectivity));
-    }, [connectivity, dispatch]);
-    // Fetch initial connectivity data
-    const fetchInitialData = useCallback(async () => {
-        if (!gpsDeviceIds)
-            return;
-        const deviceIds = gpsDeviceIds.split(",").filter(Boolean).map(Number);
-        if (deviceIds.length === 0) {
-            return;
-        }
-        const timestampFilter = getHoursAgoTimestamp(1);
-        const connectivityData = {};
-        await Promise.all(deviceIds.map(async (deviceId) => {
-            try {
-                const response = await server_get_connectivity_by_device_id(deviceId, timestampFilter);
-                if (response.status === EnumWebResponse.SUCCESS && response.data) {
-                    const trackerData = response.data.filter((conn) => !conn.session_id);
-                    if (trackerData.length > 0) {
-                        const sortedData = trackerData
-                            .sort((a, b) => new Date(b.timestamp_start || 0).getTime() -
-                            new Date(a.timestamp_start || 0).getTime())
-                            .slice(0, 100);
-                        connectivityData[deviceId] = {
-                            most_recent: sortedData[0],
-                            history: sortedData.slice(1), // Exclude the most recent item
-                        };
-                    }
-                }
-            }
-            catch (error) {
-                // Silent error handling
-            }
-        }));
-        dispatch(setActiveHerdGpsTrackersConnectivity(connectivityData));
-    }, [gpsDeviceIds, dispatch]);
+        console.log(`[CONNECTIVITY] ${data.operation} received for device ${connectivityData.device_id}:`, JSON.stringify(connectivityData));
+        const realtimeData = {
+            data: connectivityData,
+            operation,
+        };
+        setNewConnectivityItems((prev) => [realtimeData, ...prev]);
+    }, []);
+    // Clear new items when gps device IDs change (herd change)
+    const clearNewItems = useCallback(() => {
+        setNewConnectivityItems([]);
+    }, []);
     useEffect(() => {
         if (!scoutSupabase || gpsDeviceIds === "")
             return;
         // Clean up existing channels
         channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
         channels.current = [];
+        // Clear previous items when switching herds
+        clearNewItems();
         // Create connectivity channel
         const channel = scoutSupabase
             .channel(`${activeHerdId}-connectivity`, { config: { private: true } })
             .on("broadcast", { event: "*" }, handleConnectivityBroadcast)
             .subscribe();
         channels.current.push(channel);
-        // Fetch initial data
-        fetchInitialData();
         return () => {
             channels.current.forEach((ch) => scoutSupabase.removeChannel(ch));
             channels.current = [];
         };
-    }, [scoutSupabase, gpsDeviceIds, activeHerdId, handleConnectivityBroadcast]);
+    }, [
+        scoutSupabase,
+        gpsDeviceIds,
+        activeHerdId,
+        handleConnectivityBroadcast,
+        clearNewItems,
+    ]);
+    return newConnectivityItems;
 }

package/dist/hooks/useScoutRealtimeDevices copy.d.ts

@@ -0,0 +1,3 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+export declare function useScoutRealtimeDevices(scoutSupabase: SupabaseClient<Database>): void;

package/dist/hooks/useScoutRealtimeDevices copy.js

@@ -0,0 +1,55 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback } from "react";
+import { addDevice, deleteDevice, updateDevice } from "../store/scout";
+export function useScoutRealtimeDevices(scoutSupabase) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Device broadcast handler
+    const handleDeviceBroadcast = useCallback((payload) => {
+        console.log("[Devices] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        switch (data.operation) {
+            case "INSERT":
+                if (data.record)
+                    dispatch(addDevice(data.record));
+                break;
+            case "UPDATE":
+                if (data.record)
+                    dispatch(updateDevice(data.record));
+                break;
+            case "DELETE":
+                if (data.old_record)
+                    dispatch(deleteDevice(data.old_record));
+                break;
+        }
+    }, [dispatch]);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createDevicesChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-devices`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleDeviceBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Devices] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Devices] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Create devices channel for active herd
+        if (activeHerdId) {
+            const channel = createDevicesChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId]);
+}

package/dist/hooks/useScoutRealtimeDevices.d.ts

@@ -1,3 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
-export declare function useScoutRealtimeDevices(scoutSupabase: SupabaseClient<Database>): void;
+import { IDevicePrettyLocation } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimeDevices(scoutSupabase: SupabaseClient<Database>): RealtimeData<IDevicePrettyLocation>[];

package/dist/hooks/useScoutRealtimeDevices.js

@@ -1,31 +1,55 @@
 "use client";
 import { useAppDispatch } from "../store/hooks";
 import { useSelector } from "react-redux";
-import { useEffect, useRef, useCallback } from "react";
+import { useEffect, useRef, useCallback, useState } from "react";
 import { addDevice, deleteDevice, updateDevice } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
 export function useScoutRealtimeDevices(scoutSupabase) {
     const channels = useRef([]);
     const dispatch = useAppDispatch();
+    const [newDeviceItems, setNewDeviceItems] = useState([]);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
     // Device broadcast handler
     const handleDeviceBroadcast = useCallback((payload) => {
         console.log("[Devices] Broadcast received:", payload.payload.operation);
         const data = payload.payload;
+        const deviceData = data.record || data.old_record;
+        if (!deviceData)
+            return;
+        let operation;
         switch (data.operation) {
             case "INSERT":
-                if (data.record)
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record) {
+                    console.log("[Devices] New device received:", data.record);
                     dispatch(addDevice(data.record));
+                }
                 break;
             case "UPDATE":
-                if (data.record)
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record) {
                     dispatch(updateDevice(data.record));
+                }
                 break;
             case "DELETE":
-                if (data.old_record)
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record) {
                     dispatch(deleteDevice(data.old_record));
+                }
                 break;
+            default:
+                return;
         }
+        const realtimeData = {
+            data: deviceData,
+            operation,
+        };
+        setNewDeviceItems((prev) => [realtimeData, ...prev]);
     }, [dispatch]);
+    // Clear new items when herd changes
+    const clearNewItems = useCallback(() => {
+        setNewDeviceItems([]);
+    }, []);
     const cleanupChannels = () => {
         channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
         channels.current = [];
@@ -45,11 +69,14 @@ export function useScoutRealtimeDevices(scoutSupabase) {
     };
     useEffect(() => {
         cleanupChannels();
+        // Clear previous items when switching herds
+        clearNewItems();
         // Create devices channel for active herd
         if (activeHerdId) {
             const channel = createDevicesChannel(activeHerdId);
             channels.current.push(channel);
         }
         return cleanupChannels;
-    }, [activeHerdId]);
+    }, [activeHerdId, clearNewItems]);
+    return newDeviceItems;
 }

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -807,6 +807,45 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
         };
     };
     Functions: {
+        analyze_device_heartbeats: {
+            Args: {
+                p_device_id: number;
+                p_lookback_minutes?: number;
+                p_window_minutes?: number;
+            };
+            Returns: Database["public"]["CompositeTypes"]["device_heartbeat_analysis"];
+            SetofOptions: {
+                from: "*";
+                to: "device_heartbeat_analysis";
+                isOneToOne: true;
+                isSetofReturn: false;
+            };
+        };
+        analyze_herd_device_heartbeats: {
+            Args: {
+                p_device_types?: Database["public"]["Enums"]["device_type"][];
+                p_herd_id: number;
+                p_lookback_minutes?: number;
+                p_window_minutes?: number;
+            };
+            Returns: Database["public"]["CompositeTypes"]["device_heartbeat_analysis"][];
+            SetofOptions: {
+                from: "*";
+                to: "device_heartbeat_analysis";
+                isOneToOne: false;
+                isSetofReturn: true;
+            };
+        };
+        check_realtime_schema_status: {
+            Args: never;
+            Returns: {
+                check_type: string;
+                details: string;
+                schema_name: string;
+                status: string;
+                table_name: string;
+            }[];
+        };
         get_connectivity_with_coordinates: {
             Args: {
                 session_id_caller: number;
@@ -942,6 +981,22 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 isSetofReturn: true;
             };
         };
+        get_herd_uptime_summary: {
+            Args: {
+                p_device_types?: Database["public"]["Enums"]["device_type"][];
+                p_herd_id: number;
+                p_lookback_minutes?: number;
+                p_window_minutes?: number;
+            };
+            Returns: {
+                average_heartbeat_interval: number;
+                offline_devices: number;
+                online_devices: number;
+                overall_uptime_percentage: number;
+                total_devices: number;
+                total_heartbeats: number;
+            }[];
+        };
         get_sessions_with_coordinates: {
             Args: {
                 herd_id_caller: number;
@@ -1048,6 +1103,19 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
             h11_index: string | null;
             battery_percentage: number | null;
         };
+        device_heartbeat_analysis: {
+            device_id: number | null;
+            is_online: boolean | null;
+            last_heartbeat_time: string | null;
+            minutes_since_last_heartbeat: number | null;
+            heartbeat_history: boolean[] | null;
+            uptime_percentage: number | null;
+            heartbeat_intervals: number[] | null;
+            average_heartbeat_interval: number | null;
+            total_heartbeats: number | null;
+            analysis_window_start: string | null;
+            analysis_window_end: string | null;
+        };
         device_pretty_location: {
             id: number | null;
             inserted_at: string | null;

package/dist/providers/ScoutRefreshProvider.js

@@ -3,8 +3,6 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useScoutRefresh } from "../hooks/useScoutRefresh";
 import { createContext, useContext, useMemo, useRef } from "react";
 import { createBrowserClient } from "@supabase/ssr";
-import { useScoutRealtimeConnectivity } from "../hooks/useScoutRealtimeConnectivity";
-import { useScoutRealtimeDevices } from "../hooks/useScoutRealtimeDevices";
 // Create context for the Supabase client
 const SupabaseContext = createContext(null);
 const ConnectionStatusContext = createContext(null);
@@ -33,9 +31,6 @@ export function ScoutRefreshProvider({ children }) {
         console.log("[ScoutRefreshProvider] Creating Supabase client");
         return createBrowserClient(urlRef.current, anonKeyRef.current);
     }, []); // Empty dependency array ensures this only runs once
-    // Use the enhanced DB listener with connection status
-    useScoutRealtimeConnectivity(supabaseClient);
-    useScoutRealtimeDevices(supabaseClient);
     useScoutRefresh();
     // // Log connection status changes for debugging
     // if (connectionStatus.lastError) {

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 IOperator = Database["public"]["Tables"]["operators"]["Row"];
 export type IProvider = Database["public"]["Tables"]["providers"]["Row"];
 export type IEventWithTags = Database["public"]["CompositeTypes"]["event_with_tags"] & {
     earthranger_url: string | null;
@@ -32,6 +33,8 @@ export type IEventAndTagsPrettyLocation = Database["public"]["CompositeTypes"]["
 export type IZonesAndActionsPrettyLocation = Database["public"]["CompositeTypes"]["zones_and_actions_pretty_location"];
 export type ISessionWithCoordinates = Database["public"]["CompositeTypes"]["session_with_coordinates"];
 export type IConnectivityWithCoordinates = Database["public"]["CompositeTypes"]["connectivity_with_coordinates"];
+export type IDeviceHeartbeatAnalysis = Database["public"]["CompositeTypes"]["device_heartbeat_analysis"];
+export type IHerdUptimeSummary = Database["public"]["Functions"]["get_herd_uptime_summary"]["Returns"][0];
 export interface IZoneWithActions extends IZone {
     actions: IAction[];
 }

package/dist/types/herd_module.js

@@ -5,7 +5,6 @@ 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";
 import { server_get_more_zones_and_actions_for_herd } from "../helpers/zones";
@@ -64,42 +63,8 @@ export class HerdModule {
     static async from_herd(herd, client) {
         const startTime = Date.now();
         try {
-            // load devices
-            let response_new_devices = await get_devices_by_herd(herd.id, client);
-            if (response_new_devices.status == EnumWebResponse.ERROR ||
-                !response_new_devices.data) {
-                console.warn(`[HerdModule] No devices found for herd ${herd.id}`);
-                return new HerdModule(herd, [], [], Date.now());
-            }
-            const new_devices = response_new_devices.data;
-            // get api keys and events for all devices in batch
-            let recent_events_batch = {};
-            if (new_devices.length > 0) {
-                try {
-                    const device_ids = new_devices.map((device) => device.id ?? 0);
-                    // Load API keys and events in parallel
-                    const [api_keys_batch, events_response] = await Promise.all([
-                        server_list_api_keys_batch(device_ids),
-                        server_get_events_and_tags_for_devices_batch(device_ids, 1),
-                    ]);
-                    // 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] || [];
-                    }
-                    // Process events response
-                    if (events_response.status === EnumWebResponse.SUCCESS &&
-                        events_response.data) {
-                        recent_events_batch = events_response.data;
-                    }
-                }
-                catch (error) {
-                    console.error(`[HerdModule] Batch load error:`, error);
-                    // Continue without API keys and events
-                }
-            }
-            // 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, res_providers,] = await Promise.allSettled([
+            // 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 };
@@ -133,20 +98,38 @@ export class HerdModule {
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
             ]);
-            // Assign recent events to devices from batch results
-            for (let i = 0; i < new_devices.length; i++) {
+            // Load devices
+            const devicesPromise = get_devices_by_herd(herd.id, client);
+            // Wait for both devices and herd-level data
+            const [deviceResponse, herdLevelResults] = await Promise.all([
+                devicesPromise,
+                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;
+            // Load API keys for devices if we have any
+            if (new_devices.length > 0) {
                 try {
-                    const device_id = new_devices[i].id ?? 0;
-                    const events = recent_events_batch[device_id];
-                    if (events) {
-                        new_devices[i].recent_events = events;
+                    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.warn(`Failed to process events for device ${new_devices[i].id}:`, error);
+                    console.error(`[HerdModule] Failed to load API keys:`, error);
+                    // Continue without API keys
                 }
             }
-            // Extract data with safe fallbacks
+            // Extract herd-level data with safe fallbacks
+            const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions, res_layers, res_providers,] = herdLevelResults;
             const zones = res_zones.status === "fulfilled" && res_zones.value?.data
                 ? res_zones.value.data
                 : [];

package/dist/types/realtime.d.ts

@@ -0,0 +1,9 @@
+export declare enum EnumRealtimeOperation {
+    INSERT = 0,
+    UPDATE = 1,
+    DELETE = 2
+}
+export type RealtimeData<T> = {
+    data: T;
+    operation: EnumRealtimeOperation;
+};

package/dist/types/realtime.js

@@ -0,0 +1,6 @@
+export var EnumRealtimeOperation;
+(function (EnumRealtimeOperation) {
+    EnumRealtimeOperation[EnumRealtimeOperation["INSERT"] = 0] = "INSERT";
+    EnumRealtimeOperation[EnumRealtimeOperation["UPDATE"] = 1] = "UPDATE";
+    EnumRealtimeOperation[EnumRealtimeOperation["DELETE"] = 2] = "DELETE";
+})(EnumRealtimeOperation || (EnumRealtimeOperation = {}));

package/dist/types/supabase.d.ts

@@ -855,6 +855,45 @@ export type Database = {
             };
         };
         Functions: {
+            analyze_device_heartbeats: {
+                Args: {
+                    p_device_id: number;
+                    p_lookback_minutes?: number;
+                    p_window_minutes?: number;
+                };
+                Returns: Database["public"]["CompositeTypes"]["device_heartbeat_analysis"];
+                SetofOptions: {
+                    from: "*";
+                    to: "device_heartbeat_analysis";
+                    isOneToOne: true;
+                    isSetofReturn: false;
+                };
+            };
+            analyze_herd_device_heartbeats: {
+                Args: {
+                    p_device_types?: Database["public"]["Enums"]["device_type"][];
+                    p_herd_id: number;
+                    p_lookback_minutes?: number;
+                    p_window_minutes?: number;
+                };
+                Returns: Database["public"]["CompositeTypes"]["device_heartbeat_analysis"][];
+                SetofOptions: {
+                    from: "*";
+                    to: "device_heartbeat_analysis";
+                    isOneToOne: false;
+                    isSetofReturn: true;
+                };
+            };
+            check_realtime_schema_status: {
+                Args: never;
+                Returns: {
+                    check_type: string;
+                    details: string;
+                    schema_name: string;
+                    status: string;
+                    table_name: string;
+                }[];
+            };
             get_connectivity_with_coordinates: {
                 Args: {
                     session_id_caller: number;
@@ -990,6 +1029,22 @@ export type Database = {
                     isSetofReturn: true;
                 };
             };
+            get_herd_uptime_summary: {
+                Args: {
+                    p_device_types?: Database["public"]["Enums"]["device_type"][];
+                    p_herd_id: number;
+                    p_lookback_minutes?: number;
+                    p_window_minutes?: number;
+                };
+                Returns: {
+                    average_heartbeat_interval: number;
+                    offline_devices: number;
+                    online_devices: number;
+                    overall_uptime_percentage: number;
+                    total_devices: number;
+                    total_heartbeats: number;
+                }[];
+            };
             get_sessions_with_coordinates: {
                 Args: {
                     herd_id_caller: number;
@@ -1096,6 +1151,19 @@ export type Database = {
                 h11_index: string | null;
                 battery_percentage: number | null;
             };
+            device_heartbeat_analysis: {
+                device_id: number | null;
+                is_online: boolean | null;
+                last_heartbeat_time: string | null;
+                minutes_since_last_heartbeat: number | null;
+                heartbeat_history: boolean[] | null;
+                uptime_percentage: number | null;
+                heartbeat_intervals: number[] | null;
+                average_heartbeat_interval: number | null;
+                total_heartbeats: number | null;
+                analysis_window_start: string | null;
+                analysis_window_end: string | null;
+            };
             device_pretty_location: {
                 id: number | null;
                 inserted_at: string | null;

package/package.json

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