@jmruthers/pace-core 0.5.76 → 0.5.78

package/dist/{chunk-WN6XJWOS.js → chunk-MNJXXD6C.js}

@@ -1,13 +1,7 @@
 import {
-  AccessLevel,
-  init_unified
-} from "./chunk-ULBI5JGB.js";
-import {
-  DebugLogger,
-  init_debugLogger,
   init_organisationContext,
   setOrganisationContext
-} from "./chunk-XLZ7U46Z.js";
+} from "./chunk-CVMVPYAL.js";
 import {
   __esm
 } from "./chunk-PLDDJCW6.js";
@@ -75,6 +69,13 @@ var init_BaseService = __esm({
       getInitialized() {
         return this.isInitialized;
       }
+      /**
+       * Reset initialization state (allows re-initialization)
+       * Use when dependencies change and service needs to re-initialize
+       */
+      resetInitialization() {
+        this.isInitialized = false;
+      }
     };
   }
 });
@@ -86,13 +87,12 @@ var init_AuthService = __esm({
   "src/services/AuthService.ts"() {
     "use strict";
     init_BaseService();
-    init_debugLogger();
     AuthService = class extends BaseService {
       constructor(supabaseClient) {
         super();
         this.user = null;
         this.session = null;
-        this.authLoading = true;
+        this.authLoading = false;
         this.authError = null;
         this.supabaseClient = null;
         this.authStateSubscription = null;
@@ -324,21 +324,17 @@ var init_AuthService = __esm({
           this.authStateSubscription = this.supabaseClient.auth.onAuthStateChange(
             (event, session) => {
               try {
-                DebugLogger.log("AuthService", "Auth state changed:", event, session?.user?.email);
                 if (event === "SIGNED_OUT") {
-                  DebugLogger.log("AuthService", "User signed out, clearing all state");
                   this.session = null;
                   this.user = null;
                   this.authError = null;
                 } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
-                  DebugLogger.log("AuthService", "User signed in or token refreshed");
                   this.session = session;
                   this.user = session?.user ?? null;
                   if (session) {
                     this.authError = null;
                   }
                 } else if (event === "INITIAL_SESSION") {
-                  DebugLogger.log("AuthService", "Initial session event");
                   if (session) {
                     this.session = session;
                     this.user = session.user ?? null;
@@ -366,23 +362,17 @@ var init_AuthService = __esm({
           return;
         }
         try {
-          DebugLogger.log("AuthService", "Initializing authentication...");
           const { data: { session: currentSession }, error: sessionError } = await this.supabaseClient.auth.getSession();
           if (sessionError) {
             console.warn("[AuthService] Error getting current session:", sessionError);
           }
           if (currentSession) {
-            DebugLogger.log("AuthService", "Session restored from storage:", currentSession.user?.email);
             this.session = currentSession;
             this.user = currentSession.user;
             this.authError = null;
           } else {
-            DebugLogger.log("AuthService", "No session found in storage");
             const { data: { user: currentUser }, error: userError } = await this.supabaseClient.auth.getUser();
-            if (userError) {
-              DebugLogger.log("AuthService", "No user found:", userError.message);
-            } else if (currentUser) {
-              DebugLogger.log("AuthService", "User found without session:", currentUser.email);
+            if (!userError && currentUser) {
               this.user = currentUser;
             }
           }
@@ -457,461 +447,6 @@ var init_AuthServiceProvider = __esm({
   }
 });
 
-// src/services/RBACService.ts
-var RBACService;
-var init_RBACService = __esm({
-  "src/services/RBACService.ts"() {
-    "use strict";
-    init_BaseService();
-    init_unified();
-    init_debugLogger();
-    RBACService = class extends BaseService {
-      constructor(supabaseClient, user, session, appName) {
-        super();
-        this.permissions = {};
-        this.roles = [];
-        this.accessLevel = "viewer" /* VIEWER */;
-        this.rbacLoading = false;
-        this.rbacError = null;
-        this.selectedEventId = null;
-        this.appConfig = null;
-        this.userEventAccess = [];
-        this.eventAccessLoading = false;
-        this.selectedOrganisationId = null;
-        // Dependencies
-        this.supabaseClient = null;
-        this.user = null;
-        this.session = null;
-        this.appName = "";
-        this.supabaseClient = supabaseClient;
-        this.user = user;
-        this.session = session;
-        this.appName = appName;
-      }
-      // Update dependencies
-      updateDependencies(user, session, appName) {
-        this.user = user;
-        this.session = session;
-        this.appName = appName;
-        this.notify();
-      }
-      // RBAC state getters
-      getPermissions() {
-        return this.permissions;
-      }
-      getRoles() {
-        return this.roles;
-      }
-      getAccessLevel() {
-        return this.accessLevel;
-      }
-      isLoading() {
-        return this.rbacLoading;
-      }
-      getError() {
-        return this.rbacError;
-      }
-      getSelectedEventId() {
-        return this.selectedEventId;
-      }
-      getAppConfig() {
-        return this.appConfig;
-      }
-      getUserEventAccess() {
-        return this.userEventAccess;
-      }
-      isEventAccessLoading() {
-        return this.eventAccessLoading;
-      }
-      getSelectedOrganisationId() {
-        return this.selectedOrganisationId;
-      }
-      // RBAC methods
-      hasPermission(permission, orgId) {
-        return !!this.permissions[permission];
-      }
-      hasAnyPermission(permissions, orgId) {
-        return permissions.some((p) => !!this.permissions[p]);
-      }
-      hasAllPermissions(permissions, orgId) {
-        return permissions.every((p) => !!this.permissions[p]);
-      }
-      hasRole(role) {
-        const isSuperAdmin = this.user?.user_metadata?.globalRole === "super_admin";
-        if (role.toLowerCase() === "super_admin" || role.toLowerCase() === "super") {
-          return isSuperAdmin;
-        }
-        return this.roles.includes(role);
-      }
-      hasAccessLevel(level) {
-        const levels = Object.values(AccessLevel);
-        return levels.indexOf(this.accessLevel) >= levels.indexOf(level);
-      }
-      canAccess(resource, action, orgId) {
-        const permission = `${resource}:${action}`;
-        return this.hasPermission(permission, orgId);
-      }
-      async validatePermission(permission, orgId) {
-        return this.hasPermission(permission, orgId);
-      }
-      async validateAccess(resource, action, orgId) {
-        return this.canAccess(resource, action, orgId);
-      }
-      async refreshPermissions(eventId, orgId) {
-        if (!this.supabaseClient || !this.user || !this.appConfig || !this.session) {
-          DebugLogger.log("RBACService", "refreshPermissions: Missing required dependencies, clearing permissions");
-          this.permissions = {};
-          this.roles = [];
-          this.accessLevel = "viewer" /* VIEWER */;
-          this.notify();
-          return;
-        }
-        const isSuperAdmin = this.user?.user_metadata?.globalRole === "super_admin";
-        if (isSuperAdmin) {
-          this.permissions = {
-            "admin:create": true,
-            "admin:read": true,
-            "admin:update": true,
-            "admin:delete": true,
-            "users:create": true,
-            "users:read": true,
-            "users:update": true,
-            "users:delete": true,
-            "events:create": true,
-            "events:read": true,
-            "events:update": true,
-            "events:delete": true
-          };
-          this.roles = ["super_admin"];
-          this.accessLevel = "admin" /* ADMIN */;
-          this.notify();
-          return;
-        }
-        const shouldLoadDirectPermissions = !eventId && !this.appConfig.requires_event;
-        const shouldLoadEventPermissions = eventId;
-        const shouldClearPermissions = !eventId && this.appConfig.requires_event;
-        if (shouldClearPermissions) {
-          this.permissions = {};
-          this.roles = [];
-          this.accessLevel = "viewer" /* VIEWER */;
-          this.notify();
-          return;
-        }
-        if (!shouldLoadDirectPermissions && !shouldLoadEventPermissions) {
-          return;
-        }
-        this.rbacLoading = true;
-        this.rbacError = null;
-        this.notify();
-        try {
-          const { getCurrentAppName } = await import("./appNameResolver-UURKN7NF.js");
-          const resolvedAppName = getCurrentAppName() || this.appName;
-          const { data: appData, error: appError } = await this.supabaseClient.from("rbac_apps").select("id").eq("name", resolvedAppName).eq("is_active", true).single();
-          if (appError || !appData) {
-            console.warn("App not found or inactive:", resolvedAppName);
-            this.rbacLoading = false;
-            this.notify();
-            return;
-          }
-          const { data, error } = await this.supabaseClient.rpc("rbac_permissions_get", {
-            p_user_id: this.user.id,
-            p_app_id: appData.id,
-            p_event_id: eventId || null,
-            p_organisation_id: orgId || this.selectedOrganisationId || null
-          });
-          if (error) {
-            throw error;
-          }
-          const { permissions, roles, access_level } = this.transformRBACPermissions(data, this.appName);
-          this.permissions = permissions;
-          this.roles = roles;
-          this.accessLevel = access_level;
-        } catch (err) {
-          this.rbacError = err;
-        } finally {
-          this.rbacLoading = false;
-          this.notify();
-        }
-      }
-      setSelectedEventId(eventId) {
-        this.selectedEventId = eventId;
-        this.notify();
-      }
-      async loadUserEventAccess(orgId) {
-        if (!this.supabaseClient || !this.user || !this.session) {
-          DebugLogger.log("RBACService", "loadUserEventAccess: Missing required dependencies, clearing event access");
-          this.userEventAccess = [];
-          this.notify();
-          return;
-        }
-        this.eventAccessLoading = true;
-        this.notify();
-        try {
-          const { getCurrentAppName } = await import("./appNameResolver-UURKN7NF.js");
-          const resolvedAppName = getCurrentAppName() || this.appName;
-          const { data: appData, error: appError } = await this.supabaseClient.from("rbac_apps").select("id").eq("name", resolvedAppName).eq("is_active", true).single();
-          if (appError || !appData) {
-            console.warn("App not found or inactive:", resolvedAppName);
-            this.eventAccessLoading = false;
-            this.notify();
-            return;
-          }
-          const { data, error } = await this.supabaseClient.from("rbac_event_app_roles").select(`
-          event_id,
-          role,
-          granted_at
-        `).eq("user_id", this.user.id).eq("app_id", appData.id);
-          if (error) {
-            console.error("Failed to load user event access:", error);
-            this.userEventAccess = [];
-            this.notify();
-            return;
-          }
-          const eventAccess = data?.map((item) => ({
-            event_id: item.event_id,
-            event_name: item.event_name || "Unknown Event",
-            // Event details not available in this query
-            event_description: item.event_description || null,
-            // Not available in this schema
-            start_date: item.start_date || "",
-            // Event date not available in this query
-            end_date: item.end_date || "",
-            // Event date not available in this query
-            event_status: item.event_status || "unknown",
-            // Not available in this schema
-            app_id: item.app_id || appData.id,
-            access_level: item.access_level || item.role,
-            // Map role to access_level
-            granted_at: item.granted_at,
-            organisation_id: item.organisation_id || ""
-            // Will be populated from event's organisation_id if needed
-          })) || [];
-          this.userEventAccess = eventAccess;
-        } catch (error) {
-          console.error("Error loading user event access:", error);
-          this.userEventAccess = [];
-        } finally {
-          this.eventAccessLoading = false;
-          this.notify();
-        }
-      }
-      getUserEventAccessById(eventId) {
-        return this.userEventAccess.find((access) => access.event_id === eventId);
-      }
-      requireOrganisationContext() {
-        if (!this.selectedOrganisationId) {
-          throw new Error("Organisation context is required but not available");
-        }
-        return this.selectedOrganisationId;
-      }
-      // Lifecycle methods
-      async initialize() {
-        await super.initialize();
-        await this.loadAppConfig();
-        const isSuperAdmin = this.user?.user_metadata?.globalRole === "super_admin";
-        if (!isSuperAdmin && this.appConfig) {
-          await this.refreshPermissions(this.selectedEventId || void 0);
-        }
-        await this.loadPersistedState();
-      }
-      cleanup() {
-        super.cleanup();
-      }
-      async doInitialize() {
-        const isSuperAdmin = this.user?.user_metadata?.globalRole === "super_admin";
-        if (isSuperAdmin) {
-          this.roles = ["super_admin"];
-          this.accessLevel = "admin" /* ADMIN */;
-          this.permissions = {
-            "admin:create": true,
-            "admin:read": true,
-            "admin:update": true,
-            "admin:delete": true,
-            "users:create": true,
-            "users:read": true,
-            "users:update": true,
-            "users:delete": true,
-            "events:create": true,
-            "events:read": true,
-            "events:update": true,
-            "events:delete": true
-          };
-        } else {
-          this.roles = [];
-          this.accessLevel = "viewer" /* VIEWER */;
-          this.permissions = {};
-        }
-      }
-      doCleanup() {
-      }
-      async loadAppConfig() {
-        if (!this.supabaseClient) return;
-        try {
-          const { getCurrentAppName } = await import("./appNameResolver-UURKN7NF.js");
-          const resolvedAppName = getCurrentAppName() || this.appName;
-          const { data: appData, error: appError } = await this.supabaseClient.from("rbac_apps").select("id").eq("name", resolvedAppName).eq("is_active", true).single();
-          if (appError || !appData) {
-            console.warn("App not found or inactive:", resolvedAppName);
-            this.appConfig = {
-              supports_direct_access: false,
-              requires_event: true
-            };
-            return;
-          }
-          const response = await this.supabaseClient.rpc("get_app_config", {
-            app_id: appData.id
-          });
-          const { data } = response || {};
-          if (data && data.length > 0) {
-            this.appConfig = {
-              supports_direct_access: false,
-              requires_event: data[0].requires_event
-            };
-          } else {
-            this.appConfig = {
-              supports_direct_access: false,
-              requires_event: true
-            };
-          }
-        } catch (error) {
-          console.warn("Failed to load app configuration:", error);
-          this.appConfig = {
-            supports_direct_access: false,
-            requires_event: true
-          };
-        }
-      }
-      async loadPersistedState() {
-        try {
-          const persistedEvent = localStorage.getItem("pace-core-selected-event");
-          if (persistedEvent) {
-            this.selectedEventId = JSON.parse(persistedEvent);
-          }
-        } catch (error) {
-          console.warn("Clearing corrupted localStorage data");
-          localStorage.removeItem("pace-core-selected-event");
-        }
-      }
-      transformRBACPermissions(rbacData, appName) {
-        const permissions = {};
-        let roles = [];
-        let access_level = "viewer" /* VIEWER */;
-        if (!rbacData || !Array.isArray(rbacData)) {
-          return { permissions: {}, roles: ["viewer"], access_level: "viewer" /* VIEWER */ };
-        }
-        const superAdminPerm = rbacData.find((p) => p.permission_type === "all_permissions");
-        if (superAdminPerm) {
-          return {
-            permissions: { "all:all": true },
-            roles: ["super"],
-            access_level: "super" /* SUPER */
-          };
-        }
-        const eventAppPerms = rbacData.filter((p) => p.permission_type === "event_app_access");
-        if (eventAppPerms.length > 0) {
-          const role = eventAppPerms[0].role_name;
-          switch (role) {
-            case "event_admin":
-              access_level = "admin" /* ADMIN */;
-              roles = ["admin"];
-              break;
-            case "planner":
-              access_level = "planner" /* PLANNER */;
-              roles = ["planner"];
-              break;
-            case "participant":
-              access_level = "participant" /* PARTICIPANT */;
-              roles = ["participant"];
-              break;
-            case "editor":
-              access_level = "editor" /* EDITOR */;
-              roles = ["editor"];
-              break;
-            case "viewer":
-            default:
-              access_level = "viewer" /* VIEWER */;
-              roles = ["viewer"];
-              break;
-          }
-          eventAppPerms.forEach((perm) => {
-            if (perm.permission) {
-              permissions[perm.permission] = true;
-            }
-          });
-          const basePermissions = ["read"];
-          if (["event_admin", "planner"].includes(role)) {
-            basePermissions.push("create", "update");
-          }
-          if (role === "event_admin") {
-            basePermissions.push("delete");
-          }
-          basePermissions.forEach((operation) => {
-            permissions[`default:${operation}`] = true;
-          });
-        }
-        const orgPerms = rbacData.filter((p) => p.permission_type === "organisation_access");
-        if (orgPerms.length > 0) {
-          const role = orgPerms[0].role_name;
-          if (role === "org_admin") {
-            access_level = "admin" /* ADMIN */;
-            roles = ["admin"];
-            ["create", "read", "update", "delete"].forEach((operation) => {
-              permissions[`default:${operation}`] = true;
-            });
-          }
-        }
-        return { permissions, roles, access_level };
-      }
-    };
-  }
-});
-
-// src/providers/services/RBACServiceProvider.tsx
-import { createContext as createContext2, useContext as useContext2, useMemo as useMemo2, useEffect as useEffect2 } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-function RBACServiceProvider({
-  children,
-  supabaseClient,
-  user,
-  session,
-  appName
-}) {
-  const rbacService = useMemo2(
-    () => new RBACService(supabaseClient, user, session, appName),
-    [supabaseClient, user, session, appName]
-  );
-  useEffect2(() => {
-    rbacService.updateDependencies(user, session, appName);
-  }, [rbacService, user, session, appName]);
-  useEffect2(() => {
-    rbacService.initialize().catch((error) => {
-      console.error("[RBACServiceProvider] Failed to initialize RBAC service:", error);
-    });
-    return () => {
-      rbacService.cleanup();
-    };
-  }, [rbacService]);
-  const contextValue = useMemo2(() => ({
-    rbacService
-  }), [rbacService]);
-  return /* @__PURE__ */ jsx2(RBACServiceContext.Provider, { value: contextValue, children });
-}
-var RBACServiceContext, useRBACService;
-var init_RBACServiceProvider = __esm({
-  "src/providers/services/RBACServiceProvider.tsx"() {
-    "use strict";
-    init_RBACService();
-    RBACServiceContext = createContext2(null);
-    useRBACService = () => {
-      const context = useContext2(RBACServiceContext);
-      if (!context) {
-        throw new Error("useRBACService must be used within RBACServiceProvider");
-      }
-      return context.rbacService;
-    };
-  }
-});
-
 // src/services/OrganisationService.ts
 var OrganisationService;
 var init_OrganisationService = __esm({
@@ -919,7 +454,6 @@ var init_OrganisationService = __esm({
     "use strict";
     init_BaseService();
     init_organisationContext();
-    init_debugLogger();
     OrganisationService = class extends BaseService {
       constructor(supabaseClient, user, session) {
         super();
@@ -927,7 +461,7 @@ var init_OrganisationService = __esm({
         this._organisations = [];
         this._userMemberships = [];
         this._roleMapState = /* @__PURE__ */ new Map();
-        this._isLoading = true;
+        this._isLoading = false;
         this._error = null;
         this._isContextReady = false;
         this.retryCount = 0;
@@ -1002,13 +536,17 @@ var init_OrganisationService = __esm({
       }
       // Update dependencies
       updateDependencies(user, session) {
+        const wasAuthenticated = !!(this.user && this.session);
+        const isAuthenticated = !!(user && session);
         this.user = user;
         this.session = session;
+        if (wasAuthenticated && !isAuthenticated) {
+          this.isInitialized = false;
+        }
         this.notify();
       }
       // Organisation methods
       async switchOrganisation(orgId) {
-        DebugLogger.log("OrganisationService", "Switching to organisation:", orgId);
         if (!this.validateOrganisationAccess(orgId)) {
           throw new Error(`User does not have access to organisation ${orgId}`);
         }
@@ -1019,7 +557,6 @@ var init_OrganisationService = __esm({
         this._selectedOrganisation = targetOrg;
         localStorage.setItem("pace-core-selected-organisation", JSON.stringify(targetOrg));
         await this.setDatabaseOrganisationContext(targetOrg);
-        DebugLogger.log("OrganisationService", "Switched to organisation:", targetOrg.display_name);
         this.notify();
       }
       getUserRole(orgId) {
@@ -1075,14 +612,15 @@ var init_OrganisationService = __esm({
       // Lifecycle methods
       async initialize() {
         await super.initialize();
-        await this.loadUserOrganisations();
+        if (!this.isLoadingRef) {
+          await this.loadUserOrganisations();
+        }
       }
       cleanup() {
         this.isLoadingRef = false;
         this.hasFailedRef = false;
         this.lastLoadTimeRef = 0;
         if (this.abortControllerRef) {
-          this.abortControllerRef.abort();
           this.abortControllerRef = null;
         }
         this._selectedOrganisation = null;
@@ -1106,13 +644,18 @@ var init_OrganisationService = __esm({
           return;
         }
         try {
-          await setOrganisationContext(this.supabaseClient, organisation.id);
-          DebugLogger.log("OrganisationService", "Database organisation context set to:", organisation.display_name);
+          console.log("[OrganisationService] Setting database organisation context for:", organisation.id);
+          const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error("Context setting timeout after 5 seconds")), 5e3);
+          });
+          const contextPromise = setOrganisationContext(this.supabaseClient, organisation.id);
+          await Promise.race([contextPromise, timeoutPromise]);
+          console.log("[OrganisationService] Database organisation context set successfully");
           this._isContextReady = true;
           this.notify();
         } catch (error) {
           console.error("[OrganisationService] Failed to set database organisation context:", error);
-          this._isContextReady = false;
+          this._isContextReady = true;
           this.notify();
         }
       }
@@ -1120,7 +663,6 @@ var init_OrganisationService = __esm({
         const callId = Math.random().toString(36).substr(2, 9);
         console.log(`[OrganisationService] Starting loadUserOrganisations call ${callId}`);
         if (!this.user || !this.session || !this.supabaseClient) {
-          DebugLogger.log("OrganisationService", "Clearing organisation state - no user, session, or supabase client");
           this._selectedOrganisation = null;
           this._organisations = [];
           this._userMemberships = [];
@@ -1131,11 +673,19 @@ var init_OrganisationService = __esm({
         }
         if (this.isLoadingRef) {
           console.log("OrganisationService", "Already loading, skipping duplicate load");
+          this._isLoading = true;
+          this.notify();
           return;
         }
         const now = Date.now();
         if (now - this.lastLoadTimeRef < 2e3) {
           console.log("OrganisationService", "Too soon since last load, skipping");
+          if (this._organisations.length > 0 || this._selectedOrganisation) {
+            this._isLoading = false;
+          } else {
+            this._isLoading = true;
+          }
+          this.notify();
           return;
         }
         if (this.abortControllerRef) {
@@ -1149,7 +699,6 @@ var init_OrganisationService = __esm({
         this._error = null;
         this.notify();
         try {
-          DebugLogger.log("OrganisationService", "Loading organisations for user:", this.user.id);
           console.log("[OrganisationService] Supabase client ready:", {
             isConnected: !!this.supabaseClient,
             hasAuth: !!this.supabaseClient.auth,
@@ -1234,7 +783,6 @@ var init_OrganisationService = __esm({
               throw membershipError;
             }
           }
-          DebugLogger.log("OrganisationService", "Raw memberships data:", memberships);
           if (!memberships || memberships.length === 0) {
             throw new Error("User has no active organisation memberships");
           }
@@ -1258,7 +806,6 @@ var init_OrganisationService = __esm({
             console.warn("[OrganisationService] No valid organisation IDs found in memberships:", memberships);
             throw new Error("No valid organisation IDs found in memberships");
           }
-          DebugLogger.log("OrganisationService", "Valid organisation IDs:", organisationIds);
           if (abortSignal.aborted) {
             throw new Error("Request aborted");
           }
@@ -1279,7 +826,6 @@ var init_OrganisationService = __esm({
           if (activeOrgs.length === 0) {
             throw new Error("User has no access to active organisations");
           }
-          DebugLogger.log("OrganisationService", "Active organisations:", activeOrgs);
           this._organisations = activeOrgs;
           this._userMemberships = memberships;
           this._roleMapState = roleMap;
@@ -1292,7 +838,6 @@ var init_OrganisationService = __esm({
                 const validPersistedOrg = activeOrgs.find((org) => org.id === persistedOrg.id);
                 if (validPersistedOrg) {
                   initialOrg = validPersistedOrg;
-                  DebugLogger.log("OrganisationService", "Restored persisted organisation:", initialOrg.display_name);
                 } else {
                   console.warn("[OrganisationService] Persisted organisation not found in active orgs, clearing cache");
                   localStorage.removeItem("pace-core-selected-organisation");
@@ -1312,24 +857,18 @@ var init_OrganisationService = __esm({
               const foundOrg = organisations.find((org) => org.id === adminMembership.organisation_id);
               if (foundOrg) {
                 initialOrg = foundOrg;
-                DebugLogger.log("OrganisationService", "Selected org_admin organisation:", initialOrg.display_name);
               }
             }
           }
           if (!initialOrg) {
             initialOrg = activeOrgs[0];
-            DebugLogger.log("OrganisationService", "Selected first organisation:", initialOrg.display_name);
           }
           if (!initialOrg) {
             throw new Error("No valid organisation found for user");
           }
           this._selectedOrganisation = initialOrg;
           localStorage.setItem("pace-core-selected-organisation", JSON.stringify(initialOrg));
-          DebugLogger.log("OrganisationService", "Organisation context established:", {
-            selectedOrganisation: initialOrg.display_name,
-            totalOrganisations: activeOrgs.length,
-            userRole: roleMap.get(initialOrg.id)
-          });
+          await this.setDatabaseOrganisationContext(initialOrg);
           this.retryCount = 0;
           this.hasFailedRef = false;
         } catch (err) {
@@ -1360,42 +899,44 @@ var init_OrganisationService = __esm({
 });
 
 // src/providers/services/OrganisationServiceProvider.tsx
-import { createContext as createContext3, useContext as useContext3, useMemo as useMemo3, useEffect as useEffect3 } from "react";
-import { jsx as jsx3 } from "react/jsx-runtime";
+import { createContext as createContext2, useContext as useContext2, useMemo as useMemo2, useEffect as useEffect2, useRef } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
 function OrganisationServiceProvider({
   children,
   supabaseClient,
   user,
   session
 }) {
-  const organisationService = useMemo3(
-    () => new OrganisationService(supabaseClient, user, session),
-    [supabaseClient, user, session]
-  );
-  useEffect3(() => {
+  const organisationServiceRef = useRef(null);
+  if (!organisationServiceRef.current) {
+    organisationServiceRef.current = new OrganisationService(supabaseClient, user, session);
+  }
+  const organisationService = organisationServiceRef.current;
+  useEffect2(() => {
     organisationService.updateDependencies(user, session);
-  }, [organisationService, user, session]);
-  useEffect3(() => {
+    let isMounted = true;
     organisationService.initialize().catch((error) => {
-      console.error("[OrganisationServiceProvider] Failed to initialize organisation service:", error);
+      if (isMounted) {
+        console.error("[OrganisationServiceProvider] Failed to initialize organisation service:", error);
+      }
     });
     return () => {
-      organisationService.cleanup();
+      isMounted = false;
     };
-  }, [organisationService]);
-  const contextValue = useMemo3(() => ({
+  }, [organisationService, user, session]);
+  const contextValue = useMemo2(() => ({
     organisationService
   }), [organisationService]);
-  return /* @__PURE__ */ jsx3(OrganisationServiceContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx2(OrganisationServiceContext.Provider, { value: contextValue, children });
 }
 var OrganisationServiceContext, useOrganisationService;
 var init_OrganisationServiceProvider = __esm({
   "src/providers/services/OrganisationServiceProvider.tsx"() {
     "use strict";
     init_OrganisationService();
-    OrganisationServiceContext = createContext3(null);
+    OrganisationServiceContext = createContext2(null);
     useOrganisationService = () => {
-      const context = useContext3(OrganisationServiceContext);
+      const context = useContext2(OrganisationServiceContext);
       if (!context) {
         throw new Error("useOrganisationService must be used within OrganisationServiceProvider");
       }
@@ -1410,13 +951,13 @@ var init_EventService = __esm({
   "src/services/EventService.ts"() {
     "use strict";
     init_BaseService();
-    init_debugLogger();
     EventService = class extends BaseService {
       constructor(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId) {
         super();
         this.events = [];
         this.selectedEvent = null;
-        this._isLoading = true;
+        this._isLoading = false;
+        // Start as false to avoid blocking UI
         this.error = null;
         // Dependencies
         this.supabaseClient = null;
@@ -1439,12 +980,23 @@ var init_EventService = __esm({
       }
       // Update dependencies
       updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId) {
+        const previousOrgId = this.selectedOrganisation?.id;
+        const newOrgId = selectedOrganisation?.id;
         this.supabaseClient = supabaseClient;
         this.user = user;
         this.session = session;
         this.appName = appName;
         this.selectedOrganisation = selectedOrganisation;
         this.setSelectedEventId = setSelectedEventId;
+        if (previousOrgId !== newOrgId) {
+          this.resetInitialization();
+          this.isInitializedRef = false;
+          this.isFetchingRef = false;
+          if (previousOrgId !== null && newOrgId !== previousOrgId) {
+            this.events = [];
+            this.selectedEvent = null;
+          }
+        }
         this.notify();
       }
       // Event state getters
@@ -1514,12 +1066,10 @@ var init_EventService = __esm({
           if (persistedEventId && events.length > 0) {
             const persistedEvent = events.find((event) => event.event_id === persistedEventId);
             if (persistedEvent) {
-              DebugLogger.log("EventService", "Restoring persisted event:", persistedEvent.event_name);
               this.selectedEvent = persistedEvent;
               this.setSelectedEventId?.(persistedEventId);
               return true;
             } else {
-              DebugLogger.log("EventService", "Persisted event not found in current events, clearing storage");
               sessionStorage.removeItem("pace-core-selected-event");
               localStorage.removeItem("pace-core-selected-event");
             }
@@ -1550,7 +1100,6 @@ var init_EventService = __esm({
       autoSelectNextEvent(events) {
         const nextEvent = this.getNextEventByDate(events);
         if (nextEvent) {
-          DebugLogger.log("EventService", "Auto-selecting next event:", nextEvent.event_name);
           this.selectedEvent = nextEvent;
           this.setSelectedEventId?.(nextEvent.event_id);
           this.persistEventSelection(nextEvent.event_id);
@@ -1571,40 +1120,22 @@ var init_EventService = __esm({
       }
       async fetchEvents() {
         if (!this.user || !this.session || !this.supabaseClient || !this.appName || !this.selectedOrganisation) {
-          DebugLogger.log("EventService", "Missing required dependencies, skipping fetch");
-          this._isLoading = false;
           this.notify();
           return;
         }
+        this._isLoading = true;
+        this.notify();
         if (this.isFetchingRef) {
-          DebugLogger.log("EventService", "Already fetching events, skipping");
           return;
         }
-        DebugLogger.log("EventService", "User and organisation found, fetching events for:", {
-          userId: this.user.id,
-          appName: this.appName,
-          organisationId: this.selectedOrganisation.id,
-          organisationName: this.selectedOrganisation.display_name
-        });
         this.isFetchingRef = true;
         let isMounted = true;
         try {
-          DebugLogger.log("EventService", "Calling data_user_events_get RPC with:", {
-            user_id: this.user.id,
-            organisation_id: this.selectedOrganisation.id,
-            app_name: this.appName
-          });
           const { data, error: rpcError } = await this.supabaseClient.rpc("data_user_events_get", {
             p_user_id: this.user.id,
             p_organisation_id: this.selectedOrganisation.id,
             p_app_name: this.appName
           });
-          DebugLogger.log("EventService", "RPC response:", {
-            data,
-            error: rpcError,
-            dataLength: data?.length || 0,
-            organisationId: this.selectedOrganisation.id
-          });
           if (rpcError) {
             throw new Error(rpcError.message || "Failed to fetch events");
           }
@@ -1640,7 +1171,6 @@ var init_EventService = __esm({
             if (!persistedEventLoaded && !this.userClearedEventRef) {
               const nextEvent = this.getNextEventByDate(transformedEvents);
               if (nextEvent) {
-                DebugLogger.log("EventService", "Auto-selecting next event after no persisted event found:", nextEvent.event_name);
                 this.hasAutoSelectedRef = true;
                 this.selectedEvent = nextEvent;
                 this.setSelectedEventId?.(nextEvent.event_id);
@@ -1689,8 +1219,8 @@ var init_EventService = __esm({
 });
 
 // src/providers/services/EventServiceProvider.tsx
-import { createContext as createContext4, useContext as useContext4, useMemo as useMemo4, useEffect as useEffect4 } from "react";
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { createContext as createContext3, useContext as useContext3, useMemo as useMemo3, useEffect as useEffect3, useRef as useRef2 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
 function EventServiceProvider({
   children,
   supabaseClient,
@@ -1700,34 +1230,36 @@ function EventServiceProvider({
   selectedOrganisation,
   setSelectedEventId
 }) {
-  const eventService = useMemo4(
-    () => new EventService(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId),
-    [supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]
-  );
-  useEffect4(() => {
+  const eventServiceRef = useRef2(null);
+  if (!eventServiceRef.current) {
+    eventServiceRef.current = new EventService(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
+  }
+  const eventService = eventServiceRef.current;
+  useEffect3(() => {
     eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
-  }, [eventService, supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
-  useEffect4(() => {
+    let isMounted = true;
     eventService.initialize().catch((error) => {
-      console.error("[EventServiceProvider] Failed to initialize event service:", error);
+      if (isMounted) {
+        console.error("[EventServiceProvider] Failed to initialize event service:", error);
+      }
     });
     return () => {
-      eventService.cleanup();
+      isMounted = false;
     };
-  }, [eventService]);
-  const contextValue = useMemo4(() => ({
+  }, [eventService, supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
+  const contextValue = useMemo3(() => ({
     eventService
   }), [eventService]);
-  return /* @__PURE__ */ jsx4(EventServiceContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx3(EventServiceContext.Provider, { value: contextValue, children });
 }
 var EventServiceContext, useEventService;
 var init_EventServiceProvider = __esm({
   "src/providers/services/EventServiceProvider.tsx"() {
     "use strict";
     init_EventService();
-    EventServiceContext = createContext4(null);
+    EventServiceContext = createContext3(null);
     useEventService = () => {
-      const context = useContext4(EventServiceContext);
+      const context = useContext3(EventServiceContext);
       if (!context) {
         throw new Error("useEventService must be used within EventServiceProvider");
       }
@@ -2051,8 +1583,8 @@ var init_InactivityService = __esm({
 });
 
 // src/providers/services/InactivityServiceProvider.tsx
-import { createContext as createContext5, useContext as useContext5, useMemo as useMemo5, useEffect as useEffect5 } from "react";
-import { jsx as jsx5 } from "react/jsx-runtime";
+import { createContext as createContext4, useContext as useContext4, useMemo as useMemo4, useEffect as useEffect4, useRef as useRef3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
 function InactivityServiceProvider({
   children,
   supabaseClient,
@@ -2062,34 +1594,36 @@ function InactivityServiceProvider({
   warnBeforeMs = 60 * 1e3,
   onIdleLogout
 }) {
-  const inactivityService = useMemo5(
-    () => new InactivityService(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout),
-    [supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout]
-  );
-  useEffect5(() => {
+  const inactivityServiceRef = useRef3(null);
+  if (!inactivityServiceRef.current) {
+    inactivityServiceRef.current = new InactivityService(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout);
+  }
+  const inactivityService = inactivityServiceRef.current;
+  useEffect4(() => {
     inactivityService.updateDependencies(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout);
-  }, [inactivityService, supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout]);
-  useEffect5(() => {
+    let isMounted = true;
     inactivityService.initialize().catch((error) => {
-      console.error("[InactivityServiceProvider] Failed to initialize inactivity service:", error);
+      if (isMounted) {
+        console.error("[InactivityServiceProvider] Failed to initialize inactivity service:", error);
+      }
     });
     return () => {
-      inactivityService.cleanup();
+      isMounted = false;
     };
-  }, [inactivityService]);
-  const contextValue = useMemo5(() => ({
+  }, [inactivityService, supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout]);
+  const contextValue = useMemo4(() => ({
     inactivityService
   }), [inactivityService]);
-  return /* @__PURE__ */ jsx5(InactivityServiceContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx4(InactivityServiceContext.Provider, { value: contextValue, children });
 }
 var InactivityServiceContext, useInactivityService;
 var init_InactivityServiceProvider = __esm({
   "src/providers/services/InactivityServiceProvider.tsx"() {
     "use strict";
     init_InactivityService();
-    InactivityServiceContext = createContext5(null);
+    InactivityServiceContext = createContext4(null);
     useInactivityService = () => {
-      const context = useContext5(InactivityServiceContext);
+      const context = useContext4(InactivityServiceContext);
       if (!context) {
         throw new Error("useInactivityService must be used within InactivityServiceProvider");
       }
@@ -2099,14 +1633,14 @@ var init_InactivityServiceProvider = __esm({
 });
 
 // src/hooks/services/useAuthService.ts
-import { useContext as useContext6, useReducer, useEffect as useEffect6 } from "react";
+import { useContext as useContext5, useReducer, useEffect as useEffect5 } from "react";
 function useAuthService2() {
-  const context = useContext6(AuthServiceContext);
+  const context = useContext5(AuthServiceContext);
   if (!context) {
     throw new Error("useAuthService must be used within AuthServiceProvider");
   }
   const [, forceUpdate] = useReducer((x) => x + 1, 0);
-  useEffect6(() => {
+  useEffect5(() => {
     return context.authService.subscribe(() => forceUpdate());
   }, [context.authService]);
   return context.authService;
@@ -2118,35 +1652,15 @@ var init_useAuthService = __esm({
   }
 });
 
-// src/hooks/services/useRBACService.ts
-import { useContext as useContext7, useReducer as useReducer2, useEffect as useEffect7 } from "react";
-function useRBACService2() {
-  const context = useContext7(RBACServiceContext);
-  if (!context) {
-    throw new Error("useRBACService must be used within RBACServiceProvider");
-  }
-  const [, forceUpdate] = useReducer2((x) => x + 1, 0);
-  useEffect7(() => {
-    return context.rbacService.subscribe(() => forceUpdate());
-  }, [context.rbacService]);
-  return context.rbacService;
-}
-var init_useRBACService = __esm({
-  "src/hooks/services/useRBACService.ts"() {
-    "use strict";
-    init_RBACServiceProvider();
-  }
-});
-
 // src/hooks/services/useOrganisationService.ts
-import { useContext as useContext8, useReducer as useReducer3, useEffect as useEffect8 } from "react";
+import { useContext as useContext6, useReducer as useReducer2, useEffect as useEffect6 } from "react";
 function useOrganisationService2() {
-  const context = useContext8(OrganisationServiceContext);
+  const context = useContext6(OrganisationServiceContext);
   if (!context) {
     throw new Error("useOrganisationService must be used within OrganisationServiceProvider");
   }
-  const [, forceUpdate] = useReducer3((x) => x + 1, 0);
-  useEffect8(() => {
+  const [, forceUpdate] = useReducer2((x) => x + 1, 0);
+  useEffect6(() => {
     return context.organisationService.subscribe(() => forceUpdate());
   }, [context.organisationService]);
   return context.organisationService;
@@ -2159,14 +1673,14 @@ var init_useOrganisationService = __esm({
 });
 
 // src/hooks/services/useEventService.ts
-import { useContext as useContext9, useReducer as useReducer4, useEffect as useEffect9 } from "react";
+import { useContext as useContext7, useReducer as useReducer3, useEffect as useEffect7 } from "react";
 function useEventService2() {
-  const context = useContext9(EventServiceContext);
+  const context = useContext7(EventServiceContext);
   if (!context) {
     throw new Error("useEventService must be used within EventServiceProvider");
   }
-  const [, forceUpdate] = useReducer4((x) => x + 1, 0);
-  useEffect9(() => {
+  const [, forceUpdate] = useReducer3((x) => x + 1, 0);
+  useEffect7(() => {
     return context.eventService.subscribe(() => forceUpdate());
   }, [context.eventService]);
   return context.eventService;
@@ -2179,14 +1693,14 @@ var init_useEventService = __esm({
 });
 
 // src/hooks/services/useInactivityService.ts
-import { useContext as useContext10, useReducer as useReducer5, useEffect as useEffect10 } from "react";
+import { useContext as useContext8, useReducer as useReducer4, useEffect as useEffect8 } from "react";
 function useInactivityService2() {
-  const context = useContext10(InactivityServiceContext);
+  const context = useContext8(InactivityServiceContext);
   if (!context) {
     throw new Error("useInactivityService must be used within InactivityServiceProvider");
   }
-  const [, forceUpdate] = useReducer5((x) => x + 1, 0);
-  useEffect10(() => {
+  const [, forceUpdate] = useReducer4((x) => x + 1, 0);
+  useEffect8(() => {
     return context.inactivityService.subscribe(() => forceUpdate());
   }, [context.inactivityService]);
   return context.inactivityService;
@@ -2199,113 +1713,149 @@ var init_useInactivityService = __esm({
 });
 
 // src/providers/services/UnifiedAuthProvider.tsx
-import { createContext as createContext6, useContext as useContext11, useMemo as useMemo6 } from "react";
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { createContext as createContext5, useContext as useContext9, useMemo as useMemo5 } from "react";
+import { Fragment, jsx as jsx5 } from "react/jsx-runtime";
 function UnifiedAuthContextProvider({
   children,
   appName,
+  appConfig = { requires_event: true },
+  // Default to requiring events
   ...props
 }) {
   const authService = useAuthService2();
-  const rbacService = useRBACService2();
   const organisationService = useOrganisationService2();
-  const eventService = useEventService2();
   const inactivityService = useInactivityService2();
-  const contextValue = useMemo6(() => ({
-    // Auth state
-    user: authService.getUser(),
-    session: authService.getSession(),
-    isAuthenticated: authService.isAuthenticated(),
-    authLoading: authService.isLoading(),
-    authError: authService.getError(),
-    error: authService.getError(),
-    // Alias for backward compatibility
-    supabase: authService.getSupabaseClient(),
-    // Auth methods
-    signIn: authService.signIn.bind(authService),
-    signUp: authService.signUp.bind(authService),
-    signOut: authService.signOut.bind(authService),
-    resetPassword: authService.resetPassword.bind(authService),
-    updatePassword: authService.updatePassword.bind(authService),
-    refreshSession: authService.refreshSession.bind(authService),
-    // RBAC state
-    permissions: rbacService.getPermissions(),
-    roles: rbacService.getRoles(),
-    accessLevel: rbacService.getAccessLevel(),
-    rbacLoading: rbacService.isLoading(),
-    rbacError: rbacService.getError(),
-    selectedEventId: rbacService.getSelectedEventId(),
-    appConfig: rbacService.getAppConfig(),
-    userEventAccess: rbacService.getUserEventAccess(),
-    eventAccessLoading: rbacService.isEventAccessLoading(),
-    selectedOrganisationId: rbacService.getSelectedOrganisationId(),
-    // RBAC methods
-    hasPermission: rbacService.hasPermission.bind(rbacService),
-    hasAnyPermission: rbacService.hasAnyPermission.bind(rbacService),
-    hasAllPermissions: rbacService.hasAllPermissions.bind(rbacService),
-    hasRole: rbacService.hasRole.bind(rbacService),
-    hasAccessLevel: rbacService.hasAccessLevel.bind(rbacService),
-    canAccess: rbacService.canAccess.bind(rbacService),
-    validatePermission: rbacService.validatePermission.bind(rbacService),
-    validateAccess: rbacService.validateAccess.bind(rbacService),
-    refreshPermissions: rbacService.refreshPermissions.bind(rbacService),
-    setSelectedEventId: rbacService.setSelectedEventId.bind(rbacService),
-    loadUserEventAccess: rbacService.loadUserEventAccess.bind(rbacService),
-    getUserEventAccess: rbacService.getUserEventAccess.bind(rbacService),
-    requireOrganisationContext: rbacService.requireOrganisationContext.bind(rbacService),
-    // Organisation state
-    selectedOrganisation: organisationService.getSelectedOrganisation(),
-    organisations: organisationService.getOrganisations(),
-    userMemberships: organisationService.getUserMemberships(),
-    organisationLoading: organisationService.isLoading(),
-    organisationError: organisationService.getError(),
-    hasValidOrganisationContext: organisationService.hasValidOrganisationContext(),
-    isContextReady: organisationService.isContextReady(),
-    // Organisation methods
-    switchOrganisation: organisationService.switchOrganisation.bind(organisationService),
-    getUserRole: organisationService.getUserRole.bind(organisationService),
-    validateOrganisationAccess: organisationService.validateOrganisationAccess.bind(organisationService),
-    refreshOrganisations: organisationService.refreshOrganisations.bind(organisationService),
-    ensureOrganisationContext: organisationService.ensureOrganisationContext.bind(organisationService),
-    isOrganisationSecure: organisationService.isOrganisationSecure.bind(organisationService),
-    getPrimaryOrganisation: organisationService.getPrimaryOrganisation.bind(organisationService),
-    // Event state
-    events: eventService.getEvents(),
-    selectedEvent: eventService.getSelectedEvent(),
-    eventLoading: eventService.isLoading(),
-    eventError: eventService.getError(),
-    // Event methods
-    setSelectedEvent: eventService.setSelectedEvent.bind(eventService),
-    refreshEvents: eventService.refreshEvents.bind(eventService),
-    // Inactivity state
-    showInactivityWarning: inactivityService.getShowInactivityWarning(),
-    inactivityTimeRemaining: inactivityService.getInactivityTimeRemaining(),
-    isIdle: inactivityService.isIdle(),
-    timeRemaining: inactivityService.getTimeRemaining(),
-    showWarning: inactivityService.isWarningShown(),
-    isTracking: inactivityService.isTracking(),
-    // Inactivity methods
-    resetActivity: inactivityService.resetActivity.bind(inactivityService),
-    startTracking: inactivityService.startTracking.bind(inactivityService),
-    stopTracking: inactivityService.stopTracking.bind(inactivityService),
-    handleIdleLogout: inactivityService.handleIdleLogout.bind(inactivityService),
-    handleStaySignedIn: inactivityService.handleStaySignedIn.bind(inactivityService),
-    handleSignOutNow: inactivityService.handleSignOutNow.bind(inactivityService),
-    // Additional unified properties
-    appName,
-    isLoading: authService.isLoading() || rbacService.isLoading() || organisationService.isLoading() || eventService.isLoading(),
-    hasErrors: !!(authService.getError() || rbacService.getError() || organisationService.getError() || eventService.getError())
-  }), [authService, rbacService, organisationService, eventService, inactivityService, appName]);
-  return /* @__PURE__ */ jsx6(UnifiedAuthContext.Provider, { value: contextValue, children });
+  let eventService;
+  try {
+    eventService = useEventService2();
+  } catch (error) {
+    eventService = {
+      getEvents: () => [],
+      getSelectedEvent: () => null,
+      isLoading: () => false,
+      getError: () => null,
+      setSelectedEvent: () => {
+      },
+      refreshEvents: async () => {
+      }
+    };
+  }
+  const currentUser = authService.getUser();
+  const currentSession = authService.getSession();
+  const isAuth = !!(currentUser && currentSession);
+  const authLoading = authService.isLoading();
+  const orgLoading = organisationService.isLoading();
+  const eventLoading = eventService.isLoading();
+  const totalLoading = authLoading || orgLoading || eventLoading;
+  console.log("[UnifiedAuthContext] Auth state:", {
+    isAuthenticated: isAuth,
+    user: currentUser?.email,
+    session: currentSession ? "exists" : "null",
+    totalLoading,
+    authLoading,
+    orgLoading,
+    eventLoading,
+    orgContextReady: organisationService.isContextReady()
+  });
+  const contextValue = useMemo5(() => {
+    return {
+      // Auth state
+      user: currentUser,
+      session: currentSession,
+      isAuthenticated: isAuth,
+      authLoading,
+      authError: authService.getError(),
+      error: authService.getError(),
+      // Alias for backward compatibility
+      supabase: authService.getSupabaseClient(),
+      // Auth methods
+      signIn: authService.signIn.bind(authService),
+      signUp: authService.signUp.bind(authService),
+      signOut: authService.signOut.bind(authService),
+      resetPassword: authService.resetPassword.bind(authService),
+      updatePassword: authService.updatePassword.bind(authService),
+      refreshSession: authService.refreshSession.bind(authService),
+      // Organisation state
+      selectedOrganisation: organisationService.getSelectedOrganisation(),
+      organisations: organisationService.getOrganisations(),
+      userMemberships: organisationService.getUserMemberships(),
+      organisationLoading: orgLoading,
+      organisationError: organisationService.getError(),
+      hasValidOrganisationContext: organisationService.hasValidOrganisationContext(),
+      isContextReady: organisationService.isContextReady(),
+      // Organisation methods
+      switchOrganisation: organisationService.switchOrganisation.bind(organisationService),
+      getUserRole: organisationService.getUserRole.bind(organisationService),
+      validateOrganisationAccess: organisationService.validateOrganisationAccess.bind(organisationService),
+      refreshOrganisations: organisationService.refreshOrganisations.bind(organisationService),
+      ensureOrganisationContext: organisationService.ensureOrganisationContext.bind(organisationService),
+      isOrganisationSecure: organisationService.isOrganisationSecure.bind(organisationService),
+      getPrimaryOrganisation: organisationService.getPrimaryOrganisation.bind(organisationService),
+      // Event state
+      events: eventService.getEvents(),
+      selectedEvent: eventService.getSelectedEvent(),
+      eventLoading,
+      eventError: eventService.getError(),
+      // Event methods
+      setSelectedEvent: eventService.setSelectedEvent.bind(eventService),
+      refreshEvents: eventService.refreshEvents.bind(eventService),
+      // Inactivity state
+      showInactivityWarning: inactivityService.getShowInactivityWarning(),
+      inactivityTimeRemaining: inactivityService.getInactivityTimeRemaining(),
+      isIdle: inactivityService.isIdle(),
+      timeRemaining: inactivityService.getTimeRemaining(),
+      showWarning: inactivityService.isWarningShown(),
+      isTracking: inactivityService.isTracking(),
+      // Inactivity methods
+      resetActivity: inactivityService.resetActivity.bind(inactivityService),
+      startTracking: inactivityService.startTracking.bind(inactivityService),
+      stopTracking: inactivityService.stopTracking.bind(inactivityService),
+      handleIdleLogout: inactivityService.handleIdleLogout.bind(inactivityService),
+      handleStaySignedIn: inactivityService.handleStaySignedIn.bind(inactivityService),
+      handleSignOutNow: inactivityService.handleSignOutNow.bind(inactivityService),
+      // Additional unified properties
+      appName,
+      appConfig,
+      isLoading: totalLoading,
+      hasErrors: !!(authService.getError() || organisationService.getError() || eventService.getError())
+    };
+  }, [authService, organisationService, eventService, inactivityService, appName, appConfig, currentUser, currentSession, isAuth, authLoading, orgLoading, eventLoading, totalLoading]);
+  return /* @__PURE__ */ jsx5(UnifiedAuthContext.Provider, { value: contextValue, children });
+}
+function EventServiceProviderWrapper({
+  children,
+  supabaseClient,
+  user,
+  session,
+  appName
+}) {
+  const organisationService = useOrganisationService2();
+  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  if (!user || !session) {
+    return /* @__PURE__ */ jsx5(Fragment, { children });
+  }
+  return /* @__PURE__ */ jsx5(
+    EventServiceProvider,
+    {
+      supabaseClient,
+      user,
+      session,
+      appName,
+      selectedOrganisation,
+      setSelectedEventId: () => {
+      },
+      children
+    }
+  );
 }
 function ServiceAwareProviders({
   children,
   supabaseClient,
   appName,
+  appConfig,
   persistState,
   enablePersistence,
   requireOrganisationContext,
-  enableRBAC,
   idleTimeoutMs,
   warnBeforeMs,
   onIdleLogout,
@@ -2313,55 +1863,43 @@ function ServiceAwareProviders({
   dangerouslyDisableInactivity
 }) {
   const authService = useAuthService2();
-  return /* @__PURE__ */ jsx6(
-    RBACServiceProvider,
+  return /* @__PURE__ */ jsx5(
+    OrganisationServiceProvider,
     {
       supabaseClient,
       user: authService.getUser(),
       session: authService.getSession(),
-      appName,
-      children: /* @__PURE__ */ jsx6(
-        OrganisationServiceProvider,
+      children: /* @__PURE__ */ jsx5(
+        EventServiceProviderWrapper,
         {
           supabaseClient,
           user: authService.getUser(),
           session: authService.getSession(),
-          children: /* @__PURE__ */ jsx6(
-            EventServiceProvider,
+          appName,
+          children: /* @__PURE__ */ jsx5(
+            InactivityServiceProvider,
             {
               supabaseClient,
               user: authService.getUser(),
               session: authService.getSession(),
-              appName,
-              selectedOrganisation: null,
-              setSelectedEventId: (eventId) => {
-              },
-              children: /* @__PURE__ */ jsx6(
-                InactivityServiceProvider,
+              idleTimeoutMs,
+              warnBeforeMs,
+              onIdleLogout,
+              children: /* @__PURE__ */ jsx5(
+                UnifiedAuthContextProvider,
                 {
+                  appName,
+                  appConfig,
                   supabaseClient,
-                  user: authService.getUser(),
-                  session: authService.getSession(),
+                  persistState,
+                  enablePersistence,
+                  requireOrganisationContext,
                   idleTimeoutMs,
                   warnBeforeMs,
                   onIdleLogout,
-                  children: /* @__PURE__ */ jsx6(
-                    UnifiedAuthContextProvider,
-                    {
-                      appName,
-                      supabaseClient,
-                      persistState,
-                      enablePersistence,
-                      requireOrganisationContext,
-                      enableRBAC,
-                      idleTimeoutMs,
-                      warnBeforeMs,
-                      onIdleLogout,
-                      renderInactivityWarning,
-                      dangerouslyDisableInactivity,
-                      children
-                    }
-                  )
+                  renderInactivityWarning,
+                  dangerouslyDisableInactivity,
+                  children
                 }
               )
             }
@@ -2375,10 +1913,11 @@ function UnifiedAuthProvider({
   children,
   supabaseClient,
   appName,
+  appConfig = { requires_event: true },
+  // Default to requiring events
   persistState = true,
   enablePersistence,
   requireOrganisationContext = true,
-  enableRBAC = false,
   idleTimeoutMs = 30 * 60 * 1e3,
   // 30 minutes
   warnBeforeMs = 60 * 1e3,
@@ -2387,15 +1926,15 @@ function UnifiedAuthProvider({
   renderInactivityWarning,
   dangerouslyDisableInactivity = false
 }) {
-  return /* @__PURE__ */ jsx6(AuthServiceProvider, { supabaseClient, children: /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsx5(AuthServiceProvider, { supabaseClient, children: /* @__PURE__ */ jsx5(
     ServiceAwareProviders,
     {
       supabaseClient,
       appName,
+      appConfig,
       persistState,
       enablePersistence,
       requireOrganisationContext,
-      enableRBAC,
       idleTimeoutMs,
       warnBeforeMs,
       onIdleLogout,
@@ -2410,18 +1949,16 @@ var init_UnifiedAuthProvider = __esm({
   "src/providers/services/UnifiedAuthProvider.tsx"() {
     "use strict";
     init_AuthServiceProvider();
-    init_RBACServiceProvider();
     init_OrganisationServiceProvider();
     init_EventServiceProvider();
     init_InactivityServiceProvider();
     init_useAuthService();
-    init_useRBACService();
     init_useOrganisationService();
     init_useEventService();
     init_useInactivityService();
-    UnifiedAuthContext = createContext6(void 0);
+    UnifiedAuthContext = createContext5(void 0);
     useUnifiedAuth = () => {
-      const context = useContext11(UnifiedAuthContext);
+      const context = useContext9(UnifiedAuthContext);
       if (!context) {
         throw new Error("useUnifiedAuth must be used within a UnifiedAuthProvider");
       }
@@ -2435,10 +1972,6 @@ export {
   AuthServiceProvider,
   useAuthService,
   init_AuthServiceProvider,
-  RBACServiceContext,
-  RBACServiceProvider,
-  useRBACService,
-  init_RBACServiceProvider,
   OrganisationServiceContext,
   OrganisationServiceProvider,
   useOrganisationService,
@@ -2453,8 +1986,6 @@ export {
   init_InactivityServiceProvider,
   useAuthService2,
   init_useAuthService,
-  useRBACService2,
-  init_useRBACService,
   useOrganisationService2,
   init_useOrganisationService,
   useEventService2,
@@ -2465,4 +1996,4 @@ export {
   UnifiedAuthProvider,
   init_UnifiedAuthProvider
 };
-//# sourceMappingURL=chunk-WN6XJWOS.js.map
+//# sourceMappingURL=chunk-MNJXXD6C.js.map