@jmruthers/pace-core 0.6.2 → 0.6.3

package/dist/{chunk-EHMR7VYL.js → chunk-DWUBLJJM.js}

@@ -1,7 +1,7 @@
 import {
-  getAppConfigByName,
-  isSuperAdmin
-} from "./chunk-24UVZUZG.js";
+  isRBACInitialized,
+  setupRBAC
+} from "./chunk-RWEBCB47.js";
 import {
   assertOrganisationId,
   assertUserId
@@ -16,10 +16,10 @@ import {
 } from "./chunk-PWLANIRT.js";
 
 // src/providers/services/UnifiedAuthProvider.tsx
-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";
+import { createContext as createContext5, useContext as useContext6, useMemo as useMemo6, useCallback, useRef as useRef9, useEffect as useEffect10, useState as useState3, useReducer as useReducer5 } from "react";
 
 // src/providers/services/AuthServiceProvider.tsx
-import { createContext, useMemo, useEffect, useState } from "react";
+import { createContext, useMemo, useEffect, useState, useRef } from "react";
 
 // src/services/AuthService.ts
 import { AuthError } from "@supabase/supabase-js";
@@ -49,6 +49,9 @@ var BaseService = class {
    * This triggers React re-renders
    */
   notify() {
+    const serviceName = this.constructor.name;
+    const instanceId = this.instanceId || "unknown";
+    logger.debug("BaseService", `[${serviceName} ID:${instanceId}] Notifying ${this.subscribers.length} subscribers`);
     this.subscribers.forEach((callback) => {
       try {
         callback();
@@ -93,7 +96,7 @@ var BaseService = class {
 };
 
 // src/services/AuthService.ts
-var AuthService = class extends BaseService {
+var _AuthService = class _AuthService extends BaseService {
   constructor(supabaseClient, appName) {
     super();
     this.user = null;
@@ -113,11 +116,21 @@ var AuthService = class extends BaseService {
     this.appName = void 0;
     this.errorHandler = null;
     this.unhandledRejectionHandler = null;
+    this.instanceId = ++_AuthService.instanceCount;
     this.supabaseClient = supabaseClient;
     this.appName = appName;
+    logger.debug("AuthService", `Instance created [ID:${this.instanceId}]`, { appName });
+  }
+  getInstanceId() {
+    return this.instanceId;
   }
   // Auth state getters
   getUser() {
+    if (this.user) {
+      logger.debug("AuthService", `getUser() [ID:${this.instanceId}] returning user: ${this.user.id}`);
+    } else {
+      logger.debug("AuthService", `getUser() [ID:${this.instanceId}] returning null`);
+    }
     return this.user;
   }
   getSession() {
@@ -398,24 +411,29 @@ var AuthService = class extends BaseService {
       const subscription = this.supabaseClient.auth.onAuthStateChange(
         (event, session) => {
           try {
+            logger.debug("AuthService", `Auth state change [ID:${this.instanceId}]`, {
+              event,
+              hasSession: !!session,
+              userId: session?.user?.id
+            });
             if (event === "SIGNED_OUT") {
               this.session = null;
               this.user = null;
               this.authError = null;
               if (session?.user) {
                 this.trackSession("logout", session).catch((err) => {
-                  logger.warn("AuthService", "Failed to track logout session:", err);
+                  logger.warn("AuthService", `Failed to track logout session [ID:${this.instanceId}]:`, err);
                 });
               }
             } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
               this.session = session;
               this.user = session?.user ?? null;
-              if (session) {
+              if (session?.user) {
                 this.authError = null;
               }
               if (event === "SIGNED_IN" && session?.user) {
                 this.trackSession("login", session).catch((err) => {
-                  logger.warn("AuthService", "Failed to track login session:", err);
+                  logger.warn("AuthService", `Failed to track login session [ID:${this.instanceId}]:`, err);
                 });
               }
             } else if (event === "INITIAL_SESSION") {
@@ -433,13 +451,22 @@ var AuthService = class extends BaseService {
                 }
               }
               this.authLoading = false;
+              logger.debug("AuthService", `State synchronized after INITIAL_SESSION [ID:${this.instanceId}]`, {
+                hasUser: !!this.user,
+                userId: this.user?.id
+              });
               this.notify();
               return;
             }
             this.authLoading = false;
+            logger.debug("AuthService", `State synchronized after event [ID:${this.instanceId}]`, {
+              event,
+              hasUser: !!this.user,
+              userId: this.user?.id
+            });
             this.notify();
           } catch (error) {
-            logger.warn("AuthService", "Error in auth state change handler:", error);
+            logger.warn("AuthService", `Error in auth state change handler [ID:${this.instanceId}]:`, error);
             this.authLoading = false;
             this.notify();
           }
@@ -578,15 +605,20 @@ var AuthService = class extends BaseService {
     }
   }
 };
+_AuthService.instanceCount = 0;
+var AuthService = _AuthService;
 
 // src/providers/services/AuthServiceProvider.tsx
 import { jsx } from "react/jsx-runtime";
 var AuthServiceContext = createContext(null);
 function AuthServiceProvider({ children, supabaseClient, appName }) {
-  const authService = useMemo(
-    () => new AuthService(supabaseClient, appName),
-    [supabaseClient, appName]
-  );
+  const authServiceRef = useRef(null);
+  if (!authServiceRef.current) {
+    authServiceRef.current = new AuthService(supabaseClient, appName);
+  }
+  const authService = authServiceRef.current;
+  useEffect(() => {
+  }, [authService, supabaseClient, appName]);
   const [sessionRestoration, setSessionRestoration] = useState(
     () => authService.getSessionRestorationState()
   );
@@ -615,10 +647,10 @@ function AuthServiceProvider({ children, supabaseClient, appName }) {
 }
 
 // src/providers/services/OrganisationServiceProvider.tsx
-import { createContext as createContext2, useMemo as useMemo2, useEffect as useEffect2, useRef } from "react";
+import { createContext as createContext2, useMemo as useMemo2, useEffect as useEffect2, useRef as useRef2 } from "react";
 
 // src/services/OrganisationService.ts
-var OrganisationService = class extends BaseService {
+var _OrganisationService = class _OrganisationService extends BaseService {
   constructor(supabaseClient, user, session) {
     super();
     this._selectedOrganisation = null;
@@ -640,9 +672,17 @@ var OrganisationService = class extends BaseService {
     this.lastLoadTimeRef = 0;
     this.hasFailedRef = false;
     this.abortControllerRef = null;
+    this.instanceId = ++_OrganisationService.instanceCount;
     this.supabaseClient = supabaseClient;
     this.user = user;
     this.session = session;
+    logger.debug("OrganisationService", `Instance created [ID:${this.instanceId}]`, {
+      hasUser: !!user,
+      userId: user?.id
+    });
+  }
+  getInstanceId() {
+    return this.instanceId;
   }
   // Interface implementation
   getSelectedOrganisation() {
@@ -715,16 +755,35 @@ var OrganisationService = class extends BaseService {
   }
   // Update dependencies
   updateDependencies(user, session) {
-    const wasAuthenticated = !!(this.user && this.session);
-    const isAuthenticated = !!(user && session);
-    if (this.user?.id !== user?.id) {
+    const previousUserId = this.user?.id || null;
+    const newUserId = user?.id || null;
+    const userChanged = previousUserId !== newUserId;
+    const needsRetry = this._error !== null && !this.isLoadingRef;
+    const isEmpty = newUserId !== null && this._organisations.length === 0 && !this.isLoadingRef;
+    if (userChanged || needsRetry || isEmpty) {
+      if (userChanged) {
+        logger.debug("OrganisationService", `User changed [ID:${this.instanceId}], resetting initialization`, {
+          previousUserId,
+          newUserId
+        });
+      } else if (needsRetry) {
+        logger.debug("OrganisationService", `Previous error detected [ID:${this.instanceId}], retrying initialization`);
+      } else if (isEmpty) {
+        logger.debug("OrganisationService", `No organisations found [ID:${this.instanceId}], retrying initialization`);
+      }
       this._isSuperAdmin = false;
+      this.resetInitialization();
+      if (userChanged) {
+        this._organisations = [];
+        this._userMemberships = [];
+        this._roleMapState = /* @__PURE__ */ new Map();
+        this._selectedOrganisation = null;
+        this._isContextReady = false;
+      }
+      this.lastLoadTimeRef = 0;
     }
     this.user = user;
     this.session = session;
-    if (wasAuthenticated && !isAuthenticated) {
-      this.resetInitialization();
-    }
     this.notify();
   }
   // Organisation methods
@@ -793,6 +852,10 @@ var OrganisationService = class extends BaseService {
   }
   // Lifecycle methods
   async initialize() {
+    if (!this.user) {
+      logger.debug("OrganisationService", "Skipping initialization - no user");
+      return;
+    }
     await super.initialize();
     if (!this.isLoadingRef) {
       await this.loadUserOrganisations();
@@ -855,7 +918,7 @@ var OrganisationService = class extends BaseService {
       return;
     }
     const now = Date.now();
-    if (now - this.lastLoadTimeRef < 2e3) {
+    if (this._organisations.length > 0 && now - this.lastLoadTimeRef < 2e3) {
       if (this._organisations.length > 0 || this._selectedOrganisation) {
         this._isLoading = false;
       } else {
@@ -874,6 +937,9 @@ var OrganisationService = class extends BaseService {
     this._isLoading = true;
     this._error = null;
     this.notify();
+    logger.debug("OrganisationService", "Loading organisations for user", {
+      userId: this.user.id
+    });
     try {
       let memberships, membershipError, organisations = [];
       try {
@@ -932,6 +998,10 @@ var OrganisationService = class extends BaseService {
           }
         });
         organisations = Array.from(organisationsMap.values());
+        logger.debug("OrganisationService", "Query results", {
+          membershipsCount: memberships.length,
+          organisationsCount: organisations.length
+        });
       } catch (queryError) {
         if (queryError instanceof Error) {
           membershipError = queryError;
@@ -946,7 +1016,15 @@ var OrganisationService = class extends BaseService {
       let userIsSuperAdmin = false;
       if (this.user?.id) {
         try {
-          userIsSuperAdmin = await isSuperAdmin(this.user.id);
+          const { isSuperAdmin: checkSuperAdmin, isRBACInitialized: isRBACInitialized2, setupRBAC: setupRBAC2 } = await import("./api-IAGWF3ZG.js");
+          if (!isRBACInitialized2() && this.supabaseClient) {
+            setupRBAC2(this.supabaseClient);
+          }
+          if (isRBACInitialized2()) {
+            userIsSuperAdmin = await checkSuperAdmin(this.user.id);
+          } else {
+            userIsSuperAdmin = false;
+          }
           this._isSuperAdmin = userIsSuperAdmin;
         } catch (error) {
           logger.warn("OrganisationService", "Failed to check super admin status", { error });
@@ -997,7 +1075,12 @@ var OrganisationService = class extends BaseService {
         }
         throw new Error("User has no access to active organisations");
       }
-      this._organisations = activeOrgs;
+      const sortedOrgs = [...activeOrgs].sort((a, b) => {
+        const nameA = (a.display_name || a.name || "").toLowerCase();
+        const nameB = (b.display_name || b.name || "").toLowerCase();
+        return nameA.localeCompare(nameB);
+      });
+      this._organisations = sortedOrgs;
       this._userMemberships = memberships;
       this._roleMapState = roleMap;
       let initialOrg = null;
@@ -1079,6 +1162,8 @@ var OrganisationService = class extends BaseService {
     this._isContextReady = false;
   }
 };
+_OrganisationService.instanceCount = 0;
+var OrganisationService = _OrganisationService;
 
 // src/providers/services/OrganisationServiceProvider.tsx
 import { jsx as jsx2 } from "react/jsx-runtime";
@@ -1089,7 +1174,7 @@ function OrganisationServiceProvider({
   user,
   session
 }) {
-  const organisationServiceRef = useRef(null);
+  const organisationServiceRef = useRef2(null);
   if (!organisationServiceRef.current) {
     organisationServiceRef.current = new OrganisationService(supabaseClient, user, session);
   }
@@ -1123,10 +1208,10 @@ function OrganisationServiceProvider({
 }
 
 // src/providers/services/EventServiceProvider.tsx
-import { createContext as createContext3, useMemo as useMemo3, useEffect as useEffect3, useRef as useRef2 } from "react";
+import { createContext as createContext3, useMemo as useMemo3, useEffect as useEffect3, useRef as useRef3 } from "react";
 
 // src/services/EventService.ts
-var EventService = class extends BaseService {
+var _EventService = class _EventService extends BaseService {
   constructor(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId) {
     super();
     this.events = [];
@@ -1143,19 +1228,27 @@ var EventService = class extends BaseService {
     this.setSelectedEventId = null;
     this.isSuperAdmin = false;
     // Track super admin status for conditional validation
-    this.appConfig = null;
-    // Cache app config to avoid repeated lookups
+    // App config removed - scope is now page-level only (rbac_app_pages.scope_type)
     // Internal state management
     this.isInitializedRef = false;
     this.isFetchingRef = false;
     this.hasAutoSelectedRef = false;
     this.userClearedEventRef = false;
+    this.instanceId = ++_EventService.instanceCount;
     this.supabaseClient = supabaseClient;
     this.user = user;
     this.session = session;
     this.appName = appName;
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
+    logger.debug("EventService", `Instance created [ID:${this.instanceId}]`, {
+      appName,
+      hasUser: !!user,
+      userId: user?.id
+    });
+  }
+  getInstanceId() {
+    return this.instanceId;
   }
   // Helper method to get user-scoped storage key
   getStorageKey(userId) {
@@ -1182,6 +1275,11 @@ var EventService = class extends BaseService {
       this.resetInitialization();
       this.isInitializedRef = false;
       this.isFetchingRef = false;
+      logger.debug("EventService", `User changed [ID:${this.instanceId}]`, {
+        previousUserId,
+        newUserId,
+        willInitialize: newUserId !== null
+      });
     }
     this.supabaseClient = supabaseClient;
     this.user = user;
@@ -1189,15 +1287,31 @@ 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);
+        const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import("./api-IAGWF3ZG.js");
+        if (!isRBACInitialized2() && this.supabaseClient) {
+          setupRBAC2(this.supabaseClient);
+        }
+        if (isRBACInitialized2()) {
+          this.isSuperAdmin = await checkSuperAdmin(user.id);
+          logger.debug("EventService", "Super admin status updated in updateDependencies", {
+            userId: user.id,
+            isSuperAdmin: this.isSuperAdmin
+          });
+        } else {
+          logger.warn("EventService", "RBAC not initialized in updateDependencies, keeping existing super admin status", {
+            userId: user.id,
+            existingIsSuperAdmin: this.isSuperAdmin,
+            note: "RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider."
+          });
+        }
       } catch (error) {
-        logger.warn("EventService", "Failed to check super admin status", { error });
-        this.isSuperAdmin = false;
+        logger.warn("EventService", "Failed to check super admin status in updateDependencies", {
+          error,
+          userId: user.id,
+          existingIsSuperAdmin: this.isSuperAdmin
+        });
       }
     } else {
       this.isSuperAdmin = false;
@@ -1206,12 +1320,17 @@ var EventService = class extends BaseService {
       this.resetInitialization();
       this.isInitializedRef = false;
       this.isFetchingRef = false;
+      const shouldClearEvents = !this.isSuperAdmin;
       if (previousOrgId !== null && newOrgId !== null && previousOrgId !== newOrgId) {
-        this.events = [];
-        this.selectedEvent = null;
+        if (shouldClearEvents) {
+          this.events = [];
+          this.setSelectedEvent(null);
+        }
       } else if (previousOrgId !== null && newOrgId === null) {
-        this.events = [];
-        this.selectedEvent = null;
+        if (shouldClearEvents) {
+          this.events = [];
+          this.setSelectedEvent(null);
+        }
       }
     }
     this.notify();
@@ -1335,9 +1454,11 @@ var EventService = class extends BaseService {
   }
   async doInitialize() {
     if (this.isInitializedRef) {
+      logger.debug("EventService", "Skipping initialization - already initialized");
       return;
     }
     if (this.isFetchingRef) {
+      logger.debug("EventService", "Skipping initialization - already fetching");
       return;
     }
     try {
@@ -1348,10 +1469,22 @@ var EventService = class extends BaseService {
       logger.warn("EventService", "Failed to clean up old storage keys:", error);
     }
     if (!this.user) {
+      logger.debug("EventService", "Skipping initialization - no user");
       return;
     }
+    logger.debug("EventService", "Initializing", {
+      userId: this.user.id,
+      appName: this.appName,
+      hasSelectedOrganisation: !!this.selectedOrganisation,
+      hasSupabaseClient: !!this.supabaseClient,
+      hasSession: !!this.session
+    });
     await this.fetchEvents(false);
     this.isInitializedRef = true;
+    logger.debug("EventService", "Initialization complete", {
+      eventsCount: this.events.length,
+      hasError: !!this.error
+    });
   }
   doCleanup() {
   }
@@ -1368,55 +1501,91 @@ var EventService = class extends BaseService {
     this.isFetchingRef = true;
     let isMounted = true;
     try {
-      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;
+      let userIsSuperAdmin = this.isSuperAdmin;
       try {
-        userIsSuperAdmin = await isSuperAdmin(this.user.id);
+        const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import("./api-IAGWF3ZG.js");
+        if (!isRBACInitialized2() && this.supabaseClient) {
+          setupRBAC2(this.supabaseClient);
+        }
+        if (isRBACInitialized2()) {
+          userIsSuperAdmin = await checkSuperAdmin(this.user.id);
+          this.isSuperAdmin = userIsSuperAdmin;
+          logger.debug("EventService", "Super admin check completed", {
+            userId: this.user.id,
+            isSuperAdmin: userIsSuperAdmin
+          });
+        } else {
+          if (this.isSuperAdmin) {
+            userIsSuperAdmin = true;
+            logger.warn("EventService", "RBAC not initialized, using cached super admin status", {
+              userId: this.user.id,
+              cachedIsSuperAdmin: this.isSuperAdmin,
+              note: "RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider."
+            });
+          } else {
+            logger.warn("EventService", "RBAC not initialized, using cached non-super-admin status", {
+              userId: this.user.id,
+              cachedIsSuperAdmin: this.isSuperAdmin,
+              note: "RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider."
+            });
+          }
+        }
         if (userIsSuperAdmin) {
           organisationIdForRpc = null;
         } else {
           if (this.selectedEvent) {
             organisationIdForRpc = this.selectedEvent.organisation_id;
-          } else if (this.appConfig?.requires_event === true) {
-            organisationIdForRpc = null;
           } else if (this.selectedOrganisation) {
             organisationIdForRpc = this.selectedOrganisation.id;
           } else {
-            logger.warn("EventService", "No organisation context available for event fetch", {
+            logger.debug("EventService", "No organisation context available, fetching all accessible events", {
               hasSelectedEvent: !!this.selectedEvent,
-              hasSelectedOrganisation: !!this.selectedOrganisation,
-              appRequiresEvent: this.appConfig?.requires_event
+              hasSelectedOrganisation: !!this.selectedOrganisation
             });
             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) {
+        if (this.isSuperAdmin) {
+          userIsSuperAdmin = true;
           organisationIdForRpc = null;
-        } else if (this.selectedOrganisation) {
-          organisationIdForRpc = this.selectedOrganisation.id;
+          logger.warn("EventService", "Super admin check failed, using cached super admin status", {
+            error: superAdminCheckError,
+            cachedIsSuperAdmin: this.isSuperAdmin
+          });
+        } else {
+          logger.warn("EventService", "Failed to check super admin status, using organisation-scoped query", {
+            error: superAdminCheckError,
+            cachedIsSuperAdmin: this.isSuperAdmin
+          });
+          if (this.selectedEvent) {
+            organisationIdForRpc = this.selectedEvent.organisation_id;
+          } else if (this.selectedOrganisation) {
+            organisationIdForRpc = this.selectedOrganisation.id;
+          } else {
+            organisationIdForRpc = null;
+          }
         }
       }
+      logger.debug("EventService", "Fetching events", {
+        userId: this.user.id,
+        organisationIdForRpc,
+        appName: this.appName,
+        hasSelectedEvent: !!this.selectedEvent,
+        hasSelectedOrganisation: !!this.selectedOrganisation,
+        isSuperAdmin: userIsSuperAdmin
+      });
       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", {
+        dataLength: data?.length || 0,
+        hasError: !!rpcError,
+        error: rpcError
+      });
       if (rpcError) {
         logger.error("EventService", "RPC error fetching events:", rpcError);
         throw new Error(rpcError.message || "Failed to fetch events");
@@ -1439,7 +1608,15 @@ var EventService = class extends BaseService {
           created_at: (/* @__PURE__ */ new Date()).toISOString(),
           updated_at: (/* @__PURE__ */ new Date()).toISOString()
         }));
-        this.events = transformedEvents;
+        const sortedEvents = [...transformedEvents].sort((a, b) => {
+          if (a.event_date && b.event_date) {
+            return new Date(b.event_date).getTime() - new Date(a.event_date).getTime();
+          }
+          if (a.event_date && !b.event_date) return -1;
+          if (!a.event_date && b.event_date) return 1;
+          return 0;
+        });
+        this.events = sortedEvents;
         this.error = null;
         this.hasAutoSelectedRef = false;
         if (!skipLoadPersisted) {
@@ -1514,6 +1691,8 @@ var EventService = class extends BaseService {
     return null;
   }
 };
+_EventService.instanceCount = 0;
+var EventService = _EventService;
 
 // src/providers/services/EventServiceProvider.tsx
 import { jsx as jsx3 } from "react/jsx-runtime";
@@ -1527,27 +1706,52 @@ function EventServiceProvider({
   selectedOrganisation,
   setSelectedEventId
 }) {
-  const eventServiceRef = useRef2(null);
-  const initializingRef = useRef2(false);
+  const eventServiceRef = useRef3(null);
+  const initializingRef = useRef3(false);
   if (!eventServiceRef.current) {
     eventServiceRef.current = new EventService(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
   }
   const eventService = eventServiceRef.current;
   useEffect3(() => {
     let isMounted = true;
+    logger.debug("EventServiceProvider", "useEffect triggered", {
+      hasUser: !!user,
+      userId: user?.id,
+      hasSession: !!session,
+      appName,
+      isInitializing: initializingRef.current
+    });
     if (initializingRef.current) {
+      logger.debug("EventServiceProvider", "Skipping - already initializing");
       return;
     }
     const updateAndInitialize = async () => {
       initializingRef.current = true;
       try {
+        logger.debug("EventServiceProvider", "Updating dependencies and initializing", {
+          hasUser: !!user,
+          userId: user?.id,
+          hasSession: !!session,
+          appName,
+          hasSelectedOrganisation: !!selectedOrganisation
+        });
         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);
-          }
-        });
+        if (user && session && supabaseClient && appName) {
+          logger.debug("EventServiceProvider", "Initializing event service");
+          await eventService.initialize().catch((error) => {
+            if (isMounted) {
+              logger.error("EventServiceProvider", "Failed to initialize event service:", error);
+            }
+          });
+        } else {
+          logger.debug("EventServiceProvider", "Skipping initialization - missing required dependencies", {
+            hasUser: !!user,
+            hasSession: !!session,
+            hasSupabaseClient: !!supabaseClient,
+            appName
+          });
+        }
       } finally {
         initializingRef.current = false;
       }
@@ -1570,7 +1774,7 @@ function EventServiceProvider({
 }
 
 // src/providers/services/InactivityServiceProvider.tsx
-import { createContext as createContext4, useMemo as useMemo4, useEffect as useEffect4, useRef as useRef3 } from "react";
+import { createContext as createContext4, useMemo as useMemo4, useEffect as useEffect4, useRef as useRef4 } from "react";
 
 // src/services/InactivityService.ts
 var InactivityService = class extends BaseService {
@@ -1914,7 +2118,7 @@ function InactivityServiceProvider({
   // REQUIRED: No default - must be explicitly provided
   onIdleLogout
 }) {
-  const inactivityServiceRef = useRef3(null);
+  const inactivityServiceRef = useRef4(null);
   if (!inactivityServiceRef.current) {
     inactivityServiceRef.current = new InactivityService(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout);
   }
@@ -1943,14 +2147,14 @@ function InactivityServiceProvider({
 }
 
 // src/hooks/services/useAuthService.ts
-import { useContext, useReducer, useEffect as useEffect5, useRef as useRef4 } from "react";
+import { useContext, useReducer, useEffect as useEffect5, useRef as useRef5 } 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);
+  const timeoutRef = useRef5(null);
   useEffect5(() => {
     const debouncedUpdate = () => {
       if (timeoutRef.current) {
@@ -1973,14 +2177,14 @@ function useAuthService() {
 }
 
 // src/hooks/services/useOrganisationService.ts
-import { useContext as useContext2, useReducer as useReducer2, useEffect as useEffect6, useRef as useRef5 } from "react";
+import { useContext as useContext2, useReducer as useReducer2, useEffect as useEffect6, useRef as useRef6 } 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);
+  const timeoutRef = useRef6(null);
   useEffect6(() => {
     const debouncedUpdate = () => {
       if (timeoutRef.current) {
@@ -2026,14 +2230,14 @@ function useOrganisations() {
 }
 
 // src/hooks/services/useEventService.ts
-import { useContext as useContext3, useReducer as useReducer3, useEffect as useEffect7, useRef as useRef6 } from "react";
+import { useContext as useContext3, useReducer as useReducer3, useEffect as useEffect7, useRef as useRef7 } 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);
+  const timeoutRef = useRef7(null);
   useEffect7(() => {
     const debouncedUpdate = () => {
       if (timeoutRef.current) {
@@ -2056,14 +2260,14 @@ function useEventService() {
 }
 
 // src/hooks/services/useInactivityService.ts
-import { useContext as useContext4, useReducer as useReducer4, useEffect as useEffect8, useRef as useRef7 } from "react";
+import { useContext as useContext4, useReducer as useReducer4, useEffect as useEffect8, useRef as useRef8 } 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);
+  const timeoutRef = useRef8(null);
   useEffect8(() => {
     const debouncedUpdate = () => {
       if (timeoutRef.current) {
@@ -2138,7 +2342,6 @@ var useUnifiedAuth = () => {
 function UnifiedAuthContextProvider({
   children,
   appName,
-  appConfig: appConfigProp,
   supabaseClient: supabaseClientProp,
   ...props
 }) {
@@ -2158,13 +2361,6 @@ 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();
@@ -2188,9 +2384,17 @@ function UnifiedAuthContextProvider({
   const isAuth = !!(currentUser && currentSession);
   const supabase = useMemo6(() => supabaseClientProp, [supabaseClientProp]);
   const [appId, setAppId] = useState3(void 0);
-  const isResolvingAppIdRef = useRef8(false);
-  const resolvedAppIdRef = useRef8(void 0);
-  const resolvedUserIdRef = useRef8(void 0);
+  useEffect10(() => {
+    logger.debug("UnifiedAuthContextProvider", `Rendering [AuthService ID:${authService.getInstanceId?.() || "unknown"}]`, {
+      hasUser: !!currentUser,
+      userId: currentUser?.id,
+      hasSession: !!currentSession,
+      isAuth
+    });
+  }, [currentUser?.id, currentSession?.access_token, isAuth, authService]);
+  const isResolvingAppIdRef = useRef9(false);
+  const resolvedAppIdRef = useRef9(void 0);
+  const resolvedUserIdRef = useRef9(void 0);
   useEffect10(() => {
     if (!isAuth) {
       resolvedAppIdRef.current = void 0;
@@ -2210,9 +2414,9 @@ function UnifiedAuthContextProvider({
       resolvedUserIdRef.current = currentUserId;
       const userId = currentUserId;
       const appNameValue = appName;
-      import("./api-MVVQZLJI.js").then(async ({ resolveAppContext, setupRBAC }) => {
+      import("./api-IAGWF3ZG.js").then(async ({ resolveAppContext, setupRBAC: setupRBAC2 }) => {
         try {
-          setupRBAC(supabase);
+          setupRBAC2(supabase);
           const result = await resolveAppContext({
             userId,
             appName: appNameValue
@@ -2240,59 +2444,8 @@ 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-MVVQZLJI.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 = useRef8(null);
+  const forceUpdateTimeoutRef = useRef9(null);
   const debouncedForceUpdate = useCallback(() => {
     if (forceUpdateTimeoutRef.current) {
       clearTimeout(forceUpdateTimeoutRef.current);
@@ -2302,10 +2455,10 @@ function UnifiedAuthContextProvider({
       forceUpdateTimeoutRef.current = null;
     }, 100);
   }, [forceUpdate]);
-  const authServiceRef = useRef8(authService);
-  const organisationServiceRef = useRef8(organisationService);
-  const eventServiceRef = useRef8(eventService);
-  const inactivityServiceRef = useRef8(inactivityService);
+  const authServiceRef = useRef9(authService);
+  const organisationServiceRef = useRef9(organisationService);
+  const eventServiceRef = useRef9(eventService);
+  const inactivityServiceRef = useRef9(inactivityService);
   useEffect10(() => {
     authServiceRef.current = authService;
     organisationServiceRef.current = organisationService;
@@ -2336,20 +2489,7 @@ function UnifiedAuthContextProvider({
   const authError = authService.getError();
   const rawSelectedOrganisation = organisationService.getSelectedOrganisation();
   const organisationError = organisationService.getError();
-  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 selectedOrganisation = rawSelectedOrganisation;
   const hasValidOrganisationContext = organisationService.hasValidOrganisationContext();
   const isContextReady = organisationService.isContextReady();
   const rawEvents = eventService.getEvents();
@@ -2418,7 +2558,7 @@ function UnifiedAuthContextProvider({
   const handleIdleLogout = () => inactivityService.handleIdleLogout();
   const handleStaySignedIn = () => inactivityService.handleStaySignedIn();
   const handleSignOutNow = () => inactivityService.handleSignOutNow();
-  const prevStateRef = useRef8(null);
+  const prevStateRef = useRef9(null);
   const isDev = import.meta.env.DEV || import.meta.env.MODE === "development";
   if (isDev) {
     const currentState = {
@@ -2491,7 +2631,6 @@ function UnifiedAuthContextProvider({
       appName,
       appId,
       // Resolved immediately on login
-      appConfig,
       isLoading: totalLoading,
       hasErrors,
       sessionRestoration,
@@ -2524,7 +2663,6 @@ function UnifiedAuthContextProvider({
     hasErrors,
     appName,
     appId,
-    appConfig,
     sessionRestoration,
     sessionRestorationTimedOut,
     sessionRestorationTimeoutMs,
@@ -2558,13 +2696,19 @@ function EventServiceProviderWrapper({
   supabaseClient,
   user,
   session,
-  appName,
-  appConfig
+  appName
 }) {
-  const { selectedOrganisation: rawSelectedOrganisation } = useOrganisations();
-  const selectedOrganisation = appConfig !== null && appConfig?.requires_event === true && !rawSelectedOrganisation ? null : rawSelectedOrganisation;
+  const { selectedOrganisation } = useOrganisations();
   const setSelectedEventId = useCallback(() => {
   }, []);
+  useEffect10(() => {
+    logger.debug("EventServiceProviderWrapper", "Rendering with props", {
+      hasUser: !!user,
+      userId: user?.id,
+      hasSession: !!session,
+      selectedOrganisationId: selectedOrganisation?.id
+    });
+  }, [user?.id, session?.access_token, selectedOrganisation?.id]);
   return /* @__PURE__ */ jsx5(
     EventServiceProvider,
     {
@@ -2582,7 +2726,6 @@ function ServiceAwareProviders({
   children,
   supabaseClient,
   appName,
-  appConfig,
   persistState,
   enablePersistence,
   requireOrganisationContext,
@@ -2593,26 +2736,51 @@ function ServiceAwareProviders({
   dangerouslyDisableInactivity
 }) {
   const authService = useAuthService();
+  const [userState, setUserState] = useState3(() => authService.getUser());
+  const [sessionState, setSessionState] = useState3(() => authService.getSession());
+  useEffect10(() => {
+    const unsubscribe = authService.subscribe(() => {
+      const newUser = authService.getUser();
+      const newSession = authService.getSession();
+      logger.debug("ServiceAwareProviders", "Auth service notified, updating state", {
+        hasUser: !!newUser,
+        userId: newUser?.id,
+        hasSession: !!newSession
+      });
+      setUserState(newUser);
+      setSessionState(newSession);
+    });
+    return unsubscribe;
+  }, [authService]);
+  const user = userState;
+  const session = sessionState;
+  useEffect10(() => {
+    logger.debug("ServiceAwareProviders", `User/session state [AuthService ID:${authService.getInstanceId?.() || "unknown"}]`, {
+      hasUser: !!user,
+      userId: user?.id,
+      hasSession: !!session,
+      sessionToken: session?.access_token ? "present" : "missing"
+    });
+  }, [user?.id, session?.access_token, authService]);
   return /* @__PURE__ */ jsx5(
     OrganisationServiceProvider,
     {
       supabaseClient,
-      user: authService.getUser(),
-      session: authService.getSession(),
+      user,
+      session,
       children: /* @__PURE__ */ jsx5(
         EventServiceProviderWrapper,
         {
           supabaseClient,
-          user: authService.getUser(),
-          session: authService.getSession(),
+          user,
+          session,
           appName,
-          appConfig,
           children: /* @__PURE__ */ jsx5(
             InactivityServiceProvider,
             {
               supabaseClient,
-              user: authService.getUser(),
-              session: authService.getSession(),
+              user,
+              session,
               idleTimeoutMs,
               warnBeforeMs,
               onIdleLogout,
@@ -2620,7 +2788,6 @@ function ServiceAwareProviders({
                 UnifiedAuthContextProvider,
                 {
                   appName,
-                  appConfig,
                   supabaseClient,
                   persistState,
                   enablePersistence,
@@ -2644,8 +2811,6 @@ function UnifiedAuthProvider({
   children,
   supabaseClient,
   appName,
-  appConfig = { requires_event: true },
-  // Default to requiring events
   persistState = true,
   enablePersistence,
   requireOrganisationContext = true,
@@ -2658,7 +2823,7 @@ function UnifiedAuthProvider({
   renderInactivityWarning,
   dangerouslyDisableInactivity = false
 }) {
-  const clientRef = useRef8(supabaseClient);
+  const clientRef = useRef9(supabaseClient);
   useEffect10(() => {
     if (clientRef.current !== supabaseClient) {
       logger.warn("UnifiedAuthProvider", "Supabase client reference changed - this may indicate multiple client instances are being created", {
@@ -2667,14 +2832,23 @@ function UnifiedAuthProvider({
         note: 'Ensure you create the Supabase client once and reuse it. Creating multiple clients can cause performance issues and the "Multiple GoTrueClient instances" warning.'
       });
       clientRef.current = supabaseClient;
+    } else {
+      logger.debug("UnifiedAuthProvider", "Supabase client reference is stable");
     }
   }, [supabaseClient]);
+  if (supabaseClient && !isRBACInitialized()) {
+    try {
+      setupRBAC(supabaseClient);
+      logger.debug("UnifiedAuthProvider", "RBAC initialized synchronously");
+    } catch (err) {
+      logger.error("UnifiedAuthProvider", "Failed to initialize RBAC", err);
+    }
+  }
   return /* @__PURE__ */ jsx5(AuthServiceProvider, { supabaseClient, appName, children: /* @__PURE__ */ jsx5(
     ServiceAwareProviders,
     {
       supabaseClient,
       appName,
-      appConfig,
       persistState,
       enablePersistence,
       requireOrganisationContext,
@@ -2707,4 +2881,4 @@ export {
   useUnifiedAuth,
   UnifiedAuthProvider
 };
-//# sourceMappingURL=chunk-EHMR7VYL.js.map
+//# sourceMappingURL=chunk-DWUBLJJM.js.map