@adventurelabs/scout-core 1.2.5 → 1.3.1

package/dist/store/api.js

@@ -0,0 +1,377 @@
+import { createApi, fakeBaseQuery } from "@reduxjs/toolkit/query/react";
+import { generateSignedUrlsBatch } from "../helpers/storage";
+// Create the API slice
+export const scoutApi = createApi({
+    reducerPath: "scoutApi",
+    baseQuery: fakeBaseQuery(),
+    tagTypes: ["Session", "Event", "Artifact"],
+    endpoints: (builder) => ({
+        // =====================================================
+        // SESSIONS INFINITE QUERIES
+        // =====================================================
+        getSessionsInfiniteByHerd: builder.query({
+            async queryFn({ herdId, limit = 20, cursor, supabase }) {
+                try {
+                    if (!herdId) {
+                        return {
+                            error: { status: "CUSTOM_ERROR", error: "Herd ID is required" },
+                        };
+                    }
+                    const { data, error } = await supabase.rpc("get_sessions_infinite_by_herd", {
+                        herd_id_caller: herdId,
+                        limit_caller: limit + 1, // Fetch one extra to determine if there are more
+                        cursor_timestamp: cursor?.timestamp || null,
+                        cursor_id: cursor?.id || null,
+                    });
+                    if (error) {
+                        return {
+                            error: { status: "SUPABASE_ERROR", error: error.message },
+                        };
+                    }
+                    const sessions = data || [];
+                    const hasMore = sessions.length > limit;
+                    const resultSessions = hasMore ? sessions.slice(0, limit) : sessions;
+                    const nextCursor = hasMore && resultSessions.length > 0
+                        ? {
+                            timestamp: resultSessions[resultSessions.length - 1].timestamp_start ||
+                                "",
+                            id: resultSessions[resultSessions.length - 1].id || 0,
+                        }
+                        : null;
+                    return {
+                        data: {
+                            sessions: resultSessions,
+                            nextCursor,
+                            hasMore,
+                        },
+                    };
+                }
+                catch (err) {
+                    return { error: { status: "FETCH_ERROR", error: String(err) } };
+                }
+            },
+            providesTags: (result) => result
+                ? [
+                    ...result.sessions.map(({ id }) => ({
+                        type: "Session",
+                        id: id || "unknown",
+                    })),
+                    { type: "Session", id: "LIST" },
+                ]
+                : [{ type: "Session", id: "LIST" }],
+        }),
+        getSessionsInfiniteByDevice: builder.query({
+            async queryFn({ deviceId, limit = 20, cursor, supabase }) {
+                try {
+                    if (!deviceId) {
+                        return {
+                            error: { status: "CUSTOM_ERROR", error: "Device ID is required" },
+                        };
+                    }
+                    const { data, error } = await supabase.rpc("get_sessions_infinite_by_device", {
+                        device_id_caller: deviceId,
+                        limit_caller: limit + 1,
+                        cursor_timestamp: cursor?.timestamp || null,
+                        cursor_id: cursor?.id || null,
+                    });
+                    if (error) {
+                        return {
+                            error: { status: "SUPABASE_ERROR", error: error.message },
+                        };
+                    }
+                    const sessions = data || [];
+                    const hasMore = sessions.length > limit;
+                    const resultSessions = hasMore ? sessions.slice(0, limit) : sessions;
+                    const nextCursor = hasMore && resultSessions.length > 0
+                        ? {
+                            timestamp: resultSessions[resultSessions.length - 1].timestamp_start ||
+                                "",
+                            id: resultSessions[resultSessions.length - 1].id || 0,
+                        }
+                        : null;
+                    return {
+                        data: {
+                            sessions: resultSessions,
+                            nextCursor,
+                            hasMore,
+                        },
+                    };
+                }
+                catch (err) {
+                    return { error: { status: "FETCH_ERROR", error: String(err) } };
+                }
+            },
+            providesTags: (result) => result
+                ? [
+                    ...result.sessions.map(({ id }) => ({
+                        type: "Session",
+                        id: id || "unknown",
+                    })),
+                    { type: "Session", id: "LIST" },
+                ]
+                : [{ type: "Session", id: "LIST" }],
+        }),
+        // =====================================================
+        // EVENTS INFINITE QUERIES
+        // =====================================================
+        getEventsInfiniteByHerd: builder.query({
+            async queryFn({ herdId, limit = 20, cursor, supabase }) {
+                try {
+                    if (!herdId) {
+                        return {
+                            error: { status: "CUSTOM_ERROR", error: "Herd ID is required" },
+                        };
+                    }
+                    const { data, error } = await supabase.rpc("get_events_infinite_by_herd", {
+                        herd_id_caller: herdId,
+                        limit_caller: limit + 1,
+                        cursor_timestamp: cursor?.timestamp || null,
+                        cursor_id: cursor?.id || null,
+                    });
+                    if (error) {
+                        return {
+                            error: { status: "SUPABASE_ERROR", error: error.message },
+                        };
+                    }
+                    const events = data || [];
+                    const hasMore = events.length > limit;
+                    const resultEvents = hasMore ? events.slice(0, limit) : events;
+                    const nextCursor = hasMore && resultEvents.length > 0
+                        ? {
+                            timestamp: resultEvents[resultEvents.length - 1]
+                                .timestamp_observation || "",
+                            id: resultEvents[resultEvents.length - 1].id || 0,
+                        }
+                        : null;
+                    return {
+                        data: {
+                            events: resultEvents,
+                            nextCursor,
+                            hasMore,
+                        },
+                    };
+                }
+                catch (err) {
+                    return { error: { status: "FETCH_ERROR", error: String(err) } };
+                }
+            },
+            providesTags: (result) => result
+                ? [
+                    ...result.events.map(({ id }) => ({
+                        type: "Event",
+                        id: id || "unknown",
+                    })),
+                    { type: "Event", id: "LIST" },
+                ]
+                : [{ type: "Event", id: "LIST" }],
+        }),
+        getEventsInfiniteByDevice: builder.query({
+            async queryFn({ deviceId, limit = 20, cursor, supabase }) {
+                try {
+                    if (!deviceId) {
+                        return {
+                            error: { status: "CUSTOM_ERROR", error: "Device ID is required" },
+                        };
+                    }
+                    const { data, error } = await supabase.rpc("get_events_infinite_by_device", {
+                        device_id_caller: deviceId,
+                        limit_caller: limit + 1,
+                        cursor_timestamp: cursor?.timestamp || null,
+                        cursor_id: cursor?.id || null,
+                    });
+                    if (error) {
+                        return {
+                            error: { status: "SUPABASE_ERROR", error: error.message },
+                        };
+                    }
+                    const events = data || [];
+                    const hasMore = events.length > limit;
+                    const resultEvents = hasMore ? events.slice(0, limit) : events;
+                    const nextCursor = hasMore && resultEvents.length > 0
+                        ? {
+                            timestamp: resultEvents[resultEvents.length - 1]
+                                .timestamp_observation || "",
+                            id: resultEvents[resultEvents.length - 1].id || 0,
+                        }
+                        : null;
+                    return {
+                        data: {
+                            events: resultEvents,
+                            nextCursor,
+                            hasMore,
+                        },
+                    };
+                }
+                catch (err) {
+                    return { error: { status: "FETCH_ERROR", error: String(err) } };
+                }
+            },
+            providesTags: (result) => result
+                ? [
+                    ...result.events.map(({ id }) => ({
+                        type: "Event",
+                        id: id || "unknown",
+                    })),
+                    { type: "Event", id: "LIST" },
+                ]
+                : [{ type: "Event", id: "LIST" }],
+        }),
+        // =====================================================
+        // ARTIFACTS INFINITE QUERIES
+        // =====================================================
+        getArtifactsInfiniteByHerd: builder.query({
+            async queryFn({ herdId, limit = 20, cursor, supabase }) {
+                try {
+                    if (!herdId) {
+                        return {
+                            error: { status: "CUSTOM_ERROR", error: "Herd ID is required" },
+                        };
+                    }
+                    const { data, error } = await supabase.rpc("get_artifacts_infinite_by_herd", {
+                        herd_id_caller: herdId,
+                        limit_caller: limit + 1,
+                        cursor_timestamp: cursor?.timestamp || null,
+                        cursor_id: cursor?.id || null,
+                    });
+                    if (error) {
+                        return {
+                            error: { status: "SUPABASE_ERROR", error: error.message },
+                        };
+                    }
+                    const artifacts = data || [];
+                    const hasMore = artifacts.length > limit;
+                    const resultArtifacts = hasMore
+                        ? artifacts.slice(0, limit)
+                        : artifacts;
+                    // Generate signed URLs for artifacts
+                    const uniqueFilePaths = Array.from(new Set(resultArtifacts
+                        .map((artifact) => artifact.file_path)
+                        .filter((path) => path !== null && path !== undefined)));
+                    let urlMap = new Map();
+                    if (uniqueFilePaths.length > 0) {
+                        try {
+                            const urlResults = await generateSignedUrlsBatch(uniqueFilePaths);
+                            urlResults.forEach((url, index) => {
+                                if (url) {
+                                    urlMap.set(uniqueFilePaths[index], url);
+                                }
+                            });
+                        }
+                        catch (urlError) {
+                            console.warn("Failed to generate signed URLs for artifacts:", urlError);
+                        }
+                    }
+                    const artifactsWithUrls = resultArtifacts.map((artifact) => ({
+                        ...artifact,
+                        media_url: artifact.file_path
+                            ? urlMap.get(artifact.file_path) || null
+                            : null,
+                    }));
+                    const nextCursor = hasMore && resultArtifacts.length > 0
+                        ? {
+                            timestamp: resultArtifacts[resultArtifacts.length - 1].created_at,
+                            id: resultArtifacts[resultArtifacts.length - 1].id,
+                        }
+                        : null;
+                    return {
+                        data: {
+                            artifacts: artifactsWithUrls,
+                            nextCursor,
+                            hasMore,
+                        },
+                    };
+                }
+                catch (err) {
+                    return { error: { status: "FETCH_ERROR", error: String(err) } };
+                }
+            },
+            providesTags: (result) => result
+                ? [
+                    ...result.artifacts.map(({ id }) => ({
+                        type: "Artifact",
+                        id,
+                    })),
+                    { type: "Artifact", id: "LIST" },
+                ]
+                : [{ type: "Artifact", id: "LIST" }],
+        }),
+        getArtifactsInfiniteByDevice: builder.query({
+            async queryFn({ deviceId, limit = 20, cursor, supabase }) {
+                try {
+                    if (!deviceId) {
+                        return {
+                            error: { status: "CUSTOM_ERROR", error: "Device ID is required" },
+                        };
+                    }
+                    const { data, error } = await supabase.rpc("get_artifacts_infinite_by_device", {
+                        device_id_caller: deviceId,
+                        limit_caller: limit + 1,
+                        cursor_timestamp: cursor?.timestamp || null,
+                        cursor_id: cursor?.id || null,
+                    });
+                    if (error) {
+                        return {
+                            error: { status: "SUPABASE_ERROR", error: error.message },
+                        };
+                    }
+                    const artifacts = data || [];
+                    const hasMore = artifacts.length > limit;
+                    const resultArtifacts = hasMore
+                        ? artifacts.slice(0, limit)
+                        : artifacts;
+                    // Generate signed URLs for artifacts
+                    const uniqueFilePaths = Array.from(new Set(resultArtifacts
+                        .map((artifact) => artifact.file_path)
+                        .filter((path) => path !== null && path !== undefined)));
+                    let urlMap = new Map();
+                    if (uniqueFilePaths.length > 0) {
+                        try {
+                            const urlResults = await generateSignedUrlsBatch(uniqueFilePaths);
+                            urlResults.forEach((url, index) => {
+                                if (url) {
+                                    urlMap.set(uniqueFilePaths[index], url);
+                                }
+                            });
+                        }
+                        catch (urlError) {
+                            console.warn("Failed to generate signed URLs for artifacts:", urlError);
+                        }
+                    }
+                    const artifactsWithUrls = resultArtifacts.map((artifact) => ({
+                        ...artifact,
+                        media_url: artifact.file_path
+                            ? urlMap.get(artifact.file_path) || null
+                            : null,
+                    }));
+                    const nextCursor = hasMore && resultArtifacts.length > 0
+                        ? {
+                            timestamp: resultArtifacts[resultArtifacts.length - 1].created_at,
+                            id: resultArtifacts[resultArtifacts.length - 1].id,
+                        }
+                        : null;
+                    return {
+                        data: {
+                            artifacts: artifactsWithUrls,
+                            nextCursor,
+                            hasMore,
+                        },
+                    };
+                }
+                catch (err) {
+                    return { error: { status: "FETCH_ERROR", error: String(err) } };
+                }
+            },
+            providesTags: (result) => result
+                ? [
+                    ...result.artifacts.map(({ id }) => ({
+                        type: "Artifact",
+                        id,
+                    })),
+                    { type: "Artifact", id: "LIST" },
+                ]
+                : [{ type: "Artifact", id: "LIST" }],
+        }),
+    }),
+});
+// Export hooks for usage in functional components
+export const { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, } = scoutApi;

package/dist/store/configureStore.d.ts

@@ -0,0 +1,96 @@
+export declare const configureScoutStore: () => import("@reduxjs/toolkit").EnhancedStore<{
+    scout: import("./scout").ScoutState;
+    scoutApi: import("@reduxjs/toolkit/query").CombinedState<{
+        getSessionsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").SessionsInfiniteResponse, "scoutApi", unknown>;
+        getSessionsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").SessionsInfiniteResponse, "scoutApi", unknown>;
+        getEventsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").EventsInfiniteResponse, "scoutApi", unknown>;
+        getEventsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").EventsInfiniteResponse, "scoutApi", unknown>;
+        getArtifactsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+        getArtifactsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+    }, "Session" | "Event" | "Artifact", "scoutApi">;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        scout: import("./scout").ScoutState;
+        scoutApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getSessionsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").SessionsInfiniteResponse, "scoutApi", unknown>;
+            getSessionsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").SessionsInfiniteResponse, "scoutApi", unknown>;
+            getEventsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").EventsInfiniteResponse, "scoutApi", unknown>;
+            getEventsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").EventsInfiniteResponse, "scoutApi", unknown>;
+            getArtifactsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+            getArtifactsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+        }, "Session" | "Event" | "Artifact", "scoutApi">;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type RootState = ReturnType<ReturnType<typeof configureScoutStore>["getState"]>;
+export type AppDispatch = ReturnType<typeof configureScoutStore>["dispatch"];
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    scout: import("./scout").ScoutState;
+    scoutApi: import("@reduxjs/toolkit/query").CombinedState<{
+        getSessionsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").SessionsInfiniteResponse, "scoutApi", unknown>;
+        getSessionsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").SessionsInfiniteResponse, "scoutApi", unknown>;
+        getEventsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").EventsInfiniteResponse, "scoutApi", unknown>;
+        getEventsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").EventsInfiniteResponse, "scoutApi", unknown>;
+        getArtifactsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+        getArtifactsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+    }, "Session" | "Event" | "Artifact", "scoutApi">;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        scout: import("./scout").ScoutState;
+        scoutApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getSessionsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").SessionsInfiniteResponse, "scoutApi", unknown>;
+            getSessionsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").SessionsInfiniteResponse, "scoutApi", unknown>;
+            getEventsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").EventsInfiniteResponse, "scoutApi", unknown>;
+            getEventsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").EventsInfiniteResponse, "scoutApi", unknown>;
+            getArtifactsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+            getArtifactsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+        }, "Session" | "Event" | "Artifact", "scoutApi">;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;

package/dist/store/configureStore.js

@@ -0,0 +1,40 @@
+import { configureStore } from "@reduxjs/toolkit";
+import { setupListeners } from "@reduxjs/toolkit/query";
+import scoutReducer from "./scout";
+import { scoutApi } from "./api";
+// Configure the Redux store
+export const configureScoutStore = () => {
+    const store = configureStore({
+        reducer: {
+            scout: scoutReducer,
+            [scoutApi.reducerPath]: scoutApi.reducer,
+        },
+        middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+            serializableCheck: {
+                // Ignore these action types for serializable check
+                ignoredActions: [
+                    "persist/PERSIST",
+                    "persist/REHYDRATE",
+                    "persist/REGISTER",
+                    // RTK Query actions
+                    "scoutApi/executeQuery/pending",
+                    "scoutApi/executeQuery/fulfilled",
+                    "scoutApi/executeQuery/rejected",
+                    "scoutApi/executeMutation/pending",
+                    "scoutApi/executeMutation/fulfilled",
+                    "scoutApi/executeMutation/rejected",
+                ],
+                // Ignore these field paths in all actions
+                ignoredActionsPaths: ["meta.arg", "payload.timestamp"],
+                // Ignore these paths in the state
+                ignoredPaths: ["scoutApi.queries", "scoutApi.mutations"],
+            },
+        }).concat(scoutApi.middleware),
+        devTools: process.env.NODE_ENV !== "production",
+    });
+    // Enable listener behavior for the store
+    setupListeners(store.dispatch);
+    return store;
+};
+// Create a default store instance
+export const store = configureScoutStore();

package/dist/store/hooks.d.ts

@@ -1,3 +1,5 @@
+import { LoadingPerformance } from "./scout";
+import { ISessionSummary } from "../types/db";
 export declare const useAppDispatch: import("react-redux").UseDispatch<import("redux").Dispatch<import("redux").UnknownAction>>;
 export declare const useHerdModulesLoadingState: () => any;
 export declare const useIsHerdModulesLoading: () => boolean;
@@ -5,4 +7,7 @@ export declare const useIsHerdModulesLoaded: () => boolean;
 export declare const useIsHerdModulesFailed: () => boolean;
 export declare const useHerdModulesLoadedAt: () => any;
 export declare const useHerdModulesLoadingDuration: () => any;
+export declare const useLoadingPerformance: () => LoadingPerformance;
+export declare const useSessionSummariesByHerd: (herdId: number) => ISessionSummary | null;
+export declare const useHasSessionSummaries: (herdId: number) => boolean;
 export declare const useHerdModulesLoadingTimeAgo: () => string | null;

package/dist/store/hooks.js

@@ -23,18 +23,36 @@ export const useIsHerdModulesFailed = () => {
 };
 // Selector hook for getting when herd modules were last loaded
 export const useHerdModulesLoadedAt = () => {
-    return useSelector((state) => state.scout.herd_modules_loaded_in_ms);
+    return useSelector((state) => state.scout.loading_performance.herd_modules_loaded_in_ms);
 };
 // Selector hook for getting the loading duration in milliseconds
 export const useHerdModulesLoadingDuration = () => {
     return useSelector((state) => {
-        return state.scout.herd_modules_loaded_in_ms;
+        return state.scout.loading_performance.herd_modules_loaded_in_ms;
+    });
+};
+// Selector hook for getting the complete loading performance object
+export const useLoadingPerformance = () => {
+    return useSelector((state) => state.scout.loading_performance);
+};
+// Selector hook for getting session summaries for a specific herd
+export const useSessionSummariesByHerd = (herdId) => {
+    return useSelector((state) => {
+        const herdModule = state.scout.herd_modules.find((hm) => hm.herd.id === herdId);
+        return herdModule?.session_summaries || null;
+    });
+};
+// Selector hook for checking if session summaries are available for a herd
+export const useHasSessionSummaries = (herdId) => {
+    return useSelector((state) => {
+        const herdModule = state.scout.herd_modules.find((hm) => hm.herd.id === herdId);
+        return !!herdModule?.session_summaries;
     });
 };
 // Selector hook for getting formatted loading time (e.g., "2.5s ago")
 export const useHerdModulesLoadingTimeAgo = () => {
     return useSelector((state) => {
-        const loadingDuration = state.scout.herd_modules_loaded_in_ms;
+        const loadingDuration = state.scout.loading_performance.herd_modules_loaded_in_ms;
         if (!loadingDuration)
             return null;
         // Since we store the duration, we need to calculate when it was loaded

package/dist/store/index.d.ts

@@ -1 +1,2 @@
 export * from "./scout";
+export * from "./api";

package/dist/store/index.js

@@ -1 +1,2 @@
 export * from "./scout";
+export * from "./api";