@jmruthers/pace-core 0.5.191 → 0.6.1

package/dist/{chunk-6LTQQAT6.js → chunk-BYFSK72L.js}

@@ -1,7 +1,7 @@
 import {
   getAppConfigByName,
   isSuperAdmin
-} from "./chunk-ROXMHMY2.js";
+} from "./chunk-KNC55RTG.js";
 import {
   assertOrganisationId,
   assertUserId
@@ -16,7 +16,7 @@ import {
 } from "./chunk-PWLANIRT.js";
 
 // src/providers/services/UnifiedAuthProvider.tsx
-import { createContext as createContext5, useContext as useContext6, useMemo as useMemo6, useCallback, useRef as useRef4, useEffect as useEffect10, useState as useState3, useReducer as useReducer5 } from "react";
+import { createContext as createContext5, useContext as useContext6, useMemo as useMemo6, useCallback, useRef as useRef8, useEffect as useEffect10, useState as useState3, useReducer as useReducer5 } from "react";
 
 // src/providers/services/AuthServiceProvider.tsx
 import { createContext, useMemo, useEffect, useState } from "react";
@@ -627,6 +627,8 @@ var OrganisationService = class extends BaseService {
     this._roleMapState = /* @__PURE__ */ new Map();
     this._isLoading = false;
     this._error = null;
+    this._isSuperAdmin = false;
+    // Cache super admin status
     this._isContextReady = false;
     this.retryCount = 0;
     // Dependencies
@@ -667,14 +669,16 @@ var OrganisationService = class extends BaseService {
   // Additional methods for testing
   setSelectedOrganisation(organisation) {
     if (organisation && this._organisations.length > 0) {
-      const isValidOrg = this._organisations.some((org) => org.id === organisation.id);
-      if (!isValidOrg) {
-        logger.warn("OrganisationService", "Attempted to set invalid organisation - not in user's accessible organisations", {
-          organisationId: organisation.id,
-          organisationName: organisation.name,
-          accessibleOrgIds: this._organisations.map((o) => o.id)
-        });
-        return;
+      if (!this._isSuperAdmin) {
+        const isValidOrg = this._organisations.some((org) => org.id === organisation.id);
+        if (!isValidOrg) {
+          logger.warn("OrganisationService", "Attempted to set invalid organisation - not in user's accessible organisations", {
+            organisationId: organisation.id,
+            organisationName: organisation.name,
+            accessibleOrgIds: this._organisations.map((o) => o.id)
+          });
+          return;
+        }
       }
     }
     this._selectedOrganisation = organisation;
@@ -713,6 +717,9 @@ var OrganisationService = class extends BaseService {
   updateDependencies(user, session) {
     const wasAuthenticated = !!(this.user && this.session);
     const isAuthenticated = !!(user && session);
+    if (this.user?.id !== user?.id) {
+      this._isSuperAdmin = false;
+    }
     this.user = user;
     this.session = session;
     if (wasAuthenticated && !isAuthenticated) {
@@ -936,10 +943,40 @@ var OrganisationService = class extends BaseService {
         logger.error("OrganisationService", "Error loading organisation roles:", membershipError);
         throw membershipError;
       }
+      let userIsSuperAdmin = false;
+      if (this.user?.id) {
+        try {
+          userIsSuperAdmin = await isSuperAdmin(this.user.id);
+          this._isSuperAdmin = userIsSuperAdmin;
+        } catch (error) {
+          logger.warn("OrganisationService", "Failed to check super admin status", { error });
+          this._isSuperAdmin = false;
+        }
+      } else {
+        this._isSuperAdmin = false;
+      }
       if (!memberships || memberships.length === 0) {
+        if (userIsSuperAdmin) {
+          this._organisations = [];
+          this._userMemberships = [];
+          this._isLoading = false;
+          this._error = null;
+          this._isContextReady = true;
+          this.notify();
+          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();
+          return;
+        }
         throw new Error("No organisations found in role data");
       }
       const roleMap = /* @__PURE__ */ new Map();
@@ -949,6 +986,15 @@ var OrganisationService = class extends BaseService {
       const orgs = organisations;
       const activeOrgs = orgs.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();
+          return;
+        }
         throw new Error("User has no access to active organisations");
       }
       this._organisations = activeOrgs;
@@ -1149,10 +1195,6 @@ var EventService = class extends BaseService {
     if (user?.id) {
       try {
         this.isSuperAdmin = await isSuperAdmin(user.id);
-        logger.debug("EventService", "Updated super admin status", {
-          userId: user.id,
-          isSuperAdmin: this.isSuperAdmin
-        });
       } catch (error) {
         logger.warn("EventService", "Failed to check super admin status", { error });
         this.isSuperAdmin = false;
@@ -1176,7 +1218,7 @@ var EventService = class extends BaseService {
   }
   // Event state getters
   getEvents() {
-    return [...this.events];
+    return this.events;
   }
   getSelectedEvent() {
     return this.selectedEvent;
@@ -1286,31 +1328,16 @@ var EventService = class extends BaseService {
   }
   // Lifecycle methods
   async initialize() {
-    logger.debug("EventService", "initialize() called", {
-      isInitializedRef: this.isInitializedRef,
-      hasUser: !!this.user,
-      hasSession: !!this.session,
-      appName: this.appName
-    });
     await super.initialize();
   }
   cleanup() {
     super.cleanup();
   }
   async doInitialize() {
-    logger.debug("EventService", "doInitialize() called", {
-      isInitializedRef: this.isInitializedRef,
-      isFetchingRef: this.isFetchingRef,
-      hasUser: !!this.user,
-      hasSession: !!this.session,
-      appName: this.appName
-    });
     if (this.isInitializedRef) {
-      logger.debug("EventService", "Skipping initialization - already initialized");
       return;
     }
     if (this.isFetchingRef) {
-      logger.debug("EventService", "Skipping initialization - already fetching");
       return;
     }
     try {
@@ -1321,14 +1348,8 @@ var EventService = class extends BaseService {
       logger.warn("EventService", "Failed to clean up old storage keys:", error);
     }
     if (!this.user) {
-      logger.debug("EventService", "Skipping initialization - missing user");
       return;
     }
-    logger.debug("EventService", "Initializing - fetching events", {
-      userId: this.user.id,
-      organisationId: this.selectedOrganisation?.id || "derived-from-event",
-      appName: this.appName
-    });
     await this.fetchEvents(false);
     this.isInitializedRef = true;
   }
@@ -1336,19 +1357,12 @@ var EventService = class extends BaseService {
   }
   async fetchEvents(skipLoadPersisted = false) {
     if (!this.user || !this.session || !this.supabaseClient || !this.appName) {
-      logger.debug("EventService", "Skipping fetchEvents - missing dependencies", {
-        hasUser: !!this.user,
-        hasSession: !!this.session,
-        hasSupabaseClient: !!this.supabaseClient,
-        appName: this.appName
-      });
       this.notify();
       return;
     }
     this._isLoading = true;
     this.notify();
     if (this.isFetchingRef) {
-      logger.debug("EventService", "Skipping fetchEvents - already fetching");
       return;
     }
     this.isFetchingRef = true;
@@ -1370,18 +1384,11 @@ var EventService = class extends BaseService {
         userIsSuperAdmin = await isSuperAdmin(this.user.id);
         if (userIsSuperAdmin) {
           organisationIdForRpc = null;
-          logger.debug("EventService", "Super admin detected - fetching all events", {
-            userId: this.user.id
-          });
         } else {
           if (this.selectedEvent) {
             organisationIdForRpc = this.selectedEvent.organisation_id;
           } else if (this.appConfig?.requires_event === true) {
             organisationIdForRpc = null;
-            logger.debug("EventService", "Event-required app: fetching all accessible events (no event selected yet)", {
-              userId: this.user.id,
-              appName: this.appName
-            });
           } else if (this.selectedOrganisation) {
             organisationIdForRpc = this.selectedOrganisation.id;
           } else {
@@ -1405,22 +1412,11 @@ var EventService = class extends BaseService {
           organisationIdForRpc = this.selectedOrganisation.id;
         }
       }
-      logger.debug("EventService", "Fetching events via RPC", {
-        userId: this.user.id,
-        organisationId: organisationIdForRpc,
-        appName: this.appName
-      });
       let { data, error: rpcError } = await this.supabaseClient.rpc("data_user_events_get", {
         p_user_id: this.user.id,
         p_organisation_id: organisationIdForRpc,
         p_app_name: this.appName
       });
-      logger.debug("EventService", "RPC response received", {
-        hasData: !!data,
-        dataLength: Array.isArray(data) ? data.length : "not array",
-        hasError: !!rpcError,
-        error: rpcError
-      });
       if (rpcError) {
         logger.error("EventService", "RPC error fetching events:", rpcError);
         throw new Error(rpcError.message || "Failed to fetch events");
@@ -1545,13 +1541,6 @@ function EventServiceProvider({
     const updateAndInitialize = async () => {
       initializingRef.current = true;
       try {
-        logger.debug("EventServiceProvider", "Updating dependencies and initializing", {
-          hasUser: !!user,
-          hasSession: !!session,
-          appName,
-          hasSelectedOrganisation: !!selectedOrganisation,
-          organisationId: selectedOrganisation?.id
-        });
         await eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
         if (!isMounted) return;
         await eventService.initialize().catch((error) => {
@@ -1694,12 +1683,19 @@ var InactivityService = class extends BaseService {
     if (this.inactivityTracker) {
       this.inactivityTracker.resetActivity();
     }
+    const prevIsIdle = this._isIdle;
+    const prevShowWarning = this._showWarning;
+    const prevShowInactivityWarning = this._showInactivityWarning;
+    const prevInactivityTimeRemaining = this._inactivityTimeRemaining;
+    const prevTimeRemaining = this._timeRemaining;
     this._isIdle = false;
     this._showWarning = false;
     this._showInactivityWarning = false;
     this._inactivityTimeRemaining = 0;
     this._timeRemaining = this.idleTimeoutMs;
-    this.notify();
+    if (prevIsIdle !== this._isIdle || prevShowWarning !== this._showWarning || prevShowInactivityWarning !== this._showInactivityWarning || prevInactivityTimeRemaining !== this._inactivityTimeRemaining || prevTimeRemaining !== this._timeRemaining) {
+      this.notify();
+    }
   }
   startTracking() {
     if (this.inactivityTracker) {
@@ -1793,8 +1789,39 @@ var InactivityService = class extends BaseService {
     let idleTimer = null;
     let warningTimer = null;
     let lastActivity = Date.now();
-    const resetTimers = () => {
-      lastActivity = Date.now();
+    let pollInterval = null;
+    let prevIsIdle = false;
+    let prevShowWarning = false;
+    let prevShowInactivityWarning = false;
+    let prevInactivityTimeRemaining = 0;
+    let prevTimeRemaining = this.idleTimeoutMs;
+    const pollInactivityState = () => {
+      const now = Date.now();
+      const timeSinceActivity = now - lastActivity;
+      const timeUntilIdle = this.idleTimeoutMs - timeSinceActivity;
+      const timeUntilWarning = this.idleTimeoutMs - this.warnBeforeMs - timeSinceActivity;
+      const newIsIdle = timeSinceActivity >= this.idleTimeoutMs - this.warnBeforeMs;
+      const newShowWarning = newIsIdle && timeSinceActivity < this.idleTimeoutMs;
+      const newShowInactivityWarning = newShowWarning;
+      const newInactivityTimeRemaining = newShowWarning ? Math.ceil((this.idleTimeoutMs - timeSinceActivity) / 1e3) : 0;
+      const newTimeRemaining = Math.max(0, timeUntilIdle);
+      const stateChanged = prevIsIdle !== newIsIdle || prevShowWarning !== newShowWarning || prevShowInactivityWarning !== newShowInactivityWarning || prevInactivityTimeRemaining !== newInactivityTimeRemaining || prevTimeRemaining !== newTimeRemaining;
+      if (stateChanged) {
+        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;
+        this.notify();
+        if (newIsIdle && timeSinceActivity >= this.idleTimeoutMs) {
+          this.handleIdleLogout();
+        }
+      }
       if (idleTimer) {
         clearTimeout(idleTimer);
         idleTimer = null;
@@ -1803,42 +1830,48 @@ var InactivityService = class extends BaseService {
         clearTimeout(warningTimer);
         warningTimer = null;
       }
-      this._showInactivityWarning = false;
-      this._inactivityTimeRemaining = 0;
-      this._isIdle = false;
-      this._showWarning = false;
-      this.notify();
-    };
-    const startIdleTimer = () => {
-      if (idleTimer) {
-        clearTimeout(idleTimer);
+      if (!newIsIdle && timeUntilIdle > 0) {
+        idleTimer = setTimeout(() => {
+          pollInactivityState();
+        }, Math.min(1e4, timeUntilIdle));
       }
-      idleTimer = setTimeout(() => {
-        this._isIdle = true;
-        this._showWarning = true;
-        this.notify();
+      if (newShowWarning && timeUntilIdle > 0) {
         warningTimer = setTimeout(() => {
           this.handleIdleLogout();
-        }, this.warnBeforeMs);
-      }, this.idleTimeoutMs - this.warnBeforeMs);
+        }, timeUntilIdle);
+      }
     };
-    const startWarningTimer = () => {
+    const resetTimers = () => {
+      lastActivity = Date.now();
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
       if (warningTimer) {
         clearTimeout(warningTimer);
+        warningTimer = null;
       }
-      warningTimer = setTimeout(() => {
-        this.handleIdleLogout();
-      }, this.warnBeforeMs);
+      this._showInactivityWarning = false;
+      this._inactivityTimeRemaining = 0;
+      this._isIdle = false;
+      this._showWarning = false;
+      prevIsIdle = false;
+      prevShowWarning = false;
+      prevShowInactivityWarning = false;
+      prevInactivityTimeRemaining = 0;
+      prevTimeRemaining = this.idleTimeoutMs;
     };
     const activityEvents = ["mousedown", "mousemove", "keypress", "scroll", "touchstart", "click"];
     const handleActivity = () => {
       resetTimers();
-      startIdleTimer();
     };
     activityEvents.forEach((event) => {
       document.addEventListener(event, handleActivity, true);
     });
-    startIdleTimer();
+    pollInterval = setInterval(() => {
+      pollInactivityState();
+    }, 1e4);
+    pollInactivityState();
     this.cleanupHandlers = () => {
       if (idleTimer) {
         clearTimeout(idleTimer);
@@ -1848,6 +1881,10 @@ var InactivityService = class extends BaseService {
         clearTimeout(warningTimer);
         warningTimer = null;
       }
+      if (pollInterval) {
+        clearInterval(pollInterval);
+        pollInterval = null;
+      }
       activityEvents.forEach((event) => {
         document.removeEventListener(event, handleActivity, true);
       });
@@ -1906,29 +1943,61 @@ function InactivityServiceProvider({
 }
 
 // src/hooks/services/useAuthService.ts
-import { useContext, useReducer, useEffect as useEffect5 } from "react";
+import { useContext, useReducer, useEffect as useEffect5, useRef as useRef4 } from "react";
 function useAuthService() {
   const context = useContext(AuthServiceContext);
   if (!context) {
     throw new Error("useAuthService must be used within AuthServiceProvider");
   }
   const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  const timeoutRef = useRef4(null);
   useEffect5(() => {
-    return context.authService.subscribe(() => forceUpdate());
+    const debouncedUpdate = () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        forceUpdate();
+        timeoutRef.current = null;
+      }, 50);
+    };
+    const unsubscribe = context.authService.subscribe(debouncedUpdate);
+    return () => {
+      unsubscribe();
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
   }, [context.authService]);
   return context.authService;
 }
 
 // src/hooks/services/useOrganisationService.ts
-import { useContext as useContext2, useReducer as useReducer2, useEffect as useEffect6 } from "react";
+import { useContext as useContext2, useReducer as useReducer2, useEffect as useEffect6, useRef as useRef5 } from "react";
 function useOrganisationService() {
   const context = useContext2(OrganisationServiceContext);
   if (!context) {
     throw new Error("useOrganisationService must be used within OrganisationServiceProvider");
   }
   const [, forceUpdate] = useReducer2((x) => x + 1, 0);
+  const timeoutRef = useRef5(null);
   useEffect6(() => {
-    return context.organisationService.subscribe(() => forceUpdate());
+    const debouncedUpdate = () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        forceUpdate();
+        timeoutRef.current = null;
+      }, 50);
+    };
+    const unsubscribe = context.organisationService.subscribe(debouncedUpdate);
+    return () => {
+      unsubscribe();
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
   }, [context.organisationService]);
   return context.organisationService;
 }
@@ -1957,29 +2026,61 @@ function useOrganisations() {
 }
 
 // src/hooks/services/useEventService.ts
-import { useContext as useContext3, useReducer as useReducer3, useEffect as useEffect7 } from "react";
+import { useContext as useContext3, useReducer as useReducer3, useEffect as useEffect7, useRef as useRef6 } from "react";
 function useEventService() {
   const context = useContext3(EventServiceContext);
   if (!context) {
     throw new Error("useEventService must be used within EventServiceProvider");
   }
   const [, forceUpdate] = useReducer3((x) => x + 1, 0);
+  const timeoutRef = useRef6(null);
   useEffect7(() => {
-    return context.eventService.subscribe(() => forceUpdate());
+    const debouncedUpdate = () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        forceUpdate();
+        timeoutRef.current = null;
+      }, 50);
+    };
+    const unsubscribe = context.eventService.subscribe(debouncedUpdate);
+    return () => {
+      unsubscribe();
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
   }, [context.eventService]);
   return context.eventService;
 }
 
 // src/hooks/services/useInactivityService.ts
-import { useContext as useContext4, useReducer as useReducer4, useEffect as useEffect8 } from "react";
+import { useContext as useContext4, useReducer as useReducer4, useEffect as useEffect8, useRef as useRef7 } from "react";
 function useInactivityService() {
   const context = useContext4(InactivityServiceContext);
   if (!context) {
     throw new Error("useInactivityService must be used within InactivityServiceProvider");
   }
   const [, forceUpdate] = useReducer4((x) => x + 1, 0);
+  const timeoutRef = useRef7(null);
   useEffect8(() => {
-    return context.inactivityService.subscribe(() => forceUpdate());
+    const debouncedUpdate = () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        forceUpdate();
+        timeoutRef.current = null;
+      }, 50);
+    };
+    const unsubscribe = context.inactivityService.subscribe(debouncedUpdate);
+    return () => {
+      unsubscribe();
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
   }, [context.inactivityService]);
   return context.inactivityService;
 }
@@ -2037,8 +2138,7 @@ var useUnifiedAuth = () => {
 function UnifiedAuthContextProvider({
   children,
   appName,
-  appConfig = { requires_event: true },
-  // Default to requiring events
+  appConfig: appConfigProp,
   supabaseClient: supabaseClientProp,
   ...props
 }) {
@@ -2058,6 +2158,13 @@ function UnifiedAuthContextProvider({
     restorationComplete,
     restorationError
   }), [isRestoring, restorationComplete, restorationError]);
+  const [appConfigState, setAppConfigState] = useState3(appConfigProp || null);
+  const isResolvingAppConfigRef = useRef8(false);
+  const resolvedAppConfigRef = useRef8(null);
+  const appConfig = useMemo6(() => {
+    if (!appConfigState) return null;
+    return { requires_event: appConfigState.requires_event };
+  }, [appConfigState?.requires_event]);
   let eventService;
   try {
     eventService = useEventService();
@@ -2081,9 +2188,9 @@ function UnifiedAuthContextProvider({
   const isAuth = !!(currentUser && currentSession);
   const supabase = useMemo6(() => supabaseClientProp, [supabaseClientProp]);
   const [appId, setAppId] = useState3(void 0);
-  const isResolvingAppIdRef = useRef4(false);
-  const resolvedAppIdRef = useRef4(void 0);
-  const resolvedUserIdRef = useRef4(void 0);
+  const isResolvingAppIdRef = useRef8(false);
+  const resolvedAppIdRef = useRef8(void 0);
+  const resolvedUserIdRef = useRef8(void 0);
   useEffect10(() => {
     if (!isAuth) {
       resolvedAppIdRef.current = void 0;
@@ -2103,7 +2210,7 @@ function UnifiedAuthContextProvider({
       resolvedUserIdRef.current = currentUserId;
       const userId = currentUserId;
       const appNameValue = appName;
-      import("./api-IHKALJZD.js").then(async ({ resolveAppContext, setupRBAC }) => {
+      import("./api-N774RPUA.js").then(async ({ resolveAppContext, setupRBAC }) => {
         try {
           setupRBAC(supabase);
           const result = await resolveAppContext({
@@ -2113,10 +2220,6 @@ function UnifiedAuthContextProvider({
           if (result?.appId) {
             resolvedAppIdRef.current = result.appId;
             setAppId(result.appId);
-            logger.debug("UnifiedAuthProvider", "appId resolved on login", {
-              appId: result.appId,
-              appName: appNameValue
-            });
           } else {
             resolvedUserIdRef.current = void 0;
           }
@@ -2137,8 +2240,59 @@ function UnifiedAuthContextProvider({
       });
     }
   }, [isAuth, currentUser?.id, supabase, appName]);
+  useEffect10(() => {
+    if (appConfigProp !== void 0) {
+      setAppConfigState(appConfigProp);
+      resolvedAppConfigRef.current = appConfigProp;
+      return;
+    }
+    if (resolvedAppConfigRef.current !== null || isResolvingAppConfigRef.current) {
+      return;
+    }
+    if (!supabase || !appName) {
+      return;
+    }
+    isResolvingAppConfigRef.current = true;
+    import("./api-N774RPUA.js").then(async ({ getAppConfigByName: getAppConfigByName2 }) => {
+      try {
+        const config = await getAppConfigByName2(appName);
+        const resolvedConfig = config || { requires_event: false };
+        if (resolvedAppConfigRef.current?.requires_event !== resolvedConfig.requires_event) {
+          resolvedAppConfigRef.current = resolvedConfig;
+          setAppConfigState(resolvedConfig);
+        }
+        if (import.meta.env.DEV && appName === "MINT") {
+          logger.debug("UnifiedAuthProvider", "App config loaded", {
+            appName,
+            config: resolvedConfig,
+            requiresEvent: resolvedConfig.requires_event
+          });
+        }
+      } catch (error) {
+        logger.warn("UnifiedAuthProvider", "Failed to load app config, defaulting to organisation-based", {
+          error: error instanceof Error ? error.message : String(error),
+          appName
+        });
+        if (resolvedAppConfigRef.current?.requires_event !== false) {
+          const defaultConfig = { requires_event: false };
+          resolvedAppConfigRef.current = defaultConfig;
+          setAppConfigState(defaultConfig);
+        }
+      } finally {
+        isResolvingAppConfigRef.current = false;
+      }
+    }).catch((importError) => {
+      logger.error("UnifiedAuthProvider", "Failed to import RBAC API for app config", importError);
+      isResolvingAppConfigRef.current = false;
+      if (resolvedAppConfigRef.current?.requires_event !== false) {
+        const defaultConfig = { requires_event: false };
+        resolvedAppConfigRef.current = defaultConfig;
+        setAppConfigState(defaultConfig);
+      }
+    });
+  }, [supabase, appName, appConfigProp]);
   const [, forceUpdate] = useReducer5((x) => x + 1, 0);
-  const forceUpdateTimeoutRef = useRef4(null);
+  const forceUpdateTimeoutRef = useRef8(null);
   const debouncedForceUpdate = useCallback(() => {
     if (forceUpdateTimeoutRef.current) {
       clearTimeout(forceUpdateTimeoutRef.current);
@@ -2146,12 +2300,12 @@ function UnifiedAuthContextProvider({
     forceUpdateTimeoutRef.current = setTimeout(() => {
       forceUpdate();
       forceUpdateTimeoutRef.current = null;
-    }, 0);
+    }, 100);
   }, [forceUpdate]);
-  const authServiceRef = useRef4(authService);
-  const organisationServiceRef = useRef4(organisationService);
-  const eventServiceRef = useRef4(eventService);
-  const inactivityServiceRef = useRef4(inactivityService);
+  const authServiceRef = useRef8(authService);
+  const organisationServiceRef = useRef8(organisationService);
+  const eventServiceRef = useRef8(eventService);
+  const inactivityServiceRef = useRef8(inactivityService);
   useEffect10(() => {
     authServiceRef.current = authService;
     organisationServiceRef.current = organisationService;
@@ -2177,16 +2331,48 @@ function UnifiedAuthContextProvider({
   const orgLoading = organisationService.isLoading();
   const eventLoading = eventService.isLoading();
   const restorationLoading = sessionRestoration.isRestoring && !sessionRestorationTimedOut && !sessionRestoration.restorationError;
-  const totalLoading = restorationLoading || authLoading || orgLoading || eventLoading;
+  const shouldIncludeOrgLoading = appName !== "ADMIN" && appName !== "PORTAL";
+  const totalLoading = restorationLoading || authLoading || (shouldIncludeOrgLoading ? orgLoading : false) || eventLoading;
   const authError = authService.getError();
   const rawSelectedOrganisation = organisationService.getSelectedOrganisation();
-  const organisations = organisationService.getOrganisations();
-  const userMemberships = organisationService.getUserMemberships();
   const organisationError = organisationService.getError();
-  const selectedOrganisation = appConfig?.requires_event ? null : rawSelectedOrganisation;
+  const selectedOrganisation = appConfig !== null && appConfig?.requires_event === true && !rawSelectedOrganisation ? null : rawSelectedOrganisation;
+  useEffect10(() => {
+    if (import.meta.env.DEV && appName === "MINT") {
+      logger.debug("UnifiedAuthProvider", "Organisation state check", {
+        rawSelectedOrganisation: rawSelectedOrganisation?.id || null,
+        rawSelectedOrganisationType: typeof rawSelectedOrganisation,
+        appConfig,
+        appConfigRequiresEvent: appConfig?.requires_event,
+        selectedOrganisation: selectedOrganisation?.id || null,
+        selectedOrganisationId: selectedOrganisation?.id || null,
+        checkResult: appConfig?.requires_event === true
+      });
+    }
+  }, [appName, rawSelectedOrganisation?.id, appConfig?.requires_event, selectedOrganisation?.id]);
   const hasValidOrganisationContext = organisationService.hasValidOrganisationContext();
   const isContextReady = organisationService.isContextReady();
-  const events = eventService.getEvents();
+  const rawEvents = eventService.getEvents();
+  const rawOrganisations = organisationService.getOrganisations();
+  const rawUserMemberships = organisationService.getUserMemberships();
+  const events = useMemo6(() => {
+    return rawEvents;
+  }, [
+    // Create dependency string from event IDs - only changes when events actually change
+    rawEvents.map((e) => e.event_id || e.id).join(",")
+  ]);
+  const organisations = useMemo6(() => {
+    return rawOrganisations;
+  }, [
+    // Create dependency string from organisation IDs - only changes when orgs actually change
+    rawOrganisations.map((o) => o.id).join(",")
+  ]);
+  const userMemberships = useMemo6(() => {
+    return rawUserMemberships;
+  }, [
+    // Create dependency string from membership IDs - only changes when memberships actually change
+    rawUserMemberships.map((m) => `${m.organisation_id}-${m.user_id}`).join(",")
+  ]);
   const selectedEvent = eventService.getSelectedEvent();
   const eventError = eventService.getError();
   const showInactivityWarning = inactivityService.getShowInactivityWarning();
@@ -2195,29 +2381,44 @@ function UnifiedAuthContextProvider({
   const timeRemaining = inactivityService.getTimeRemaining();
   const showWarning = inactivityService.isWarningShown();
   const isTracking = inactivityService.isTracking();
+  const inactivityState = useMemo6(() => ({
+    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]);
-  const signOut = useCallback(() => authService.signOut(), [authService]);
-  const resetPassword = useCallback((email) => authService.resetPassword(email), [authService]);
-  const updatePassword = useCallback((password) => authService.updatePassword(password), [authService]);
-  const refreshSession = useCallback(() => authService.refreshSession(), [authService]);
-  const switchOrganisation = useCallback((orgId) => organisationService.switchOrganisation(orgId), [organisationService]);
-  const getUserRole = useCallback((orgId) => organisationService.getUserRole(orgId), [organisationService]);
-  const validateOrganisationAccess = useCallback((orgId) => organisationService.validateOrganisationAccess(orgId), [organisationService]);
-  const refreshOrganisations = useCallback(() => organisationService.refreshOrganisations(), [organisationService]);
-  const ensureOrganisationContext = useCallback(() => organisationService.ensureOrganisationContext(), [organisationService]);
-  const isOrganisationSecure = useCallback(() => organisationService.isOrganisationSecure(), [organisationService]);
-  const getPrimaryOrganisation = useCallback(() => organisationService.getPrimaryOrganisation(), [organisationService]);
-  const setSelectedEvent = useCallback((event) => eventService.setSelectedEvent(event), [eventService]);
-  const refreshEvents = useCallback(() => eventService.refreshEvents(), [eventService]);
-  const resetActivity = useCallback(() => inactivityService.resetActivity(), [inactivityService]);
-  const startTracking = useCallback(() => inactivityService.startTracking(), [inactivityService]);
-  const stopTracking = useCallback(() => inactivityService.stopTracking(), [inactivityService]);
-  const handleIdleLogout = useCallback(() => inactivityService.handleIdleLogout(), [inactivityService]);
-  const handleStaySignedIn = useCallback(() => inactivityService.handleStaySignedIn(), [inactivityService]);
-  const handleSignOutNow = useCallback(() => inactivityService.handleSignOutNow(), [inactivityService]);
-  const prevStateRef = useRef4(null);
+  const signIn = (email, password) => authService.signIn(email, password);
+  const signUp = (email, password) => authService.signUp(email, password);
+  const signOut = () => authService.signOut();
+  const resetPassword = (email) => authService.resetPassword(email);
+  const updatePassword = (password) => authService.updatePassword(password);
+  const refreshSession = () => authService.refreshSession();
+  const switchOrganisation = (orgId) => organisationService.switchOrganisation(orgId);
+  const getUserRole = (orgId) => organisationService.getUserRole(orgId);
+  const validateOrganisationAccess = (orgId) => organisationService.validateOrganisationAccess(orgId);
+  const refreshOrganisations = () => organisationService.refreshOrganisations();
+  const ensureOrganisationContext = () => organisationService.ensureOrganisationContext();
+  const isOrganisationSecure = () => organisationService.isOrganisationSecure();
+  const getPrimaryOrganisation = () => organisationService.getPrimaryOrganisation();
+  const setSelectedEvent = (event) => eventService.setSelectedEvent(event);
+  const refreshEvents = () => eventService.refreshEvents();
+  const resetActivity = () => inactivityService.resetActivity();
+  const startTracking = () => inactivityService.startTracking();
+  const stopTracking = () => inactivityService.stopTracking();
+  const handleIdleLogout = () => inactivityService.handleIdleLogout();
+  const handleStaySignedIn = () => inactivityService.handleStaySignedIn();
+  const handleSignOutNow = () => inactivityService.handleSignOutNow();
+  const prevStateRef = useRef8(null);
   const isDev = import.meta.env.DEV || import.meta.env.MODE === "development";
   if (isDev) {
     const currentState = {
@@ -2248,6 +2449,7 @@ function UnifiedAuthContextProvider({
       refreshSession,
       // Organisation state
       selectedOrganisation,
+      selectedOrganisationId: selectedOrganisation?.id || null,
       organisations,
       userMemberships,
       organisationLoading: orgLoading,
@@ -2265,18 +2467,19 @@ function UnifiedAuthContextProvider({
       // Event state
       events,
       selectedEvent,
+      selectedEventId: selectedEvent?.event_id || null,
       eventLoading,
       eventError,
       // Event methods
       setSelectedEvent,
       refreshEvents,
       // Inactivity state
-      showInactivityWarning,
-      inactivityTimeRemaining,
-      isIdle,
-      timeRemaining,
-      showWarning,
-      isTracking,
+      showInactivityWarning: inactivityState.showInactivityWarning,
+      inactivityTimeRemaining: inactivityState.inactivityTimeRemaining,
+      isIdle: inactivityState.isIdle,
+      timeRemaining: inactivityState.timeRemaining,
+      showWarning: inactivityState.showWarning,
+      isTracking: inactivityState.isTracking,
       // Inactivity methods
       resetActivity,
       startTracking,
@@ -2315,12 +2518,8 @@ function UnifiedAuthContextProvider({
     selectedEvent,
     eventLoading,
     eventError,
-    showInactivityWarning,
-    inactivityTimeRemaining,
-    isIdle,
-    timeRemaining,
-    showWarning,
-    isTracking,
+    inactivityState,
+    // Use memoized object instead of individual values
     totalLoading,
     hasErrors,
     appName,
@@ -2363,7 +2562,7 @@ function EventServiceProviderWrapper({
   appConfig
 }) {
   const { selectedOrganisation: rawSelectedOrganisation } = useOrganisations();
-  const selectedOrganisation = appConfig?.requires_event ? null : rawSelectedOrganisation;
+  const selectedOrganisation = appConfig !== null && appConfig?.requires_event === true && !rawSelectedOrganisation ? null : rawSelectedOrganisation;
   const setSelectedEventId = useCallback(() => {
   }, []);
   return /* @__PURE__ */ jsx5(
@@ -2459,7 +2658,7 @@ function UnifiedAuthProvider({
   renderInactivityWarning,
   dangerouslyDisableInactivity = false
 }) {
-  const clientRef = useRef4(supabaseClient);
+  const clientRef = useRef8(supabaseClient);
   useEffect10(() => {
     if (clientRef.current !== supabaseClient) {
       logger.warn("UnifiedAuthProvider", "Supabase client reference changed - this may indicate multiple client instances are being created", {
@@ -2508,4 +2707,4 @@ export {
   useUnifiedAuth,
   UnifiedAuthProvider
 };
-//# sourceMappingURL=chunk-6LTQQAT6.js.map
+//# sourceMappingURL=chunk-BYFSK72L.js.map