@jmruthers/pace-core 0.5.189 → 0.5.191

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

@@ -1,3 +1,7 @@
+import {
+  getAppConfigByName,
+  isSuperAdmin
+} from "./chunk-ROXMHMY2.js";
 import {
   assertOrganisationId,
   assertUserId
@@ -315,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();
   }
@@ -420,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();
@@ -487,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);
@@ -653,6 +666,17 @@ 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;
+      }
+    }
     this._selectedOrganisation = organisation;
     if (organisation) {
       localStorage.setItem("pace-core-selected-organisation", JSON.stringify(organisation));
@@ -844,118 +868,80 @@ 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;
       }
       if (!memberships || memberships.length === 0) {
         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);
-        }
-        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");
-      }
-      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;
+      if (!organisations || organisations.length === 0) {
+        throw new Error("No organisations found in role data");
       }
-      const organisations = allOrganisations?.filter(
-        (org) => organisationIds.includes(org.id)
-      ) || [];
       const roleMap = /* @__PURE__ */ new Map();
       memberships?.forEach((membership) => {
         roleMap.set(membership.organisation_id, membership.role);
@@ -980,16 +966,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) {
@@ -1009,17 +992,29 @@ var OrganisationService = class extends BaseService {
       if (!initialOrg) {
         throw new Error("No valid organisation found for user");
       }
+      const currentSelectedOrg = this._selectedOrganisation;
+      if (currentSelectedOrg && !activeOrgs.some((org) => org.id === currentSelectedOrg.id)) {
+        logger.warn("OrganisationService", "Current selected organisation is no longer valid, resetting", {
+          invalidOrgId: currentSelectedOrg.id,
+          validOrgIds: activeOrgs.map((o) => o.id)
+        });
+        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) {
-      logger.error("OrganisationService", "Failed to load organisations:", err);
-      this._error = err;
+      const error = err;
+      if (error.message !== "User has no access to active organisations") {
+        logger.error("OrganisationService", "Failed to load organisations:", err);
+      }
+      this._error = error;
       this.retryCount = this.retryCount + 1;
       this.hasFailedRef = true;
       this.clearAllCachedData();
+      this._isContextReady = true;
     } finally {
       this.isLoadingRef = false;
       this._isLoading = false;
@@ -1058,7 +1053,12 @@ function OrganisationServiceProvider({
     let isMounted = true;
     organisationService.initialize().catch((error) => {
       if (isMounted) {
-        logger.error("OrganisationServiceProvider", "Failed to initialize organisation service:", error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage === "User has no access to active organisations") {
+          logger.warn("OrganisationServiceProvider", "User has no active organisations (this is expected for users without organisation access):", error);
+        } else {
+          logger.error("OrganisationServiceProvider", "Failed to initialize organisation service:", error);
+        }
       }
     });
     return () => {
@@ -1095,6 +1095,10 @@ var EventService = class extends BaseService {
     this.appName = "";
     this.selectedOrganisation = null;
     this.setSelectedEventId = null;
+    this.isSuperAdmin = false;
+    // Track super admin status for conditional validation
+    this.appConfig = null;
+    // Cache app config to avoid repeated lookups
     // Internal state management
     this.isInitializedRef = false;
     this.isFetchingRef = false;
@@ -1120,6 +1124,7 @@ var EventService = class extends BaseService {
     const newOrgId = selectedOrganisation?.id;
     const previousUserId = this.user?.id || null;
     const newUserId = user?.id || null;
+    const previousAppName = this.appName;
     if (previousUserId !== newUserId) {
       if (previousUserId !== null) {
         await this.clearEventSelectionForUser(previousUserId);
@@ -1128,6 +1133,9 @@ var EventService = class extends BaseService {
         this.selectedEvent = null;
         this.setSelectedEventId?.(null);
       }
+      this.resetInitialization();
+      this.isInitializedRef = false;
+      this.isFetchingRef = false;
     }
     this.supabaseClient = supabaseClient;
     this.user = user;
@@ -1135,6 +1143,23 @@ var EventService = class extends BaseService {
     this.appName = appName;
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
+    if (previousAppName !== appName) {
+      this.appConfig = null;
+    }
+    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;
+      }
+    } else {
+      this.isSuperAdmin = false;
+    }
     if (previousOrgId !== newOrgId) {
       this.resetInitialization();
       this.isInitializedRef = false;
@@ -1165,18 +1190,6 @@ var EventService = class extends BaseService {
   // Event methods
   setSelectedEvent(event) {
     if (event) {
-      try {
-        if (this.selectedOrganisation && event.organisation_id !== this.selectedOrganisation.id) {
-          logger.error("EventService", "Event organisation_id does not match selected organisation", {
-            eventOrganisationId: event.organisation_id,
-            selectedOrganisationId: this.selectedOrganisation.id,
-            eventName: event.event_name
-          });
-          return;
-        }
-      } catch (error) {
-        logger.error("EventService", "Error during event validation:", error);
-      }
       this.selectedEvent = event;
       this.setSelectedEventId?.(event.event_id);
       this.persistEventSelection(event.event_id).catch((error) => {
@@ -1273,16 +1286,31 @@ 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 {
@@ -1292,31 +1320,107 @@ var EventService = class extends BaseService {
     } catch (error) {
       logger.warn("EventService", "Failed to clean up old storage keys:", error);
     }
-    if (!this.user || !this.selectedOrganisation) {
+    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;
   }
   doCleanup() {
   }
   async fetchEvents(skipLoadPersisted = false) {
-    if (!this.user || !this.session || !this.supabaseClient || !this.appName || !this.selectedOrganisation) {
+    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;
     let isMounted = true;
     try {
-      const { data, error: rpcError } = await this.supabaseClient.rpc("data_user_events_get", {
+      if (!this.appConfig && this.appName) {
+        try {
+          this.appConfig = await getAppConfigByName(this.appName);
+        } catch (configError) {
+          logger.warn("EventService", "Failed to load app config, defaulting to event-required", {
+            error: configError
+          });
+          this.appConfig = { requires_event: true };
+        }
+      }
+      let organisationIdForRpc = null;
+      let userIsSuperAdmin = false;
+      try {
+        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 {
+            logger.warn("EventService", "No organisation context available for event fetch", {
+              hasSelectedEvent: !!this.selectedEvent,
+              hasSelectedOrganisation: !!this.selectedOrganisation,
+              appRequiresEvent: this.appConfig?.requires_event
+            });
+            organisationIdForRpc = null;
+          }
+        }
+      } catch (superAdminCheckError) {
+        logger.warn("EventService", "Failed to check super admin status, using organisation-scoped query", {
+          error: superAdminCheckError
+        });
+        if (this.selectedEvent) {
+          organisationIdForRpc = this.selectedEvent.organisation_id;
+        } else if (this.appConfig?.requires_event === true) {
+          organisationIdForRpc = null;
+        } else if (this.selectedOrganisation) {
+          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: this.selectedOrganisation.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");
@@ -1428,24 +1532,41 @@ function EventServiceProvider({
   setSelectedEventId
 }) {
   const eventServiceRef = useRef2(null);
+  const initializingRef = useRef2(false);
   if (!eventServiceRef.current) {
     eventServiceRef.current = new EventService(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
   }
   const eventService = eventServiceRef.current;
   useEffect3(() => {
     let isMounted = true;
+    if (initializingRef.current) {
+      return;
+    }
     const updateAndInitialize = async () => {
-      await eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
-      if (!isMounted) return;
-      await eventService.initialize().catch((error) => {
-        if (isMounted) {
-          logger.error("EventServiceProvider", "Failed to initialize event service:", error);
-        }
-      });
+      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) => {
+          if (isMounted) {
+            logger.error("EventServiceProvider", "Failed to initialize event service:", error);
+          }
+        });
+      } finally {
+        initializingRef.current = false;
+      }
     };
     updateAndInitialize();
     return () => {
       isMounted = false;
+      initializingRef.current = false;
     };
   }, [supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
   useEffect3(() => {
@@ -1750,8 +1871,10 @@ function InactivityServiceProvider({
   supabaseClient,
   user,
   session,
-  idleTimeoutMs = 30 * 60 * 1e3,
-  warnBeforeMs = 60 * 1e3,
+  idleTimeoutMs,
+  // REQUIRED: No default - must be explicitly provided
+  warnBeforeMs,
+  // REQUIRED: No default - must be explicitly provided
   onIdleLogout
 }) {
   const inactivityServiceRef = useRef3(null);
@@ -1810,6 +1933,29 @@ function useOrganisationService() {
   return context.organisationService;
 }
 
+// src/hooks/useOrganisations.ts
+function useOrganisations() {
+  const organisationService = useOrganisationService();
+  const selectedOrg = organisationService.getSelectedOrganisation();
+  return {
+    selectedOrganisation: selectedOrg,
+    organisations: organisationService.getOrganisations(),
+    userMemberships: organisationService.getUserMemberships(),
+    isLoading: organisationService.isLoading(),
+    error: organisationService.getError(),
+    hasValidOrganisationContext: organisationService.hasValidOrganisationContext(),
+    isContextReady: organisationService.isContextReady(),
+    setSelectedOrganisation: (org) => organisationService.setSelectedOrganisation(org),
+    switchOrganisation: (orgId) => organisationService.switchOrganisation(orgId),
+    getUserRole: (orgId) => organisationService.getUserRole(orgId),
+    validateOrganisationAccess: (orgId) => organisationService.validateOrganisationAccess(orgId),
+    refreshOrganisations: () => organisationService.refreshOrganisations(),
+    ensureOrganisationContext: () => organisationService.ensureOrganisationContext(),
+    isOrganisationSecure: () => organisationService.isOrganisationSecure(),
+    getPrimaryOrganisation: () => organisationService.getPrimaryOrganisation()
+  };
+}
+
 // src/hooks/services/useEventService.ts
 import { useContext as useContext3, useReducer as useReducer3, useEffect as useEffect7 } from "react";
 function useEventService() {
@@ -1893,6 +2039,7 @@ function UnifiedAuthContextProvider({
   appName,
   appConfig = { requires_event: true },
   // Default to requiring events
+  supabaseClient: supabaseClientProp,
   ...props
 }) {
   const authService = useAuthService();
@@ -1932,15 +2079,31 @@ function UnifiedAuthContextProvider({
   const currentUser = authService.getUser();
   const currentSession = authService.getSession();
   const isAuth = !!(currentUser && currentSession);
-  const supabase = authService.getSupabaseClient();
+  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);
   useEffect10(() => {
-    if (isAuth && currentUser?.id && supabase && appName && !appId && !isResolvingAppIdRef.current) {
+    if (!isAuth) {
+      resolvedAppIdRef.current = void 0;
+      resolvedUserIdRef.current = void 0;
+      setAppId(void 0);
+      return;
+    }
+    if (currentUser?.id && resolvedUserIdRef.current && resolvedUserIdRef.current !== currentUser.id) {
+      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;
-      const userId = currentUser.id;
+      resolvedUserIdRef.current = currentUserId;
+      const userId = currentUserId;
       const appNameValue = appName;
-      import("./api-YP7XD5L6.js").then(async ({ resolveAppContext, setupRBAC }) => {
+      import("./api-IHKALJZD.js").then(async ({ resolveAppContext, setupRBAC }) => {
         try {
           setupRBAC(supabase);
           const result = await resolveAppContext({
@@ -1948,11 +2111,14 @@ function UnifiedAuthContextProvider({
             appName: appNameValue
           });
           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;
           }
         } catch (error) {
           logger.error("UnifiedAuthProvider", "Failed to resolve appId on login", {
@@ -1960,41 +2126,64 @@ function UnifiedAuthContextProvider({
             appName: appNameValue,
             userId
           });
+          resolvedUserIdRef.current = void 0;
         } finally {
           isResolvingAppIdRef.current = false;
         }
       }).catch((importError) => {
         logger.error("UnifiedAuthProvider", "Failed to import RBAC API", importError);
         isResolvingAppIdRef.current = false;
+        resolvedUserIdRef.current = void 0;
       });
     }
-    if (!isAuth) {
-      setAppId(void 0);
-    }
-  }, [isAuth, currentUser?.id, supabase, appName, appId]);
+  }, [isAuth, currentUser?.id, supabase, appName]);
   const [, forceUpdate] = useReducer5((x) => x + 1, 0);
+  const forceUpdateTimeoutRef = useRef4(null);
+  const debouncedForceUpdate = useCallback(() => {
+    if (forceUpdateTimeoutRef.current) {
+      clearTimeout(forceUpdateTimeoutRef.current);
+    }
+    forceUpdateTimeoutRef.current = setTimeout(() => {
+      forceUpdate();
+      forceUpdateTimeoutRef.current = null;
+    }, 0);
+  }, [forceUpdate]);
+  const authServiceRef = useRef4(authService);
+  const organisationServiceRef = useRef4(organisationService);
+  const eventServiceRef = useRef4(eventService);
+  const inactivityServiceRef = useRef4(inactivityService);
   useEffect10(() => {
-    const unsubscribeAuth = authService.subscribe(() => forceUpdate());
-    const unsubscribeOrg = organisationService.subscribe(() => forceUpdate());
-    const unsubscribeEvent = eventService.subscribe(() => forceUpdate());
-    const unsubscribeInactivity = inactivityService.subscribe(() => forceUpdate());
+    authServiceRef.current = authService;
+    organisationServiceRef.current = organisationService;
+    eventServiceRef.current = eventService;
+    inactivityServiceRef.current = inactivityService;
+  }, [authService, organisationService, eventService, inactivityService]);
+  useEffect10(() => {
+    const unsubscribeAuth = authServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubscribeOrg = organisationServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubscribeEvent = eventServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubscribeInactivity = inactivityServiceRef.current.subscribe(debouncedForceUpdate);
     return () => {
       unsubscribeAuth();
       unsubscribeOrg();
       unsubscribeEvent();
       unsubscribeInactivity();
+      if (forceUpdateTimeoutRef.current) {
+        clearTimeout(forceUpdateTimeoutRef.current);
+      }
     };
-  }, [authService, organisationService, eventService, inactivityService]);
+  }, [debouncedForceUpdate]);
   const authLoading = authService.isLoading();
   const orgLoading = organisationService.isLoading();
   const eventLoading = eventService.isLoading();
   const restorationLoading = sessionRestoration.isRestoring && !sessionRestorationTimedOut && !sessionRestoration.restorationError;
   const totalLoading = restorationLoading || authLoading || orgLoading || eventLoading;
   const authError = authService.getError();
-  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  const rawSelectedOrganisation = organisationService.getSelectedOrganisation();
   const organisations = organisationService.getOrganisations();
   const userMemberships = organisationService.getUserMemberships();
   const organisationError = organisationService.getError();
+  const selectedOrganisation = appConfig?.requires_event ? null : rawSelectedOrganisation;
   const hasValidOrganisationContext = organisationService.hasValidOrganisationContext();
   const isContextReady = organisationService.isContextReady();
   const events = eventService.getEvents();
@@ -2170,10 +2359,13 @@ function EventServiceProviderWrapper({
   supabaseClient,
   user,
   session,
-  appName
+  appName,
+  appConfig
 }) {
-  const organisationService = useOrganisationService();
-  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  const { selectedOrganisation: rawSelectedOrganisation } = useOrganisations();
+  const selectedOrganisation = appConfig?.requires_event ? null : rawSelectedOrganisation;
+  const setSelectedEventId = useCallback(() => {
+  }, []);
   return /* @__PURE__ */ jsx5(
     EventServiceProvider,
     {
@@ -2182,8 +2374,7 @@ function EventServiceProviderWrapper({
       session,
       appName,
       selectedOrganisation,
-      setSelectedEventId: () => {
-      },
+      setSelectedEventId,
       children
     }
   );
@@ -2216,6 +2407,7 @@ function ServiceAwareProviders({
           user: authService.getUser(),
           session: authService.getSession(),
           appName,
+          appConfig,
           children: /* @__PURE__ */ jsx5(
             InactivityServiceProvider,
             {
@@ -2258,11 +2450,12 @@ function UnifiedAuthProvider({
   persistState = true,
   enablePersistence,
   requireOrganisationContext = true,
-  idleTimeoutMs = 30 * 60 * 1e3,
-  // 30 minutes
-  warnBeforeMs = 60 * 1e3,
-  // 60 seconds
+  idleTimeoutMs,
+  // REQUIRED: No default - must be explicitly provided
+  warnBeforeMs,
+  // REQUIRED: No default - must be explicitly provided
   onIdleLogout,
+  // REQUIRED: No default - must be explicitly provided
   renderInactivityWarning,
   dangerouslyDisableInactivity = false
 }) {
@@ -2307,6 +2500,7 @@ export {
   InactivityServiceProvider,
   useAuthService,
   useOrganisationService,
+  useOrganisations,
   useEventService,
   useInactivityService,
   useSessionRestoration,
@@ -2314,4 +2508,4 @@ export {
   useUnifiedAuth,
   UnifiedAuthProvider
 };
-//# sourceMappingURL=chunk-VGZZXKBR.js.map
+//# sourceMappingURL=chunk-6LTQQAT6.js.map