@elevasis/ui 1.2.1 → 1.3.1

package/dist/{chunk-WNWKOCGJ.js → chunk-A3MCANC6.js}

@@ -1,7 +1,11 @@
-import { UuidSchema, ResourceTypeSchema, NonEmptyStringSchema, OriginResourceTypeSchema } from './chunk-JKERRYVS.js';
+import { useSupabase } from './chunk-JGJSZ3UE.js';
+import { UuidSchema, ResourceTypeSchema, NonEmptyStringSchema, OriginResourceTypeSchema } from './chunk-BLO4SISK.js';
+import { useNotificationAdapter } from './chunk-TIRMFDM4.js';
+import { useStableAccessToken } from './chunk-FWZJH3TL.js';
 import { useElevasisServices } from './chunk-KA7LO7U5.js';
 import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
 import { z } from 'zod';
+import { useCallback, useState, useEffect, useMemo, useId, useRef } from 'react';
 
 // src/hooks/executions/queryKeys.ts
 var executionsKeys = {
@@ -658,6 +662,43 @@ function useExecutionHealth({ timeRange }) {
     // 30s monitoring stale time
   });
 }
+function useErrorNotification() {
+  const adapter = useNotificationAdapter();
+  return useCallback(
+    (error) => {
+      adapter.apiError(error);
+    },
+    [adapter]
+  );
+}
+function useSuccessNotification() {
+  const adapter = useNotificationAdapter();
+  return useCallback((title, message) => adapter.success(title, message), [adapter]);
+}
+function useWarningNotification() {
+  const adapter = useNotificationAdapter();
+  return useCallback((title, message) => adapter.warning(title, message), [adapter]);
+}
+function useBatchDelete(tableName, invalidateQueryKeys) {
+  const supabase = useSupabase();
+  const queryClient = useQueryClient();
+  const adapter = useNotificationAdapter();
+  return useMutation({
+    mutationFn: async (ids) => {
+      if (ids.length === 0) return;
+      const { error } = await supabase.from(tableName).delete().in("id", ids);
+      if (error) throw error;
+    },
+    onSuccess: () => {
+      for (const key of invalidateQueryKeys) {
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+    },
+    onError: (err) => {
+      adapter.apiError(err);
+    }
+  });
+}
 
 // src/hooks/observability/queryKeys.ts
 var observabilityKeys = {
@@ -1063,5 +1104,258 @@ function useDeleteSchedule() {
     }
   });
 }
+function usePaginationState(pageSize, resetDeps, total) {
+  const [page, setPage] = useState(1);
+  useEffect(() => {
+    if (resetDeps) {
+      setPage(1);
+    }
+  }, resetDeps ?? []);
+  useEffect(() => {
+    if (total === void 0) return;
+    const lastPage = Math.max(1, Math.ceil(total / pageSize));
+    if (page > lastPage) {
+      setPage(lastPage);
+    }
+  }, [total, pageSize]);
+  return useMemo(
+    () => ({
+      page,
+      setPage,
+      offset: (page - 1) * pageSize,
+      totalPages: (total2) => Math.ceil(total2 / pageSize)
+    }),
+    [page, pageSize]
+  );
+}
+function useTableSelection(items, allItems) {
+  const [selectedIds, setSelectedIds] = useState(/* @__PURE__ */ new Set());
+  const pageIds = useMemo(() => new Set(items.map((i) => i.id)), [items]);
+  useEffect(() => {
+    setSelectedIds((prev) => {
+      const validIds = allItems ? new Set(allItems.map((i) => i.id)) : pageIds;
+      const next = new Set([...prev].filter((id) => validIds.has(id)));
+      return next.size === prev.size ? prev : next;
+    });
+  }, [allItems, pageIds]);
+  const toggle = useCallback((id) => {
+    setSelectedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }, []);
+  const togglePage = useCallback(() => {
+    setSelectedIds((prev) => {
+      const allPageSelected = items.every((i) => prev.has(i.id));
+      const next = new Set(prev);
+      if (allPageSelected) {
+        for (const item of items) next.delete(item.id);
+      } else {
+        for (const item of items) next.add(item.id);
+      }
+      return next;
+    });
+  }, [items]);
+  const clear = useCallback(() => setSelectedIds(/* @__PURE__ */ new Set()), []);
+  const isPageAllSelected = items.length > 0 && items.every((i) => selectedIds.has(i.id));
+  const isPagePartiallySelected = !isPageAllSelected && items.some((i) => selectedIds.has(i.id));
+  return {
+    selectedIds,
+    toggle,
+    togglePage,
+    clear,
+    isPageAllSelected,
+    isPagePartiallySelected,
+    selectedCount: selectedIds.size,
+    isSelected: (id) => selectedIds.has(id)
+  };
+}
+function useTableSort(defaultColumn, defaultDirection = "desc") {
+  const [sort, setSort] = useState({ column: defaultColumn, direction: defaultDirection });
+  const toggleSort = useCallback((column) => {
+    setSort((prev) => {
+      if (prev.column === column) {
+        return { column, direction: prev.direction === "asc" ? "desc" : "asc" };
+      }
+      return { column, direction: "desc" };
+    });
+  }, []);
+  return { sort, toggleSort };
+}
+function sortData(data, sort, accessors) {
+  const accessor = accessors[sort.column];
+  if (!accessor) return data;
+  return [...data].sort((a, b) => {
+    const aVal = accessor(a);
+    const bVal = accessor(b);
+    if (aVal == null && bVal == null) return 0;
+    if (aVal == null) return 1;
+    if (bVal == null) return -1;
+    let comparison = 0;
+    if (typeof aVal === "string" && typeof bVal === "string") {
+      comparison = aVal.localeCompare(bVal);
+    } else if (typeof aVal === "number" && typeof bVal === "number") {
+      comparison = aVal - bVal;
+    } else {
+      comparison = String(aVal).localeCompare(String(bVal));
+    }
+    return sort.direction === "asc" ? comparison : -comparison;
+  });
+}
+function useSortedData(data, defaultColumn, accessors, defaultDirection = "desc") {
+  const { sort, toggleSort } = useTableSort(defaultColumn, defaultDirection);
+  const sorted = useMemo(() => sortData(data, sort, accessors), [data, sort, accessors]);
+  return { sorted, sort, toggleSort };
+}
+function createUseFeatureAccess({
+  useInitialization,
+  useOrganization,
+  optInFeatures = [],
+  getCoursesByGroup = () => []
+}) {
+  return function useFeatureAccess() {
+    const { profile, organizationReady } = useInitialization();
+    const { currentMembership } = useOrganization();
+    const { orgConfig, membershipConfig } = useMemo(() => {
+      const organizationConfig = currentMembership?.organization?.config;
+      const memberConfig = currentMembership?.config;
+      return { orgConfig: organizationConfig, membershipConfig: memberConfig };
+    }, [currentMembership]);
+    const userConfig = profile?.config;
+    const checkFeature = useCallback(
+      (featureKey) => {
+        const key = featureKey;
+        const orgValue = orgConfig?.features?.[key];
+        if (!profile?.is_platform_admin) {
+          const membershipValue = membershipConfig?.features?.[key];
+          if (membershipValue === false) return { allowed: false, restrictedBy: "membership" };
+          if (membershipValue === true) return { allowed: true, restrictedBy: null };
+        }
+        if (optInFeatures.includes(featureKey)) {
+          return orgValue === true ? { allowed: true, restrictedBy: null } : { allowed: false, restrictedBy: "org" };
+        }
+        return orgValue === false ? { allowed: false, restrictedBy: "org" } : { allowed: true, restrictedBy: null };
+      },
+      [profile?.is_platform_admin, membershipConfig, orgConfig]
+    );
+    const hasFeature = useCallback((featureKey) => checkFeature(featureKey).allowed, [checkFeature]);
+    const hasTrainingAccess = useCallback(() => {
+      if (profile?.is_platform_admin) return true;
+      return userConfig?.training?.enabled ?? true;
+    }, [profile?.is_platform_admin, userConfig?.training?.enabled]);
+    const getAllowedCourses = useCallback(() => {
+      if (userConfig?.training?.allowed_courses?.length) {
+        return userConfig.training.allowed_courses;
+      }
+      return null;
+    }, [userConfig?.training?.allowed_courses]);
+    const getResolvedCourseAccess = useCallback(() => {
+      if (profile?.is_platform_admin) return null;
+      const orgGroups = orgConfig?.training?.allowed_course_groups ?? [];
+      const userGroups = userConfig?.training?.allowed_course_groups ?? [];
+      const userCourses = userConfig?.training?.allowed_courses ?? [];
+      if (!orgGroups.length && !userGroups.length && !userCourses.length) return null;
+      const foundationCourses = getCoursesByGroup("foundation");
+      const orgCourseSlugs = orgGroups.flatMap(getCoursesByGroup);
+      const userGroupCourseSlugs = userGroups.flatMap(getCoursesByGroup);
+      return [.../* @__PURE__ */ new Set([...foundationCourses, ...orgCourseSlugs, ...userGroupCourseSlugs, ...userCourses])];
+    }, [
+      profile?.is_platform_admin,
+      orgConfig?.training?.allowed_course_groups,
+      userConfig?.training?.allowed_course_groups,
+      userConfig?.training?.allowed_courses
+    ]);
+    const hasAccessToCourse = useCallback(
+      (courseSlug) => {
+        const resolved = getResolvedCourseAccess();
+        if (resolved === null) return true;
+        return resolved.includes(courseSlug);
+      },
+      [getResolvedCourseAccess]
+    );
+    const getEnabledGroups = useCallback(() => {
+      const orgGroups = orgConfig?.training?.allowed_course_groups ?? [];
+      const userGroups = userConfig?.training?.allowed_course_groups ?? [];
+      return [.../* @__PURE__ */ new Set(["foundation", ...orgGroups, ...userGroups])];
+    }, [orgConfig?.training?.allowed_course_groups, userConfig?.training?.allowed_course_groups]);
+    return {
+      orgConfig,
+      membershipConfig,
+      userConfig,
+      hasFeature,
+      checkFeature,
+      hasTrainingAccess,
+      getAllowedCourses,
+      getResolvedCourseAccess,
+      hasAccessToCourse,
+      getEnabledGroups,
+      isReady: organizationReady
+    };
+  };
+}
+function useSSEConnection({
+  manager,
+  connectionKey,
+  url,
+  enabled = true,
+  headers,
+  onmessage,
+  onopen,
+  onerror,
+  onclose
+}) {
+  const [connected, setConnected] = useState(false);
+  const [error, setError] = useState(null);
+  const getAccessToken = useStableAccessToken();
+  const subscriberId = useId();
+  const onmessageRef = useRef(onmessage);
+  const onopenRef = useRef(onopen);
+  const onerrorRef = useRef(onerror);
+  const oncloseRef = useRef(onclose);
+  const headersRef = useRef(headers);
+  onmessageRef.current = onmessage;
+  onopenRef.current = onopen;
+  onerrorRef.current = onerror;
+  oncloseRef.current = onclose;
+  headersRef.current = headers;
+  useEffect(() => {
+    if (!enabled) return;
+    const unsubscribe = manager.subscribe(connectionKey, subscriberId, {
+      url,
+      getToken: getAccessToken,
+      headers: headersRef.current ?? {},
+      onopen(response) {
+        if (response.ok) {
+          setConnected(true);
+          setError(null);
+        }
+        const customError = onopenRef.current?.(response);
+        if (customError) setError(customError);
+      },
+      onmessage(event) {
+        if (!event.data || event.data.trim() === "") return;
+        onmessageRef.current(event.data);
+      },
+      onerror(err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        setConnected(false);
+        setError(msg);
+        onerrorRef.current?.(err instanceof Error ? err : new Error(msg));
+      },
+      onclose() {
+        setConnected(false);
+        oncloseRef.current?.();
+      }
+    });
+    return () => {
+      unsubscribe();
+      setConnected(false);
+      setError(null);
+    };
+  }, [enabled, connectionKey, url, subscriberId, getAccessToken, manager]);
+  return { connected, error };
+}
 
-export { OperationsService, executionsKeys, observabilityKeys, scheduleKeys, useActivities, useActivityTrend, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule };
+export { OperationsService, createUseFeatureAccess, executionsKeys, observabilityKeys, scheduleKeys, sortData, useActivities, useActivityTrend, useBatchDelete, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, usePaginationState, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useSSEConnection, useSortedData, useSuccessNotification, useTableSelection, useTableSort, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule, useWarningNotification };

package/dist/{chunk-JKERRYVS.js → chunk-BLO4SISK.js}

@@ -1,5 +1,5 @@
+import { useNotificationAdapter } from './chunk-TIRMFDM4.js';
 import { useElevasisServices } from './chunk-KA7LO7U5.js';
-import { showApiErrorNotification } from './chunk-7AI5ZYJ4.js';
 import { useQueryClient, useMutation, useQuery } from '@tanstack/react-query';
 import { z } from 'zod';
 
@@ -26,6 +26,8 @@ z.object({
   startDate: z.string().datetime(),
   endDate: z.string().datetime()
 });
+
+// ../core/src/operations/notifications/api-schemas.ts
 var NotificationCategorySchema = z.enum(["info", "queue", "alert", "error", "system"]);
 var GetNotificationsQuerySchema = z.object({
   limit: z.coerce.number().int().min(1).max(100).default(50),
@@ -47,6 +49,7 @@ z.object({
 function useMarkAsRead() {
   const queryClient = useQueryClient();
   const { apiRequest } = useElevasisServices();
+  const notify = useNotificationAdapter();
   return useMutation({
     mutationFn: async (notificationId) => {
       MarkAsReadParamsSchema.parse({ id: notificationId });
@@ -58,13 +61,14 @@ function useMarkAsRead() {
       queryClient.invalidateQueries({ queryKey: ["notifications"] });
     },
     onError: (error) => {
-      showApiErrorNotification(error);
+      notify.apiError(error);
     }
   });
 }
 function useMarkAllAsRead() {
   const queryClient = useQueryClient();
   const { apiRequest } = useElevasisServices();
+  const notify = useNotificationAdapter();
   return useMutation({
     mutationFn: async () => {
       await apiRequest("/notifications/mark-all-read", {
@@ -75,7 +79,7 @@ function useMarkAllAsRead() {
       queryClient.invalidateQueries({ queryKey: ["notifications"] });
     },
     onError: (error) => {
-      showApiErrorNotification(error);
+      notify.apiError(error);
     }
   });
 }

package/dist/chunk-DD3CCMCZ.js

@@ -0,0 +1,15 @@
+import { createContext, useContext } from 'react';
+
+// src/organization/context/OrganizationContext.tsx
+var OrganizationContext = createContext(null);
+function useOrganization() {
+  const ctx = useContext(OrganizationContext);
+  if (!ctx) {
+    throw new Error(
+      "useOrganization must be used within an OrganizationProvider. Wrap your app (or the relevant subtree) with <OrganizationProvider>."
+    );
+  }
+  return ctx;
+}
+
+export { OrganizationContext, useOrganization };

package/dist/chunk-FWZJH3TL.js

@@ -0,0 +1,13 @@
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { useRef, useCallback } from 'react';
+
+function useStableAccessToken() {
+  const { getAccessToken } = useAuthContext();
+  const getAccessTokenRef = useRef(getAccessToken);
+  getAccessTokenRef.current = getAccessToken;
+  return useCallback(() => {
+    return getAccessTokenRef.current();
+  }, []);
+}
+
+export { useStableAccessToken };

package/dist/{chunk-GEFB5YIR.js → chunk-JBFFCZI4.js}

@@ -1,4 +1,4 @@
-import { useUserProfile } from './chunk-5UWFGBFM.js';
+import { useUserProfile } from './chunk-L2CM2CUA.js';
 import { useAuthContext } from './chunk-7PLEQFHO.js';
 import { useState, useRef, useEffect, useCallback } from 'react';
 import { Button, Loader, Menu, Text, Badge } from '@mantine/core';

package/dist/chunk-JGJSZ3UE.js

@@ -0,0 +1,47 @@
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { createClient } from '@supabase/supabase-js';
+import { useMemo } from 'react';
+
+function getSupabaseConfig() {
+  const url = import.meta.env?.VITE_SUPABASE_URL;
+  const anonKey = import.meta.env?.VITE_SUPABASE_ANON_KEY;
+  if (!url || !anonKey) {
+    throw new Error("Missing Supabase environment variables (VITE_SUPABASE_URL, VITE_SUPABASE_ANON_KEY)");
+  }
+  return { url, anonKey };
+}
+var _supabase = null;
+function getSupabaseClient() {
+  if (!_supabase) {
+    const { url, anonKey } = getSupabaseConfig();
+    _supabase = createClient(url, anonKey);
+  }
+  return _supabase;
+}
+var useSupabase = () => {
+  const { getAccessToken } = useAuthContext();
+  const { url, anonKey } = getSupabaseConfig();
+  return useMemo(
+    () => createClient(url, anonKey, {
+      global: {
+        headers: {
+          // Additional headers if needed
+        }
+      },
+      accessToken: async () => {
+        try {
+          const token = await getAccessToken();
+          if (!token) {
+            return null;
+          }
+          return token;
+        } catch {
+          return null;
+        }
+      }
+    }),
+    [getAccessToken, url, anonKey]
+  );
+};
+
+export { getSupabaseClient, useSupabase };

package/dist/{chunk-7AI5ZYJ4.js → chunk-JVAZHVNV.js}

@@ -1,99 +1,7 @@
+import { getErrorInfo, formatErrorMessage, getErrorTitle } from './chunk-4VGWQ5AN.js';
 import { notifications } from '@mantine/notifications';
 import { IconUser, IconExternalLink, IconPlug, IconBolt, IconGitBranch, IconBrain } from '@tabler/icons-react';
 
-// src/utils/notify.tsx
-
-// src/utils/error-utils.ts
-var APIClientError = class extends Error {
-  statusCode;
-  code;
-  requestId;
-  fields;
-  retryAfter;
-  constructor(message, code, statusCode, requestId, fields, retryAfter) {
-    super(message);
-    this.name = "APIClientError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.requestId = requestId;
-    this.fields = fields;
-    this.retryAfter = retryAfter;
-  }
-};
-function isAPIClientError(error) {
-  return error instanceof APIClientError;
-}
-function getErrorInfo(error) {
-  if (isAPIClientError(error)) {
-    return {
-      message: error.message,
-      code: error.code,
-      requestId: error.requestId,
-      statusCode: error.statusCode,
-      fields: error.fields,
-      retryAfter: error.retryAfter
-    };
-  }
-  if (error instanceof Error) {
-    return {
-      message: error.message
-    };
-  }
-  return {
-    message: String(error)
-  };
-}
-function getErrorTitle(code) {
-  if (!code) return "Error";
-  switch (code) {
-    case "VALIDATION_ERROR":
-      return "Validation Error";
-    case "AUTHENTICATION_FAILED":
-      return "Authentication Required";
-    case "FORBIDDEN":
-      return "Access Denied";
-    case "NOT_FOUND":
-      return "Not Found";
-    case "CONFLICT":
-      return "Conflict";
-    case "RATE_LIMIT_EXCEEDED":
-      return "Rate Limit Exceeded";
-    case "INTERNAL_SERVER_ERROR":
-      return "Server Error";
-    case "SERVICE_UNAVAILABLE":
-      return "Service Temporarily Unavailable";
-    default:
-      return "Error";
-  }
-}
-function formatErrorMessage(message, requestId, fields, retryAfter) {
-  let formatted = message;
-  if (fields && Object.keys(fields).length > 0) {
-    const fieldErrors = [];
-    for (const [field, errors] of Object.entries(fields)) {
-      const fieldName = field === "root" || field === "_root" ? "Request" : field;
-      errors.forEach((error) => {
-        fieldErrors.push(`\u2022 ${fieldName}: ${error}`);
-      });
-    }
-    if (fieldErrors.length > 0) {
-      formatted = fieldErrors.join("\n");
-    }
-  }
-  if (retryAfter) {
-    formatted += `
-
-Please wait ${retryAfter} seconds before retrying.`;
-  }
-  if (requestId) {
-    formatted += `
-
-Request ID: ${requestId}`;
-  }
-  return formatted;
-}
-
-// src/utils/notify.tsx
 var showInfoNotification = (message) => {
   notifications.show({
     title: "Info",
@@ -199,4 +107,4 @@ function getResourceIcon(type) {
   return iconNameToComponent[iconName];
 }
 
-export { APIClientError, formatDate, formatErrorMessage, getErrorInfo, getErrorTitle, getResourceColor, getResourceIcon, isAPIClientError, showApiErrorNotification, showErrorNotification, showInfoNotification, showSuccessNotification, showWarningNotification, validateEmail };
+export { formatDate, getResourceColor, getResourceIcon, showApiErrorNotification, showErrorNotification, showInfoNotification, showSuccessNotification, showWarningNotification, validateEmail };

package/dist/{chunk-ZGHDPDTF.js → chunk-JYSYHVLU.js}

@@ -1,7 +1,7 @@
-import { useSubmitAction, useDeleteTask } from './chunk-J3FALDQE.js';
+import { useSubmitAction, useDeleteTask } from './chunk-NXHL23JW.js';
 import { FormFieldRenderer } from './chunk-PSLKGOBZ.js';
-import { ContextViewer, JsonViewer } from './chunk-OUHGHTE7.js';
-import { getErrorInfo, formatErrorMessage } from './chunk-7AI5ZYJ4.js';
+import { ContextViewer, JsonViewer } from './chunk-O3PY6B6E.js';
+import { getErrorInfo, formatErrorMessage } from './chunk-4VGWQ5AN.js';
 import { Modal, Stack, Title, Text, Textarea, Alert, Group, Button, Card, ThemeIcon, Badge, Loader, Menu, ActionIcon, Accordion } from '@mantine/core';
 import { IconMail, IconSend, IconFileText, IconClock, IconArrowUp, IconMessageCircle, IconRocket, IconEye, IconEdit, IconAlertTriangle, IconRefresh, IconX, IconCheck, IconAlertCircle, IconRobot, IconGitBranch, IconDotsVertical, IconTrash, IconPlayerPlay, IconExternalLink } from '@tabler/icons-react';
 import { useState } from 'react';

package/dist/{chunk-5UWFGBFM.js → chunk-L2CM2CUA.js}

@@ -1,6 +1,6 @@
 import { useElevasisServices } from './chunk-KA7LO7U5.js';
 import { useAuthContext } from './chunk-7PLEQFHO.js';
-import { useState, useEffect } from 'react';
+import { createContext, useState, useEffect, useContext, createElement } from 'react';
 
 // src/profile/services/UserProfileService.ts
 var UserProfileService = class {
@@ -65,8 +65,6 @@ var UserProfileService = class {
     }
   }
 };
-
-// src/profile/hooks/useUserProfile.ts
 var useUserProfile = (options) => {
   const { user, isLoading: authLoading } = useAuthContext();
   const { apiRequest } = useElevasisServices();
@@ -125,5 +123,19 @@ var useUserProfile = (options) => {
     refetch
   };
 };
+var ProfileContext = createContext(null);
+function useProfile() {
+  const ctx = useContext(ProfileContext);
+  if (!ctx) {
+    throw new Error(
+      "useProfile must be used within a ProfileProvider. Wrap your app (or the relevant subtree) with <ProfileProvider>."
+    );
+  }
+  return ctx;
+}
+function ProfileProvider({ children }) {
+  const value = useUserProfile();
+  return createElement(ProfileContext.Provider, { value }, children);
+}
 
-export { UserProfileService, useUserProfile };
+export { ProfileProvider, UserProfileService, useProfile, useUserProfile };

package/dist/chunk-NEK6JKPW.js

@@ -0,0 +1,75 @@
+import { useProfile } from './chunk-L2CM2CUA.js';
+import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { createContext, useContext, useMemo, useCallback, createElement } from 'react';
+
+var InitializationContext = createContext(null);
+function useInitialization() {
+  const ctx = useContext(InitializationContext);
+  if (!ctx) {
+    throw new Error(
+      "useInitialization must be used within an InitializationProvider. Wrap your app (or the relevant subtree) with <InitializationProvider>."
+    );
+  }
+  return ctx;
+}
+function InitializationProvider({ children }) {
+  const { user, isLoading: authLoading } = useAuthContext();
+  const { profile, loading: profileLoading, error: profileError, refetch } = useProfile();
+  const {
+    isInitializing: orgInitializing,
+    isOrgRefreshing: orgLoading,
+    error: orgErrorMsg,
+    currentWorkOSOrganizationId,
+    memberships,
+    retry: orgRetry
+  } = useOrganization();
+  const isInitializing = authLoading || profileLoading || orgInitializing || orgLoading;
+  const userReady = !authLoading && !profileLoading && !!user && !!profile && !profileError;
+  const organizationReady = userReady && !orgInitializing && !orgLoading && !!currentWorkOSOrganizationId && !orgErrorMsg;
+  const allReady = organizationReady;
+  const error = useMemo(() => {
+    if (profileError) {
+      return {
+        layer: "profile",
+        message: "Failed to load user profile",
+        originalError: profileError
+      };
+    }
+    if (orgErrorMsg) {
+      return {
+        layer: "organization",
+        message: orgErrorMsg,
+        originalError: new Error(orgErrorMsg)
+      };
+    }
+    if (userReady && !orgInitializing && !orgLoading && !currentWorkOSOrganizationId && memberships.length > 0) {
+      return {
+        layer: "organization",
+        message: "No organization membership found. Please contact your administrator for an invitation."
+      };
+    }
+    return null;
+  }, [profileError, orgErrorMsg, userReady, orgInitializing, orgLoading, currentWorkOSOrganizationId, memberships]);
+  const retry = useCallback(async () => {
+    if (profileError && refetch) {
+      await refetch();
+    }
+    await orgRetry();
+  }, [profileError, refetch, orgRetry]);
+  const value = useMemo(
+    () => ({
+      userReady,
+      organizationReady,
+      allReady,
+      isInitializing,
+      error,
+      retry,
+      profile
+    }),
+    [userReady, organizationReady, allReady, isInitializing, error, retry, profile]
+  );
+  return createElement(InitializationContext.Provider, { value }, children);
+}
+
+export { InitializationContext, InitializationProvider, useInitialization };