@adventurelabs/scout-core 1.4.2 → 1.4.4

package/dist/constants/env.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This helper checks multiple possible environment variable names to support
+ * different frameworks and build tools:
+ * - NEXT_PUBLIC_* (Next.js convention, also works in other frameworks)
+ * - VITE_* (Vite convention)
+ * - REACT_APP_* (Create React App convention)
+ * - Direct access (for runtime configuration)
+ */
+/**
+ * Get an environment variable, checking multiple possible names
+ *
+ * @param name - The base name of the environment variable (without prefix)
+ * @param defaultValue - Optional default value if not found
+ * @returns The environment variable value or default
+ */
+export declare function getEnvVar(name: string, defaultValue?: string): string;
+/**
+ * Get Supabase URL from environment variables
+ */
+export declare function getSupabaseUrl(): string;
+/**
+ * Get Supabase anonymous key from environment variables
+ */
+export declare function getSupabaseAnonKey(): string;

package/dist/constants/env.js

@@ -0,0 +1,47 @@
+/**
+ * This helper checks multiple possible environment variable names to support
+ * different frameworks and build tools:
+ * - NEXT_PUBLIC_* (Next.js convention, also works in other frameworks)
+ * - VITE_* (Vite convention)
+ * - REACT_APP_* (Create React App convention)
+ * - Direct access (for runtime configuration)
+ */
+/**
+ * Get an environment variable, checking multiple possible names
+ *
+ * @param name - The base name of the environment variable (without prefix)
+ * @param defaultValue - Optional default value if not found
+ * @returns The environment variable value or default
+ */
+export function getEnvVar(name, defaultValue = "") {
+    // Check multiple possible prefixes
+    const possibleNames = [
+        `NEXT_PUBLIC_${name}`, // Next.js (also works in other frameworks)
+        `VITE_${name}`, // Vite
+        `REACT_APP_${name}`, // Create React App
+        name, // Direct access (for runtime configuration)
+    ];
+    // Try each possible name
+    for (const envName of possibleNames) {
+        if (typeof process !== "undefined" && process.env?.[envName]) {
+            return process.env[envName];
+        }
+        // Also check window object for runtime configuration (PWA use case)
+        if (typeof window !== "undefined" && window.__SCOUT_CONFIG__?.[name]) {
+            return window.__SCOUT_CONFIG__[name];
+        }
+    }
+    return defaultValue;
+}
+/**
+ * Get Supabase URL from environment variables
+ */
+export function getSupabaseUrl() {
+    return getEnvVar("SUPABASE_URL", "");
+}
+/**
+ * Get Supabase anonymous key from environment variables
+ */
+export function getSupabaseAnonKey() {
+    return getEnvVar("SUPABASE_ANON_KEY", "");
+}

package/dist/constants/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./annotator";
 export * from "./app";
+export * from "./env";

package/dist/constants/index.js

@@ -1,2 +1,3 @@
 export * from "./annotator";
 export * from "./app";
+export * from "./env";

package/dist/helpers/connectivity.d.ts

@@ -1,4 +1,7 @@
 import { IWebResponseCompatible } from "../types/requests";
-import { IConnectivityWithCoordinates } from "../types/db";
+import { IConnectivityWithCoordinates, IConnectivity, ConnectivityInsert, ConnectivityUpdate } from "../types/db";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_connectivity_by_session_id(sessionId: number): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
 export declare function server_get_connectivity_by_device_id(deviceId: number, timestamp: string): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
+export declare function server_insert_connectivity(connectivity: ConnectivityInsert, client?: SupabaseClient): Promise<IWebResponseCompatible<IConnectivity | null>>;
+export declare function server_update_connectivity(connectivityId: number, updates: ConnectivityUpdate, client?: SupabaseClient): Promise<IWebResponseCompatible<IConnectivity | null>>;

package/dist/helpers/connectivity.js

@@ -44,3 +44,51 @@ export async function server_get_connectivity_by_device_id(deviceId, timestamp)
     });
     return IWebResponse.success(sortedConnectivity).to_compatible();
 }
+// Insert a new connectivity record
+export async function server_insert_connectivity(connectivity, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase
+        .from("connectivity")
+        .insert([connectivity])
+        .select("*")
+        .single();
+    if (error) {
+        console.warn("Error inserting connectivity:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+// Update an existing connectivity record
+export async function server_update_connectivity(connectivityId, updates, client) {
+    const supabase = client || (await newServerClient());
+    // Remove fields that shouldn't be updated
+    const updateData = { ...updates };
+    delete updateData.id;
+    delete updateData.inserted_at;
+    const { data, error } = await supabase
+        .from("connectivity")
+        .update(updateData)
+        .eq("id", connectivityId)
+        .select("*")
+        .single();
+    if (error) {
+        console.warn("Error updating connectivity:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    if (!data) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "Connectivity record not found or update failed",
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/db.js

@@ -1,7 +1,8 @@
 import { createClient } from "@supabase/supabase-js";
+import { getSupabaseUrl, getSupabaseAnonKey } from "../constants/env";
 export function createClientWithApiKey(user_api_key) {
-    const supabase_url = process.env.NEXT_PUBLIC_SUPABASE_URL;
-    const supabase_anon_key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+    const supabase_url = getSupabaseUrl();
+    const supabase_anon_key = getSupabaseAnonKey();
     if (!supabase_url || !supabase_anon_key) {
         return null;
     }

package/dist/helpers/events.d.ts

@@ -1,3 +1,7 @@
 import { IWebResponseCompatible } from "../types/requests";
 import { EnumSessionsVisibility } from "../types/events";
+import { IEvent, EventInsert, EventUpdate } from "../types/db";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_total_events_by_herd(herd_id: number, sessions_visibility: EnumSessionsVisibility): Promise<IWebResponseCompatible<number>>;
+export declare function server_insert_event(event: EventInsert, client?: SupabaseClient): Promise<IWebResponseCompatible<IEvent | null>>;
+export declare function server_update_event(eventId: number, updates: EventUpdate, client?: SupabaseClient): Promise<IWebResponseCompatible<IEvent | null>>;

package/dist/helpers/events.js

@@ -22,3 +22,51 @@ export async function server_get_total_events_by_herd(herd_id, sessions_visibili
         return IWebResponse.success(data || 0).to_compatible();
     }
 }
+// Insert a new event
+export async function server_insert_event(event, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase
+        .from("events")
+        .insert([event])
+        .select("*")
+        .single();
+    if (error) {
+        console.warn("Error inserting event:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+// Update an existing event
+export async function server_update_event(eventId, updates, client) {
+    const supabase = client || (await newServerClient());
+    // Remove fields that shouldn't be updated
+    const updateData = { ...updates };
+    delete updateData.id;
+    delete updateData.inserted_at;
+    const { data, error } = await supabase
+        .from("events")
+        .update(updateData)
+        .eq("id", eventId)
+        .select("*")
+        .single();
+    if (error) {
+        console.warn("Error updating event:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    if (!data) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "Event not found or update failed",
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/sessions.d.ts

@@ -1,7 +1,9 @@
-import { ISessionWithCoordinates, ISessionUsageOverTime, IEventAndTagsPrettyLocation } from "../types/db";
+import { ISessionWithCoordinates, ISessionUsageOverTime, IEventAndTagsPrettyLocation, ISession, SessionInsert, SessionUpdate } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_session_by_id(sessionId: number, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionWithCoordinates | null>>;
 export declare function server_get_session_usage_over_time_by_herd(herd_id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionUsageOverTime>>;
 export declare function server_get_session_usage_over_time_by_device(device_id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionUsageOverTime>>;
 export declare function server_get_events_and_tags_by_session_id(sessionId: number, limit?: number, offset?: number): Promise<IWebResponseCompatible<IEventAndTagsPrettyLocation[]>>;
+export declare function server_insert_session(session: SessionInsert, client?: SupabaseClient): Promise<IWebResponseCompatible<ISession | null>>;
+export declare function server_update_session(sessionId: number, updates: SessionUpdate, client?: SupabaseClient): Promise<IWebResponseCompatible<ISession | null>>;

package/dist/helpers/sessions.js

@@ -71,3 +71,51 @@ export async function server_get_events_and_tags_by_session_id(sessionId, limit
     }
     return IWebResponse.success(data || []).to_compatible();
 }
+// Insert a new session
+export async function server_insert_session(session, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase
+        .from("sessions")
+        .insert([session])
+        .select("*")
+        .single();
+    if (error) {
+        console.warn("Error inserting session:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+// Update an existing session
+export async function server_update_session(sessionId, updates, client) {
+    const supabase = client || (await newServerClient());
+    // Remove fields that shouldn't be updated
+    const updateData = { ...updates };
+    delete updateData.id;
+    delete updateData.inserted_at;
+    const { data, error } = await supabase
+        .from("sessions")
+        .update(updateData)
+        .eq("id", sessionId)
+        .select("*")
+        .single();
+    if (error) {
+        console.warn("Error updating session:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    if (!data) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "Session not found or update failed",
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/hooks/useScoutRealtimeDevices.js

@@ -1,15 +1,12 @@
 "use client";
-import { useAppDispatch } from "../store/hooks";
 import { useSelector } from "react-redux";
 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 [latestDeviceUpdate, setLatestDeviceUpdate] = useState(null);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Device broadcast handler
+    // Device broadcast handler - just pass data, don't mutate state
     const handleDeviceBroadcast = useCallback((payload) => {
         console.log("[Devices] Broadcast received:", payload.payload.operation);
         const data = payload.payload;
@@ -20,22 +17,15 @@ export function useScoutRealtimeDevices(scoutSupabase) {
         switch (data.operation) {
             case "INSERT":
                 operation = EnumRealtimeOperation.INSERT;
-                if (data.record) {
-                    console.log("[Devices] New device received:", data.record);
-                    dispatch(addDevice(data.record));
-                }
+                console.log("[Devices] New device received:", data.record);
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record) {
-                    dispatch(updateDevice(data.record));
-                }
+                console.log("[Devices] Device updated:", data.record);
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record) {
-                    dispatch(deleteDevice(data.old_record));
-                }
+                console.log("[Devices] Device deleted:", data.old_record);
                 break;
             default:
                 return;
@@ -46,7 +36,7 @@ export function useScoutRealtimeDevices(scoutSupabase) {
         };
         console.log(`[scout-core realtime] DEVICE ${data.operation} received:`, JSON.stringify(realtimeData));
         setLatestDeviceUpdate(realtimeData);
-    }, [dispatch]);
+    }, []);
     // Clear latest update
     const clearLatestUpdate = useCallback(() => {
         setLatestDeviceUpdate(null);

package/dist/hooks/useScoutRealtimeEvents.d.ts

@@ -2,4 +2,4 @@ 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>, invalidateRTKQuery?: boolean): [RealtimeData<IEventAndTagsPrettyLocation> | null, () => void];
+export declare function useScoutRealtimeEvents(scoutSupabase: SupabaseClient<Database>): [RealtimeData<IEventAndTagsPrettyLocation> | null, () => void];

package/dist/hooks/useScoutRealtimeEvents.js

@@ -1,15 +1,12 @@
 "use client";
-import { useAppDispatch } from "../store/hooks";
 import { useSelector } from "react-redux";
 import { useEffect, useRef, useCallback, useState } from "react";
 import { EnumRealtimeOperation } from "../types/realtime";
-import { scoutApi } from "../store/api";
-export function useScoutRealtimeEvents(scoutSupabase, invalidateRTKQuery = true) {
+export function useScoutRealtimeEvents(scoutSupabase) {
     const channels = useRef([]);
-    const dispatch = useAppDispatch();
     const [latestEventUpdate, setLatestEventUpdate] = useState(null);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Event broadcast handler
+    // Event broadcast handler - just pass data, don't mutate state
     const handleEventBroadcast = useCallback((payload) => {
         console.log("[Events] Broadcast received:", payload.payload.operation);
         const data = payload.payload;
@@ -20,30 +17,15 @@ export function useScoutRealtimeEvents(scoutSupabase, invalidateRTKQuery = true)
         switch (data.operation) {
             case "INSERT":
                 operation = EnumRealtimeOperation.INSERT;
-                if (data.record && invalidateRTKQuery) {
-                    console.log("[Events] New event received, invalidating RTK Query cache:", data.record);
-                    // Invalidate all events queries to refetch fresh data
-                    dispatch(scoutApi.util.invalidateTags(["Event"]));
-                }
+                console.log("[Events] New event received:", data.record);
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record && invalidateRTKQuery) {
-                    console.log("[Events] Event updated, invalidating RTK Query cache:", data.record);
-                    // Invalidate specific event and list queries
-                    dispatch(scoutApi.util.invalidateTags([
-                        { type: "Event", id: data.record.id || "unknown" },
-                        { type: "Event", id: "LIST" },
-                    ]));
-                }
+                console.log("[Events] Event updated:", data.record);
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record && invalidateRTKQuery) {
-                    console.log("[Events] Event deleted, invalidating RTK Query cache:", data.old_record);
-                    // Invalidate all events queries since item was deleted
-                    dispatch(scoutApi.util.invalidateTags(["Event"]));
-                }
+                console.log("[Events] Event deleted:", data.old_record);
                 break;
             default:
                 return;
@@ -54,7 +36,7 @@ export function useScoutRealtimeEvents(scoutSupabase, invalidateRTKQuery = true)
         };
         console.log(`[scout-core realtime] EVENT ${data.operation} received:`, JSON.stringify(realtimeData));
         setLatestEventUpdate(realtimeData);
-    }, [dispatch, invalidateRTKQuery]);
+    }, []);
     // Clear latest update
     const clearLatestUpdate = useCallback(() => {
         setLatestEventUpdate(null);

package/dist/hooks/useScoutRealtimeParts.js

@@ -1,15 +1,12 @@
 "use client";
-import { useAppDispatch } from "../store/hooks";
 import { useSelector } from "react-redux";
 import { useEffect, useRef, useCallback, useState } from "react";
 import { EnumRealtimeOperation } from "../types/realtime";
 export function useScoutRealtimeParts(scoutSupabase) {
     const channels = useRef([]);
-    const dispatch = useAppDispatch();
     const [latestPartUpdate, setLatestPartUpdate] = useState(null);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    const herdModules = useSelector((state) => state.scout.herd_modules);
-    // Part broadcast handler
+    // Part broadcast handler - just pass data, don't mutate state
     const handlePartBroadcast = useCallback((payload) => {
         console.log("[Parts] Broadcast received:", payload.payload.operation);
         const data = payload.payload;
@@ -17,55 +14,18 @@ export function useScoutRealtimeParts(scoutSupabase) {
         if (!partData)
             return;
         let operation;
-        // Find the target herd module and device
-        const herdModule = herdModules.find((hm) => hm.herd.id.toString() === activeHerdId);
-        if (!herdModule) {
-            console.warn("[Parts] No herd module found for active herd");
-            return;
-        }
-        const targetDevice = herdModule.devices.find((device) => device.id === partData.device_id);
-        if (!targetDevice) {
-            console.warn(`[Parts] No device found with ID: ${partData.device_id}`);
-            return;
-        }
-        // Ensure device has parts array
-        if (!targetDevice.parts) {
-            targetDevice.parts = [];
-        }
         switch (data.operation) {
             case "INSERT":
                 operation = EnumRealtimeOperation.INSERT;
-                if (data.record) {
-                    console.log("[Parts] New part received:", data.record);
-                    // Add part to device's parts array if not already present
-                    const existingPartIndex = targetDevice.parts.findIndex((p) => p.id === data.record.id);
-                    if (existingPartIndex === -1) {
-                        targetDevice.parts.push(data.record);
-                    }
-                }
+                console.log("[Parts] New part received:", data.record);
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record) {
-                    console.log("[Parts] Part updated:", data.record);
-                    // Update existing part in device's parts array
-                    const partIndex = targetDevice.parts.findIndex((p) => p.id === data.record.id);
-                    if (partIndex !== -1) {
-                        targetDevice.parts[partIndex] = data.record;
-                    }
-                    else {
-                        // Part not found, add it
-                        targetDevice.parts.push(data.record);
-                    }
-                }
+                console.log("[Parts] Part updated:", data.record);
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record) {
-                    console.log("[Parts] Part deleted:", data.old_record);
-                    // Remove part from device's parts array
-                    targetDevice.parts = targetDevice.parts.filter((p) => p.id !== data.old_record.id);
-                }
+                console.log("[Parts] Part deleted:", data.old_record);
                 break;
             default:
                 return;
@@ -76,7 +36,7 @@ export function useScoutRealtimeParts(scoutSupabase) {
         };
         console.log(`[scout-core realtime] PART ${data.operation} received:`, JSON.stringify(realtimeData));
         setLatestPartUpdate(realtimeData);
-    }, [dispatch, activeHerdId, herdModules]);
+    }, []);
     // Clear latest update
     const clearLatestUpdate = useCallback(() => {
         setLatestPartUpdate(null);

package/dist/hooks/useScoutRealtimePins.d.ts

@@ -2,4 +2,4 @@ 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];
+export declare function useScoutRealtimePins(scoutSupabase: SupabaseClient<Database>): [RealtimeData<IPin> | null, () => void];

package/dist/hooks/useScoutRealtimePins.js

@@ -2,11 +2,11 @@
 import { useSelector } from "react-redux";
 import { useEffect, useRef, useCallback, useState } from "react";
 import { EnumRealtimeOperation } from "../types/realtime";
-export function useScoutRealtimePins(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+export function useScoutRealtimePins(scoutSupabase) {
     const channels = useRef([]);
     const [latestPinUpdate, setLatestPinUpdate] = useState(null);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Pin broadcast handler
+    // Pin broadcast handler - just pass data, don't mutate state
     const handlePinBroadcast = useCallback((payload) => {
         console.log("[Pins] Broadcast received:", payload.payload.operation);
         const data = payload.payload;
@@ -17,22 +17,15 @@ export function useScoutRealtimePins(scoutSupabase, shouldUpdateGlobalStateOnCha
         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));
-                }
+                console.log("[Pins] New pin received:", data.record);
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record && shouldUpdateGlobalStateOnChanges) {
-                    // TODO: dispatch(updatePinInStore(data.record));
-                }
+                console.log("[Pins] Pin updated:", data.record);
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
-                    // TODO: dispatch(deletePinFromStore(data.old_record));
-                }
+                console.log("[Pins] Pin deleted:", data.old_record);
                 break;
             default:
                 return;
@@ -43,7 +36,7 @@ export function useScoutRealtimePins(scoutSupabase, shouldUpdateGlobalStateOnCha
         };
         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);

package/dist/hooks/useScoutRealtimePlans.d.ts

@@ -2,4 +2,4 @@ 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];
+export declare function useScoutRealtimePlans(scoutSupabase: SupabaseClient<Database>): [RealtimeData<IPlan> | null, () => void];

package/dist/hooks/useScoutRealtimePlans.js

@@ -1,15 +1,12 @@
 "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) {
+export function useScoutRealtimePlans(scoutSupabase) {
     const channels = useRef([]);
-    const dispatch = useAppDispatch();
     const [latestPlanUpdate, setLatestPlanUpdate] = useState(null);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Plan broadcast handler
+    // Plan broadcast handler - just pass data, don't mutate state
     const handlePlanBroadcast = useCallback((payload) => {
         console.log("[Plans] Broadcast received:", payload.payload.operation);
         const data = payload.payload;
@@ -20,22 +17,15 @@ export function useScoutRealtimePlans(scoutSupabase, shouldUpdateGlobalStateOnCh
         switch (data.operation) {
             case "INSERT":
                 operation = EnumRealtimeOperation.INSERT;
-                if (data.record && shouldUpdateGlobalStateOnChanges) {
-                    console.log("[Plans] New plan received:", data.record);
-                    dispatch(addPlan(data.record));
-                }
+                console.log("[Plans] New plan received:", data.record);
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record && shouldUpdateGlobalStateOnChanges) {
-                    dispatch(updatePlan(data.record));
-                }
+                console.log("[Plans] Plan updated:", data.record);
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
-                    dispatch(deletePlan(data.old_record));
-                }
+                console.log("[Plans] Plan deleted:", data.old_record);
                 break;
             default:
                 return;
@@ -46,7 +36,7 @@ export function useScoutRealtimePlans(scoutSupabase, shouldUpdateGlobalStateOnCh
         };
         console.log(`[scout-core realtime] PLAN ${data.operation} received:`, JSON.stringify(realtimeData));
         setLatestPlanUpdate(realtimeData);
-    }, [dispatch]);
+    }, []);
     // Clear latest update
     const clearLatestUpdate = useCallback(() => {
         setLatestPlanUpdate(null);

package/dist/hooks/useScoutRealtimeSessions.d.ts

@@ -2,4 +2,4 @@ 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>, invalidateRTKQuery?: boolean): [RealtimeData<ISessionWithCoordinates> | null, () => void];
+export declare function useScoutRealtimeSessions(scoutSupabase: SupabaseClient<Database>): [RealtimeData<ISessionWithCoordinates> | null, () => void];

package/dist/hooks/useScoutRealtimeSessions.js

@@ -1,15 +1,12 @@
 "use client";
 import { useSelector } from "react-redux";
-import { useAppDispatch } from "../store/hooks";
 import { useEffect, useRef, useCallback, useState } from "react";
 import { EnumRealtimeOperation } from "../types/realtime";
-import { scoutApi } from "../store/api";
-export function useScoutRealtimeSessions(scoutSupabase, invalidateRTKQuery = true) {
+export function useScoutRealtimeSessions(scoutSupabase) {
     const channels = useRef([]);
-    const dispatch = useAppDispatch();
     const [latestSessionUpdate, setLatestSessionUpdate] = useState(null);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Session broadcast handler
+    // Session broadcast handler - just pass data, don't mutate state
     const handleSessionBroadcast = useCallback((payload) => {
         console.log("[Sessions] Broadcast received:", payload.payload.operation);
         const data = payload.payload;
@@ -20,30 +17,15 @@ export function useScoutRealtimeSessions(scoutSupabase, invalidateRTKQuery = tru
         switch (data.operation) {
             case "INSERT":
                 operation = EnumRealtimeOperation.INSERT;
-                if (data.record && invalidateRTKQuery) {
-                    console.log("[Sessions] New session received, invalidating RTK Query cache:", data.record);
-                    // Invalidate all sessions queries to refetch fresh data
-                    dispatch(scoutApi.util.invalidateTags(["Session"]));
-                }
+                console.log("[Sessions] New session received:", data.record);
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record && invalidateRTKQuery) {
-                    console.log("[Sessions] Session updated, invalidating RTK Query cache:", data.record);
-                    // Invalidate specific session and list queries
-                    dispatch(scoutApi.util.invalidateTags([
-                        { type: "Session", id: data.record.id || "unknown" },
-                        { type: "Session", id: "LIST" },
-                    ]));
-                }
+                console.log("[Sessions] Session updated:", data.record);
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record && invalidateRTKQuery) {
-                    console.log("[Sessions] Session deleted, invalidating RTK Query cache:", data.old_record);
-                    // Invalidate all sessions queries since item was deleted
-                    dispatch(scoutApi.util.invalidateTags(["Session"]));
-                }
+                console.log("[Sessions] Session deleted:", data.old_record);
                 break;
             default:
                 return;
@@ -54,7 +36,7 @@ export function useScoutRealtimeSessions(scoutSupabase, invalidateRTKQuery = tru
         };
         console.log(`[scout-core realtime] SESSION ${data.operation} received:`, JSON.stringify(realtimeData));
         setLatestSessionUpdate(realtimeData);
-    }, [invalidateRTKQuery, dispatch]);
+    }, []);
     // Clear latest update
     const clearLatestUpdate = useCallback(() => {
         setLatestSessionUpdate(null);
@@ -86,6 +68,6 @@ export function useScoutRealtimeSessions(scoutSupabase, invalidateRTKQuery = tru
             channels.current.push(channel);
         }
         return cleanupChannels;
-    }, [activeHerdId, clearLatestUpdate, handleSessionBroadcast]);
+    }, [activeHerdId, clearLatestUpdate]);
     return [latestSessionUpdate, clearLatestUpdate];
 }

package/dist/hooks/useScoutRealtimeTags.d.ts

@@ -2,4 +2,4 @@ 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>, invalidateRTKQuery?: boolean): [RealtimeData<ITagPrettyLocation> | null, () => void];
+export declare function useScoutRealtimeTags(scoutSupabase: SupabaseClient<Database>): [RealtimeData<ITagPrettyLocation> | null, () => void];

package/dist/hooks/useScoutRealtimeTags.js

@@ -1,15 +1,12 @@
 "use client";
-import { useAppDispatch } from "../store/hooks";
 import { useSelector } from "react-redux";
 import { useEffect, useRef, useCallback, useState } from "react";
 import { EnumRealtimeOperation } from "../types/realtime";
-import { scoutApi } from "../store/api";
-export function useScoutRealtimeTags(scoutSupabase, invalidateRTKQuery = true) {
+export function useScoutRealtimeTags(scoutSupabase) {
     const channels = useRef([]);
-    const dispatch = useAppDispatch();
     const [latestTagUpdate, setLatestTagUpdate] = useState(null);
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Tag broadcast handler
+    // Tag broadcast handler - just pass data, don't mutate state
     const handleTagBroadcast = useCallback((payload) => {
         console.log("[Tags] Broadcast received:", payload.payload.operation);
         const data = payload.payload;
@@ -20,27 +17,15 @@ export function useScoutRealtimeTags(scoutSupabase, invalidateRTKQuery = true) {
         switch (data.operation) {
             case "INSERT":
                 operation = EnumRealtimeOperation.INSERT;
-                if (data.record && invalidateRTKQuery) {
-                    console.log("[Tags] New tag received, invalidating RTK Query cache:", data.record);
-                    // Tags are part of events, so invalidate events queries
-                    dispatch(scoutApi.util.invalidateTags(["Event"]));
-                }
+                console.log("[Tags] New tag received:", data.record);
                 break;
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
-                if (data.record && invalidateRTKQuery) {
-                    console.log("[Tags] Tag updated, invalidating RTK Query cache:", data.record);
-                    // Invalidate events queries since tags are embedded in events
-                    dispatch(scoutApi.util.invalidateTags(["Event"]));
-                }
+                console.log("[Tags] Tag updated:", data.record);
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
-                if (data.old_record && invalidateRTKQuery) {
-                    console.log("[Tags] Tag deleted, invalidating RTK Query cache:", data.old_record);
-                    // Invalidate events queries since tags are embedded in events
-                    dispatch(scoutApi.util.invalidateTags(["Event"]));
-                }
+                console.log("[Tags] Tag deleted:", data.old_record);
                 break;
             default:
                 return;
@@ -51,7 +36,7 @@ export function useScoutRealtimeTags(scoutSupabase, invalidateRTKQuery = true) {
         };
         console.log(`[scout-core realtime] TAG ${data.operation} received:`, JSON.stringify(realtimeData));
         setLatestTagUpdate(realtimeData);
-    }, [dispatch, invalidateRTKQuery]);
+    }, []);
     // Clear latest update
     const clearLatestUpdate = useCallback(() => {
         setLatestTagUpdate(null);

package/dist/hooks/useScoutRefresh.js

@@ -7,6 +7,7 @@ import { server_load_herd_modules } from "../helpers/herds";
 import { scoutCache } from "../helpers/cache";
 import { EnumDataSource } from "../types/data_source";
 import { createBrowserClient } from "@supabase/ssr";
+import { getSupabaseUrl, getSupabaseAnonKey } from "../constants/env";
 /**
  * Hook for refreshing scout data with detailed timing measurements and cache-first loading
  *
@@ -37,8 +38,9 @@ export function useScoutRefresh(options = {}) {
     const store = useStore();
     const refreshInProgressRef = useRef(false);
     // Create Supabase client directly to avoid circular dependency
+    // Uses flexible environment variable helper for better PWA compatibility
     const supabase = useMemo(() => {
-        return createBrowserClient(process.env.NEXT_PUBLIC_SUPABASE_URL || "", process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "");
+        return createBrowserClient(getSupabaseUrl(), getSupabaseAnonKey());
     }, []);
     // Refs to store timing measurements
     const timingRefs = useRef({

package/dist/providers/ScoutRefreshProvider.js

@@ -3,6 +3,7 @@ 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 { getSupabaseUrl, getSupabaseAnonKey } from "../constants/env";
 // Create context for the Supabase client
 const SupabaseContext = createContext(null);
 const ConnectionStatusContext = createContext(null);
@@ -24,8 +25,9 @@ export function useConnectionStatus() {
 }
 export function ScoutRefreshProvider({ children }) {
     // Use refs to store the URL and key to prevent unnecessary recreations
-    const urlRef = useRef(process.env.NEXT_PUBLIC_SUPABASE_URL || "");
-    const anonKeyRef = useRef(process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "");
+    // Uses flexible environment variable helper for better PWA compatibility
+    const urlRef = useRef(getSupabaseUrl());
+    const anonKeyRef = useRef(getSupabaseAnonKey());
     // Create a single Supabase client instance that only runs once
     const supabaseClient = useMemo(() => {
         console.log("[ScoutRefreshProvider] Creating Supabase client");

package/dist/types/db.d.ts

@@ -54,6 +54,12 @@ export type PartInsert = Database["public"]["Tables"]["parts"]["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 SessionInsert = Database["public"]["Tables"]["sessions"]["Insert"];
+export type SessionUpdate = Database["public"]["Tables"]["sessions"]["Update"];
+export type ConnectivityInsert = Database["public"]["Tables"]["connectivity"]["Insert"];
+export type ConnectivityUpdate = Database["public"]["Tables"]["connectivity"]["Update"];
+export type EventInsert = Database["public"]["Tables"]["events"]["Insert"];
+export type EventUpdate = Database["public"]["Tables"]["events"]["Update"];
 export type IEventWithTags = Database["public"]["CompositeTypes"]["event_with_tags"] & {
     earthranger_url: string | null;
     file_path: string | null;

package/package.json

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