@jmruthers/pace-core 0.6.10 → 0.6.11

package/dist/{chunk-Y4PF6HIM.js → chunk-4R3T5ENU.js}

@@ -1,10 +1,13 @@
-import { isRBACInitialized, setupRBAC } from './chunk-LNHFAF4X.js';
+import { setPrintAppName } from './chunk-D6BMFMQZ.js';
+import { isRBACInitialized, setupRBAC } from './chunk-7A6IMHH2.js';
 import { assertOrganisationId, assertUserId } from './chunk-4SXLQIZO.js';
 import { secureStorage } from './chunk-RMLY6KB5.js';
 import { createLogger, logger } from './chunk-BTHN5MKC.js';
+import { err, ok } from './chunk-44CNXN4P.js';
 import { createContext, useRef, useEffect, useState, useMemo, useContext, useReducer, useCallback } from 'react';
 import { AuthError } from '@supabase/supabase-js';
 import { jsx } from 'react/jsx-runtime';
+import { flushSync } from 'react-dom';
 
 // src/services/base/BaseService.ts
 var BaseService = class {
@@ -74,6 +77,13 @@ var BaseService = class {
   }
 };
 
+// src/utils/security/auth-utils.ts
+function toApiError(error) {
+  const message = error.message || "An unexpected error occurred";
+  const code = "status" in error && typeof error.status === "number" ? `AUTH_${error.status}` : error.name || "AUTH_ERROR";
+  return { code, message };
+}
+
 // src/services/AuthService.ts
 var _AuthService = class _AuthService extends BaseService {
   // Track previous auth state to detect transitions
@@ -135,7 +145,7 @@ var _AuthService = class _AuthService extends BaseService {
       const error = new AuthError("Supabase client not available");
       this.authError = error;
       this.notify();
-      return { user: null, session: null, error };
+      return err(toApiError(error));
     }
     try {
       const { data, error } = await this.supabaseClient.auth.signInWithPassword({
@@ -146,24 +156,25 @@ var _AuthService = class _AuthService extends BaseService {
         this.authError = error;
         this.user = null;
         this.session = null;
-      } else {
-        this.authError = null;
-        this.user = data.user;
-        this.session = data.session;
-        if (!this.wasAuthenticatedRef && data.user) {
-          this.clearPersistenceOnLogin(null, true);
-          this.wasAuthenticatedRef = true;
-        }
+        this.notify();
+        return err(toApiError(error));
+      }
+      this.authError = null;
+      this.user = data.user;
+      this.session = data.session;
+      if (!this.wasAuthenticatedRef && data.user) {
+        this.clearPersistenceOnLogin(null, true);
+        this.wasAuthenticatedRef = true;
       }
       this.notify();
-      return { user: data.user, session: data.session, error };
+      return ok({ user: data.user, session: data.session });
     } catch (error) {
       const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
       this.authError = authError;
       this.user = null;
       this.session = null;
       this.notify();
-      return { user: null, session: null, error: authError };
+      return err(toApiError(authError));
     }
   }
   async signUp(email, password) {
@@ -171,7 +182,7 @@ var _AuthService = class _AuthService extends BaseService {
       const error = new AuthError("Supabase client not available");
       this.authError = error;
       this.notify();
-      return { user: null, session: null, error };
+      return err(toApiError(error));
     }
     try {
       const { data, error } = await this.supabaseClient.auth.signUp({
@@ -182,24 +193,25 @@ var _AuthService = class _AuthService extends BaseService {
         this.authError = error;
         this.user = null;
         this.session = null;
-      } else {
-        this.authError = null;
-        this.user = data.user;
-        this.session = data.session;
-        if (!this.wasAuthenticatedRef && data.user) {
-          this.clearPersistenceOnLogin(null, true);
-          this.wasAuthenticatedRef = true;
-        }
+        this.notify();
+        return err(toApiError(error));
+      }
+      this.authError = null;
+      this.user = data.user;
+      this.session = data.session;
+      if (!this.wasAuthenticatedRef && data.user) {
+        this.clearPersistenceOnLogin(null, true);
+        this.wasAuthenticatedRef = true;
       }
       this.notify();
-      return { user: data.user, session: data.session, error };
+      return ok({ user: data.user, session: data.session });
     } catch (error) {
       const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
       this.authError = authError;
       this.user = null;
       this.session = null;
       this.notify();
-      return { user: null, session: null, error: authError };
+      return err(toApiError(authError));
     }
   }
   async signOut() {
@@ -207,36 +219,47 @@ var _AuthService = class _AuthService extends BaseService {
       const error = new AuthError("Supabase client not available");
       this.authError = error;
       this.notify();
-      return { user: null, session: null, error };
+      return err(toApiError(error));
     }
-    try {
-      const { error } = await this.supabaseClient.auth.signOut();
+    const clearLocalState = () => {
+      this.authError = null;
+      this.user = null;
+      this.session = null;
       try {
         sessionStorage.clear();
       } catch (storageError) {
         logger.warn("AuthService", "Failed to clear sessionStorage", { error: storageError });
       }
+      this.notify();
+    };
+    try {
+      const { error } = await this.supabaseClient.auth.signOut();
       if (error) {
-        this.authError = error;
-      } else {
-        this.authError = null;
-        this.user = null;
-        this.session = null;
+        logger.warn("AuthService", "signOut (global) failed, clearing local state and trying local scope", {
+          message: error.message,
+          status: error.status
+        });
+        clearLocalState();
+        const { error: localError } = await this.supabaseClient.auth.signOut({ scope: "local" });
+        if (localError) {
+          logger.warn("AuthService", "signOut (local) also failed", { message: localError.message });
+        }
+        return err(toApiError(error));
       }
-      this.notify();
-      return { user: null, session: null, error };
+      clearLocalState();
+      return ok({ user: null, session: null });
     } catch (error) {
+      logger.warn("AuthService", "signOut threw, clearing local state and trying local scope", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      clearLocalState();
       try {
-        sessionStorage.clear();
-      } catch (storageError) {
-        logger.warn("AuthService", "Failed to clear sessionStorage", { error: storageError });
+        await this.supabaseClient.auth.signOut({ scope: "local" });
+      } catch (_localError) {
       }
       const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
       this.authError = authError;
-      this.user = null;
-      this.session = null;
-      this.notify();
-      return { user: null, session: null, error: authError };
+      return err(toApiError(authError));
     }
   }
   async resetPassword(email) {
@@ -244,22 +267,23 @@ var _AuthService = class _AuthService extends BaseService {
       const error = new AuthError("Supabase client not available");
       this.authError = error;
       this.notify();
-      return { user: null, session: null, error };
+      return err(toApiError(error));
     }
     try {
       const { error } = await this.supabaseClient.auth.resetPasswordForEmail(email);
       if (error) {
         this.authError = error;
-      } else {
-        this.authError = null;
+        this.notify();
+        return err(toApiError(error));
       }
+      this.authError = null;
       this.notify();
-      return { user: null, session: null, error };
+      return ok({ user: this.user, session: this.session });
     } catch (error) {
       const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
       this.authError = authError;
       this.notify();
-      return { user: null, session: null, error: authError };
+      return err(toApiError(authError));
     }
   }
   async updatePassword(password) {
@@ -267,7 +291,7 @@ var _AuthService = class _AuthService extends BaseService {
       const error = new AuthError("Supabase client not available");
       this.authError = error;
       this.notify();
-      return { user: null, session: null, error };
+      return err(toApiError(error));
     }
     try {
       const { error } = await this.supabaseClient.auth.updateUser({
@@ -275,16 +299,17 @@ var _AuthService = class _AuthService extends BaseService {
       });
       if (error) {
         this.authError = error;
-      } else {
-        this.authError = null;
+        this.notify();
+        return err(toApiError(error));
       }
+      this.authError = null;
       this.notify();
-      return { user: null, session: null, error };
+      return ok({ user: this.user, session: this.session });
     } catch (error) {
-      const authError = error;
+      const authError = error instanceof AuthError ? error : error;
       this.authError = authError;
       this.notify();
-      return { user: null, session: null, error: authError };
+      return err(toApiError(authError));
     }
   }
   async refreshSession() {
@@ -292,7 +317,7 @@ var _AuthService = class _AuthService extends BaseService {
       const error = new AuthError("Supabase client not available");
       this.authError = error;
       this.notify();
-      return { user: null, session: null, error };
+      return err(toApiError(error));
     }
     try {
       const { data, error } = await this.supabaseClient.auth.refreshSession();
@@ -300,29 +325,29 @@ var _AuthService = class _AuthService extends BaseService {
         this.authError = error;
         this.user = null;
         this.session = null;
+        this.notify();
+        return err(toApiError(error));
+      }
+      this.authError = null;
+      if (data?.user && data?.session) {
+        this.user = data.user;
+        this.session = data.session;
       } else {
-        this.authError = null;
-        if (data?.user && data?.session) {
-          this.user = data.user;
-          this.session = data.session;
-        } else {
-          this.user = null;
-          this.session = null;
-        }
+        this.user = null;
+        this.session = null;
       }
       this.notify();
-      return {
+      return ok({
         user: data?.user && data?.session ? data.user : null,
-        session: data?.session ?? null,
-        error
-      };
+        session: data?.session ?? null
+      });
     } catch (error) {
       const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
       this.authError = authError;
       this.user = null;
       this.session = null;
       this.notify();
-      return { user: null, session: null, error: authError };
+      return err(toApiError(authError));
     }
   }
   // Lifecycle methods
@@ -432,6 +457,62 @@ var _AuthService = class _AuthService extends BaseService {
       logger.warn("AuthService", `Failed to clear persistence [ID:${this.instanceId}]:`, error);
     }
   }
+  handleSignedOut(session) {
+    this.session = null;
+    this.user = null;
+    this.authError = null;
+    this.wasAuthenticatedRef = false;
+    if (session?.user) {
+      this.trackSession("logout", session).catch((err2) => {
+        logger.warn("AuthService", `Failed to track logout session [ID:${this.instanceId}]:`, err2);
+      });
+    }
+  }
+  handleSignedInOrTokenRefreshed(event, session, wasAuthenticated, isNowAuthenticated, userChanged, previousUserId) {
+    this.session = session;
+    this.user = session?.user ?? null;
+    if (session?.user) {
+      this.authError = null;
+    }
+    if (!wasAuthenticated && isNowAuthenticated && event === "SIGNED_IN") {
+      this.clearPersistenceOnLogin(null, true);
+    } else if (userChanged && previousUserId) {
+      this.clearPersistenceOnLogin(previousUserId, true);
+    }
+    this.wasAuthenticatedRef = isNowAuthenticated;
+    if (event === "SIGNED_IN" && session?.user) {
+      this.trackSession("login", session).catch((err2) => {
+        logger.warn("AuthService", `Failed to track login session [ID:${this.instanceId}]:`, err2);
+      });
+    }
+  }
+  handleInitialSession(session, wasAuthenticated) {
+    if (session) {
+      const previousUserId = this.user?.id ?? null;
+      const newUserId = session.user?.id ?? null;
+      const userChanged = previousUserId !== null && newUserId !== null && previousUserId !== newUserId;
+      this.session = session;
+      this.user = session.user ?? null;
+      this.authError = null;
+      if (userChanged && previousUserId) {
+        this.clearPersistenceOnLogin(previousUserId, true);
+      } else if (!wasAuthenticated && !!session.user) {
+        this.clearPersistenceOnLogin(null, true);
+      }
+      this.wasAuthenticatedRef = !!session.user;
+      const hasTimeoutError = this.sessionRestorationState.restorationError?.name === "SessionRestorationTimeoutError";
+      if (this.sessionRestorationState.isRestoring || this.sessionRestorationState.restorationError || hasTimeoutError && session) {
+        this.finishSessionRestoration();
+      }
+    } else {
+      this.wasAuthenticatedRef = false;
+      if (this.sessionRestorationState.isRestoring) {
+        this.finishSessionRestoration();
+      }
+    }
+    this.authLoading = false;
+    this.notify();
+  }
   async setupAuthStateListener() {
     if (!this.supabaseClient) {
       this.authLoading = false;
@@ -444,62 +525,22 @@ var _AuthService = class _AuthService extends BaseService {
           try {
             const wasAuthenticated = this.wasAuthenticatedRef;
             const isNowAuthenticated = !!session?.user;
-            const previousUserId = this.user?.id || null;
-            const newUserId = session?.user?.id || null;
+            const previousUserId = this.user?.id ?? null;
+            const newUserId = session?.user?.id ?? null;
             const userChanged = previousUserId !== null && newUserId !== null && previousUserId !== newUserId;
             if (event === "SIGNED_OUT") {
-              this.session = null;
-              this.user = null;
-              this.authError = null;
-              this.wasAuthenticatedRef = false;
-              if (session?.user) {
-                this.trackSession("logout", session).catch((err) => {
-                  logger.warn("AuthService", `Failed to track logout session [ID:${this.instanceId}]:`, err);
-                });
-              }
+              this.handleSignedOut(session);
             } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
-              this.session = session;
-              this.user = session?.user ?? null;
-              if (session?.user) {
-                this.authError = null;
-              }
-              if (!wasAuthenticated && isNowAuthenticated && event === "SIGNED_IN") {
-                this.clearPersistenceOnLogin(null, true);
-              } else if (userChanged && previousUserId) {
-                this.clearPersistenceOnLogin(previousUserId, true);
-              }
-              this.wasAuthenticatedRef = isNowAuthenticated;
-              if (event === "SIGNED_IN" && session?.user) {
-                this.trackSession("login", session).catch((err) => {
-                  logger.warn("AuthService", `Failed to track login session [ID:${this.instanceId}]:`, err);
-                });
-              }
+              this.handleSignedInOrTokenRefreshed(
+                event,
+                session,
+                wasAuthenticated,
+                isNowAuthenticated,
+                userChanged,
+                previousUserId
+              );
             } else if (event === "INITIAL_SESSION") {
-              if (session) {
-                const previousUserId2 = this.user?.id || null;
-                const newUserId2 = session.user?.id || null;
-                const userChanged2 = previousUserId2 !== null && newUserId2 !== null && previousUserId2 !== newUserId2;
-                this.session = session;
-                this.user = session.user ?? null;
-                this.authError = null;
-                if (userChanged2 && previousUserId2) {
-                  this.clearPersistenceOnLogin(previousUserId2, true);
-                } else if (!wasAuthenticated && !!session.user) {
-                  this.clearPersistenceOnLogin(null, true);
-                }
-                this.wasAuthenticatedRef = !!session.user;
-                const hasTimeoutError = this.sessionRestorationState.restorationError?.name === "SessionRestorationTimeoutError";
-                if (this.sessionRestorationState.isRestoring || this.sessionRestorationState.restorationError || hasTimeoutError && session) {
-                  this.finishSessionRestoration();
-                }
-              } else {
-                this.wasAuthenticatedRef = false;
-                if (this.sessionRestorationState.isRestoring) {
-                  this.finishSessionRestoration();
-                }
-              }
-              this.authLoading = false;
-              this.notify();
+              this.handleInitialSession(session, wasAuthenticated);
               return;
             }
             this.authLoading = false;
@@ -732,6 +773,7 @@ function AuthServiceProvider({ children, supabaseClient, appName }) {
   }), [authService, sessionRestoration]);
   return /* @__PURE__ */ jsx(AuthServiceContext.Provider, { value: contextValue, children });
 }
+var OrganisationServiceContext = createContext(null);
 
 // src/services/OrganisationService.ts
 var _OrganisationService = class _OrganisationService extends BaseService {
@@ -959,7 +1001,8 @@ var _OrganisationService = class _OrganisationService extends BaseService {
     this._isContextReady = true;
     this.notify();
   }
-  async loadUserOrganisations() {
+  /** Returns false if load should return early; when true, abort controller and loading state are set. */
+  prepareLoad() {
     if (!this.user || !this.session || !this.supabaseClient) {
       this._selectedOrganisation = null;
       this._organisations = [];
@@ -967,12 +1010,12 @@ var _OrganisationService = class _OrganisationService extends BaseService {
       this._isLoading = false;
       this._error = null;
       this.notify();
-      return;
+      return false;
     }
     if (this.isLoadingRef) {
       this._isLoading = true;
       this.notify();
-      return;
+      return false;
     }
     const now = Date.now();
     if (this._organisations.length > 0 && now - this.lastLoadTimeRef < 2e3) {
@@ -982,146 +1025,183 @@ var _OrganisationService = class _OrganisationService extends BaseService {
         this._isLoading = true;
       }
       this.notify();
-      return;
+      return false;
     }
     if (this.abortControllerRef) {
       this.abortControllerRef.abort();
     }
     this.abortControllerRef = new AbortController();
-    const abortSignal = this.abortControllerRef.signal;
     this.lastLoadTimeRef = now;
     this.isLoadingRef = true;
     this._isLoading = true;
     this._error = null;
     this.notify();
+    return true;
+  }
+  async fetchRolesAndOrganisations(signal) {
+    if (signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    if (!this.supabaseClient || !this.user) {
+      throw new Error("Missing supabase client or user");
+    }
     try {
-      let memberships, membershipError, organisations = [];
-      try {
-        if (abortSignal.aborted) {
-          throw new Error("Request aborted");
-        }
-        const { data: rolesData, error: rolesError } = await this.supabaseClient.from("rbac_organisation_roles").select(`
+      const { data: rolesData, error: rolesError } = await this.supabaseClient.from("rbac_organisation_roles").select(`
+          id,
+          user_id,
+          organisation_id,
+          role,
+          status,
+          granted_at,
+          granted_by,
+          revoked_at,
+          revoked_by,
+          notes,
+          created_at,
+          updated_at,
+          core_organisations!inner(
             id,
-            user_id,
-            organisation_id,
-            role,
-            status,
-            granted_at,
-            granted_by,
-            revoked_at,
-            revoked_by,
-            notes,
+            name,
+            display_name,
+            subscription_tier,
+            settings,
+            is_active,
+            parent_id,
             created_at,
-            updated_at,
-            core_organisations!inner(
-              id,
-              name,
-              display_name,
-              subscription_tier,
-              settings,
-              is_active,
-              parent_id,
-              created_at,
-              updated_at
-            )
-          `).eq("user_id", this.user.id).eq("status", "active").is("revoked_at", null);
-        if (rolesError) {
-          logger.error("OrganisationService", "Error loading organisation roles:", rolesError);
-          throw rolesError;
-        }
-        memberships = rolesData?.map((m) => ({
-          ...m,
-          user_id: assertUserId(m.user_id),
-          organisation_id: assertOrganisationId(m.organisation_id)
-        })) || [];
-        const organisationsMap = /* @__PURE__ */ new Map();
-        rolesData?.forEach((role) => {
-          const roleWithOrg = role;
-          const orgData = roleWithOrg.core_organisations;
-          if (orgData && roleWithOrg.organisation_id && !organisationsMap.has(roleWithOrg.organisation_id)) {
-            organisationsMap.set(roleWithOrg.organisation_id, {
-              id: orgData.id,
-              name: orgData.name,
-              display_name: orgData.display_name,
-              subscription_tier: orgData.subscription_tier,
-              settings: orgData.settings,
-              is_active: orgData.is_active,
-              parent_id: orgData.parent_id,
-              created_at: orgData.created_at,
-              updated_at: orgData.updated_at
-            });
-          }
-        });
-        organisations = Array.from(organisationsMap.values());
-      } catch (queryError) {
-        if (queryError instanceof Error) {
-          membershipError = queryError;
-        } else if (queryError && typeof queryError === "object" && "message" in queryError) {
-          membershipError = new Error(String(queryError.message));
-        } else {
-          membershipError = new Error(String(queryError));
+            updated_at
+          )
+        `).eq("user_id", this.user.id).eq("status", "active").is("revoked_at", null);
+      if (rolesError) {
+        logger.error("OrganisationService", "Error loading organisation roles:", rolesError);
+        throw rolesError;
+      }
+      const memberships = rolesData?.map((m) => ({
+        ...m,
+        user_id: assertUserId(m.user_id),
+        organisation_id: assertOrganisationId(m.organisation_id)
+      })) || [];
+      const organisationsMap = /* @__PURE__ */ new Map();
+      rolesData?.forEach((role) => {
+        const roleWithOrg = role;
+        const orgData = roleWithOrg.core_organisations;
+        if (orgData && roleWithOrg.organisation_id && !organisationsMap.has(roleWithOrg.organisation_id)) {
+          organisationsMap.set(roleWithOrg.organisation_id, {
+            id: orgData.id,
+            name: orgData.name,
+            display_name: orgData.display_name,
+            subscription_tier: orgData.subscription_tier,
+            settings: orgData.settings,
+            is_active: orgData.is_active,
+            parent_id: orgData.parent_id,
+            created_at: orgData.created_at,
+            updated_at: orgData.updated_at
+          });
         }
-        logger.error("OrganisationService", "Error loading organisation roles:", membershipError);
-        throw membershipError;
+      });
+      const organisations = Array.from(organisationsMap.values());
+      return { memberships, organisations };
+    } catch (queryError) {
+      const err2 = queryError instanceof Error ? queryError : queryError && typeof queryError === "object" && "message" in queryError ? new Error(String(queryError.message)) : new Error(String(queryError));
+      logger.error("OrganisationService", "Error loading organisation roles:", err2);
+      throw err2;
+    }
+  }
+  async checkAndCacheSuperAdmin() {
+    if (!this.user?.id) {
+      this._isSuperAdmin = false;
+      return false;
+    }
+    try {
+      const { isSuperAdmin: checkSuperAdmin, isRBACInitialized: isRBACInitialized2, setupRBAC: setupRBAC2 } = await import('./api-BZR2CYXL.js');
+      if (!isRBACInitialized2() && this.supabaseClient) {
+        setupRBAC2(this.supabaseClient);
       }
-      let userIsSuperAdmin = false;
-      if (this.user?.id) {
-        try {
-          const { isSuperAdmin: checkSuperAdmin, isRBACInitialized: isRBACInitialized2, setupRBAC: setupRBAC2 } = await import('./api-F47QJ7FX.js');
-          if (!isRBACInitialized2() && this.supabaseClient) {
-            setupRBAC2(this.supabaseClient);
-          }
-          if (isRBACInitialized2()) {
-            userIsSuperAdmin = await checkSuperAdmin(this.user.id);
+      if (isRBACInitialized2()) {
+        const result = await checkSuperAdmin(this.user.id);
+        const isSuper = result.ok && result.data;
+        this._isSuperAdmin = isSuper;
+        return isSuper;
+      }
+      this._isSuperAdmin = false;
+      return false;
+    } catch (error) {
+      logger.warn("OrganisationService", "Failed to check super admin status", { error });
+      this._isSuperAdmin = false;
+      return false;
+    }
+  }
+  applyEmptyStateAndNotify() {
+    this._organisations = [];
+    this._userMemberships = [];
+    this._isLoading = false;
+    this._error = null;
+    this._isContextReady = true;
+    this.notify();
+  }
+  selectInitialOrganisation(activeOrgs, memberships, organisations) {
+    let initialOrg = null;
+    try {
+      const persistedOrgString = localStorage.getItem("pace-core-selected-organisation");
+      if (persistedOrgString) {
+        const persistedOrg = JSON.parse(persistedOrgString);
+        if (persistedOrg.id && typeof persistedOrg.id === "string" && persistedOrg.id.trim() !== "") {
+          const validPersistedOrg = activeOrgs.find((org) => org.id === persistedOrg.id);
+          if (validPersistedOrg) {
+            initialOrg = validPersistedOrg;
           } else {
-            userIsSuperAdmin = false;
+            localStorage.removeItem("pace-core-selected-organisation");
           }
-          this._isSuperAdmin = userIsSuperAdmin;
-        } catch (error) {
-          logger.warn("OrganisationService", "Failed to check super admin status", { error });
-          this._isSuperAdmin = false;
+        } else {
+          localStorage.removeItem("pace-core-selected-organisation");
         }
-      } else {
-        this._isSuperAdmin = false;
       }
+    } catch {
+      localStorage.removeItem("pace-core-selected-organisation");
+    }
+    if (!initialOrg) {
+      const adminMembership = memberships.find((m) => m.role === "org_admin");
+      if (adminMembership) {
+        const foundOrg = organisations.find((org) => org.id === adminMembership.organisation_id);
+        if (foundOrg) initialOrg = foundOrg;
+      }
+    }
+    if (!initialOrg) {
+      initialOrg = activeOrgs[0];
+    }
+    if (!initialOrg) {
+      throw new Error("No valid organisation found for user");
+    }
+    localStorage.setItem("pace-core-selected-organisation", JSON.stringify(initialOrg));
+    return initialOrg;
+  }
+  async loadUserOrganisations() {
+    if (!this.prepareLoad()) return;
+    const abortSignal = this.abortControllerRef.signal;
+    try {
+      const { memberships, organisations } = await this.fetchRolesAndOrganisations(abortSignal);
+      const userIsSuperAdmin = await this.checkAndCacheSuperAdmin();
       if (!memberships || memberships.length === 0) {
         if (userIsSuperAdmin) {
-          this._organisations = [];
-          this._userMemberships = [];
-          this._isLoading = false;
-          this._error = null;
-          this._isContextReady = true;
-          this.notify();
+          this.applyEmptyStateAndNotify();
           return;
         }
         throw new Error("User has no active organisation memberships");
       }
       if (!organisations || organisations.length === 0) {
         if (userIsSuperAdmin) {
-          this._organisations = [];
-          this._userMemberships = [];
-          this._isLoading = false;
-          this._error = null;
-          this._isContextReady = true;
-          this.notify();
+          this.applyEmptyStateAndNotify();
           return;
         }
         throw new Error("No organisations found in role data");
       }
       const roleMap = /* @__PURE__ */ new Map();
-      memberships?.forEach((membership) => {
+      memberships.forEach((membership) => {
         roleMap.set(membership.organisation_id, membership.role);
       });
-      const orgs = organisations;
-      const activeOrgs = orgs.filter((org) => org.is_active);
+      const activeOrgs = organisations.filter((org) => org.is_active);
       if (activeOrgs.length === 0) {
         if (userIsSuperAdmin) {
-          this._organisations = [];
-          this._userMemberships = [];
-          this._isLoading = false;
-          this._error = null;
-          this._isContextReady = true;
-          this.notify();
+          this.applyEmptyStateAndNotify();
           return;
         }
         throw new Error("User has no access to active organisations");
@@ -1134,44 +1214,7 @@ var _OrganisationService = class _OrganisationService extends BaseService {
       this._organisations = sortedOrgs;
       this._userMemberships = memberships;
       this._roleMapState = roleMap;
-      let initialOrg = null;
-      let _selectionMethod = "first";
-      try {
-        const persistedOrgString = localStorage.getItem("pace-core-selected-organisation");
-        if (persistedOrgString) {
-          const persistedOrg = JSON.parse(persistedOrgString);
-          if (persistedOrg.id && typeof persistedOrg.id === "string" && persistedOrg.id.trim() !== "") {
-            const validPersistedOrg = activeOrgs.find((org) => org.id === persistedOrg.id);
-            if (validPersistedOrg) {
-              initialOrg = validPersistedOrg;
-              _selectionMethod = "persisted";
-            } else {
-              localStorage.removeItem("pace-core-selected-organisation");
-            }
-          } else {
-            localStorage.removeItem("pace-core-selected-organisation");
-          }
-        }
-      } catch (_storageError) {
-        localStorage.removeItem("pace-core-selected-organisation");
-      }
-      if (!initialOrg) {
-        const adminMembership = memberships.find((m) => m.role === "org_admin");
-        if (adminMembership) {
-          const foundOrg = organisations.find((org) => org.id === adminMembership.organisation_id);
-          if (foundOrg) {
-            initialOrg = foundOrg;
-            _selectionMethod = "admin";
-          }
-        }
-      }
-      if (!initialOrg) {
-        initialOrg = activeOrgs[0];
-        _selectionMethod = "first";
-      }
-      if (!initialOrg) {
-        throw new Error("No valid organisation found for user");
-      }
+      const initialOrg = this.selectInitialOrganisation(activeOrgs, memberships, organisations);
       const currentSelectedOrg = this._selectedOrganisation;
       if (currentSelectedOrg && !activeOrgs.some((org) => org.id === currentSelectedOrg.id)) {
         logger.warn("OrganisationService", "Current selected organisation is no longer valid, resetting", {
@@ -1181,14 +1224,13 @@ var _OrganisationService = class _OrganisationService extends BaseService {
         this._selectedOrganisation = null;
       }
       this._selectedOrganisation = initialOrg;
-      localStorage.setItem("pace-core-selected-organisation", JSON.stringify(initialOrg));
       await this.setDatabaseOrganisationContext(initialOrg);
       this.retryCount = 0;
       this.hasFailedRef = false;
-    } catch (err) {
-      const error = err;
+    } catch (err2) {
+      const error = err2;
       if (error.message !== "User has no access to active organisations") {
-        logger.error("OrganisationService", "Failed to load organisations:", err);
+        logger.error("OrganisationService", "Failed to load organisations:", err2);
       }
       this._error = error;
       this.retryCount = this.retryCount + 1;
@@ -1215,7 +1257,6 @@ var _OrganisationService = class _OrganisationService extends BaseService {
 };
 _OrganisationService.instanceCount = 0;
 var OrganisationService = _OrganisationService;
-var OrganisationServiceContext = createContext(null);
 function OrganisationServiceProvider({
   children,
   supabaseClient,
@@ -1303,86 +1344,100 @@ var _EventService = class _EventService extends BaseService {
     const newOrgId = selectedOrganisation?.id;
     const previousUserId = this.user?.id || null;
     const newUserId = user?.id || null;
-    this.appName;
-    if (previousUserId !== newUserId) {
-      if (previousUserId !== null) {
-        await this.clearEventSelectionForUser(previousUserId);
-      }
-      if (newUserId === null) {
-        this.selectedEvent = null;
-        this.setSelectedEventId?.(null);
-      }
-      this.resetInitialization();
-      this.isInitializedRef = false;
-      this.isFetchingRef = false;
-      this.userClearedEventRef = false;
-      this.hasAutoSelectedRef = false;
+    await this.handleUserChange(previousUserId, newUserId);
+    this.applyNewDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
+    await this.updateSuperAdminStatus(user);
+    this.handleOrganisationChange(previousOrgId, newOrgId);
+    this.notify();
+  }
+  async handleUserChange(previousUserId, newUserId) {
+    if (previousUserId === newUserId) {
+      return;
+    }
+    if (previousUserId !== null) {
+      await this.clearEventSelectionForUser(previousUserId);
+    }
+    if (newUserId === null) {
+      this.selectedEvent = null;
+      this.setSelectedEventId?.(null);
     }
+    this.resetInitialization();
+    this.isInitializedRef = false;
+    this.isFetchingRef = false;
+    this.userClearedEventRef = false;
+    this.hasAutoSelectedRef = false;
+  }
+  applyNewDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId) {
     this.supabaseClient = supabaseClient;
     this.user = user;
     this.session = session;
     this.appName = appName;
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
-    if (user?.id) {
-      try {
-        const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import('./api-F47QJ7FX.js');
-        if (!isRBACInitialized2() && this.supabaseClient) {
-          setupRBAC2(this.supabaseClient);
-        }
-        if (isRBACInitialized2()) {
-          this.isSuperAdmin = await checkSuperAdmin(user.id);
-        } else {
-          logger.warn("EventService", "RBAC not initialized in updateDependencies, keeping existing super admin status", {
-            userId: user.id,
-            existingIsSuperAdmin: this.isSuperAdmin,
-            note: "RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider."
-          });
-        }
-      } catch (error) {
-        logger.warn("EventService", "Failed to check super admin status in updateDependencies", {
-          error,
+  }
+  async updateSuperAdminStatus(user) {
+    if (!user?.id) {
+      this.isSuperAdmin = false;
+      return;
+    }
+    try {
+      const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import('./api-BZR2CYXL.js');
+      if (!isRBACInitialized2() && this.supabaseClient) {
+        setupRBAC2(this.supabaseClient);
+      }
+      if (isRBACInitialized2()) {
+        const result = await checkSuperAdmin(user.id);
+        this.isSuperAdmin = result.ok && result.data;
+      } else {
+        logger.warn("EventService", "RBAC not initialized in updateDependencies, keeping existing super admin status", {
           userId: user.id,
-          existingIsSuperAdmin: this.isSuperAdmin
+          existingIsSuperAdmin: this.isSuperAdmin,
+          note: "RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider."
         });
       }
-    } else {
-      this.isSuperAdmin = false;
+    } catch (error) {
+      logger.warn("EventService", "Failed to check super admin status in updateDependencies", {
+        error,
+        userId: user.id,
+        existingIsSuperAdmin: this.isSuperAdmin
+      });
     }
-    if (previousOrgId !== newOrgId) {
-      this.resetInitialization();
-      this.isInitializedRef = false;
-      this.isFetchingRef = false;
-      const shouldClearEvents = !this.isSuperAdmin;
-      const isFirstOrgSet = (previousOrgId === null || previousOrgId === void 0) && newOrgId !== null && newOrgId !== void 0;
-      if (isFirstOrgSet) {
-        const hadAutoSelectedEvent = this.hasAutoSelectedRef && !!this.selectedEvent;
-        this.userClearedEventRef = false;
-        if (!hadAutoSelectedEvent) {
-          this.hasAutoSelectedRef = false;
-        }
-        logger.debug("EventService", "Organisation first set - preserving event and resetting auto-selection flags", {
-          organisationId: newOrgId,
-          hasSelectedEvent: !!this.selectedEvent,
-          selectedEventId: this.selectedEvent?.event_id,
-          hadAutoSelectedEvent,
-          preservingEvent: hadAutoSelectedEvent,
-          previousOrgId,
-          newOrgId
-        });
-      } else if (previousOrgId !== null && previousOrgId !== void 0 && newOrgId !== null && newOrgId !== void 0 && previousOrgId !== newOrgId) {
-        if (shouldClearEvents) {
-          this.events = [];
-          this.setSelectedEvent(null);
-        }
-      } else if (previousOrgId !== null && previousOrgId !== void 0 && newOrgId === null) {
-        if (shouldClearEvents) {
-          this.events = [];
-          this.setSelectedEvent(null);
-        }
+  }
+  handleOrganisationChange(previousOrgId, newOrgId) {
+    if (previousOrgId === newOrgId) {
+      return;
+    }
+    this.resetInitialization();
+    this.isInitializedRef = false;
+    this.isFetchingRef = false;
+    const shouldClearEvents = !this.isSuperAdmin;
+    const isFirstOrgSet = (previousOrgId === null || previousOrgId === void 0) && newOrgId !== null && newOrgId !== void 0;
+    if (isFirstOrgSet) {
+      const hadAutoSelectedEvent = this.hasAutoSelectedRef && !!this.selectedEvent;
+      this.userClearedEventRef = false;
+      if (!hadAutoSelectedEvent) {
+        this.hasAutoSelectedRef = false;
       }
+      logger.debug("EventService", "Organisation first set - preserving event and resetting auto-selection flags", {
+        organisationId: newOrgId,
+        hasSelectedEvent: !!this.selectedEvent,
+        selectedEventId: this.selectedEvent?.event_id,
+        hadAutoSelectedEvent,
+        preservingEvent: hadAutoSelectedEvent,
+        previousOrgId,
+        newOrgId
+      });
+      return;
+    }
+    const switchingOrgs = previousOrgId != null && newOrgId != null && previousOrgId !== newOrgId;
+    const orgRemoved = previousOrgId != null && newOrgId === null;
+    if (switchingOrgs && shouldClearEvents) {
+      this.events = [];
+      this.setSelectedEvent(null);
+    } else if (orgRemoved && shouldClearEvents) {
+      this.events = [];
+      this.setSelectedEvent(null);
     }
-    this.notify();
   }
   // Event state getters
   getEvents() {
@@ -1524,6 +1579,122 @@ var _EventService = class _EventService extends BaseService {
   }
   doCleanup() {
   }
+  async resolveOrganisationIdForRpc() {
+    let userIsSuperAdmin = this.isSuperAdmin;
+    try {
+      const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import('./api-BZR2CYXL.js');
+      if (!isRBACInitialized2() && this.supabaseClient) {
+        setupRBAC2(this.supabaseClient);
+      }
+      if (isRBACInitialized2()) {
+        const result = await checkSuperAdmin(this.user.id);
+        userIsSuperAdmin = result.ok && result.data;
+        this.isSuperAdmin = userIsSuperAdmin;
+      } else {
+        if (this.isSuperAdmin) {
+          userIsSuperAdmin = true;
+          logger.warn("EventService", "RBAC not initialized, using cached super admin status", {
+            userId: this.user.id,
+            cachedIsSuperAdmin: this.isSuperAdmin,
+            note: "RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider."
+          });
+        } else {
+          logger.warn("EventService", "RBAC not initialized, using cached non-super-admin status", {
+            userId: this.user.id,
+            cachedIsSuperAdmin: this.isSuperAdmin,
+            note: "RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider."
+          });
+        }
+      }
+      if (userIsSuperAdmin) {
+        return null;
+      }
+      if (this.selectedEvent) {
+        return this.selectedEvent.organisation_id;
+      }
+      if (this.selectedOrganisation) {
+        return this.selectedOrganisation.id;
+      }
+      return null;
+    } catch (superAdminCheckError) {
+      if (this.isSuperAdmin) {
+        logger.warn("EventService", "Super admin check failed, using cached super admin status", {
+          error: superAdminCheckError,
+          cachedIsSuperAdmin: this.isSuperAdmin
+        });
+        return null;
+      }
+      logger.warn("EventService", "Failed to check super admin status, using organisation-scoped query", {
+        error: superAdminCheckError,
+        cachedIsSuperAdmin: this.isSuperAdmin
+      });
+      if (this.selectedEvent) {
+        return this.selectedEvent.organisation_id;
+      }
+      if (this.selectedOrganisation) {
+        return this.selectedOrganisation.id;
+      }
+      return null;
+    }
+  }
+  transformRpcDataToEvents(data) {
+    const eventsData = Array.isArray(data) ? data : [];
+    const transformed = eventsData.map((event) => ({
+      id: event.event_id,
+      event_id: event.event_id,
+      event_name: event.event_name,
+      event_code: event.event_code,
+      event_date: event.event_date ?? void 0,
+      event_venue: event.event_venue ?? void 0,
+      event_participants: event.event_participants ?? void 0,
+      event_colours: event.event_colours,
+      event_logo: "",
+      organisation_id: assertOrganisationId(event.organisation_id),
+      is_visible: event.is_visible,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    return [...transformed].sort((a, b) => {
+      if (a.event_date && b.event_date) {
+        return new Date(b.event_date).getTime() - new Date(a.event_date).getTime();
+      }
+      if (a.event_date && !b.event_date) return -1;
+      if (!a.event_date && b.event_date) return 1;
+      return 0;
+    });
+  }
+  validateSelectedEventInList(events) {
+    if (!this.selectedEvent) {
+      return;
+    }
+    const selectedEventId = this.selectedEvent.event_id;
+    const eventStillExists = events.some((e) => e.event_id === selectedEventId);
+    if (!eventStillExists) {
+      const previousUserClearedRef = this.userClearedEventRef;
+      this.selectedEvent = null;
+      this.setSelectedEventId?.(null);
+      this.userClearedEventRef = previousUserClearedRef;
+    }
+  }
+  async runPersistedOrAutoSelection(events, skipLoadPersisted) {
+    this.hasAutoSelectedRef = false;
+    if (!skipLoadPersisted) {
+      const persistedEventLoaded = await this.loadPersistedEvent(events);
+      if (!persistedEventLoaded && !this.userClearedEventRef) {
+        const nextEvent = this.getNextEventByDate(events);
+        if (nextEvent) {
+          this.hasAutoSelectedRef = true;
+          this.setSelectedEvent(nextEvent);
+        }
+      }
+    } else if (!this.userClearedEventRef) {
+      const nextEvent = this.getNextEventByDate(events);
+      if (nextEvent) {
+        this.hasAutoSelectedRef = true;
+        this.setSelectedEvent(nextEvent);
+      }
+    }
+  }
   async fetchEvents(skipLoadPersisted = false) {
     if (!this.user || !this.session || !this.supabaseClient || !this.appName) {
       this.notify();
@@ -1537,65 +1708,7 @@ var _EventService = class _EventService extends BaseService {
     this.isFetchingRef = true;
     const isMounted = true;
     try {
-      let organisationIdForRpc = null;
-      let userIsSuperAdmin = this.isSuperAdmin;
-      try {
-        const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import('./api-F47QJ7FX.js');
-        if (!isRBACInitialized2() && this.supabaseClient) {
-          setupRBAC2(this.supabaseClient);
-        }
-        if (isRBACInitialized2()) {
-          userIsSuperAdmin = await checkSuperAdmin(this.user.id);
-          this.isSuperAdmin = userIsSuperAdmin;
-        } else {
-          if (this.isSuperAdmin) {
-            userIsSuperAdmin = true;
-            logger.warn("EventService", "RBAC not initialized, using cached super admin status", {
-              userId: this.user.id,
-              cachedIsSuperAdmin: this.isSuperAdmin,
-              note: "RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider."
-            });
-          } else {
-            logger.warn("EventService", "RBAC not initialized, using cached non-super-admin status", {
-              userId: this.user.id,
-              cachedIsSuperAdmin: this.isSuperAdmin,
-              note: "RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider."
-            });
-          }
-        }
-        if (userIsSuperAdmin) {
-          organisationIdForRpc = null;
-        } else {
-          if (this.selectedEvent) {
-            organisationIdForRpc = this.selectedEvent.organisation_id;
-          } else if (this.selectedOrganisation) {
-            organisationIdForRpc = this.selectedOrganisation.id;
-          } else {
-            organisationIdForRpc = null;
-          }
-        }
-      } catch (superAdminCheckError) {
-        if (this.isSuperAdmin) {
-          userIsSuperAdmin = true;
-          organisationIdForRpc = null;
-          logger.warn("EventService", "Super admin check failed, using cached super admin status", {
-            error: superAdminCheckError,
-            cachedIsSuperAdmin: this.isSuperAdmin
-          });
-        } else {
-          logger.warn("EventService", "Failed to check super admin status, using organisation-scoped query", {
-            error: superAdminCheckError,
-            cachedIsSuperAdmin: this.isSuperAdmin
-          });
-          if (this.selectedEvent) {
-            organisationIdForRpc = this.selectedEvent.organisation_id;
-          } else if (this.selectedOrganisation) {
-            organisationIdForRpc = this.selectedOrganisation.id;
-          } else {
-            organisationIdForRpc = null;
-          }
-        }
-      }
+      const organisationIdForRpc = await this.resolveOrganisationIdForRpc();
       const { data, error: rpcError } = await this.supabaseClient.rpc("data_user_events_get", {
         p_user_id: this.user.id,
         p_organisation_id: organisationIdForRpc,
@@ -1606,71 +1719,15 @@ var _EventService = class _EventService extends BaseService {
         throw new Error(rpcError.message || "Failed to fetch events");
       }
       if (isMounted) {
-        const eventsData = data || [];
-        const transformedEvents = eventsData.map((event) => ({
-          id: event.event_id,
-          event_id: event.event_id,
-          event_name: event.event_name,
-          event_code: event.event_code,
-          event_date: event.event_date,
-          event_venue: event.event_venue,
-          event_participants: event.event_participants,
-          event_colours: event.event_colours,
-          event_logo: "",
-          // No logo field in event table
-          organisation_id: assertOrganisationId(event.organisation_id),
-          is_visible: event.is_visible,
-          created_at: (/* @__PURE__ */ new Date()).toISOString(),
-          updated_at: (/* @__PURE__ */ new Date()).toISOString()
-        }));
-        const sortedEvents = [...transformedEvents].sort((a, b) => {
-          if (a.event_date && b.event_date) {
-            return new Date(b.event_date).getTime() - new Date(a.event_date).getTime();
-          }
-          if (a.event_date && !b.event_date) return -1;
-          if (!a.event_date && b.event_date) return 1;
-          return 0;
-        });
-        this.events = sortedEvents;
+        const transformedEvents = this.transformRpcDataToEvents(data ?? []);
+        this.events = transformedEvents;
         this.error = null;
-        if (this.selectedEvent) {
-          const selectedEventId = this.selectedEvent.event_id;
-          const eventStillExists = transformedEvents.some(
-            (e) => e.event_id === selectedEventId
-          );
-          if (!eventStillExists) {
-            const previousUserClearedRef = this.userClearedEventRef;
-            this.selectedEvent = null;
-            this.setSelectedEventId?.(null);
-            this.userClearedEventRef = previousUserClearedRef;
-          }
-        }
-        this.hasAutoSelectedRef = false;
-        if (!skipLoadPersisted) {
-          const persistedEventLoaded = await this.loadPersistedEvent(transformedEvents);
-          if (!persistedEventLoaded && !this.userClearedEventRef) {
-            const nextEvent = this.getNextEventByDate(transformedEvents);
-            if (nextEvent) {
-              this.hasAutoSelectedRef = true;
-              this.setSelectedEvent(nextEvent);
-            }
-          } else if (persistedEventLoaded) {
-          } else if (this.userClearedEventRef) {
-          }
-        } else {
-          if (!this.userClearedEventRef) {
-            const nextEvent = this.getNextEventByDate(transformedEvents);
-            if (nextEvent) {
-              this.hasAutoSelectedRef = true;
-              this.setSelectedEvent(nextEvent);
-            }
-          } else {
-          }
-        }
+        this.validateSelectedEventInList(transformedEvents);
+        await this.runPersistedOrAutoSelection(transformedEvents, skipLoadPersisted);
       }
-    } catch (err) {
-      logger.error("EventService", "Error fetching events:", err);
-      const _error = err instanceof Error ? err : new Error("Unknown error occurred");
+    } catch (err2) {
+      logger.error("EventService", "Error fetching events:", err2);
+      const _error = err2 instanceof Error ? err2 : new Error("Unknown error occurred");
       {
         this.error = _error;
         this.events = [];
@@ -1782,6 +1839,7 @@ function EventServiceProvider({
   }), [eventService]);
   return /* @__PURE__ */ jsx(EventServiceContext.Provider, { value: contextValue, children });
 }
+var InactivityServiceContext = createContext(null);
 
 // src/services/InactivityService.ts
 var InactivityService = class extends BaseService {
@@ -2005,163 +2063,157 @@ var InactivityService = class extends BaseService {
     }
     this.setupEventHandlers();
   }
-  setupEventHandlers() {
-    if (typeof window === "undefined") return;
-    let warningTimer = null;
-    let logoutTimer = null;
-    let countdownInterval = null;
-    let lastActivity = Date.now();
-    let prevIsIdle = false;
-    let prevShowWarning = false;
-    let prevShowInactivityWarning = false;
-    let prevInactivityTimeRemaining = 0;
-    let prevTimeRemaining = this.idleTimeoutMs;
-    const getTimeUntilWarning = () => {
-      const timeSinceActivity = Date.now() - lastActivity;
-      return Math.max(0, this.idleTimeoutMs - this.warnBeforeMs - timeSinceActivity);
-    };
-    const getTimeUntilLogout = () => {
-      const timeSinceActivity = Date.now() - lastActivity;
-      return Math.max(0, this.idleTimeoutMs - timeSinceActivity);
-    };
-    const updateState = (forceNotify = false) => {
-      const now = Date.now();
-      const timeSinceActivity = now - lastActivity;
-      const timeUntilIdle = this.idleTimeoutMs - timeSinceActivity;
-      const newIsIdle = timeSinceActivity >= this.idleTimeoutMs;
-      const newShowWarning = timeSinceActivity >= this.idleTimeoutMs - this.warnBeforeMs && !newIsIdle;
-      const newShowInactivityWarning = newShowWarning;
-      const newInactivityTimeRemaining = newShowWarning ? Math.ceil(timeUntilIdle / 1e3) : 0;
-      const newTimeRemaining = Math.max(0, timeUntilIdle);
-      const stateChanged = prevIsIdle !== newIsIdle || prevShowWarning !== newShowWarning || prevShowInactivityWarning !== newShowInactivityWarning || newShowWarning && prevInactivityTimeRemaining !== newInactivityTimeRemaining || prevTimeRemaining !== newTimeRemaining;
-      if (stateChanged || forceNotify) {
-        this._isIdle = newIsIdle;
-        this._showWarning = newShowWarning;
-        this._showInactivityWarning = newShowInactivityWarning;
-        this._inactivityTimeRemaining = newInactivityTimeRemaining;
-        this._timeRemaining = newTimeRemaining;
-        prevIsIdle = newIsIdle;
-        prevShowWarning = newShowWarning;
-        prevShowInactivityWarning = newShowInactivityWarning;
-        prevInactivityTimeRemaining = newInactivityTimeRemaining;
-        prevTimeRemaining = newTimeRemaining;
-        if (stateChanged) {
-          this.notify();
-        }
-        if (newIsIdle) {
-          this.handleIdleLogout();
-        }
+  runUpdateState(ctx, forceNotify = false) {
+    const now = Date.now();
+    const timeSinceActivity = now - ctx.lastActivity;
+    const timeUntilIdle = this.idleTimeoutMs - timeSinceActivity;
+    const newIsIdle = timeSinceActivity >= this.idleTimeoutMs;
+    const newShowWarning = timeSinceActivity >= this.idleTimeoutMs - this.warnBeforeMs && !newIsIdle;
+    const newShowInactivityWarning = newShowWarning;
+    const newInactivityTimeRemaining = newShowWarning ? Math.ceil(timeUntilIdle / 1e3) : 0;
+    const newTimeRemaining = Math.max(0, timeUntilIdle);
+    const stateChanged = ctx.prevIsIdle !== newIsIdle || ctx.prevShowWarning !== newShowWarning || ctx.prevShowInactivityWarning !== newShowInactivityWarning || newShowWarning && ctx.prevInactivityTimeRemaining !== newInactivityTimeRemaining || ctx.prevTimeRemaining !== newTimeRemaining;
+    if (stateChanged || forceNotify) {
+      this._isIdle = newIsIdle;
+      this._showWarning = newShowWarning;
+      this._showInactivityWarning = newShowInactivityWarning;
+      this._inactivityTimeRemaining = newInactivityTimeRemaining;
+      this._timeRemaining = newTimeRemaining;
+      ctx.prevIsIdle = newIsIdle;
+      ctx.prevShowWarning = newShowWarning;
+      ctx.prevShowInactivityWarning = newShowInactivityWarning;
+      ctx.prevInactivityTimeRemaining = newInactivityTimeRemaining;
+      ctx.prevTimeRemaining = newTimeRemaining;
+      if (stateChanged) {
+        this.notify();
       }
-    };
-    const scheduleNextCheck = () => {
-      if (warningTimer) {
-        clearTimeout(warningTimer);
-        warningTimer = null;
-      }
-      if (logoutTimer) {
-        clearTimeout(logoutTimer);
-        logoutTimer = null;
-      }
-      if (countdownInterval) {
-        clearInterval(countdownInterval);
-        countdownInterval = null;
-      }
-      const timeUntilWarning = getTimeUntilWarning();
-      const timeUntilLogout = getTimeUntilLogout();
-      const timeSinceActivity = Date.now() - lastActivity;
-      if (timeSinceActivity >= this.idleTimeoutMs) {
-        return;
-      }
-      if (timeSinceActivity >= this.idleTimeoutMs - this.warnBeforeMs) {
-        updateState();
-        countdownInterval = setInterval(() => {
-          updateState();
-          if (Date.now() - lastActivity >= this.idleTimeoutMs) {
-            if (countdownInterval) {
-              clearInterval(countdownInterval);
-              countdownInterval = null;
-            }
-            this.handleIdleLogout();
-          }
-        }, 1e3);
-        logoutTimer = setTimeout(() => {
-          if (countdownInterval) {
-            clearInterval(countdownInterval);
-            countdownInterval = null;
+      if (newIsIdle) {
+        this.handleIdleLogout();
+      }
+    }
+  }
+  runScheduleNextCheck(ctx) {
+    if (ctx.warningTimer) {
+      clearTimeout(ctx.warningTimer);
+      ctx.warningTimer = null;
+    }
+    if (ctx.logoutTimer) {
+      clearTimeout(ctx.logoutTimer);
+      ctx.logoutTimer = null;
+    }
+    if (ctx.countdownInterval) {
+      clearInterval(ctx.countdownInterval);
+      ctx.countdownInterval = null;
+    }
+    const getTimeUntilWarning = () => Math.max(0, this.idleTimeoutMs - this.warnBeforeMs - (Date.now() - ctx.lastActivity));
+    const getTimeUntilLogout = () => Math.max(0, this.idleTimeoutMs - (Date.now() - ctx.lastActivity));
+    const timeUntilWarning = getTimeUntilWarning();
+    const timeUntilLogout = getTimeUntilLogout();
+    const timeSinceActivity = Date.now() - ctx.lastActivity;
+    if (timeSinceActivity >= this.idleTimeoutMs) {
+      return;
+    }
+    if (timeSinceActivity >= this.idleTimeoutMs - this.warnBeforeMs) {
+      this.runUpdateState(ctx);
+      ctx.countdownInterval = setInterval(() => {
+        this.runUpdateState(ctx);
+        if (Date.now() - ctx.lastActivity >= this.idleTimeoutMs) {
+          if (ctx.countdownInterval) {
+            clearInterval(ctx.countdownInterval);
+            ctx.countdownInterval = null;
           }
           this.handleIdleLogout();
-        }, timeUntilLogout);
-      } else {
-        const timeUntilWarningMs = timeUntilWarning;
-        const adaptiveInterval = timeUntilWarningMs > 5 * 60 * 1e3 ? 60 * 1e3 : timeUntilWarningMs > 60 * 1e3 ? 10 * 1e3 : 1e3;
-        warningTimer = setTimeout(() => {
-          updateState();
-          scheduleNextCheck();
-        }, Math.min(adaptiveInterval, timeUntilWarningMs));
-      }
-    };
-    const resetTimers = () => {
-      lastActivity = Date.now();
-      if (warningTimer) {
-        clearTimeout(warningTimer);
-        warningTimer = null;
-      }
-      if (logoutTimer) {
-        clearTimeout(logoutTimer);
-        logoutTimer = null;
-      }
-      if (countdownInterval) {
-        clearInterval(countdownInterval);
-        countdownInterval = null;
-      }
-      const hadWarning = this._showWarning || this._showInactivityWarning;
-      this._showInactivityWarning = false;
-      this._inactivityTimeRemaining = 0;
-      this._isIdle = false;
-      this._showWarning = false;
-      this._timeRemaining = this.idleTimeoutMs;
-      prevIsIdle = false;
-      prevShowWarning = false;
-      prevShowInactivityWarning = false;
-      prevInactivityTimeRemaining = 0;
-      prevTimeRemaining = this.idleTimeoutMs;
-      if (hadWarning) {
-        this.notify();
-      }
-      scheduleNextCheck();
+        }
+      }, 1e3);
+      ctx.logoutTimer = setTimeout(() => {
+        if (ctx.countdownInterval) {
+          clearInterval(ctx.countdownInterval);
+          ctx.countdownInterval = null;
+        }
+        this.handleIdleLogout();
+      }, timeUntilLogout);
+    } else {
+      const timeUntilWarningMs = timeUntilWarning;
+      const adaptiveInterval = timeUntilWarningMs > 5 * 60 * 1e3 ? 60 * 1e3 : timeUntilWarningMs > 60 * 1e3 ? 10 * 1e3 : 1e3;
+      ctx.warningTimer = setTimeout(() => {
+        this.runUpdateState(ctx);
+        this.runScheduleNextCheck(ctx);
+      }, Math.min(adaptiveInterval, timeUntilWarningMs));
+    }
+  }
+  runResetTimers(ctx) {
+    ctx.lastActivity = Date.now();
+    if (ctx.warningTimer) {
+      clearTimeout(ctx.warningTimer);
+      ctx.warningTimer = null;
+    }
+    if (ctx.logoutTimer) {
+      clearTimeout(ctx.logoutTimer);
+      ctx.logoutTimer = null;
+    }
+    if (ctx.countdownInterval) {
+      clearInterval(ctx.countdownInterval);
+      ctx.countdownInterval = null;
+    }
+    const hadWarning = this._showWarning || this._showInactivityWarning;
+    this._showInactivityWarning = false;
+    this._inactivityTimeRemaining = 0;
+    this._isIdle = false;
+    this._showWarning = false;
+    this._timeRemaining = this.idleTimeoutMs;
+    ctx.prevIsIdle = false;
+    ctx.prevShowWarning = false;
+    ctx.prevShowInactivityWarning = false;
+    ctx.prevInactivityTimeRemaining = 0;
+    ctx.prevTimeRemaining = this.idleTimeoutMs;
+    if (hadWarning) {
+      this.notify();
+    }
+    this.runScheduleNextCheck(ctx);
+  }
+  setupEventHandlers() {
+    if (typeof window === "undefined") return;
+    const ctx = {
+      warningTimer: null,
+      logoutTimer: null,
+      countdownInterval: null,
+      activityThrottleTimer: null,
+      lastActivity: Date.now(),
+      prevIsIdle: false,
+      prevShowWarning: false,
+      prevShowInactivityWarning: false,
+      prevInactivityTimeRemaining: 0,
+      prevTimeRemaining: this.idleTimeoutMs
     };
     const activityEvents = ["mousedown", "mousemove", "keypress", "scroll", "touchstart", "click"];
-    let activityThrottleTimer = null;
     const handleActivity = () => {
-      if (activityThrottleTimer) {
-        return;
-      }
-      activityThrottleTimer = setTimeout(() => {
-        activityThrottleTimer = null;
-        resetTimers();
+      if (ctx.activityThrottleTimer) return;
+      ctx.activityThrottleTimer = setTimeout(() => {
+        ctx.activityThrottleTimer = null;
+        this.runResetTimers(ctx);
       }, 1e3);
     };
     activityEvents.forEach((event) => {
       document.addEventListener(event, handleActivity, true);
     });
-    updateState(true);
-    scheduleNextCheck();
+    this.runUpdateState(ctx, true);
+    this.runScheduleNextCheck(ctx);
     this.cleanupHandlers = () => {
-      if (warningTimer) {
-        clearTimeout(warningTimer);
-        warningTimer = null;
+      if (ctx.warningTimer) {
+        clearTimeout(ctx.warningTimer);
+        ctx.warningTimer = null;
       }
-      if (logoutTimer) {
-        clearTimeout(logoutTimer);
-        logoutTimer = null;
+      if (ctx.logoutTimer) {
+        clearTimeout(ctx.logoutTimer);
+        ctx.logoutTimer = null;
       }
-      if (countdownInterval) {
-        clearInterval(countdownInterval);
-        countdownInterval = null;
+      if (ctx.countdownInterval) {
+        clearInterval(ctx.countdownInterval);
+        ctx.countdownInterval = null;
       }
-      if (activityThrottleTimer) {
-        clearTimeout(activityThrottleTimer);
-        activityThrottleTimer = null;
+      if (ctx.activityThrottleTimer) {
+        clearTimeout(ctx.activityThrottleTimer);
+        ctx.activityThrottleTimer = null;
       }
       activityEvents.forEach((event) => {
         document.removeEventListener(event, handleActivity, true);
@@ -2176,7 +2228,6 @@ var InactivityService = class extends BaseService {
     this._isTracking = true;
   }
 };
-var InactivityServiceContext = createContext(null);
 function InactivityServiceProvider({
   children,
   supabaseClient,
@@ -2391,33 +2442,7 @@ function useUnifiedAuth() {
   }
   return context;
 }
-function UnifiedAuthContextProvider({
-  children,
-  appName,
-  supabaseClient: supabaseClientProp,
-  ..._props
-}) {
-  const authService = useAuthService();
-  const organisationService = useOrganisationService();
-  const inactivityService = useInactivityService();
-  const sessionRestorationState = useSessionRestoration();
-  const {
-    hasTimedOut: sessionRestorationTimedOut,
-    timeoutMs: sessionRestorationTimeoutMs,
-    isRestoring,
-    restorationComplete,
-    restorationError
-  } = sessionRestorationState;
-  const sessionRestoration = useMemo(() => ({
-    isRestoring,
-    restorationComplete,
-    restorationError
-  }), [isRestoring, restorationComplete, restorationError]);
-  const eventService = useEventService();
-  const currentUser = authService.getUser();
-  const currentSession = authService.getSession();
-  const isAuth = !!(currentUser && currentSession);
-  const supabase = useMemo(() => supabaseClientProp, [supabaseClientProp]);
+function useAppIdResolution(supabase, appName, isAuth, currentUserId) {
   const [appId, setAppId] = useState(void 0);
   const isResolvingAppIdRef = useRef(false);
   const resolvedAppIdRef = useRef(void 0);
@@ -2429,54 +2454,51 @@ function UnifiedAuthContextProvider({
       setAppId(void 0);
       return;
     }
-    if (currentUser?.id && resolvedUserIdRef.current && resolvedUserIdRef.current !== currentUser.id) {
+    if (currentUserId && resolvedUserIdRef.current && resolvedUserIdRef.current !== currentUserId) {
       resolvedAppIdRef.current = void 0;
       resolvedUserIdRef.current = void 0;
       setAppId(void 0);
     }
-    const currentUserId = currentUser?.id;
-    if (isAuth && currentUserId && supabase && appName && resolvedUserIdRef.current !== currentUserId && // Haven't resolved for this user yet
-    !isResolvingAppIdRef.current) {
-      isResolvingAppIdRef.current = true;
-      resolvedUserIdRef.current = currentUserId;
-      const userId = currentUserId;
-      const appNameValue = appName;
-      import('./api-F47QJ7FX.js').then(async ({ resolveAppContext, setupRBAC: setupRBAC2 }) => {
-        try {
-          setupRBAC2(supabase);
-          const result = await resolveAppContext({
-            userId,
-            appName: appNameValue
-          });
-          if (result?.appId) {
-            resolvedAppIdRef.current = result.appId;
-            setAppId(result.appId);
-          } else {
-            resolvedUserIdRef.current = void 0;
-          }
-        } catch (error) {
-          logger.error("UnifiedAuthProvider", "Failed to resolve appId on login", {
-            error: error instanceof Error ? error.message : String(error),
-            appName: appNameValue,
-            userId
-          });
+    const shouldResolve = isAuth && currentUserId && supabase && appName && resolvedUserIdRef.current !== currentUserId && !isResolvingAppIdRef.current;
+    if (!shouldResolve) return;
+    isResolvingAppIdRef.current = true;
+    resolvedUserIdRef.current = currentUserId;
+    const userId = currentUserId;
+    const appNameValue = appName;
+    import('./api-BZR2CYXL.js').then(async ({ resolveAppContext, setupRBAC: setupRBAC2 }) => {
+      try {
+        setupRBAC2(supabase);
+        const result = await resolveAppContext({ userId, appName: appNameValue });
+        if (result.ok && result.data?.appId) {
+          const appIdValue = result.data.appId;
+          resolvedAppIdRef.current = appIdValue;
+          setAppId(appIdValue);
+        } else {
           resolvedUserIdRef.current = void 0;
-        } finally {
-          isResolvingAppIdRef.current = false;
         }
-      }).catch((importError) => {
-        logger.error("UnifiedAuthProvider", "Failed to import RBAC API", importError);
-        isResolvingAppIdRef.current = false;
+      } catch (error) {
+        logger.error("UnifiedAuthProvider", "Failed to resolve appId on login", {
+          error: error instanceof Error ? error.message : String(error),
+          appName: appNameValue,
+          userId
+        });
         resolvedUserIdRef.current = void 0;
-      });
-    }
-  }, [isAuth, currentUser?.id, supabase, appName]);
+      } finally {
+        isResolvingAppIdRef.current = false;
+      }
+    }).catch((importError) => {
+      logger.error("UnifiedAuthProvider", "Failed to import RBAC API", importError);
+      isResolvingAppIdRef.current = false;
+      resolvedUserIdRef.current = void 0;
+    });
+  }, [isAuth, currentUserId, supabase, appName]);
+  return appId;
+}
+function useUnifiedAuthSubscriptions(authService, organisationService, eventService, inactivityService) {
   const [, forceUpdate] = useReducer((x) => x + 1, 0);
   const forceUpdateTimeoutRef = useRef(null);
   const debouncedForceUpdate = useCallback(() => {
-    if (forceUpdateTimeoutRef.current) {
-      clearTimeout(forceUpdateTimeoutRef.current);
-    }
+    if (forceUpdateTimeoutRef.current) clearTimeout(forceUpdateTimeoutRef.current);
     forceUpdateTimeoutRef.current = setTimeout(() => {
       forceUpdate();
       forceUpdateTimeoutRef.current = null;
@@ -2493,20 +2515,86 @@ function UnifiedAuthContextProvider({
     inactivityServiceRef.current = inactivityService;
   }, [authService, organisationService, eventService, inactivityService]);
   useEffect(() => {
-    const unsubscribeAuth = authServiceRef.current.subscribe(debouncedForceUpdate);
-    const unsubscribeOrg = organisationServiceRef.current.subscribe(debouncedForceUpdate);
-    const unsubscribeEvent = eventServiceRef.current.subscribe(debouncedForceUpdate);
-    const unsubscribeInactivity = inactivityServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubAuth = authServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubOrg = organisationServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubEvent = eventServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubInactivity = inactivityServiceRef.current.subscribe(debouncedForceUpdate);
     return () => {
-      unsubscribeAuth();
-      unsubscribeOrg();
-      unsubscribeEvent();
-      unsubscribeInactivity();
-      if (forceUpdateTimeoutRef.current) {
-        clearTimeout(forceUpdateTimeoutRef.current);
-      }
+      unsubAuth();
+      unsubOrg();
+      unsubEvent();
+      unsubInactivity();
+      if (forceUpdateTimeoutRef.current) clearTimeout(forceUpdateTimeoutRef.current);
     };
   }, [debouncedForceUpdate]);
+}
+function useUnifiedAuthContextValue(state, callbacks, appId, appName, supabase) {
+  return useMemo(
+    () => {
+      const selectedOrganisationId = state.selectedOrganisation?.id ?? state.selectedEvent?.organisation_id ?? null;
+      return {
+        user: state.currentUser,
+        session: state.currentSession,
+        isAuthenticated: state.isAuth,
+        authLoading: state.authLoading,
+        authError: state.authError,
+        supabase,
+        signIn: callbacks.signIn,
+        signUp: callbacks.signUp,
+        signOut: callbacks.signOut,
+        resetPassword: callbacks.resetPassword,
+        updatePassword: callbacks.updatePassword,
+        refreshSession: callbacks.refreshSession,
+        selectedOrganisation: state.selectedOrganisation,
+        selectedOrganisationId,
+        organisations: state.organisations,
+        userMemberships: state.userMemberships,
+        organisationLoading: state.orgLoading,
+        organisationError: state.organisationError,
+        hasValidOrganisationContext: state.hasValidOrganisationContext,
+        isContextReady: state.isContextReady,
+        switchOrganisation: callbacks.switchOrganisation,
+        getUserRole: callbacks.getUserRole,
+        validateOrganisationAccess: callbacks.validateOrganisationAccess,
+        refreshOrganisations: callbacks.refreshOrganisations,
+        ensureOrganisationContext: callbacks.ensureOrganisationContext,
+        isOrganisationSecure: callbacks.isOrganisationSecure,
+        getPrimaryOrganisation: callbacks.getPrimaryOrganisation,
+        events: state.events,
+        selectedEvent: state.selectedEvent,
+        selectedEventId: state.selectedEvent?.event_id ?? null,
+        eventLoading: state.eventLoading,
+        eventError: state.eventError,
+        setSelectedEvent: callbacks.setSelectedEvent,
+        refreshEvents: callbacks.refreshEvents,
+        showInactivityWarning: state.inactivityState.showInactivityWarning,
+        inactivityTimeRemaining: state.inactivityState.inactivityTimeRemaining,
+        isIdle: state.inactivityState.isIdle,
+        timeRemaining: state.inactivityState.timeRemaining,
+        showWarning: state.inactivityState.showWarning,
+        isTracking: state.inactivityState.isTracking,
+        resetActivity: callbacks.resetActivity,
+        startTracking: callbacks.startTracking,
+        stopTracking: callbacks.stopTracking,
+        handleIdleLogout: callbacks.handleIdleLogout,
+        handleStaySignedIn: callbacks.handleStaySignedIn,
+        handleSignOutNow: callbacks.handleSignOutNow,
+        appName,
+        appId,
+        isLoading: state.totalLoading,
+        hasErrors: state.hasErrors,
+        sessionRestoration: state.sessionRestoration,
+        sessionRestorationTimedOut: state.sessionRestorationTimedOut,
+        sessionRestorationTimeoutMs: state.sessionRestorationTimeoutMs
+      };
+    },
+    [state, callbacks, appId, appName, supabase]
+  );
+}
+function useUnifiedAuthStateAndCallbacks(authService, organisationService, eventService, inactivityService, sessionRestoration, sessionRestorationTimedOut, sessionRestorationTimeoutMs, appName, userOverride, sessionOverride) {
+  const currentUser = userOverride !== void 0 ? userOverride : authService.getUser();
+  const currentSession = sessionOverride !== void 0 ? sessionOverride : authService.getSession();
+  const isAuth = !!(currentUser && currentSession);
   const authLoading = authService.isLoading();
   const orgLoading = organisationService.isLoading();
   const eventLoading = eventService.isLoading();
@@ -2514,23 +2602,16 @@ function UnifiedAuthContextProvider({
   const shouldIncludeOrgLoading = appName !== "ADMIN" && appName !== "PORTAL";
   const totalLoading = restorationLoading || authLoading || (shouldIncludeOrgLoading ? orgLoading : false) || eventLoading;
   const authError = authService.getError();
-  const rawSelectedOrganisation = organisationService.getSelectedOrganisation();
+  const selectedOrganisation = organisationService.getSelectedOrganisation();
   const organisationError = organisationService.getError();
-  const selectedOrganisation = rawSelectedOrganisation;
   const hasValidOrganisationContext = organisationService.hasValidOrganisationContext();
   const isContextReady = organisationService.isContextReady();
   const rawEvents = eventService.getEvents();
   const rawOrganisations = organisationService.getOrganisations();
   const rawUserMemberships = organisationService.getUserMemberships();
-  const events = useMemo(() => {
-    return rawEvents;
-  }, [rawEvents]);
-  const organisations = useMemo(() => {
-    return rawOrganisations;
-  }, [rawOrganisations]);
-  const userMemberships = useMemo(() => {
-    return rawUserMemberships;
-  }, [rawUserMemberships]);
+  const events = useMemo(() => rawEvents, [rawEvents]);
+  const organisations = useMemo(() => rawOrganisations, [rawOrganisations]);
+  const userMemberships = useMemo(() => rawUserMemberships, [rawUserMemberships]);
   const selectedEvent = eventService.getSelectedEvent();
   const eventError = eventService.getError();
   const showInactivityWarning = inactivityService.getShowInactivityWarning();
@@ -2546,14 +2627,7 @@ function UnifiedAuthContextProvider({
     timeRemaining,
     showWarning,
     isTracking
-  }), [
-    showInactivityWarning,
-    inactivityTimeRemaining,
-    isIdle,
-    timeRemaining,
-    showWarning,
-    isTracking
-  ]);
+  }), [showInactivityWarning, inactivityTimeRemaining, isIdle, timeRemaining, showWarning, isTracking]);
   const hasErrors = !!(authError || organisationError || eventError || sessionRestoration.restorationError);
   const signIn = useCallback((email, password) => authService.signIn(email, password), [authService]);
   const signUp = useCallback((email, password) => authService.signUp(email, password), [authService]);
@@ -2576,94 +2650,12 @@ function UnifiedAuthContextProvider({
   const handleIdleLogout = useCallback(() => inactivityService.handleIdleLogout(), [inactivityService]);
   const handleStaySignedIn = useCallback(() => inactivityService.handleStaySignedIn(), [inactivityService]);
   const handleSignOutNow = useCallback(() => inactivityService.handleSignOutNow(), [inactivityService]);
-  const prevStateRef = useRef(null);
-  const isDev = import.meta.env.DEV || import.meta.env.MODE === "development";
-  if (isDev) {
-    const currentState = {
-      isAuthenticated: isAuth,
-      userEmail: currentUser?.email,
-      totalLoading
-    };
-    const prevState = prevStateRef.current;
-    if (!prevState || prevState.isAuthenticated !== currentState.isAuthenticated || prevState.userEmail !== currentState.userEmail || prevState.totalLoading !== currentState.totalLoading) {
-      prevStateRef.current = currentState;
-    }
-  }
-  const contextValue = useMemo(() => {
-    return {
-      // Auth state
-      user: currentUser,
-      session: currentSession,
-      isAuthenticated: isAuth,
-      authLoading,
-      authError,
-      supabase,
-      // Auth methods
-      signIn,
-      signUp,
-      signOut,
-      resetPassword,
-      updatePassword,
-      refreshSession,
-      // Organisation state
-      selectedOrganisation,
-      selectedOrganisationId: selectedOrganisation?.id || null,
-      organisations,
-      userMemberships,
-      organisationLoading: orgLoading,
-      organisationError,
-      hasValidOrganisationContext,
-      isContextReady,
-      // Organisation methods
-      switchOrganisation,
-      getUserRole,
-      validateOrganisationAccess,
-      refreshOrganisations,
-      ensureOrganisationContext,
-      isOrganisationSecure,
-      getPrimaryOrganisation,
-      // Event state
-      events,
-      selectedEvent,
-      selectedEventId: selectedEvent?.event_id || null,
-      eventLoading,
-      eventError,
-      // Event methods
-      setSelectedEvent,
-      refreshEvents,
-      // Inactivity state
-      showInactivityWarning: inactivityState.showInactivityWarning,
-      inactivityTimeRemaining: inactivityState.inactivityTimeRemaining,
-      isIdle: inactivityState.isIdle,
-      timeRemaining: inactivityState.timeRemaining,
-      showWarning: inactivityState.showWarning,
-      isTracking: inactivityState.isTracking,
-      // Inactivity methods
-      resetActivity,
-      startTracking,
-      stopTracking,
-      handleIdleLogout,
-      handleStaySignedIn,
-      handleSignOutNow,
-      // Additional unified properties
-      appName,
-      appId,
-      // Resolved immediately on login
-      isLoading: totalLoading,
-      hasErrors,
-      sessionRestoration,
-      sessionRestorationTimedOut,
-      sessionRestorationTimeoutMs
-    };
-  }, [
-    // All primitive values extracted from services
-    // Note: Arrays/objects from services are stable references (same reference unless data changes)
+  const state = useMemo(() => ({
     currentUser,
     currentSession,
     isAuth,
     authLoading,
     authError,
-    supabase,
     selectedOrganisation,
     organisations,
     userMemberships,
@@ -2676,15 +2668,58 @@ function UnifiedAuthContextProvider({
     eventLoading,
     eventError,
     inactivityState,
-    // Use memoized object instead of individual values
     totalLoading,
     hasErrors,
-    appName,
-    appId,
     sessionRestoration,
     sessionRestorationTimedOut,
-    sessionRestorationTimeoutMs,
-    // Stable function references from useCallback (services are stable, so callbacks are too)
+    sessionRestorationTimeoutMs
+  }), [
+    currentUser,
+    currentSession,
+    isAuth,
+    authLoading,
+    authError,
+    selectedOrganisation,
+    organisations,
+    userMemberships,
+    orgLoading,
+    organisationError,
+    hasValidOrganisationContext,
+    isContextReady,
+    events,
+    selectedEvent,
+    eventLoading,
+    eventError,
+    inactivityState,
+    totalLoading,
+    hasErrors,
+    sessionRestoration,
+    sessionRestorationTimedOut,
+    sessionRestorationTimeoutMs
+  ]);
+  const callbacks = useMemo(() => ({
+    signIn,
+    signUp,
+    signOut,
+    resetPassword,
+    updatePassword,
+    refreshSession,
+    switchOrganisation,
+    getUserRole,
+    validateOrganisationAccess,
+    refreshOrganisations,
+    ensureOrganisationContext,
+    isOrganisationSecure,
+    getPrimaryOrganisation,
+    setSelectedEvent,
+    refreshEvents,
+    resetActivity,
+    startTracking,
+    stopTracking,
+    handleIdleLogout,
+    handleStaySignedIn,
+    handleSignOutNow
+  }), [
     signIn,
     signUp,
     signOut,
@@ -2707,6 +2742,48 @@ function UnifiedAuthContextProvider({
     handleStaySignedIn,
     handleSignOutNow
   ]);
+  return { state, callbacks };
+}
+function UnifiedAuthContextProvider({
+  children,
+  appName,
+  supabaseClient: supabaseClientProp,
+  user: userFromParent,
+  session: sessionFromParent
+}) {
+  const authService = useAuthService();
+  const organisationService = useOrganisationService();
+  const inactivityService = useInactivityService();
+  const eventService = useEventService();
+  const sessionRestorationState = useSessionRestoration();
+  const sessionRestoration = useMemo(() => ({
+    isRestoring: sessionRestorationState.isRestoring,
+    restorationComplete: sessionRestorationState.restorationComplete,
+    restorationError: sessionRestorationState.restorationError
+  }), [sessionRestorationState.isRestoring, sessionRestorationState.restorationComplete, sessionRestorationState.restorationError]);
+  const { hasTimedOut: sessionRestorationTimedOut, timeoutMs: sessionRestorationTimeoutMs } = sessionRestorationState;
+  const currentUser = userFromParent !== void 0 ? userFromParent : authService.getUser();
+  const currentSession = sessionFromParent !== void 0 ? sessionFromParent : authService.getSession();
+  const isAuth = !!(currentUser && currentSession);
+  const supabase = useMemo(() => supabaseClientProp, [supabaseClientProp]);
+  const appId = useAppIdResolution(supabase, appName, isAuth, currentUser?.id);
+  useUnifiedAuthSubscriptions(authService, organisationService, eventService, inactivityService);
+  const { state, callbacks } = useUnifiedAuthStateAndCallbacks(
+    authService,
+    organisationService,
+    eventService,
+    inactivityService,
+    sessionRestoration,
+    sessionRestorationTimedOut,
+    sessionRestorationTimeoutMs,
+    appName,
+    currentUser,
+    currentSession
+  );
+  const contextValue = useUnifiedAuthContextValue(state, callbacks, appId, appName, supabase);
+  useEffect(() => {
+    if (appName) setPrintAppName(appName);
+  }, [appName]);
   return /* @__PURE__ */ jsx(UnifiedAuthContext.Provider, { value: contextValue, children });
 }
 function EventServiceProviderWrapper({
@@ -2754,8 +2831,10 @@ function ServiceAwareProviders({
     const unsubscribe = authService.subscribe(() => {
       const newUser = authService.getUser();
       const newSession = authService.getSession();
-      setUserState(newUser);
-      setSessionState(newSession);
+      flushSync(() => {
+        setUserState(newUser);
+        setSessionState(newSession);
+      });
     });
     return unsubscribe;
   }, [authService]);
@@ -2788,6 +2867,8 @@ function ServiceAwareProviders({
                 {
                   appName,
                   supabaseClient,
+                  user,
+                  session,
                   persistState,
                   enablePersistence,
                   requireOrganisationContext,
@@ -2837,8 +2918,8 @@ function UnifiedAuthProvider({
     try {
       setupRBAC(supabaseClient);
       logger.debug("UnifiedAuthProvider", "RBAC initialized synchronously");
-    } catch (err) {
-      logger.error("UnifiedAuthProvider", "Failed to initialize RBAC", err);
+    } catch (err2) {
+      logger.error("UnifiedAuthProvider", "Failed to initialize RBAC", err2);
     }
   }
   return /* @__PURE__ */ jsx(AuthServiceProvider, { supabaseClient, appName, children: /* @__PURE__ */ jsx(