@jmruthers/pace-core 0.5.190 → 0.5.193

package/dist/{chunk-J2XXC7R5.js → chunk-7FLMSG37.js}

@@ -1,7 +1,7 @@
 import {
   getAppConfigByName,
   isSuperAdmin
-} from "./chunk-RUYZKXOD.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";
@@ -319,6 +319,8 @@ var AuthService = class extends BaseService {
   // Lifecycle methods
   async initialize() {
     await super.initialize();
+    this.authLoading = true;
+    this.notify();
     await this.setupAuthStateListener();
     await this.restoreSession();
   }
@@ -424,13 +426,15 @@ var AuthService = class extends BaseService {
                 const hasTimeoutError = this.sessionRestorationState.restorationError?.name === "SessionRestorationTimeoutError";
                 if (this.sessionRestorationState.isRestoring || this.sessionRestorationState.restorationError || hasTimeoutError && session) {
                   this.finishSessionRestoration();
-                  return;
+                }
+              } else {
+                if (this.sessionRestorationState.isRestoring) {
+                  this.finishSessionRestoration();
                 }
               }
-              if (this.sessionRestorationState.isRestoring) {
-                this.finishSessionRestoration();
-                return;
-              }
+              this.authLoading = false;
+              this.notify();
+              return;
             }
             this.authLoading = false;
             this.notify();
@@ -491,7 +495,12 @@ var AuthService = class extends BaseService {
         this.user = null;
         this.authError = null;
       }
-      this.finishSessionRestoration();
+      setTimeout(() => {
+        if (this.sessionRestorationState.isRestoring && !this.sessionRestorationState.restorationComplete) {
+          logger.debug("AuthService", "INITIAL_SESSION event did not fire, finishing restoration");
+          this.finishSessionRestoration();
+        }
+      }, 100);
     } catch (error) {
       const restorationError = error instanceof Error ? error : new Error("Unknown error during auth initialization");
       logger.error("AuthService", "Error during auth initialization:", restorationError);
@@ -618,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
@@ -658,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;
@@ -704,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) {
@@ -859,118 +875,110 @@ var OrganisationService = class extends BaseService {
     this._error = null;
     this.notify();
     try {
-      let memberships, membershipError;
+      let memberships, membershipError, organisations = [];
       try {
-        const timeoutPromise = new Promise((_, reject) => {
-          const timeoutId = setTimeout(() => reject(new Error("RPC call timeout after 10 seconds")), 1e4);
-          abortSignal.addEventListener("abort", () => {
-            clearTimeout(timeoutId);
-            reject(new Error("Request aborted"));
-          });
-        });
-        const rpcPromise = this.supabaseClient.rpc("data_user_organisation_roles_get", {
-          p_user_id: this.user.id,
-          p_organisation_id: null
-        });
         if (abortSignal.aborted) {
           throw new Error("Request aborted");
         }
-        const result = await Promise.race([rpcPromise, timeoutPromise]);
-        memberships = result.data?.filter(
-          (role) => ["org_admin", "leader", "member", "supporter"].includes(role.role)
-        ).map((m) => ({
+        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,
+              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)
         })) || [];
-        membershipError = result.error;
-      } catch (queryError) {
-        membershipError = queryError instanceof Error ? queryError : new Error(String(queryError));
-      }
-      if (membershipError) {
-        logger.error("OrganisationService", "Error loading memberships:", membershipError);
-        if (membershipError.message?.includes("timeout")) {
-          try {
-            if (abortSignal.aborted) {
-              throw new Error("Request aborted");
-            }
-            const { data: fallbackData, error: fallbackError } = 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,
-                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).in("role", ["org_admin", "leader", "member", "supporter"]);
-            if (fallbackError) {
-              logger.error("OrganisationService", "Fallback query also failed:", fallbackError);
-              throw membershipError;
-            }
-            memberships = fallbackData?.map((m) => ({
-              ...m,
-              user_id: assertUserId(m.user_id),
-              organisation_id: assertOrganisationId(m.organisation_id)
-            })) || [];
-            membershipError = null;
-          } catch (fallbackErr) {
-            logger.error("OrganisationService", "Fallback query failed:", fallbackErr);
-            throw membershipError;
+        const organisationsMap = /* @__PURE__ */ new Map();
+        rolesData?.forEach((role) => {
+          const orgData = role.core_organisations;
+          if (orgData && role.organisation_id && !organisationsMap.has(role.organisation_id)) {
+            organisationsMap.set(role.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 {
-          throw membershipError;
+          membershipError = new Error(String(queryError));
+        }
+        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");
       }
-      const organisationIds = memberships.map((m) => m.organisation_id).filter((id) => {
-        if (!id || typeof id !== "string") {
-          logger.warn("OrganisationService", "Invalid organisation ID (not string):", id);
-          return false;
-        }
-        const trimmedId = id.trim();
-        if (trimmedId === "") {
-          logger.warn("OrganisationService", "Empty organisation ID found");
-          return false;
-        }
-        const isValidUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmedId);
-        if (!isValidUuid) {
-          logger.warn("OrganisationService", "Invalid UUID format:", trimmedId);
+      if (!organisations || organisations.length === 0) {
+        if (userIsSuperAdmin) {
+          this._organisations = [];
+          this._userMemberships = [];
+          this._isLoading = false;
+          this._error = null;
+          this._isContextReady = true;
+          this.notify();
+          return;
         }
-        return isValidUuid;
-      });
-      if (organisationIds.length === 0) {
-        logger.warn("OrganisationService", "No valid organisation IDs found in memberships:", memberships);
-        throw new Error("No valid organisation IDs found in memberships");
+        throw new Error("No organisations found in role data");
       }
-      if (abortSignal.aborted) {
-        throw new Error("Request aborted");
-      }
-      const { data: allOrganisations, error: orgError } = await this.supabaseClient.from("organisations").select("id, name, display_name, subscription_tier, settings, is_active, parent_id, created_at, updated_at");
-      if (orgError) {
-        logger.error("OrganisationService", "Error loading organisations:", orgError);
-        throw orgError;
-      }
-      const organisations = allOrganisations?.filter(
-        (org) => organisationIds.includes(org.id)
-      ) || [];
       const roleMap = /* @__PURE__ */ new Map();
       memberships?.forEach((membership) => {
         roleMap.set(membership.organisation_id, membership.role);
@@ -978,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;
@@ -995,16 +1012,13 @@ var OrganisationService = class extends BaseService {
               initialOrg = validPersistedOrg;
               selectionMethod = "persisted";
             } else {
-              logger.warn("OrganisationService", "Persisted organisation not found in active orgs, clearing cache");
               localStorage.removeItem("pace-core-selected-organisation");
             }
           } else {
-            logger.warn("OrganisationService", "Invalid persisted organisation ID, clearing cache");
             localStorage.removeItem("pace-core-selected-organisation");
           }
         }
       } catch (storageError) {
-        logger.warn("OrganisationService", "Failed to restore persisted organisation:", storageError);
         localStorage.removeItem("pace-core-selected-organisation");
       }
       if (!initialOrg) {
@@ -1039,9 +1053,7 @@ var OrganisationService = class extends BaseService {
       this.hasFailedRef = false;
     } catch (err) {
       const error = err;
-      if (error.message === "User has no access to active organisations") {
-        logger.warn("OrganisationService", "User has no active organisations (this is expected for users without organisation access):", error);
-      } else {
+      if (error.message !== "User has no access to active organisations") {
         logger.error("OrganisationService", "Failed to load organisations:", err);
       }
       this._error = error;
@@ -1183,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;
@@ -1210,7 +1218,7 @@ var EventService = class extends BaseService {
   }
   // Event state getters
   getEvents() {
-    return [...this.events];
+    return this.events;
   }
   getSelectedEvent() {
     return this.selectedEvent;
@@ -1320,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 {
@@ -1355,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;
   }
@@ -1370,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;
@@ -1404,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 {
@@ -1439,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");
@@ -1579,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) => {
@@ -1728,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) {
@@ -1827,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;
@@ -1837,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);
@@ -1882,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);
       });
@@ -1940,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;
 }
@@ -1991,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;
 }
@@ -2071,8 +2138,7 @@ var useUnifiedAuth = () => {
 function UnifiedAuthContextProvider({
   children,
   appName,
-  appConfig = { requires_event: true },
-  // Default to requiring events
+  appConfig: appConfigProp,
   supabaseClient: supabaseClientProp,
   ...props
 }) {
@@ -2092,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();
@@ -2115,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;
@@ -2137,7 +2210,7 @@ function UnifiedAuthContextProvider({
       resolvedUserIdRef.current = currentUserId;
       const userId = currentUserId;
       const appNameValue = appName;
-      import("./api-I6UCQ5S6.js").then(async ({ resolveAppContext, setupRBAC }) => {
+      import("./api-N774RPUA.js").then(async ({ resolveAppContext, setupRBAC }) => {
         try {
           setupRBAC(supabase);
           const result = await resolveAppContext({
@@ -2147,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;
           }
@@ -2171,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);
@@ -2180,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;
@@ -2211,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();
@@ -2229,6 +2381,21 @@ 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]);
@@ -2251,7 +2418,7 @@ function UnifiedAuthContextProvider({
   const handleIdleLogout = useCallback(() => inactivityService.handleIdleLogout(), [inactivityService]);
   const handleStaySignedIn = useCallback(() => inactivityService.handleStaySignedIn(), [inactivityService]);
   const handleSignOutNow = useCallback(() => inactivityService.handleSignOutNow(), [inactivityService]);
-  const prevStateRef = useRef4(null);
+  const prevStateRef = useRef8(null);
   const isDev = import.meta.env.DEV || import.meta.env.MODE === "development";
   if (isDev) {
     const currentState = {
@@ -2282,6 +2449,7 @@ function UnifiedAuthContextProvider({
       refreshSession,
       // Organisation state
       selectedOrganisation,
+      selectedOrganisationId: selectedOrganisation?.id || null,
       organisations,
       userMemberships,
       organisationLoading: orgLoading,
@@ -2299,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,
@@ -2349,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,
@@ -2397,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(
@@ -2493,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", {
@@ -2542,4 +2707,4 @@ export {
   useUnifiedAuth,
   UnifiedAuthProvider
 };
-//# sourceMappingURL=chunk-J2XXC7R5.js.map
+//# sourceMappingURL=chunk-7FLMSG37.js.map