@adventurelabs/scout-core 1.5.0 → 1.5.1

package/dist/helpers/documents.d.ts

@@ -6,6 +6,7 @@ export declare function get_documents_by_herd_id(client: SupabaseClient<Database
 export declare function get_documents_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IDocument[]>>;
 export declare function get_documents_by_user_id(client: SupabaseClient<Database>, user_id: string): Promise<IWebResponseCompatible<IDocument[]>>;
 export declare function get_documents_by_product_id(client: SupabaseClient<Database>, product_id: number): Promise<IWebResponseCompatible<IDocument[]>>;
+export declare function get_documents_by_operating_context_id(client: SupabaseClient<Database>, operating_context_id: number): Promise<IWebResponseCompatible<IDocument[]>>;
 export declare function get_document_by_id(client: SupabaseClient<Database>, document_id: number): Promise<IWebResponseCompatible<IDocument | null>>;
 export declare function create_document(client: SupabaseClient<Database>, row: DocumentInsert): Promise<IWebResponseCompatible<IDocument | null>>;
 export declare function update_document(client: SupabaseClient<Database>, document_id: number, patch: DocumentUpdate): Promise<IWebResponseCompatible<IDocument | null>>;

package/dist/helpers/documents.js

@@ -4,10 +4,16 @@ function assert_document_insert(row) {
         return IWebResponse.error("uri is required")
             .to_compatible();
     }
-    const owners = [row.user_id, row.herd_id, row.device_id, row.product_id];
+    const owners = [
+        row.user_id,
+        row.herd_id,
+        row.device_id,
+        row.product_id,
+        row.operating_context_id,
+    ];
     const owner_count = owners.filter((owner) => owner != null).length;
     if (owner_count !== 1) {
-        return IWebResponse.error("exactly one of user_id, herd_id, device_id, or product_id is required").to_compatible();
+        return IWebResponse.error("exactly one document owner is required").to_compatible();
     }
     return null;
 }
@@ -34,6 +40,9 @@ export async function get_documents_by_user_id(client, user_id) {
 export async function get_documents_by_product_id(client, product_id) {
     return get_documents_by(client, "product_id", product_id);
 }
+export async function get_documents_by_operating_context_id(client, operating_context_id) {
+    return get_documents_by(client, "operating_context_id", operating_context_id);
+}
 export async function get_document_by_id(client, document_id) {
     const { data, error } = await client
         .from("documents")

package/dist/helpers/index.d.ts

@@ -26,6 +26,7 @@ export * from "./documents";
 export * from "./maintenance_requests";
 export * from "./session_incidents";
 export * from "./contacts";
+export * from "./operating_contexts";
 export * from "./plans";
 export * from "./sessions";
 export * from "./segmentations_sam3";

package/dist/helpers/index.js

@@ -26,6 +26,7 @@ export * from "./documents";
 export * from "./maintenance_requests";
 export * from "./session_incidents";
 export * from "./contacts";
+export * from "./operating_contexts";
 export * from "./plans";
 export * from "./sessions";
 export * from "./segmentations_sam3";

package/dist/helpers/operating_contexts.d.ts

@@ -0,0 +1,43 @@
+import { DocumentConditionCreateInput, DocumentConditionUpdateInput, IDocumentCondition, IOperatingContext, IOperatingContextEquipmentCategory, IOperatingContextEquipmentItem, IOperatingContextEquipmentRequirement, IOperatingContextPayload, IOperatingContextRegion, IOperatingContextRisk, IOperatingContextRole, IOperatingContextRoleAssignment, IOperatingContextType, IOperatingContextWeatherSnapshot, OperatingContextCreateInput, OperatingContextEquipmentCategoryCreateInput, OperatingContextEquipmentCategoryUpdateInput, OperatingContextEquipmentItemCreateInput, OperatingContextEquipmentItemUpdateInput, OperatingContextEquipmentRequirementCreateInput, OperatingContextEquipmentRequirementUpdateInput, OperatingContextListOptions, OperatingContextPayloadCreateInput, OperatingContextPayloadUpdateInput, OperatingContextRegionCreateInput, OperatingContextRegionUpdateInput, OperatingContextRiskCreateInput, OperatingContextRiskUpdateInput, OperatingContextRoleAssignmentCreateInput, OperatingContextRoleAssignmentUpdateInput, OperatingContextRoleCreateInput, OperatingContextRoleUpdateInput, OperatingContextTypeCreateInput, OperatingContextTypeUpdateInput, OperatingContextUpdateInput } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_document_conditions_by_localization(localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IDocumentCondition[]>>;
+export declare function server_create_document_condition(row: DocumentConditionCreateInput): Promise<IWebResponseCompatible<IDocumentCondition | null>>;
+export declare function server_update_document_condition(id: number, updates: DocumentConditionUpdateInput): Promise<IWebResponseCompatible<IDocumentCondition | null>>;
+export declare function server_get_operating_context_types_by_localization(localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextType[]>>;
+export declare function server_create_operating_context_type(row: OperatingContextTypeCreateInput): Promise<IWebResponseCompatible<IOperatingContextType | null>>;
+export declare function server_update_operating_context_type(id: number, updates: OperatingContextTypeUpdateInput): Promise<IWebResponseCompatible<IOperatingContextType | null>>;
+export declare function server_get_operating_context_roles_by_localization(localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRole[]>>;
+export declare function server_create_operating_context_role(row: OperatingContextRoleCreateInput): Promise<IWebResponseCompatible<IOperatingContextRole | null>>;
+export declare function server_update_operating_context_role(id: number, updates: OperatingContextRoleUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRole | null>>;
+export declare function server_get_operating_context_equipment_categories_by_localization(localization_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextEquipmentCategory[]>>;
+export declare function server_create_operating_context_equipment_category(row: OperatingContextEquipmentCategoryCreateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentCategory | null>>;
+export declare function server_update_operating_context_equipment_category(id: number, updates: OperatingContextEquipmentCategoryUpdateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentCategory | null>>;
+export declare function server_get_operating_context_equipment_items_by_category(equipment_category_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextEquipmentItem[]>>;
+export declare function server_create_operating_context_equipment_item(row: OperatingContextEquipmentItemCreateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentItem | null>>;
+export declare function server_update_operating_context_equipment_item(id: number, updates: OperatingContextEquipmentItemUpdateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentItem | null>>;
+export declare function server_get_operating_contexts_by_herd(herd_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContext[]>>;
+export declare function server_get_operating_context_by_id(id: number): Promise<IWebResponseCompatible<IOperatingContext | null>>;
+export declare function server_create_operating_context(row: OperatingContextCreateInput): Promise<IWebResponseCompatible<IOperatingContext | null>>;
+export declare function server_update_operating_context(id: number, updates: OperatingContextUpdateInput): Promise<IWebResponseCompatible<IOperatingContext | null>>;
+export declare function server_get_operating_context_payloads_by_operating_context(operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextPayload[]>>;
+export declare function server_create_operating_context_payload(row: OperatingContextPayloadCreateInput): Promise<IWebResponseCompatible<IOperatingContextPayload | null>>;
+export declare function server_update_operating_context_payload(id: number, updates: OperatingContextPayloadUpdateInput): Promise<IWebResponseCompatible<IOperatingContextPayload | null>>;
+export declare function server_get_operating_context_role_assignments_by_operating_context(operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRoleAssignment[]>>;
+export declare function server_create_operating_context_role_assignment(row: OperatingContextRoleAssignmentCreateInput): Promise<IWebResponseCompatible<IOperatingContextRoleAssignment | null>>;
+export declare function server_update_operating_context_role_assignment(id: number, updates: OperatingContextRoleAssignmentUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRoleAssignment | null>>;
+export declare function server_get_operating_context_equipment_requirements_by_operating_context(operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextEquipmentRequirement[]>>;
+export declare function server_create_operating_context_equipment_requirement(row: OperatingContextEquipmentRequirementCreateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentRequirement | null>>;
+export declare function server_update_operating_context_equipment_requirement(id: number, updates: OperatingContextEquipmentRequirementUpdateInput): Promise<IWebResponseCompatible<IOperatingContextEquipmentRequirement | null>>;
+export declare function server_get_operating_context_regions_by_operating_context(operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRegion[]>>;
+export declare function server_create_operating_context_region(row: OperatingContextRegionCreateInput): Promise<IWebResponseCompatible<IOperatingContextRegion | null>>;
+export declare function server_update_operating_context_region(id: number, updates: OperatingContextRegionUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRegion | null>>;
+export declare function server_get_operating_context_risks_by_operating_context(operating_context_id: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextRisk[]>>;
+export declare function server_create_operating_context_risk(row: OperatingContextRiskCreateInput): Promise<IWebResponseCompatible<IOperatingContextRisk | null>>;
+export declare function server_update_operating_context_risk(id: number, updates: OperatingContextRiskUpdateInput): Promise<IWebResponseCompatible<IOperatingContextRisk | null>>;
+export declare function server_get_operating_context_weather_snapshots(operating_context_id: number, options?: {
+    limit?: number;
+    cursor?: {
+        collected_at: string;
+        id: number;
+    };
+}): Promise<IWebResponseCompatible<IOperatingContextWeatherSnapshot[]>>;

package/dist/helpers/operating_contexts.js

@@ -0,0 +1,222 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { IWebResponse } from "../types/requests";
+function error(message) {
+    return IWebResponse.error(message).to_compatible();
+}
+function page_limit(options) {
+    const limit = options?.limit ?? 100;
+    return limit < 1 || limit > 500 ? null : limit;
+}
+async function authenticated_user_id(client) {
+    const { data, error: authError } = await client.auth.getUser();
+    return authError ? null : (data.user?.id ?? null);
+}
+function with_lifecycle_actor(updates, user_id) {
+    return updates.lifecycle
+        ? { ...updates, lifecycle_changed_by: user_id }
+        : updates;
+}
+function with_update_actor(updates, user_id) {
+    return { ...with_lifecycle_actor(updates, user_id), updated_by: user_id };
+}
+function update_error(updates) {
+    if (Object.keys(updates).length === 0)
+        return "no fields to update";
+    if (updates.lifecycle_reason !== undefined && updates.lifecycle === undefined) {
+        return "lifecycle_reason requires lifecycle";
+    }
+    return null;
+}
+async function list_by(table, column, value, options) {
+    const limit = page_limit(options);
+    if (limit == null)
+        return error("limit must be between 1 and 500");
+    const supabase = await newServerClient();
+    let query = supabase
+        .from(table)
+        .select("*")
+        .eq(column, value)
+        .order("id")
+        .limit(limit);
+    if (!options?.include_inactive)
+        query = query.eq("lifecycle", "active");
+    if (options?.after_id != null)
+        query = query.gt("id", options.after_id);
+    const { data, error: queryError } = await query;
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success((data ?? [])).to_compatible();
+}
+async function insert_row(table, row) {
+    const supabase = await newServerClient();
+    const { data, error: queryError } = await supabase
+        .from(table)
+        .insert(row)
+        .select("*")
+        .single();
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data).to_compatible();
+}
+async function insert_with_creator(table, row) {
+    const supabase = await newServerClient();
+    const user_id = await authenticated_user_id(supabase);
+    if (!user_id)
+        return error("authentication required");
+    const { data, error: queryError } = await supabase
+        .from(table)
+        .insert({ ...row, created_by: user_id })
+        .select("*")
+        .single();
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data).to_compatible();
+}
+async function patch_row(table, id, updates, actor) {
+    const invalid = update_error(updates);
+    if (invalid)
+        return error(invalid);
+    const supabase = await newServerClient();
+    const user_id = await authenticated_user_id(supabase);
+    if (!user_id)
+        return error("authentication required");
+    const payload = actor === "update"
+        ? with_update_actor(updates, user_id)
+        : with_lifecycle_actor(updates, user_id);
+    const { data, error: queryError } = await supabase
+        .from(table)
+        .update(payload)
+        .eq("id", id)
+        .select("*")
+        .single();
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data).to_compatible();
+}
+export async function server_get_document_conditions_by_localization(localization_id, options) {
+    return list_by("document_conditions", "localization_id", localization_id, options);
+}
+export async function server_create_document_condition(row) {
+    return insert_row("document_conditions", row);
+}
+export async function server_update_document_condition(id, updates) {
+    return patch_row("document_conditions", id, updates, "lifecycle");
+}
+export async function server_get_operating_context_types_by_localization(localization_id, options) {
+    return list_by("operating_context_types", "localization_id", localization_id, options);
+}
+export async function server_create_operating_context_type(row) {
+    return insert_row("operating_context_types", row);
+}
+export async function server_update_operating_context_type(id, updates) {
+    return patch_row("operating_context_types", id, updates, "lifecycle");
+}
+export async function server_get_operating_context_roles_by_localization(localization_id, options) {
+    return list_by("operating_context_roles", "localization_id", localization_id, options);
+}
+export async function server_create_operating_context_role(row) {
+    return insert_row("operating_context_roles", row);
+}
+export async function server_update_operating_context_role(id, updates) {
+    return patch_row("operating_context_roles", id, updates, "lifecycle");
+}
+export async function server_get_operating_context_equipment_categories_by_localization(localization_id, options) {
+    return list_by("operating_context_equipment_categories", "localization_id", localization_id, options);
+}
+export async function server_create_operating_context_equipment_category(row) {
+    return insert_row("operating_context_equipment_categories", row);
+}
+export async function server_update_operating_context_equipment_category(id, updates) {
+    return patch_row("operating_context_equipment_categories", id, updates, "lifecycle");
+}
+export async function server_get_operating_context_equipment_items_by_category(equipment_category_id, options) {
+    return list_by("operating_context_equipment_items", "equipment_category_id", equipment_category_id, options);
+}
+export async function server_create_operating_context_equipment_item(row) {
+    return insert_row("operating_context_equipment_items", row);
+}
+export async function server_update_operating_context_equipment_item(id, updates) {
+    return patch_row("operating_context_equipment_items", id, updates, "lifecycle");
+}
+export async function server_get_operating_contexts_by_herd(herd_id, options) {
+    return list_by("operating_contexts", "herd_id", herd_id, options);
+}
+export async function server_get_operating_context_by_id(id) {
+    const supabase = await newServerClient();
+    const { data, error: queryError } = await supabase
+        .from("operating_contexts")
+        .select("*")
+        .eq("id", id)
+        .maybeSingle();
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data).to_compatible();
+}
+export async function server_create_operating_context(row) {
+    return insert_with_creator("operating_contexts", row);
+}
+export async function server_update_operating_context(id, updates) {
+    return patch_row("operating_contexts", id, updates, "update");
+}
+export async function server_get_operating_context_payloads_by_operating_context(operating_context_id, options) {
+    return list_by("operating_context_payloads", "operating_context_id", operating_context_id, options);
+}
+export async function server_create_operating_context_payload(row) {
+    return insert_with_creator("operating_context_payloads", row);
+}
+export async function server_update_operating_context_payload(id, updates) {
+    return patch_row("operating_context_payloads", id, updates, "update");
+}
+export async function server_get_operating_context_role_assignments_by_operating_context(operating_context_id, options) {
+    return list_by("operating_context_role_assignments", "operating_context_id", operating_context_id, options);
+}
+export async function server_create_operating_context_role_assignment(row) {
+    return insert_row("operating_context_role_assignments", row);
+}
+export async function server_update_operating_context_role_assignment(id, updates) {
+    return patch_row("operating_context_role_assignments", id, updates, "lifecycle");
+}
+export async function server_get_operating_context_equipment_requirements_by_operating_context(operating_context_id, options) {
+    return list_by("operating_context_equipment_requirements", "operating_context_id", operating_context_id, options);
+}
+export async function server_create_operating_context_equipment_requirement(row) {
+    return insert_row("operating_context_equipment_requirements", row);
+}
+export async function server_update_operating_context_equipment_requirement(id, updates) {
+    return patch_row("operating_context_equipment_requirements", id, updates, "lifecycle");
+}
+export async function server_get_operating_context_regions_by_operating_context(operating_context_id, options) {
+    return list_by("operating_context_regions", "operating_context_id", operating_context_id, options);
+}
+export async function server_create_operating_context_region(row) {
+    return insert_with_creator("operating_context_regions", row);
+}
+export async function server_update_operating_context_region(id, updates) {
+    return patch_row("operating_context_regions", id, updates, "update");
+}
+export async function server_get_operating_context_risks_by_operating_context(operating_context_id, options) {
+    return list_by("operating_context_risks", "operating_context_id", operating_context_id, options);
+}
+export async function server_create_operating_context_risk(row) {
+    return insert_with_creator("operating_context_risks", row);
+}
+export async function server_update_operating_context_risk(id, updates) {
+    return patch_row("operating_context_risks", id, updates, "update");
+}
+export async function server_get_operating_context_weather_snapshots(operating_context_id, options) {
+    if (options?.limit != null &&
+        (options.limit < 1 || options.limit > 500)) {
+        return error("limit must be between 1 and 500");
+    }
+    const supabase = await newServerClient();
+    const { data, error: queryError } = await supabase.rpc("get_operating_context_weather_snapshots", {
+        operating_context_id_caller: operating_context_id,
+        limit_caller: options?.limit,
+        cursor_collected_at: options?.cursor?.collected_at,
+        cursor_id: options?.cursor?.id,
+    });
+    return queryError
+        ? error(queryError.message)
+        : IWebResponse.success(data ?? []).to_compatible();
+}

package/dist/helpers/realtime_topic_access.d.ts

@@ -0,0 +1,5 @@
+import { IClientAbilitiesTokenMint } from "../types/client_abilities_token";
+import { EnumJwtMintStatus } from "../types/jwt_mint";
+export declare function realtime_topic_ability(topic: string): string;
+export declare function can_access_realtime_topic(mint: IClientAbilitiesTokenMint | null | undefined, topic: string): boolean;
+export declare function filter_realtime_topics(status: EnumJwtMintStatus, mint: IClientAbilitiesTokenMint | null | undefined, topics: string[]): string[];

package/dist/helpers/realtime_topic_access.js

@@ -0,0 +1,55 @@
+import { can_herd_ability, } from "../types/client_abilities_token";
+import { EnumJwtMintStatus } from "../types/jwt_mint";
+export function realtime_topic_ability(topic) {
+    const channel = topic.slice(topic.indexOf("-") + 1);
+    switch (channel) {
+        case "contacts":
+            return "contacts.read";
+        case "maintenance_requests":
+            return "maintenance_requests.read";
+        case "herd_documents":
+            return "herd_documents.read";
+        case "device_documents":
+            return "device_documents.read";
+        case "user_documents":
+            return "user_documents.read";
+        case "operating_contexts":
+        case "operating_context_documents":
+            return "operating_contexts.read";
+        default:
+            return "content.read";
+    }
+}
+export function can_access_realtime_topic(mint, topic) {
+    if (topic === "versions_software_changes" ||
+        /^user_[0-9a-f-]+-documents$/i.test(topic)) {
+        return true;
+    }
+    const isProductDocuments = topic === "product_documents_changes";
+    const isAnalysis = topic === "analysis_jobs_changes" ||
+        topic === "analysis_tasks_changes";
+    const herd_match = /^(\d+)-/.exec(topic);
+    if (!isProductDocuments && !isAnalysis && !herd_match)
+        return true;
+    if (!mint?.token || mint.exp <= Math.floor(Date.now() / 1000))
+        return false;
+    if (isProductDocuments) {
+        return (mint.platform_superadmin ||
+            mint.herds.some((herd) => herd.abilities.includes("content.read")));
+    }
+    if (isAnalysis)
+        return mint.platform_superadmin;
+    if (!herd_match)
+        return true;
+    return can_herd_ability(mint, Number(herd_match[1]), realtime_topic_ability(topic));
+}
+export function filter_realtime_topics(status, mint, topics) {
+    if (status === EnumJwtMintStatus.IDLE)
+        return topics;
+    if (!mint?.token) {
+        return status === EnumJwtMintStatus.LOADING
+            ? topics.filter((topic) => can_access_realtime_topic(mint, topic))
+            : topics;
+    }
+    return topics.filter((topic) => can_access_realtime_topic(mint, topic));
+}

package/dist/hooks/index.d.ts

@@ -1,5 +1,5 @@
 export { useScoutRefresh, type UseScoutRefreshOptions, } from "./useScoutRefresh";
-export { useScoutRealtimeBroadcast } from "./useScoutRealtimeBroadcast";
+export { useScoutRealtimeBroadcast, type ScoutRealtimeBroadcastOptions, type ScoutRealtimeAuthErrorMode, } from "./useScoutRealtimeBroadcast";
 export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
 export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";
 export { useScoutRealtimeVersionsSoftware } from "./useScoutRealtimeVersionsSoftware";
@@ -15,5 +15,6 @@ export { useScoutRealtimeDocuments, type DocumentRealtimeChannel, } from "./useS
 export { useScoutRealtimeMaintenanceRequests } from "./useScoutRealtimeMaintenanceRequests";
 export { useScoutRealtimeContacts } from "./useScoutRealtimeContacts";
 export { useScoutRealtimeSessionIncidents } from "./useScoutRealtimeSessionIncidents";
+export { useScoutRealtimeOperatingContexts, type OperatingContextRealtimeData, type OperatingContextRealtimeRow, } from "./useScoutRealtimeOperatingContexts";
 export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useInfiniteAnalysisJobs, useInfiniteAnalysisTasks, useIntersectionObserver, type UseInfiniteScrollOptions, type UseAnalysisJobsInfiniteOptions, type UseAnalysisTasksInfiniteOptions, } from "./useInfiniteQuery";
 export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/index.js

@@ -1,5 +1,5 @@
 export { useScoutRefresh, } from "./useScoutRefresh";
-export { useScoutRealtimeBroadcast } from "./useScoutRealtimeBroadcast";
+export { useScoutRealtimeBroadcast, } from "./useScoutRealtimeBroadcast";
 export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
 export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";
 export { useScoutRealtimeVersionsSoftware } from "./useScoutRealtimeVersionsSoftware";
@@ -15,6 +15,7 @@ export { useScoutRealtimeDocuments, } from "./useScoutRealtimeDocuments";
 export { useScoutRealtimeMaintenanceRequests } from "./useScoutRealtimeMaintenanceRequests";
 export { useScoutRealtimeContacts } from "./useScoutRealtimeContacts";
 export { useScoutRealtimeSessionIncidents } from "./useScoutRealtimeSessionIncidents";
+export { useScoutRealtimeOperatingContexts, } from "./useScoutRealtimeOperatingContexts";
 // RTK Query infinite scroll hooks
 export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useInfiniteAnalysisJobs, useInfiniteAnalysisTasks, useIntersectionObserver, } from "./useInfiniteQuery";
 // Session summaries and performance hooks

package/dist/hooks/useAuthorizedRealtimeTopics.d.ts

@@ -0,0 +1 @@
+export declare function useAuthorizedRealtimeTopics(topics: string[]): string[];

package/dist/hooks/useAuthorizedRealtimeTopics.js

@@ -0,0 +1,14 @@
+"use client";
+import { useMemo } from "react";
+import { filter_realtime_topics } from "../helpers/realtime_topic_access";
+import { useOptionalClientAbilitiesMint } from "../providers/ScoutRefreshProvider";
+export function useAuthorizedRealtimeTopics(topics) {
+    const abilities = useOptionalClientAbilitiesMint();
+    const topicsKey = topics.join("|");
+    return useMemo(() => {
+        const requested = topicsKey.split("|").filter(Boolean);
+        if (!abilities)
+            return requested;
+        return filter_realtime_topics(abilities.status, abilities.mint, requested);
+    }, [abilities, topicsKey]);
+}

package/dist/hooks/useScoutRealtimeAnalysisJobs.d.ts

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

package/dist/hooks/useScoutRealtimeAnalysisJobs.js

@@ -1,7 +1,5 @@
 "use client";
-import { useScoutRealtimeBroadcast } from "./useScoutRealtimeBroadcast";
-export function useScoutRealtimeAnalysisJobs(scoutSupabase) {
-    return useScoutRealtimeBroadcast(scoutSupabase, [
-        "analysis_jobs_changes",
-    ]);
+import { useScoutRealtimeBroadcast, } from "./useScoutRealtimeBroadcast";
+export function useScoutRealtimeAnalysisJobs(scoutSupabase, options) {
+    return useScoutRealtimeBroadcast(scoutSupabase, ["analysis_jobs_changes"], options);
 }

package/dist/hooks/useScoutRealtimeAnalysisTasks.d.ts

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

package/dist/hooks/useScoutRealtimeAnalysisTasks.js

@@ -1,7 +1,5 @@
 "use client";
-import { useScoutRealtimeBroadcast } from "./useScoutRealtimeBroadcast";
-export function useScoutRealtimeAnalysisTasks(scoutSupabase) {
-    return useScoutRealtimeBroadcast(scoutSupabase, [
-        "analysis_tasks_changes",
-    ]);
+import { useScoutRealtimeBroadcast, } from "./useScoutRealtimeBroadcast";
+export function useScoutRealtimeAnalysisTasks(scoutSupabase, options) {
+    return useScoutRealtimeBroadcast(scoutSupabase, ["analysis_tasks_changes"], options);
 }

package/dist/hooks/useScoutRealtimeBroadcast.d.ts

@@ -1,8 +1,12 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { RealtimeData } from "../types/realtime";
-/**
- * Subscribes to private realtime topics and reports the most recent row change across them.
- * Changing the topic set resubscribes and clears the pending change.
- */
-export declare function useScoutRealtimeBroadcast<T>(scoutSupabase: SupabaseClient<Database>, topics: string[]): [RealtimeData<T> | null, () => void];
+export type ScoutRealtimeAuthErrorMode = "stop" | "backoff";
+export type ScoutRealtimeBroadcastOptions = {
+    /** `stop` prevents Phoenix rejoin loops on auth failure. */
+    authErrorRetry?: ScoutRealtimeAuthErrorMode;
+    backoffInitialMs?: number;
+    backoffMaxMs?: number;
+    backoffMaxAttempts?: number;
+};
+export declare function useScoutRealtimeBroadcast<T>(scoutSupabase: SupabaseClient<Database>, topics: string[], options?: ScoutRealtimeBroadcastOptions, rowFilter?: (row: T) => boolean): [RealtimeData<T> | null, () => void];