@adventurelabs/scout-core 1.2.1 → 1.2.4

package/dist/helpers/index.d.ts

@@ -22,3 +22,4 @@ export * from "./operators";
 export * from "./components";
 export * from "./versions_software";
 export * from "./artifacts";
+export * from "./pins";

package/dist/helpers/index.js

@@ -22,3 +22,4 @@ export * from "./operators";
 export * from "./components";
 export * from "./versions_software";
 export * from "./artifacts";
+export * from "./pins";

package/dist/helpers/pins.d.ts

@@ -0,0 +1,11 @@
+import { Database } from "../types/supabase";
+import { IPin, PinInsert } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function get_pins_for_herd(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IPin[]>>;
+export declare function get_pin_by_id(client: SupabaseClient<Database>, pin_id: number): Promise<IWebResponseCompatible<IPin | null>>;
+export declare function create_pin(client: SupabaseClient<Database>, newPin: PinInsert): Promise<IWebResponseCompatible<IPin | null>>;
+export declare function update_pin(client: SupabaseClient<Database>, pin_id: number, updatedPin: Partial<PinInsert>): Promise<IWebResponseCompatible<IPin | null>>;
+export declare function delete_pin(client: SupabaseClient<Database>, pin_id: number): Promise<IWebResponseCompatible<IPin | null>>;
+export declare function get_pins_by_created_by(client: SupabaseClient<Database>, user_id: string): Promise<IWebResponseCompatible<IPin[]>>;
+export declare function get_pins_by_color(client: SupabaseClient<Database>, herd_id: number, color: string): Promise<IWebResponseCompatible<IPin[]>>;

package/dist/helpers/pins.js

@@ -0,0 +1,142 @@
+import { IWebResponse } from "../types/requests";
+export async function get_pins_for_herd(client, herd_id) {
+    // Call get_pins_for_herd with rpc
+    const { data, error } = await client.rpc("get_pins_for_herd", {
+        herd_id_caller: herd_id,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No pins found for herd").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_pin_by_id(client, pin_id) {
+    const { data, error } = await client
+        .from("pins")
+        .select("*")
+        .eq("id", pin_id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Pin not found").to_compatible();
+    }
+    // Convert to pretty location format with coordinates
+    const pinWithCoords = {
+        ...data,
+        latitude: data.latitude ? parseFloat(data.latitude.toString()) : 0,
+        longitude: data.longitude ? parseFloat(data.longitude.toString()) : 0,
+    };
+    return IWebResponse.success(pinWithCoords).to_compatible();
+}
+export async function create_pin(client, newPin) {
+    const { data, error } = await client
+        .from("pins")
+        .insert([newPin])
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Failed to create pin").to_compatible();
+    }
+    // Convert to pretty location format with coordinates
+    const pinWithCoords = {
+        ...data,
+        latitude: data.latitude ? parseFloat(data.latitude.toString()) : 0,
+        longitude: data.longitude ? parseFloat(data.longitude.toString()) : 0,
+    };
+    return IWebResponse.success(pinWithCoords).to_compatible();
+}
+export async function update_pin(client, pin_id, updatedPin) {
+    // Remove fields that shouldn't be updated
+    const updateData = { ...updatedPin };
+    delete updateData.id;
+    delete updateData.created_at;
+    delete updateData.created_by; // RLS handles permissions
+    const { data, error } = await client
+        .from("pins")
+        .update(updateData)
+        .eq("id", pin_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Pin not found or update failed").to_compatible();
+    }
+    // Convert to pretty location format with coordinates
+    const pinWithCoords = {
+        ...data,
+        latitude: data.latitude ? parseFloat(data.latitude.toString()) : 0,
+        longitude: data.longitude ? parseFloat(data.longitude.toString()) : 0,
+    };
+    return IWebResponse.success(pinWithCoords).to_compatible();
+}
+export async function delete_pin(client, pin_id) {
+    const { data, error } = await client
+        .from("pins")
+        .delete()
+        .eq("id", pin_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Pin not found or deletion failed").to_compatible();
+    }
+    // Convert to pretty location format with coordinates
+    const pinWithCoords = {
+        ...data,
+        latitude: data.latitude ? parseFloat(data.latitude.toString()) : 0,
+        longitude: data.longitude ? parseFloat(data.longitude.toString()) : 0,
+    };
+    return IWebResponse.success(pinWithCoords).to_compatible();
+}
+export async function get_pins_by_created_by(client, user_id) {
+    const { data, error } = await client
+        .from("pins")
+        .select("*")
+        .eq("created_by", user_id)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No pins found for user").to_compatible();
+    }
+    // Convert to pretty location format with coordinates
+    const pinsWithCoords = data.map((pin) => ({
+        ...pin,
+        latitude: pin.latitude ? parseFloat(pin.latitude.toString()) : 0,
+        longitude: pin.longitude ? parseFloat(pin.longitude.toString()) : 0,
+    }));
+    return IWebResponse.success(pinsWithCoords).to_compatible();
+}
+export async function get_pins_by_color(client, herd_id, color) {
+    const { data, error } = await client
+        .from("pins")
+        .select("*")
+        .eq("herd_id", herd_id)
+        .eq("color", color)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error(`No pins found with color: ${color}`).to_compatible();
+    }
+    // Convert to pretty location format with coordinates
+    const pinsWithCoords = data.map((pin) => ({
+        ...pin,
+        latitude: pin.latitude ? parseFloat(pin.latitude.toString()) : 0,
+        longitude: pin.longitude ? parseFloat(pin.longitude.toString()) : 0,
+    }));
+    return IWebResponse.success(pinsWithCoords).to_compatible();
+}

package/dist/hooks/index.d.ts

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

package/dist/hooks/index.js

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

package/dist/hooks/useScoutRealtimeConnectivity.d.ts

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

package/dist/hooks/useScoutRealtimeConnectivity.js

@@ -4,7 +4,7 @@ import { useEffect, useRef, useCallback, useState, useMemo } from "react";
 import { EnumRealtimeOperation } from "../types/realtime";
 export function useScoutRealtimeConnectivity(scoutSupabase) {
     const channels = useRef([]);
-    const [newConnectivityItems, setNewConnectivityItems] = useState([]);
+    const [latestConnectivityUpdate, setLatestConnectivityUpdate] = useState(null);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
     const herdModules = useSelector((state) => state.scout.herd_modules);
     // Create stable reference for GPS device IDs to prevent unnecessary refetching
@@ -49,11 +49,11 @@ export function useScoutRealtimeConnectivity(scoutSupabase) {
             data: connectivityData,
             operation,
         };
-        setNewConnectivityItems((prev) => [realtimeData, ...prev]);
+        setLatestConnectivityUpdate(realtimeData);
     }, []);
-    // Clear new items when gps device IDs change (herd change)
-    const clearNewItems = useCallback(() => {
-        setNewConnectivityItems([]);
+    // Clear latest update
+    const clearLatestUpdate = useCallback(() => {
+        setLatestConnectivityUpdate(null);
     }, []);
     useEffect(() => {
         if (!scoutSupabase || gpsDeviceIds === "")
@@ -61,8 +61,8 @@ export function useScoutRealtimeConnectivity(scoutSupabase) {
         // Clean up existing channels
         channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
         channels.current = [];
-        // Clear previous items when switching herds
-        clearNewItems();
+        // Clear previous update when switching herds
+        clearLatestUpdate();
         // Create connectivity channel
         const channel = scoutSupabase
             .channel(`${activeHerdId}-connectivity`, { config: { private: true } })
@@ -78,7 +78,7 @@ export function useScoutRealtimeConnectivity(scoutSupabase) {
         gpsDeviceIds,
         activeHerdId,
         handleConnectivityBroadcast,
-        clearNewItems,
+        clearLatestUpdate,
     ]);
-    return newConnectivityItems;
+    return [latestConnectivityUpdate, clearLatestUpdate];
 }

package/dist/hooks/useScoutRealtimeDevices.d.ts

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

package/dist/hooks/useScoutRealtimeDevices.js

@@ -7,7 +7,7 @@ import { EnumRealtimeOperation } from "../types/realtime";
 export function useScoutRealtimeDevices(scoutSupabase) {
     const channels = useRef([]);
     const dispatch = useAppDispatch();
-    const [newDeviceItems, setNewDeviceItems] = useState([]);
+    const [latestDeviceUpdate, setLatestDeviceUpdate] = useState(null);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
     // Device broadcast handler
     const handleDeviceBroadcast = useCallback((payload) => {
@@ -45,11 +45,11 @@ export function useScoutRealtimeDevices(scoutSupabase) {
             operation,
         };
         console.log(`[scout-core realtime] DEVICE ${data.operation} received:`, JSON.stringify(realtimeData));
-        setNewDeviceItems((prev) => [realtimeData, ...prev]);
+        setLatestDeviceUpdate(realtimeData);
     }, [dispatch]);
-    // Clear new items when herd changes
-    const clearNewItems = useCallback(() => {
-        setNewDeviceItems([]);
+    // Clear latest update
+    const clearLatestUpdate = useCallback(() => {
+        setLatestDeviceUpdate(null);
     }, []);
     const cleanupChannels = () => {
         channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
@@ -70,14 +70,14 @@ export function useScoutRealtimeDevices(scoutSupabase) {
     };
     useEffect(() => {
         cleanupChannels();
-        // Clear previous items when switching herds
-        clearNewItems();
+        // Clear previous update when switching herds
+        clearLatestUpdate();
         // Create devices channel for active herd
         if (activeHerdId) {
             const channel = createDevicesChannel(activeHerdId);
             channels.current.push(channel);
         }
         return cleanupChannels;
-    }, [activeHerdId, clearNewItems]);
-    return newDeviceItems;
+    }, [activeHerdId, clearLatestUpdate]);
+    return [latestDeviceUpdate, clearLatestUpdate];
 }

package/dist/hooks/useScoutRealtimeEvents.d.ts

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

package/dist/hooks/useScoutRealtimeEvents.js

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

package/dist/hooks/useScoutRealtimePins.d.ts

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

package/dist/hooks/useScoutRealtimePins.js

@@ -0,0 +1,80 @@
+"use client";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimePins(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+    const channels = useRef([]);
+    const [latestPinUpdate, setLatestPinUpdate] = useState(null);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Pin broadcast handler
+    const handlePinBroadcast = useCallback((payload) => {
+        console.log("[Pins] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const pinData = data.record || data.old_record;
+        if (!pinData)
+            return;
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Pins] New pin received:", data.record);
+                    // TODO: dispatch(addPinToStore(data.record));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    // TODO: dispatch(updatePinInStore(data.record));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
+                    // TODO: dispatch(deletePinFromStore(data.old_record));
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: pinData,
+            operation,
+        };
+        console.log(`[scout-core realtime] PIN ${data.operation} received for pin "${pinData.name}" (${pinData.id}):`, JSON.stringify(realtimeData));
+        setLatestPinUpdate(realtimeData);
+    }, [shouldUpdateGlobalStateOnChanges]);
+    // Clear latest update
+    const clearLatestUpdate = useCallback(() => {
+        setLatestPinUpdate(null);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createPinsChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-pins`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handlePinBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Pins] ✅ Connected to herd ${herdId} pins broadcasts`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Pins] 🟡 Failed to connect to herd ${herdId} pins broadcasts`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous update when switching herds
+        clearLatestUpdate();
+        // Create pins channel for active herd
+        if (activeHerdId) {
+            const channel = createPinsChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearLatestUpdate]);
+    return [latestPinUpdate, clearLatestUpdate];
+}

package/dist/hooks/useScoutRealtimePlans.d.ts

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

package/dist/hooks/useScoutRealtimePlans.js

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

package/dist/hooks/useScoutRealtimeSessions.d.ts

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

package/dist/hooks/useScoutRealtimeSessions.js

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

package/dist/hooks/useScoutRealtimeTags.d.ts

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

package/dist/hooks/useScoutRealtimeTags.js

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

package/dist/hooks/useScoutRealtimeVersionsSoftware.d.ts

@@ -2,4 +2,4 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { IVersionsSoftware } from "../types/db";
 import { RealtimeData } from "../types/realtime";
-export declare function useScoutRealtimeVersionsSoftware(scoutSupabase: SupabaseClient<Database>): RealtimeData<IVersionsSoftware>[];
+export declare function useScoutRealtimeVersionsSoftware(scoutSupabase: SupabaseClient<Database>): [RealtimeData<IVersionsSoftware> | null, () => void];

package/dist/hooks/useScoutRealtimeVersionsSoftware.js

@@ -3,7 +3,7 @@ import { useEffect, useRef, useCallback, useState } from "react";
 import { EnumRealtimeOperation } from "../types/realtime";
 export function useScoutRealtimeVersionsSoftware(scoutSupabase) {
     const channels = useRef([]);
-    const [newVersionsItems, setNewVersionsItems] = useState([]);
+    const [latestVersionUpdate, setLatestVersionUpdate] = useState(null);
     // Handle versions software broadcasts
     const handleVersionsSoftwareBroadcast = useCallback((payload) => {
         const { event, payload: data } = payload;
@@ -30,11 +30,11 @@ export function useScoutRealtimeVersionsSoftware(scoutSupabase) {
             data: versionData,
             operation,
         };
-        setNewVersionsItems((prev) => [realtimeData, ...prev]);
+        setLatestVersionUpdate(realtimeData);
     }, []);
-    // Clear new items
-    const clearNewItems = useCallback(() => {
-        setNewVersionsItems([]);
+    // Clear latest update
+    const clearLatestUpdate = useCallback(() => {
+        setLatestVersionUpdate(null);
     }, []);
     useEffect(() => {
         if (!scoutSupabase)
@@ -42,8 +42,8 @@ export function useScoutRealtimeVersionsSoftware(scoutSupabase) {
         // Clean up existing channels
         channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
         channels.current = [];
-        // Clear previous items when setting up
-        clearNewItems();
+        // Clear previous update when setting up
+        clearLatestUpdate();
         // Create versions_software channel
         const channel = scoutSupabase
             .channel("versions_software_changes", { config: { private: true } })
@@ -61,6 +61,6 @@ export function useScoutRealtimeVersionsSoftware(scoutSupabase) {
             channels.current.forEach((ch) => scoutSupabase.removeChannel(ch));
             channels.current = [];
         };
-    }, [scoutSupabase, handleVersionsSoftwareBroadcast, clearNewItems]);
-    return newVersionsItems;
+    }, [scoutSupabase, handleVersionsSoftwareBroadcast, clearLatestUpdate]);
+    return [latestVersionUpdate, clearLatestUpdate];
 }

package/dist/index.d.ts

@@ -21,6 +21,7 @@ export * from "./helpers/events";
 export * from "./helpers/gps";
 export * from "./helpers/herds";
 export * from "./helpers/location";
+export * from "./helpers/pins";
 export * from "./helpers/plans";
 export * from "./helpers/layers";
 export * from "./helpers/sessions";
@@ -41,6 +42,10 @@ export * from "./helpers/components";
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
 export * from "./hooks/useScoutRealtimeVersionsSoftware";
+export * from "./hooks/useScoutRealtimeEvents";
+export * from "./hooks/useScoutRealtimeTags";
+export * from "./hooks/useScoutRealtimeSessions";
+export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRefresh";
 export * from "./providers";
 export * from "./store/scout";

package/dist/index.js

@@ -24,6 +24,7 @@ export * from "./helpers/events";
 export * from "./helpers/gps";
 export * from "./helpers/herds";
 export * from "./helpers/location";
+export * from "./helpers/pins";
 export * from "./helpers/plans";
 export * from "./helpers/layers";
 export * from "./helpers/sessions";
@@ -45,6 +46,10 @@ export * from "./helpers/components";
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
 export * from "./hooks/useScoutRealtimeVersionsSoftware";
+export * from "./hooks/useScoutRealtimeEvents";
+export * from "./hooks/useScoutRealtimeTags";
+export * from "./hooks/useScoutRealtimeSessions";
+export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRefresh";
 // Providers
 export * from "./providers";

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -547,6 +547,57 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 referencedColumns: ["id"];
             }];
         };
+        pins: {
+            Row: {
+                altitude_relative_to_ground: number;
+                color: string;
+                created_at: string;
+                created_by: string | null;
+                description: string | null;
+                herd_id: number;
+                id: number;
+                latitude: unknown;
+                longitude: unknown;
+                name: string;
+            };
+            Insert: {
+                altitude_relative_to_ground: number;
+                color: string;
+                created_at?: string;
+                created_by?: string | null;
+                description?: string | null;
+                herd_id: number;
+                id?: number;
+                latitude: unknown;
+                longitude: unknown;
+                name: string;
+            };
+            Update: {
+                altitude_relative_to_ground?: number;
+                color?: string;
+                created_at?: string;
+                created_by?: string | null;
+                description?: string | null;
+                herd_id?: number;
+                id?: number;
+                latitude?: unknown;
+                longitude?: unknown;
+                name?: string;
+            };
+            Relationships: [{
+                foreignKeyName: "pins_created_by_fkey";
+                columns: ["created_by"];
+                isOneToOne: false;
+                referencedRelation: "users";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "pins_herd_id_fkey";
+                columns: ["herd_id"];
+                isOneToOne: false;
+                referencedRelation: "herds";
+                referencedColumns: ["id"];
+            }];
+        };
         plans: {
             Row: {
                 herd_id: number;
@@ -1265,6 +1316,18 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 total_heartbeats: number;
             }[];
         };
+        get_pins_for_herd: {
+            Args: {
+                herd_id_caller: number;
+            };
+            Returns: Database["public"]["CompositeTypes"]["pins_pretty_location"][];
+            SetofOptions: {
+                from: "*";
+                to: "pins_pretty_location";
+                isOneToOne: false;
+                isSetofReturn: true;
+            };
+        };
         get_sessions_with_coordinates: {
             Args: {
                 herd_id_caller: number;
@@ -1484,6 +1547,18 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
             is_public: boolean | null;
             tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
         };
+        pins_pretty_location: {
+            id: number | null;
+            created_at: string | null;
+            altitude_relative_to_ground: number | null;
+            color: string | null;
+            name: string | null;
+            description: string | null;
+            herd_id: number | null;
+            created_by: string | null;
+            latitude: number | null;
+            longitude: number | null;
+        };
         session_with_coordinates: {
             id: number | null;
             device_id: number | null;

package/dist/types/db.d.ts

@@ -9,6 +9,7 @@ export type IUser = User;
 export type IDevice = Database["public"]["CompositeTypes"]["device_pretty_location"] & {
     api_keys_scout?: IApiKeyScout[];
 };
+export type IPin = Database["public"]["CompositeTypes"]["pins_pretty_location"];
 export type IEvent = Database["public"]["Tables"]["events"]["Row"];
 export type ITag = Database["public"]["Tables"]["tags"]["Row"];
 export type ITagPrettyLocation = Database["public"]["CompositeTypes"]["tags_pretty_location"];
@@ -32,6 +33,7 @@ export type IArtifactWithMediaUrl = IArtifact & {
 export type ComponentInsert = Database["public"]["Tables"]["components"]["Insert"];
 export type VersionsSoftwareInsert = Database["public"]["Tables"]["versions_software"]["Insert"];
 export type ArtifactInsert = Database["public"]["Tables"]["artifacts"]["Insert"];
+export type PinInsert = Database["public"]["Tables"]["pins"]["Insert"];
 export type IEventWithTags = Database["public"]["CompositeTypes"]["event_with_tags"] & {
     earthranger_url: string | null;
     file_path: string | null;

package/dist/types/supabase.d.ts

@@ -574,6 +574,60 @@ export type Database = {
                     }
                 ];
             };
+            pins: {
+                Row: {
+                    altitude_relative_to_ground: number;
+                    color: string;
+                    created_at: string;
+                    created_by: string | null;
+                    description: string | null;
+                    herd_id: number;
+                    id: number;
+                    latitude: unknown;
+                    longitude: unknown;
+                    name: string;
+                };
+                Insert: {
+                    altitude_relative_to_ground: number;
+                    color: string;
+                    created_at?: string;
+                    created_by?: string | null;
+                    description?: string | null;
+                    herd_id: number;
+                    id?: number;
+                    latitude: unknown;
+                    longitude: unknown;
+                    name: string;
+                };
+                Update: {
+                    altitude_relative_to_ground?: number;
+                    color?: string;
+                    created_at?: string;
+                    created_by?: string | null;
+                    description?: string | null;
+                    herd_id?: number;
+                    id?: number;
+                    latitude?: unknown;
+                    longitude?: unknown;
+                    name?: string;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "pins_created_by_fkey";
+                        columns: ["created_by"];
+                        isOneToOne: false;
+                        referencedRelation: "users";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "pins_herd_id_fkey";
+                        columns: ["herd_id"];
+                        isOneToOne: false;
+                        referencedRelation: "herds";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
             plans: {
                 Row: {
                     herd_id: number;
@@ -1317,6 +1371,18 @@ export type Database = {
                     total_heartbeats: number;
                 }[];
             };
+            get_pins_for_herd: {
+                Args: {
+                    herd_id_caller: number;
+                };
+                Returns: Database["public"]["CompositeTypes"]["pins_pretty_location"][];
+                SetofOptions: {
+                    from: "*";
+                    to: "pins_pretty_location";
+                    isOneToOne: false;
+                    isSetofReturn: true;
+                };
+            };
             get_sessions_with_coordinates: {
                 Args: {
                     herd_id_caller: number;
@@ -1536,6 +1602,18 @@ export type Database = {
                 is_public: boolean | null;
                 tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
             };
+            pins_pretty_location: {
+                id: number | null;
+                created_at: string | null;
+                altitude_relative_to_ground: number | null;
+                color: string | null;
+                name: string | null;
+                description: string | null;
+                herd_id: number | null;
+                created_by: string | null;
+                latitude: number | null;
+                longitude: number | null;
+            };
             session_with_coordinates: {
                 id: number | null;
                 device_id: number | null;

package/package.json

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