@adventurelabs/scout-core 1.0.61 → 1.0.63

package/dist/helpers/herds.d.ts

@@ -1,9 +1,9 @@
 import { IHerd } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IHerdModule } from "../types/herd_module";
+import { IHerdModulesResponseWithStatus } from "../types/herd_module";
 export declare function get_herds(client: SupabaseClient): Promise<IWebResponseCompatible<IHerd[]>>;
 export declare function get_herd_by_slug(slug: string): Promise<IWebResponseCompatible<IHerd>>;
 export declare function deleteHerd(herd_id: number): Promise<IWebResponseCompatible<boolean>>;
 export declare function createHerd(newHerd: any): Promise<IWebResponseCompatible<boolean>>;
-export declare function server_load_herd_modules(): Promise<IHerdModule[]>;
+export declare function server_load_herd_modules(): Promise<IHerdModulesResponseWithStatus>;

package/dist/helpers/herds.js

@@ -1,7 +1,7 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { HerdModule } from "../types/herd_module";
+import { HerdModule, } from "../types/herd_module";
 export async function get_herds(client) {
     const { data: herds } = await client.from("herds").select();
     if (!herds) {
@@ -70,7 +70,14 @@ export async function server_load_herd_modules() {
     const client_supabase = await newServerClient();
     let new_herds = await get_herds(client_supabase);
     if (new_herds.status != EnumWebResponse.SUCCESS || !new_herds.data) {
-        return [];
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "No herds found",
+            data: null,
+            time_finished: Date.now(),
+            time_sent: Date.now(),
+            server_processing_time_ms: Date.now() - startTime,
+        };
     }
     console.log(`[server_load_herd_modules] Loading ${new_herds.data.length} herds in parallel...`);
     let new_herd_modules = [];
@@ -81,5 +88,14 @@ export async function server_load_herd_modules() {
     const endTime = Date.now();
     const totalLoadTime = endTime - startTime;
     console.log(`[server_load_herd_modules] Loaded ${new_herds.data.length} herds in ${totalLoadTime}ms (parallel processing)`);
-    return serialized_herd_modules;
+    // Record the time when we're about to send the response
+    const timeSent = Date.now();
+    return {
+        status: EnumWebResponse.SUCCESS,
+        msg: "Herd modules loaded successfully",
+        data: serialized_herd_modules,
+        time_finished: endTime,
+        time_sent: timeSent,
+        server_processing_time_ms: totalLoadTime,
+    };
 }

package/dist/hooks/useScoutRefresh.js

@@ -4,6 +4,7 @@ import { EnumScoutStateStatus, setActiveHerdId, setHerdModules, setStatus, setHe
 import { EnumHerdModulesLoadingState } from "../types/herd_module";
 import { server_load_herd_modules } from "../helpers/herds";
 import { server_get_user } from "../helpers/users";
+import { EnumWebResponse } from "../types/requests";
 /**
  * Hook for refreshing scout data with detailed timing measurements
  *
@@ -72,10 +73,47 @@ export function useScoutRefresh(options = {}) {
             const parallelDuration = Date.now() - parallelStartTime;
             console.log(`[useScoutRefresh] Parallel API requests completed in ${parallelDuration}ms`);
             // Extract results and timing
-            const compatible_new_herd_modules = herdModulesResult.result;
+            const herdModulesResponse = herdModulesResult.result;
             const res_new_user = userResult.result;
             const herdModulesDuration = herdModulesResult.duration;
             const userApiDuration = userResult.duration;
+            // Calculate network latency for herd modules
+            let networkLatencyMs = 0;
+            if (herdModulesResponse.status === EnumWebResponse.SUCCESS &&
+                herdModulesResponse.data) {
+                const serverFinishTime = herdModulesResponse.time_finished;
+                const serverSentTime = herdModulesResponse.time_sent;
+                const clientReceiveTime = Date.now();
+                // More accurate network latency: from when server sent to when client received
+                const estimatedNetworkLatency = clientReceiveTime - serverSentTime;
+                networkLatencyMs = Math.max(0, estimatedNetworkLatency);
+                // Time between server finishing processing and sending response
+                const serverOverhead = serverSentTime - serverFinishTime;
+                console.log(`[useScoutRefresh] Network latency calculation:`);
+                console.log(`  - Server finished processing at: ${new Date(serverFinishTime).toISOString()}`);
+                console.log(`  - Server sent response at: ${new Date(serverSentTime).toISOString()}`);
+                console.log(`  - Client received at: ${new Date(clientReceiveTime).toISOString()}`);
+                console.log(`  - Server processing time: ${herdModulesResponse.server_processing_time_ms}ms`);
+                console.log(`  - Server overhead (finish to send): ${serverOverhead}ms`);
+                console.log(`  - Estimated network latency: ${networkLatencyMs}ms`);
+                console.log(`  - Client total time: ${herdModulesDuration}ms`);
+                console.log(`  - Breakdown: ${herdModulesResponse.server_processing_time_ms}ms (server) + ${serverOverhead}ms (overhead) + ${networkLatencyMs}ms (network) = ${herdModulesResponse.server_processing_time_ms +
+                    serverOverhead +
+                    networkLatencyMs}ms`);
+                // Additional analysis
+                if (herdModulesResponse.data.length > 0) {
+                    const totalDevices = herdModulesResponse.data.reduce((sum, hm) => sum + (hm.devices?.length || 0), 0);
+                    const totalEvents = herdModulesResponse.data.reduce((sum, hm) => sum + (hm.events?.length || 0), 0);
+                    console.log(`  - Response size analysis:`);
+                    console.log(`    * Herds: ${herdModulesResponse.data.length}`);
+                    console.log(`    * Total devices: ${totalDevices}`);
+                    console.log(`    * Total events: ${totalEvents}`);
+                    console.log(`    * Estimated payload: ~${Math.round((herdModulesResponse.data.length * 2 +
+                        totalDevices * 3 +
+                        totalEvents * 5) /
+                        1024)}KB`);
+                }
+            }
             // Store timing values
             timingRefs.current.herdModulesDuration = herdModulesDuration;
             timingRefs.current.userApiDuration = userApiDuration;
@@ -90,14 +128,22 @@ export function useScoutRefresh(options = {}) {
             console.log(`  - User API: ${userApiDuration}ms (server processing + network)`);
             console.log(`  - Parallel execution: ${parallelDuration}ms`);
             console.log(`  - Network overhead: ${networkOverhead}ms`);
+            if (networkLatencyMs > 0) {
+                console.log(`  - Estimated network latency: ${networkLatencyMs}ms`);
+            }
             // Validate API responses
-            if (!compatible_new_herd_modules ||
-                !Array.isArray(compatible_new_herd_modules)) {
+            const validationStartTime = Date.now();
+            if (!herdModulesResponse.data ||
+                !Array.isArray(herdModulesResponse.data)) {
                 throw new Error("Invalid herd modules response");
             }
             if (!res_new_user || !res_new_user.data) {
                 throw new Error("Invalid user response");
             }
+            const validationDuration = Date.now() - validationStartTime;
+            console.log(`[useScoutRefresh] Data validation took: ${validationDuration}ms`);
+            // Use the validated data
+            const compatible_new_herd_modules = herdModulesResponse.data;
             // Measure data processing duration
             const dataProcessingStartTime = Date.now();
             dispatch(setHerdModules(compatible_new_herd_modules));

package/dist/types/herd_module.d.ts

@@ -1,5 +1,6 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
+import { EnumWebResponse } from "./requests";
 export declare enum EnumHerdModulesLoadingState {
     NOT_LOADING = "NOT_LOADING",
     LOADING = "LOADING",
@@ -39,3 +40,16 @@ export interface IHerdModule {
     sessions: ISessionWithCoordinates[];
     layers: ILayer[];
 }
+export interface IHerdModulesResponse {
+    data: IHerdModule[];
+    time_finished: number;
+    server_processing_time_ms: number;
+}
+export interface IHerdModulesResponseWithStatus {
+    status: EnumWebResponse;
+    msg: string;
+    data: IHerdModule[] | null;
+    time_finished: number;
+    time_sent: number;
+    server_processing_time_ms: number;
+}

package/package.json

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