@elevasis/ui 1.2.1 → 1.3.1

package/dist/CoreAuthKitInner-3J4RVQO6.js

@@ -0,0 +1,43 @@
+import { AuthProvider } from './chunk-7PLEQFHO.js';
+import { AuthKitProvider, useAuth } from '@workos-inc/authkit-react';
+import { useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+function CoreAuthKitInner({ auth, children }) {
+  return /* @__PURE__ */ jsx(
+    AuthKitProvider,
+    {
+      clientId: auth.clientId,
+      apiHostname: auth.apiHostname ?? "api.workos.com",
+      redirectUri: auth.redirectUri,
+      devMode: auth.devMode ?? false,
+      children: /* @__PURE__ */ jsx(WorkOSAuthAdapter, { children })
+    }
+  );
+}
+var WORKOS_REFRESH_TOKEN_KEY = "workos:refresh-token";
+function hasWorkOSRefreshToken() {
+  try {
+    return !!localStorage.getItem(WORKOS_REFRESH_TOKEN_KEY);
+  } catch {
+    return false;
+  }
+}
+function WorkOSAuthAdapter({ children }) {
+  const { user, isLoading, getAccessToken, organizationId, signIn } = useAuth();
+  const adaptedUser = useMemo(() => user ? { id: user.id } : null, [user?.id]);
+  const value = useMemo(
+    () => ({
+      user: adaptedUser,
+      isLoading,
+      getAccessToken,
+      organizationId: organizationId ?? null,
+      signIn,
+      canRecover: hasWorkOSRefreshToken
+    }),
+    [adaptedUser, isLoading, getAccessToken, organizationId, signIn]
+  );
+  return /* @__PURE__ */ jsx(AuthProvider, { value, children });
+}
+
+export { CoreAuthKitInner };

package/dist/api/index.d.ts

@@ -5,8 +5,10 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
  */
 interface ApiClientContextValue {
     getAccessToken: () => Promise<string | undefined>;
+    /** @deprecated Read via getOrganizationId() instead. Kept for downstream context consumers during migration. */
     organizationId: string | null;
     isOrganizationReady: boolean;
+    getOrganizationId: () => string | null;
     onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
 }
 interface ApiErrorDetails {
@@ -17,7 +19,19 @@ interface ApiErrorDetails {
 interface ApiClientProviderProps {
     children: React.ReactNode;
     getAccessToken: () => Promise<string | undefined>;
-    organizationId: string | null;
+    /**
+     * Static org ID. Used when org ID is stable at render time.
+     * Cannot reflect org switches without re-rendering the provider.
+     * Prefer getOrganizationId for dynamic org context.
+     * @deprecated Pass getOrganizationId instead for dynamic org resolution.
+     */
+    organizationId?: string | null;
+    /**
+     * Callback invoked on every request to read the current org ID.
+     * Takes precedence over organizationId when provided.
+     * Allows org switching without re-rendering the provider tree.
+     */
+    getOrganizationId?: () => string | null;
     isOrganizationReady: boolean;
     onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
 }
@@ -52,36 +66,36 @@ declare function useApiClientContext(): ApiClientContextValue;
  * }
  * ```
  */
-declare function ApiClientProvider({ children, getAccessToken, organizationId, isOrganizationReady, onError }: ApiClientProviderProps): react_jsx_runtime.JSX.Element;
+declare function ApiClientProvider({ children, getAccessToken, organizationId, getOrganizationId: getOrganizationIdProp, isOrganizationReady, onError }: ApiClientProviderProps): react_jsx_runtime.JSX.Element;
 
 /**
- * Return type of useOrganizations hook (subset needed by useApiClient)
- */
-interface UseOrganizationsReturn {
-    isInitializing: boolean;
-    isOrgRefreshing: boolean;
-}
-/**
- * Factory function to create a useApiClient hook for your app.
+ * Hook that returns apiRequest and deferredApiRequest bound to the current
+ * ApiClientContext. apiUrl is the only parameter because org ID is resolved
+ * at call time via getOrganizationId() from context.
  *
- * This pattern allows the shared package to provide the hook logic
- * while each app provides its own useOrganizations hook and API URL.
+ * When OrganizationProvider is present in the tree, isOrganizationReady and
+ * isInitializing reflect the live org state (currentWorkOSOrganizationId,
+ * isInitializing, isOrgRefreshing). When OrganizationProvider is absent
+ * (e.g. theme-only mode, testing), the hook falls back to the values from
+ * ApiClientContext.
  *
- * Usage in app:
+ * Usage:
  * ```typescript
- * import { createUseApiClient } from '@repo/ui/api'
- * import { useOrganizations } from './organization/hooks/useOrganizations'
+ * import { useApiClient } from '@repo/ui/api'
  *
  * const API_URL = import.meta.env.VITE_API_SERVER || 'http://localhost:5170'
- * export const useApiClient = createUseApiClient(useOrganizations, API_URL)
+ *
+ * function useMyClient() {
+ *   return useApiClient(API_URL)
+ * }
  * ```
  */
-declare function createUseApiClient(useOrganizations: () => UseOrganizationsReturn, apiUrl: string): () => {
+declare function useApiClient(apiUrl: string): {
     apiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
     deferredApiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
     isOrganizationReady: boolean;
     isInitializing: boolean;
 };
 
-export { ApiClientProvider, createUseApiClient, useApiClientContext };
+export { ApiClientProvider, useApiClient, useApiClientContext };
 export type { ApiClientContextValue, ApiClientProviderProps, ApiErrorDetails };

package/dist/api/index.js

@@ -1,3 +1,5 @@
 import '../chunk-XCYKC6OZ.js';
-export { ApiClientProvider, createUseApiClient, useApiClientContext } from '../chunk-GDV44UWF.js';
-import '../chunk-7AI5ZYJ4.js';
+export { ApiClientProvider, useApiClient, useApiClientContext } from '../chunk-XLV6LYN2.js';
+import '../chunk-JVAZHVNV.js';
+import '../chunk-4VGWQ5AN.js';
+import '../chunk-DD3CCMCZ.js';

package/dist/auth/context.d.ts

@@ -1,19 +1,37 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 
-interface AuthAdapter {
+interface AuthContextValue {
     user: {
         id: string;
     } | null;
     isLoading: boolean;
     getAccessToken: () => Promise<string>;
     organizationId?: string | null;
+    /**
+     * Trigger WorkOS AuthKit's sign-in flow (redirect to WorkOS hosted auth page).
+     * Used by ProtectedRoute for auto-recovery when `canRecover()` returns true.
+     */
+    signIn: (options?: {
+        state?: {
+            returnTo?: string;
+        };
+    }) => void;
+    /**
+     * Returns true when a previous session can be recovered (refresh token
+     * exists in storage). ProtectedRoute calls `signIn()` only when this returns
+     * true; otherwise it navigates to the login page.
+     *
+     * Explicit logout clears the stored token, so canRecover() returns false
+     * and the user sees the login page as expected.
+     */
+    canRecover: () => boolean;
 }
-declare function useAuthContext(): AuthAdapter;
+declare function useAuthContext(): AuthContextValue;
 declare function AuthProvider({ value, children }: {
-    value: AuthAdapter;
+    value: AuthContextValue;
     children: ReactNode;
-}): react.FunctionComponentElement<react.ProviderProps<AuthAdapter | null>>;
+}): react.FunctionComponentElement<react.ProviderProps<AuthContextValue | null>>;
 
 export { AuthProvider, useAuthContext };
-export type { AuthAdapter };
+export type { AuthContextValue };

package/dist/auth/index.d.ts

@@ -2,43 +2,37 @@ import * as react from 'react';
 import { ReactNode } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
-interface AuthAdapter {
+interface AuthContextValue {
     user: {
         id: string;
     } | null;
     isLoading: boolean;
     getAccessToken: () => Promise<string>;
     organizationId?: string | null;
+    /**
+     * Trigger WorkOS AuthKit's sign-in flow (redirect to WorkOS hosted auth page).
+     * Used by ProtectedRoute for auto-recovery when `canRecover()` returns true.
+     */
+    signIn: (options?: {
+        state?: {
+            returnTo?: string;
+        };
+    }) => void;
+    /**
+     * Returns true when a previous session can be recovered (refresh token
+     * exists in storage). ProtectedRoute calls `signIn()` only when this returns
+     * true; otherwise it navigates to the login page.
+     *
+     * Explicit logout clears the stored token, so canRecover() returns false
+     * and the user sees the login page as expected.
+     */
+    canRecover: () => boolean;
 }
-declare function useAuthContext(): AuthAdapter;
+declare function useAuthContext(): AuthContextValue;
 declare function AuthProvider({ value, children }: {
-    value: AuthAdapter;
+    value: AuthContextValue;
     children: ReactNode;
-}): react.FunctionComponentElement<react.ProviderProps<AuthAdapter | null>>;
-
-/**
- * Bridge component that reads WorkOS AuthKit state and provides it
- * via the generic AuthContext. Place inside AuthKitProvider.
- *
- * Narrows WorkOS User to { id: string } -- @repo/ui hooks only need the ID.
- * Uses useMemo to stabilize the user object and prevent unnecessary
- * useEffect re-runs in downstream hooks.
- */
-declare function WorkOSAuthBridge({ children }: {
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
-
-interface OAuthContextValue {
-    user: {
-        id: string;
-    } | null;
-    isLoading: boolean;
-    organizationId: string | null;
-    getAccessToken: () => Promise<string>;
-    error: string | null;
-    initiateOAuthFlow: () => void;
-}
-declare function useOAuthContext(): OAuthContextValue;
+}): react.FunctionComponentElement<react.ProviderProps<AuthContextValue | null>>;
 
 /**
  * Returns a stable reference to getAccessToken that won't change between renders
@@ -83,5 +77,100 @@ declare function useStableAccessToken(): () => Promise<string>;
  */
 declare function useSessionCheck(): void;
 
-export { AuthProvider, WorkOSAuthBridge, useAuthContext, useOAuthContext, useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken };
-export type { AuthAdapter, OAuthContextValue };
+interface InitializationError {
+    layer: 'auth' | 'profile' | 'organization';
+    message: string;
+    originalError?: Error;
+}
+
+interface ProtectedRouteProps {
+    children: ReactNode;
+    /**
+     * Path to redirect to when user is unauthenticated and the auth adapter
+     * does not provide a `signIn` function.
+     * @default '/login'
+     */
+    redirectTo?: string;
+    /**
+     * Rendered while initialization is in progress.
+     * When not provided, nothing is rendered during initialization.
+     */
+    fallback?: ReactNode;
+    /**
+     * Rendered when initialization fails with a non-organization error.
+     * Receives the error and a retry callback.
+     * When not provided, the error is silently swallowed (children not rendered).
+     */
+    errorFallback?: (error: InitializationError, retry: () => void) => ReactNode;
+    /**
+     * When true (default), waits for both user AND organization to be ready
+     * before rendering children. When false, only waits for user readiness.
+     * @default true
+     */
+    waitForOrganization?: boolean;
+}
+/**
+ * Headless route guard for authenticated pages.
+ *
+ * Reads initialization state from the nearest InitializationProvider.
+ *
+ * When `canRecover()` returns true (refresh token exists), unauthenticated users
+ * are sent directly to WorkOS AuthKit via `signIn()`. WorkOS checks its
+ * server-side session and either signs the user in immediately (page-reload case)
+ * or shows a login form (logged-out case). Explicit logout destroys the
+ * server-side session, so the next auto-signIn correctly presents a login form
+ * rather than looping.
+ *
+ * When `canRecover()` returns false, falls back to navigating to `redirectTo`
+ * (default: '/login') with a `returnTo` search param.
+ *
+ * Organization-layer errors are allowed through -- routes like /invitations
+ * must be accessible even when the user has no org membership.
+ *
+ * @example
+ * // With custom fallback (your Mantine loader):
+ * <ProtectedRoute fallback={<AppShellLoader />}>
+ *   <DashboardPage />
+ * </ProtectedRoute>
+ *
+ * @example
+ * // Wait only for user, not org (e.g. /invitations route):
+ * <ProtectedRoute waitForOrganization={false}>
+ *   <InvitationsPage />
+ * </ProtectedRoute>
+ */
+declare function ProtectedRoute({ children, redirectTo, fallback, errorFallback, waitForOrganization }: ProtectedRouteProps): react_jsx_runtime.JSX.Element | null;
+
+interface AdminGuardProps {
+    children: ReactNode;
+    /**
+     * Path to redirect non-admin users to.
+     * @default '/'
+     */
+    redirectTo?: string;
+    /**
+     * Rendered while user readiness is being determined.
+     * When not provided, nothing is rendered during initialization.
+     */
+    fallback?: ReactNode;
+}
+/**
+ * Headless route guard for platform admin pages.
+ *
+ * Reads `profile.is_platform_admin` from the nearest InitializationProvider.
+ * Non-admin users are redirected to `redirectTo` (default: '/').
+ *
+ * Must be nested inside a ProtectedRoute (or equivalent) so that
+ * `userReady` is guaranteed to be true when this guard runs.
+ *
+ * @example
+ * <ProtectedRoute>
+ *   <AdminGuard fallback={<AppShellLoader />}>
+ *     <AdminDashboard />
+ *   </AdminGuard>
+ * </ProtectedRoute>
+ */
+declare function AdminGuard({ children, redirectTo, fallback }: AdminGuardProps): react_jsx_runtime.JSX.Element | null;
+
+export { AdminGuard, AuthProvider, ProtectedRoute, useAuthContext, useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken };
+export type { AdminGuardProps, AuthContextValue, ProtectedRouteProps };

package/dist/auth/index.js

@@ -1,4 +1,7 @@
-export { useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken } from '../chunk-HBRMWW6V.js';
-export { WorkOSAuthBridge } from '../chunk-NIAVTSMB.js';
-export { useOAuthContext } from '../chunk-QSVZP2NU.js';
+export { AdminGuard, ProtectedRoute, useSessionCheck as useRefocusSessionCheck, useSessionCheck } from '../chunk-2JBWPFHF.js';
+export { useStableAccessToken } from '../chunk-FWZJH3TL.js';
+import '../chunk-NEK6JKPW.js';
+import '../chunk-L2CM2CUA.js';
+import '../chunk-DD3CCMCZ.js';
+import '../chunk-KA7LO7U5.js';
 export { AuthProvider, useAuthContext } from '../chunk-7PLEQFHO.js';

package/dist/chunk-2JBWPFHF.js

@@ -0,0 +1,108 @@
+import { useInitialization } from './chunk-NEK6JKPW.js';
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { useRef, useEffect } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { useNavigate, useLocation } from '@tanstack/react-router';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+function useSessionCheck() {
+  const { user } = useAuthContext();
+  const queryClient = useQueryClient();
+  const isCheckingRef = useRef(false);
+  const hadUserRef = useRef(false);
+  if (user) {
+    hadUserRef.current = true;
+  }
+  useEffect(() => {
+    const handleVisibilityChange = async () => {
+      if (isCheckingRef.current || document.visibilityState !== "visible") {
+        return;
+      }
+      isCheckingRef.current = true;
+      try {
+        if (!user && hadUserRef.current) {
+          window.location.replace("/login");
+          return;
+        }
+        if (user) {
+          await queryClient.cancelQueries();
+          queryClient.invalidateQueries();
+        }
+      } finally {
+        isCheckingRef.current = false;
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    window.addEventListener("focus", handleVisibilityChange);
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+      window.removeEventListener("focus", handleVisibilityChange);
+    };
+  }, [user, queryClient]);
+}
+function ProtectedRoute({
+  children,
+  redirectTo = "/login",
+  fallback = null,
+  errorFallback,
+  waitForOrganization = true
+}) {
+  const { userReady, allReady, isInitializing, error, retry } = useInitialization();
+  const { signIn, canRecover } = useAuthContext();
+  const navigate = useNavigate();
+  const location = useLocation();
+  const hasRedirected = useRef(false);
+  const unauthenticated = !isInitializing && !userReady && error?.layer !== "profile";
+  useEffect(() => {
+    if (unauthenticated && !hasRedirected.current) {
+      hasRedirected.current = true;
+      const searchStr = location.searchStr ?? "";
+      const returnTo = location.pathname + searchStr;
+      if (canRecover()) {
+        signIn({ state: { returnTo: returnTo !== "/" ? returnTo : void 0 } });
+      } else {
+        navigate({
+          to: redirectTo,
+          search: returnTo !== "/" ? { returnTo } : {}
+        });
+      }
+    }
+  }, [unauthenticated, signIn, canRecover, navigate, redirectTo, location]);
+  if (isInitializing) {
+    return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+  }
+  if (error && error.layer !== "organization") {
+    if (errorFallback) {
+      return /* @__PURE__ */ jsx(Fragment, { children: errorFallback(error, retry) });
+    }
+    return null;
+  }
+  if (unauthenticated) {
+    return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+  }
+  if (waitForOrganization && !allReady && error?.layer !== "organization") {
+    return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+function AdminGuard({ children, redirectTo = "/", fallback = null }) {
+  const { userReady, profile } = useInitialization();
+  const navigate = useNavigate();
+  useEffect(() => {
+    if (!userReady || !profile) {
+      return;
+    }
+    if (!profile.is_platform_admin) {
+      navigate({ to: redirectTo });
+    }
+  }, [userReady, profile, navigate, redirectTo]);
+  if (!userReady) {
+    return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+  }
+  if (!profile?.is_platform_admin) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+
+export { AdminGuard, ProtectedRoute, useSessionCheck };

package/dist/chunk-4VGWQ5AN.js

@@ -0,0 +1,91 @@
+// 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;
+}
+
+export { APIClientError, formatErrorMessage, getErrorInfo, getErrorTitle, isAPIClientError };

package/dist/chunk-72HOBFMP.js

@@ -0,0 +1,87 @@
+import { OrganizationProvider } from './chunk-UMXDDEAG.js';
+import { ApiClientProvider, useApiClient } from './chunk-XLV6LYN2.js';
+import { NotificationProvider } from './chunk-TIRMFDM4.js';
+import { InitializationProvider } from './chunk-NEK6JKPW.js';
+import { ProfileProvider } from './chunk-L2CM2CUA.js';
+import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { ElevasisServiceProvider, useElevasisServices } from './chunk-KA7LO7U5.js';
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { lazy, Suspense, useRef } from 'react';
+import { QueryClientProvider, QueryClient } from '@tanstack/react-query';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+var LazyCoreAuthKitInner = lazy(() => import('./CoreAuthKitInner-3J4RVQO6.js').then((m) => ({ default: m.CoreAuthKitInner })));
+var defaultQueryClient = null;
+function getDefaultQueryClient() {
+  if (!defaultQueryClient) {
+    defaultQueryClient = new QueryClient({
+      defaultOptions: { queries: { retry: 1 } }
+    });
+  }
+  return defaultQueryClient;
+}
+function ElevasisCoreProvider({
+  auth,
+  queryClient,
+  apiUrl,
+  onError,
+  notifications,
+  children
+}) {
+  if (auth.mode === "apiKey") {
+    throw new Error(
+      `ElevasisCoreProvider: auth mode 'apiKey' is not yet implemented. Only 'authkit' mode is supported.`
+    );
+  }
+  const resolvedQueryClient = queryClient ?? getDefaultQueryClient();
+  const content = apiUrl ? /* @__PURE__ */ jsx(CoreServiceBridge, { apiUrl, onError, notifications, children }) : children;
+  const AuthInner = /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(LazyCoreAuthKitInner, { auth, children: content }) });
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: resolvedQueryClient, children: AuthInner });
+}
+function CoreServiceBridge({
+  apiUrl,
+  onError,
+  notifications,
+  children
+}) {
+  const { getAccessToken } = useAuthContext();
+  const orgIdRef = useRef(null);
+  const getOrganizationId = useRef(() => orgIdRef.current).current;
+  return /* @__PURE__ */ jsx(
+    ApiClientProvider,
+    {
+      getAccessToken,
+      getOrganizationId,
+      isOrganizationReady: false,
+      onError,
+      children: /* @__PURE__ */ jsx(CoreServiceBridgeInner, { apiUrl, orgIdRef, notifications, children })
+    }
+  );
+}
+function CoreServiceBridgeInner({
+  apiUrl,
+  orgIdRef,
+  notifications,
+  children
+}) {
+  const { apiRequest } = useApiClient(apiUrl);
+  return /* @__PURE__ */ jsx(ElevasisServiceProvider, { apiRequest, organizationId: null, isReady: false, children: /* @__PURE__ */ jsx(ProfileProvider, { children: /* @__PURE__ */ jsx(OrganizationProvider, { children: /* @__PURE__ */ jsx(OrgIdBridge, { orgIdRef, children: /* @__PURE__ */ jsx(CoreNotificationLayer, { notifications, children: /* @__PURE__ */ jsx(InitializationProvider, { children }) }) }) }) }) });
+}
+function OrgIdBridge({ orgIdRef, children }) {
+  const { currentWorkOSOrganizationId, isInitializing, isOrgRefreshing } = useOrganization();
+  const { apiRequest } = useElevasisServices();
+  orgIdRef.current = currentWorkOSOrganizationId;
+  const isReady = !!currentWorkOSOrganizationId && !isInitializing && !isOrgRefreshing;
+  return /* @__PURE__ */ jsx(ElevasisServiceProvider, { apiRequest, organizationId: currentWorkOSOrganizationId, isReady, children });
+}
+function CoreNotificationLayer({
+  notifications,
+  children
+}) {
+  if (notifications) {
+    return /* @__PURE__ */ jsx(NotificationProvider, { adapter: notifications, children });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+
+export { ElevasisCoreProvider };