@jmruthers/pace-core 0.5.74 → 0.5.75

package/dist/chunk-WN6XJWOS.js

@@ -0,0 +1,2468 @@
+import {
+  AccessLevel,
+  init_unified
+} from "./chunk-ULBI5JGB.js";
+import {
+  DebugLogger,
+  init_debugLogger,
+  init_organisationContext,
+  setOrganisationContext
+} from "./chunk-XLZ7U46Z.js";
+import {
+  __esm
+} from "./chunk-PLDDJCW6.js";
+
+// src/services/base/BaseService.ts
+var BaseService;
+var init_BaseService = __esm({
+  "src/services/base/BaseService.ts"() {
+    "use strict";
+    BaseService = class {
+      constructor() {
+        this.subscribers = [];
+        this.isInitialized = false;
+      }
+      /**
+       * Subscribe to state changes
+       * @param callback Function to call when state changes
+       * @returns Unsubscribe function
+       */
+      subscribe(callback) {
+        this.subscribers.push(callback);
+        return () => {
+          const index = this.subscribers.indexOf(callback);
+          if (index > -1) {
+            this.subscribers.splice(index, 1);
+          }
+        };
+      }
+      /**
+       * Notify all subscribers of state changes
+       * This triggers React re-renders
+       */
+      notify() {
+        this.subscribers.forEach((callback) => {
+          try {
+            callback();
+          } catch (error) {
+            console.error("[BaseService] Error in subscriber callback:", error);
+          }
+        });
+      }
+      /**
+       * Initialize the service
+       * Override in subclasses to implement initialization logic
+       */
+      async initialize() {
+        if (this.isInitialized) {
+          return;
+        }
+        await this.doInitialize();
+        this.isInitialized = true;
+      }
+      /**
+       * Cleanup the service
+       * Override in subclasses to implement cleanup logic
+       */
+      cleanup() {
+        this.subscribers = [];
+        this.doCleanup();
+        this.isInitialized = false;
+      }
+      /**
+       * Check if service is initialized
+       */
+      getInitialized() {
+        return this.isInitialized;
+      }
+    };
+  }
+});
+
+// src/services/AuthService.ts
+import { AuthError } from "@supabase/supabase-js";
+var AuthService;
+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.authError = null;
+        this.supabaseClient = null;
+        this.authStateSubscription = null;
+        this.supabaseClient = supabaseClient;
+      }
+      // Auth state getters
+      getUser() {
+        return this.user;
+      }
+      getSession() {
+        return this.session;
+      }
+      isAuthenticated() {
+        return !!(this.user && this.session);
+      }
+      isLoading() {
+        return this.authLoading;
+      }
+      getError() {
+        return this.authError;
+      }
+      getSupabaseClient() {
+        return this.supabaseClient;
+      }
+      // Auth methods
+      async signIn(email, password) {
+        if (!this.supabaseClient) {
+          const error = new AuthError("Supabase client not available");
+          this.authError = error;
+          this.notify();
+          return { user: null, session: null, error };
+        }
+        try {
+          const { data, error } = await this.supabaseClient.auth.signInWithPassword({
+            email,
+            password: password || ""
+          });
+          if (error) {
+            this.authError = error;
+            this.user = null;
+            this.session = null;
+          } else {
+            this.authError = null;
+            this.user = data.user;
+            this.session = data.session;
+          }
+          this.notify();
+          return { user: data.user, session: data.session, error };
+        } catch (error) {
+          const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
+          this.authError = authError;
+          this.user = null;
+          this.session = null;
+          this.notify();
+          return { user: null, session: null, error: authError };
+        }
+      }
+      async signUp(email, password) {
+        if (!this.supabaseClient) {
+          const error = new AuthError("Supabase client not available");
+          this.authError = error;
+          this.notify();
+          return { user: null, session: null, error };
+        }
+        try {
+          const { data, error } = await this.supabaseClient.auth.signUp({
+            email,
+            password
+          });
+          if (error) {
+            this.authError = error;
+            this.user = null;
+            this.session = null;
+          } else {
+            this.authError = null;
+            this.user = data.user;
+            this.session = data.session;
+          }
+          this.notify();
+          return { user: data.user, session: data.session, error };
+        } catch (error) {
+          const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
+          this.authError = authError;
+          this.user = null;
+          this.session = null;
+          this.notify();
+          return { user: null, session: null, error: authError };
+        }
+      }
+      async signOut() {
+        if (!this.supabaseClient) {
+          const error = new AuthError("Supabase client not available");
+          this.authError = error;
+          this.notify();
+          return { user: null, session: null, error };
+        }
+        try {
+          const { error } = await this.supabaseClient.auth.signOut();
+          if (error) {
+            this.authError = error;
+          } else {
+            this.authError = null;
+            this.user = null;
+            this.session = null;
+          }
+          this.notify();
+          return { user: null, session: null, error };
+        } catch (error) {
+          const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
+          this.authError = authError;
+          this.user = null;
+          this.session = null;
+          this.notify();
+          return { user: null, session: null, error: authError };
+        }
+      }
+      async resetPassword(email) {
+        if (!this.supabaseClient) {
+          const error = new AuthError("Supabase client not available");
+          this.authError = error;
+          this.notify();
+          return { user: null, session: null, error };
+        }
+        try {
+          const { error } = await this.supabaseClient.auth.resetPasswordForEmail(email);
+          if (error) {
+            this.authError = error;
+          } else {
+            this.authError = null;
+          }
+          this.notify();
+          return { user: null, session: null, error };
+        } catch (error) {
+          const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
+          this.authError = authError;
+          this.notify();
+          return { user: null, session: null, error: authError };
+        }
+      }
+      async updatePassword(password) {
+        if (!this.supabaseClient) {
+          const error = new AuthError("Supabase client not available");
+          this.authError = error;
+          this.notify();
+          return { user: null, session: null, error };
+        }
+        try {
+          const { error } = await this.supabaseClient.auth.updateUser({
+            password
+          });
+          if (error) {
+            this.authError = error;
+          } else {
+            this.authError = null;
+          }
+          this.notify();
+          return { user: null, session: null, error };
+        } catch (error) {
+          const authError = error;
+          this.authError = authError;
+          this.notify();
+          return { user: null, session: null, error: authError };
+        }
+      }
+      async refreshSession() {
+        if (!this.supabaseClient) {
+          const error = new AuthError("Supabase client not available");
+          this.authError = error;
+          this.notify();
+          return { user: null, session: null, error };
+        }
+        try {
+          const { data, error } = await this.supabaseClient.auth.refreshSession();
+          if (error) {
+            this.authError = error;
+            this.user = null;
+            this.session = null;
+          } else {
+            this.authError = null;
+            if (data?.user && data?.session) {
+              this.user = data.user;
+              this.session = data.session;
+            } else {
+              this.user = null;
+              this.session = null;
+            }
+          }
+          this.notify();
+          return {
+            user: data?.user && data?.session ? data.user : null,
+            session: data?.session ?? null,
+            error
+          };
+        } catch (error) {
+          const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
+          this.authError = authError;
+          this.user = null;
+          this.session = null;
+          this.notify();
+          return { user: null, session: null, error: authError };
+        }
+      }
+      // Lifecycle methods
+      async initialize() {
+        await super.initialize();
+        await this.setupAuthStateListener();
+        await this.restoreSession();
+      }
+      cleanup() {
+        if (this.authStateSubscription && typeof this.authStateSubscription.unsubscribe === "function") {
+          this.authStateSubscription.unsubscribe();
+          this.authStateSubscription = null;
+        }
+        super.cleanup();
+      }
+      async doInitialize() {
+        this.setupErrorHandlers();
+      }
+      doCleanup() {
+        this.removeErrorHandlers();
+      }
+      async setupAuthStateListener() {
+        if (!this.supabaseClient) {
+          this.authLoading = false;
+          this.notify();
+          return;
+        }
+        try {
+          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;
+                    this.authError = null;
+                  }
+                }
+                this.authLoading = false;
+                this.notify();
+              } catch (error) {
+                console.warn("[AuthService] Error in auth state change handler:", error);
+                this.authLoading = false;
+                this.notify();
+              }
+            }
+          );
+        } catch (error) {
+          console.error("[AuthService] Failed to setup auth state listener:", error);
+          throw error;
+        }
+      }
+      async restoreSession() {
+        if (!this.supabaseClient) {
+          this.authLoading = false;
+          this.notify();
+          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);
+              this.user = currentUser;
+            }
+          }
+          this.authLoading = false;
+          this.notify();
+        } catch (error) {
+          console.error("[AuthService] Error during auth initialization:", error);
+          this.authLoading = false;
+          this.notify();
+        }
+      }
+      setupErrorHandlers() {
+        if (typeof window === "undefined") return;
+        const handleError = (event) => {
+          if (event.error?.message?.includes("AuthSessionMissingError") || event.error?.message?.includes("Auth session missing")) {
+            console.warn("[AuthService] Suppressing AuthSessionMissingError during logout");
+            event.preventDefault();
+            return false;
+          }
+        };
+        const handleUnhandledRejection = (event) => {
+          if (event.reason?.message?.includes("AuthSessionMissingError") || event.reason?.message?.includes("Auth session missing")) {
+            console.warn("[AuthService] Suppressing unhandled AuthSessionMissingError");
+            event.preventDefault();
+            return false;
+          }
+        };
+        window.addEventListener("error", handleError);
+        window.addEventListener("unhandledrejection", handleUnhandledRejection);
+      }
+      removeErrorHandlers() {
+        if (typeof window === "undefined") return;
+      }
+    };
+  }
+});
+
+// src/providers/services/AuthServiceProvider.tsx
+import { createContext, useContext, useMemo, useEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+function AuthServiceProvider({ children, supabaseClient }) {
+  const authService = useMemo(
+    () => new AuthService(supabaseClient),
+    [supabaseClient]
+  );
+  useEffect(() => {
+    authService.initialize().catch((error) => {
+      console.error("[AuthServiceProvider] Failed to initialize auth service:", error);
+    });
+    return () => {
+      authService.cleanup();
+    };
+  }, [authService]);
+  const contextValue = useMemo(() => ({
+    authService
+  }), [authService]);
+  return /* @__PURE__ */ jsx(AuthServiceContext.Provider, { value: contextValue, children });
+}
+var AuthServiceContext, useAuthService;
+var init_AuthServiceProvider = __esm({
+  "src/providers/services/AuthServiceProvider.tsx"() {
+    "use strict";
+    init_AuthService();
+    AuthServiceContext = createContext(null);
+    useAuthService = () => {
+      const context = useContext(AuthServiceContext);
+      if (!context) {
+        throw new Error("useAuthService must be used within AuthServiceProvider");
+      }
+      return context.authService;
+    };
+  }
+});
+
+// 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({
+  "src/services/OrganisationService.ts"() {
+    "use strict";
+    init_BaseService();
+    init_organisationContext();
+    init_debugLogger();
+    OrganisationService = class extends BaseService {
+      constructor(supabaseClient, user, session) {
+        super();
+        this._selectedOrganisation = null;
+        this._organisations = [];
+        this._userMemberships = [];
+        this._roleMapState = /* @__PURE__ */ new Map();
+        this._isLoading = true;
+        this._error = null;
+        this._isContextReady = false;
+        this.retryCount = 0;
+        // Dependencies
+        this.supabaseClient = null;
+        this.user = null;
+        this.session = null;
+        // Internal state management
+        this.isLoadingRef = false;
+        this.lastLoadTimeRef = 0;
+        this.hasFailedRef = false;
+        this.abortControllerRef = null;
+        this.supabaseClient = supabaseClient;
+        this.user = user;
+        this.session = session;
+      }
+      // Interface implementation
+      getSelectedOrganisation() {
+        return this._selectedOrganisation;
+      }
+      getOrganisations() {
+        return this._organisations;
+      }
+      getUserMemberships() {
+        return this._userMemberships;
+      }
+      isLoading() {
+        return this._isLoading;
+      }
+      getError() {
+        return this._error;
+      }
+      hasValidOrganisationContext() {
+        return !!(this._selectedOrganisation && !this._isLoading && !this._error && this._isContextReady);
+      }
+      isContextReady() {
+        return this._isContextReady;
+      }
+      // Additional methods for testing
+      setSelectedOrganisation(organisation) {
+        this._selectedOrganisation = organisation;
+        if (organisation) {
+          localStorage.setItem("pace-core-selected-organisation", JSON.stringify(organisation));
+          this.setDatabaseOrganisationContext(organisation);
+        } else {
+          localStorage.removeItem("pace-core-selected-organisation");
+          this._isContextReady = false;
+        }
+        this.notify();
+      }
+      // For testing: expose dependencies
+      getDependencies() {
+        return {
+          user: this.user,
+          session: this.session,
+          supabaseClient: this.supabaseClient
+        };
+      }
+      // For testing: manually set state
+      setTestState(organisations, memberships, roleMap, selectedOrg = null) {
+        this._organisations = organisations;
+        this._userMemberships = memberships;
+        this._roleMapState = roleMap;
+        if (selectedOrg) {
+          this._selectedOrganisation = selectedOrg;
+        } else if (organisations.length > 0) {
+          this._selectedOrganisation = organisations[0];
+        }
+        this._isLoading = false;
+        this._error = null;
+        this.notify();
+      }
+      // Update dependencies
+      updateDependencies(user, session) {
+        this.user = user;
+        this.session = session;
+        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}`);
+        }
+        const targetOrg = this._organisations.find((org) => org.id === orgId);
+        if (!targetOrg) {
+          throw new Error(`Organisation ${orgId} not found in user's organisations`);
+        }
+        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) {
+        const targetOrgId = orgId || this._selectedOrganisation?.id;
+        if (!targetOrgId) return "no_access";
+        return this._roleMapState.get(targetOrgId) || "no_access";
+      }
+      validateOrganisationAccess(orgId) {
+        return this._userMemberships.some(
+          (m) => m.organisation_id === orgId && m.status === "active" && m.revoked_at === null
+        );
+      }
+      async refreshOrganisations() {
+        if (!this.user || !this.session || !this.supabaseClient) return;
+        this._isLoading = true;
+        this.notify();
+        await this.loadUserOrganisations();
+      }
+      ensureOrganisationContext() {
+        if (!this._selectedOrganisation) {
+          throw new Error("Organisation context is required but not available");
+        }
+        return this._selectedOrganisation;
+      }
+      isOrganisationSecure() {
+        return !!(this._selectedOrganisation && this.user);
+      }
+      getPrimaryOrganisation() {
+        const rolePriority = ["org_admin", "leader", "member"];
+        for (const role of rolePriority) {
+          const membership = this._userMemberships.find((m) => m.role === role);
+          if (membership) {
+            return this._organisations.find((org) => org.id === membership.organisation_id) || null;
+          }
+        }
+        return null;
+      }
+      buildOrganisationHierarchy(orgs) {
+        const orgMap = /* @__PURE__ */ new Map();
+        orgs.forEach((org) => orgMap.set(org.id, org));
+        const roots = [];
+        orgs.forEach((org) => {
+          if (!org.parent_id) {
+            roots.push({
+              organisation: org,
+              children: [],
+              depth: 0
+            });
+          }
+        });
+        return roots;
+      }
+      // Lifecycle methods
+      async initialize() {
+        await super.initialize();
+        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;
+        this._organisations = [];
+        this._userMemberships = [];
+        this._roleMapState = /* @__PURE__ */ new Map();
+        this._isLoading = false;
+        this._error = null;
+        this._isContextReady = false;
+        super.cleanup();
+      }
+      async doInitialize() {
+      }
+      doCleanup() {
+      }
+      async setDatabaseOrganisationContext(organisation) {
+        if (!this.supabaseClient || !this.session) {
+          console.warn("[OrganisationService] No Supabase client or session available for setting organisation context");
+          this._isContextReady = false;
+          this.notify();
+          return;
+        }
+        try {
+          await setOrganisationContext(this.supabaseClient, organisation.id);
+          DebugLogger.log("OrganisationService", "Database organisation context set to:", organisation.display_name);
+          this._isContextReady = true;
+          this.notify();
+        } catch (error) {
+          console.error("[OrganisationService] Failed to set database organisation context:", error);
+          this._isContextReady = false;
+          this.notify();
+        }
+      }
+      async loadUserOrganisations() {
+        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 = [];
+          this._isLoading = false;
+          this._error = null;
+          this.notify();
+          return;
+        }
+        if (this.isLoadingRef) {
+          console.log("OrganisationService", "Already loading, skipping duplicate load");
+          return;
+        }
+        const now = Date.now();
+        if (now - this.lastLoadTimeRef < 2e3) {
+          console.log("OrganisationService", "Too soon since last load, skipping");
+          return;
+        }
+        if (this.abortControllerRef) {
+          this.abortControllerRef.abort();
+        }
+        this.abortControllerRef = new AbortController();
+        const abortSignal = this.abortControllerRef.signal;
+        this.lastLoadTimeRef = now;
+        this.isLoadingRef = true;
+        this._isLoading = true;
+        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,
+            hasRpc: !!this.supabaseClient.rpc
+          });
+          let memberships, membershipError;
+          try {
+            console.log("[OrganisationService] Making RPC call to data_user_organisation_roles_get...");
+            const timeoutPromise = new Promise((_, reject) => {
+              const timeoutId = setTimeout(() => reject(new Error("RPC call timeout after 10 seconds")), 1e4);
+              abortSignal.addEventListener("abort", () => {
+                clearTimeout(timeoutId);
+                reject(new Error("Request aborted"));
+              });
+            });
+            const rpcPromise = this.supabaseClient.rpc("data_user_organisation_roles_get", {
+              p_user_id: this.user.id,
+              p_organisation_id: null
+            });
+            if (abortSignal.aborted) {
+              throw new Error("Request aborted");
+            }
+            const result = await Promise.race([rpcPromise, timeoutPromise]);
+            console.log("[OrganisationService] RPC call completed:", {
+              hasData: !!result.data,
+              hasError: !!result.error,
+              dataLength: result.data?.length || 0,
+              errorMessage: result.error?.message || "No error"
+            });
+            memberships = result.data?.filter(
+              (role) => ["org_admin", "leader", "member"].includes(role.role)
+            ) || [];
+            membershipError = result.error;
+          } catch (queryError) {
+            membershipError = queryError;
+          }
+          if (membershipError) {
+            console.error("[OrganisationService] Error loading memberships:", membershipError);
+            if (membershipError.message?.includes("timeout")) {
+              console.log("[OrganisationService] RPC timed out, trying direct database query as fallback...");
+              try {
+                if (abortSignal.aborted) {
+                  throw new Error("Request aborted");
+                }
+                const { data: fallbackData, error: fallbackError } = await this.supabaseClient.from("rbac_organisation_roles").select(`
+                id,
+                user_id,
+                organisation_id,
+                role,
+                status,
+                granted_at,
+                granted_by,
+                revoked_at,
+                revoked_by,
+                notes,
+                created_at,
+                updated_at,
+                organisations!inner(
+                  id,
+                  name,
+                  display_name,
+                  subscription_tier,
+                  settings,
+                  is_active,
+                  parent_id,
+                  created_at,
+                  updated_at
+                )
+              `).eq("user_id", this.user.id).eq("status", "active").is("revoked_at", null).in("role", ["org_admin", "leader", "member"]);
+                if (fallbackError) {
+                  console.error("[OrganisationService] Fallback query also failed:", fallbackError);
+                  throw membershipError;
+                }
+                console.log("[OrganisationService] Fallback query successful, got", fallbackData?.length || 0, "memberships");
+                memberships = fallbackData || [];
+                membershipError = null;
+              } catch (fallbackErr) {
+                console.error("[OrganisationService] Fallback query failed:", fallbackErr);
+                throw membershipError;
+              }
+            } else {
+              throw membershipError;
+            }
+          }
+          DebugLogger.log("OrganisationService", "Raw memberships data:", memberships);
+          if (!memberships || memberships.length === 0) {
+            throw new Error("User has no active organisation memberships");
+          }
+          const organisationIds = memberships.map((m) => m.organisation_id).filter((id) => {
+            if (!id || typeof id !== "string") {
+              console.warn("[OrganisationService] Invalid organisation ID (not string):", id);
+              return false;
+            }
+            const trimmedId = id.trim();
+            if (trimmedId === "") {
+              console.warn("[OrganisationService] Empty organisation ID found");
+              return false;
+            }
+            const isValidUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmedId);
+            if (!isValidUuid) {
+              console.warn("[OrganisationService] Invalid UUID format:", trimmedId);
+            }
+            return isValidUuid;
+          });
+          if (organisationIds.length === 0) {
+            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");
+          }
+          const { data: allOrganisations, error: orgError } = await this.supabaseClient.from("organisations").select("id, name, display_name, subscription_tier, settings, is_active, parent_id, created_at, updated_at");
+          if (orgError) {
+            console.error("[OrganisationService] Error loading organisations:", orgError);
+            throw orgError;
+          }
+          const organisations = allOrganisations?.filter(
+            (org) => organisationIds.includes(org.id)
+          ) || [];
+          const roleMap = /* @__PURE__ */ new Map();
+          memberships?.forEach((membership) => {
+            roleMap.set(membership.organisation_id, membership.role);
+          });
+          const orgs = organisations;
+          const activeOrgs = orgs.filter((org) => org.is_active);
+          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;
+          let initialOrg = null;
+          try {
+            const persistedOrgString = localStorage.getItem("pace-core-selected-organisation");
+            if (persistedOrgString) {
+              const persistedOrg = JSON.parse(persistedOrgString);
+              if (persistedOrg.id && typeof persistedOrg.id === "string" && persistedOrg.id.trim() !== "") {
+                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");
+                }
+              } else {
+                console.warn("[OrganisationService] Invalid persisted organisation ID, clearing cache");
+                localStorage.removeItem("pace-core-selected-organisation");
+              }
+            }
+          } catch (storageError) {
+            console.warn("[OrganisationService] Failed to restore persisted organisation:", storageError);
+            localStorage.removeItem("pace-core-selected-organisation");
+          }
+          if (!initialOrg) {
+            const adminMembership = memberships.find((m) => m.role === "org_admin");
+            if (adminMembership) {
+              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)
+          });
+          this.retryCount = 0;
+          this.hasFailedRef = false;
+        } catch (err) {
+          console.error("[OrganisationService] Failed to load organisations:", err);
+          this._error = err;
+          this.retryCount = this.retryCount + 1;
+          this.hasFailedRef = true;
+          this.clearAllCachedData();
+        } finally {
+          this.isLoadingRef = false;
+          this._isLoading = false;
+          this.abortControllerRef = null;
+          this.notify();
+        }
+      }
+      clearAllCachedData() {
+        localStorage.removeItem("pace-core-selected-organisation");
+        localStorage.removeItem("pace-core-organisation-context");
+        this._selectedOrganisation = null;
+        this._organisations = [];
+        this._userMemberships = [];
+        this._roleMapState = /* @__PURE__ */ new Map();
+        this.retryCount = 0;
+        this._isContextReady = false;
+      }
+    };
+  }
+});
+
+// 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";
+function OrganisationServiceProvider({
+  children,
+  supabaseClient,
+  user,
+  session
+}) {
+  const organisationService = useMemo3(
+    () => new OrganisationService(supabaseClient, user, session),
+    [supabaseClient, user, session]
+  );
+  useEffect3(() => {
+    organisationService.updateDependencies(user, session);
+  }, [organisationService, user, session]);
+  useEffect3(() => {
+    organisationService.initialize().catch((error) => {
+      console.error("[OrganisationServiceProvider] Failed to initialize organisation service:", error);
+    });
+    return () => {
+      organisationService.cleanup();
+    };
+  }, [organisationService]);
+  const contextValue = useMemo3(() => ({
+    organisationService
+  }), [organisationService]);
+  return /* @__PURE__ */ jsx3(OrganisationServiceContext.Provider, { value: contextValue, children });
+}
+var OrganisationServiceContext, useOrganisationService;
+var init_OrganisationServiceProvider = __esm({
+  "src/providers/services/OrganisationServiceProvider.tsx"() {
+    "use strict";
+    init_OrganisationService();
+    OrganisationServiceContext = createContext3(null);
+    useOrganisationService = () => {
+      const context = useContext3(OrganisationServiceContext);
+      if (!context) {
+        throw new Error("useOrganisationService must be used within OrganisationServiceProvider");
+      }
+      return context.organisationService;
+    };
+  }
+});
+
+// src/services/EventService.ts
+var EventService;
+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.error = null;
+        // Dependencies
+        this.supabaseClient = null;
+        this.user = null;
+        this.session = null;
+        this.appName = "";
+        this.selectedOrganisation = null;
+        this.setSelectedEventId = null;
+        // Internal state management
+        this.isInitializedRef = false;
+        this.isFetchingRef = false;
+        this.hasAutoSelectedRef = false;
+        this.userClearedEventRef = false;
+        this.supabaseClient = supabaseClient;
+        this.user = user;
+        this.session = session;
+        this.appName = appName;
+        this.selectedOrganisation = selectedOrganisation;
+        this.setSelectedEventId = setSelectedEventId;
+      }
+      // Update dependencies
+      updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId) {
+        this.supabaseClient = supabaseClient;
+        this.user = user;
+        this.session = session;
+        this.appName = appName;
+        this.selectedOrganisation = selectedOrganisation;
+        this.setSelectedEventId = setSelectedEventId;
+        this.notify();
+      }
+      // Event state getters
+      getEvents() {
+        return this.events;
+      }
+      getSelectedEvent() {
+        return this.selectedEvent;
+      }
+      isLoading() {
+        return this._isLoading;
+      }
+      getError() {
+        return this.error;
+      }
+      // Event methods
+      setSelectedEvent(event) {
+        if (event) {
+          try {
+            console.log("[EventService] Event selection validation:", {
+              eventId: event.event_id,
+              eventName: event.event_name,
+              eventOrganisationId: event.organisation_id,
+              selectedOrganisationId: this.selectedOrganisation?.id,
+              selectedOrganisationName: this.selectedOrganisation?.display_name,
+              match: event.organisation_id === this.selectedOrganisation?.id
+            });
+            if (this.selectedOrganisation && event.organisation_id !== this.selectedOrganisation.id) {
+              console.error("[EventService] Event organisation_id does not match selected organisation", {
+                eventOrganisationId: event.organisation_id,
+                selectedOrganisationId: this.selectedOrganisation.id,
+                eventName: event.event_name
+              });
+              return;
+            }
+          } catch (error) {
+            console.error("[EventService] Error during event validation:", error);
+          }
+          this.selectedEvent = event;
+          this.setSelectedEventId?.(event.event_id);
+          this.persistEventSelection(event.event_id);
+          this.userClearedEventRef = false;
+        } else {
+          this.selectedEvent = null;
+          this.setSelectedEventId?.(null);
+          sessionStorage.removeItem("pace-core-selected-event");
+          localStorage.removeItem("pace-core-selected-event");
+          this.hasAutoSelectedRef = false;
+          this.userClearedEventRef = true;
+        }
+        this.notify();
+      }
+      async refreshEvents() {
+        this.isInitializedRef = false;
+        this.isFetchingRef = false;
+        await this.fetchEvents();
+      }
+      async loadPersistedEvent(events) {
+        try {
+          let persistedEventId = sessionStorage.getItem("pace-core-selected-event");
+          if (!persistedEventId) {
+            persistedEventId = localStorage.getItem("pace-core-selected-event");
+            if (persistedEventId) {
+              sessionStorage.setItem("pace-core-selected-event", persistedEventId);
+            }
+          }
+          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");
+            }
+          }
+        } catch (error) {
+          console.warn("[EventService] Failed to load persisted event:", error);
+        }
+        return false;
+      }
+      persistEventSelection(eventId) {
+        try {
+          sessionStorage.setItem("pace-core-selected-event", eventId);
+          localStorage.setItem("pace-core-selected-event", eventId);
+        } catch (error) {
+          console.warn("[EventService] Failed to persist event selection:", error);
+        }
+      }
+      clearEventSelection() {
+        try {
+          sessionStorage.removeItem("pace-core-selected-event");
+          localStorage.removeItem("pace-core-selected-event");
+          this.selectedEvent = null;
+          this.setSelectedEventId?.(null);
+        } catch (error) {
+          console.warn("[EventService] Failed to clear event selection:", error);
+        }
+      }
+      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);
+        }
+      }
+      // Lifecycle methods
+      async initialize() {
+        await super.initialize();
+        await this.fetchEvents();
+      }
+      cleanup() {
+        super.cleanup();
+      }
+      async doInitialize() {
+        await this.fetchEvents();
+      }
+      doCleanup() {
+      }
+      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;
+        }
+        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");
+          }
+          if (isMounted) {
+            const eventsData = data || [];
+            console.log("[EventService] Loaded events:", eventsData.map((event) => ({
+              eventId: event.event_id,
+              eventName: event.event_name,
+              organisationId: event.organisation_id,
+              selectedOrganisationId: this.selectedOrganisation?.id
+            })));
+            const transformedEvents = eventsData.map((event) => ({
+              id: event.event_id,
+              // Use event_id as the primary id
+              event_id: event.event_id,
+              event_name: event.event_name,
+              event_date: event.event_date,
+              event_venue: event.event_venue,
+              event_participants: event.event_participants,
+              event_colours: event.event_colours,
+              event_logo: "",
+              // No logo field in event table
+              organisation_id: event.organisation_id,
+              is_visible: event.is_visible,
+              // Legacy compatibility
+              name: event.event_name,
+              start_date: event.event_date
+            }));
+            this.events = transformedEvents;
+            this.error = null;
+            this.hasAutoSelectedRef = false;
+            const persistedEventLoaded = await this.loadPersistedEvent(transformedEvents);
+            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);
+                this.persistEventSelection(nextEvent.event_id);
+              }
+            }
+          }
+        } catch (err) {
+          console.error("[EventService] Error fetching events:", err);
+          const _error = err instanceof Error ? err : new Error("Unknown error occurred");
+          if (isMounted) {
+            this.error = _error;
+            this.events = [];
+          }
+        } finally {
+          if (isMounted) {
+            this._isLoading = false;
+          }
+          this.isFetchingRef = false;
+          this.notify();
+        }
+      }
+      getNextEventByDate(events) {
+        const eventsToUse = events || this.events;
+        if (!eventsToUse || eventsToUse.length === 0) {
+          return null;
+        }
+        const now = /* @__PURE__ */ new Date();
+        const futureEvents = eventsToUse.filter((event) => {
+          if (!event.event_date) return false;
+          const eventDate = new Date(event.event_date);
+          return eventDate >= now;
+        });
+        if (futureEvents.length === 0) {
+          return null;
+        }
+        const sortedFutureEvents = futureEvents.sort((a, b) => {
+          const dateA = new Date(a.event_date);
+          const dateB = new Date(b.event_date);
+          return dateA.getTime() - dateB.getTime();
+        });
+        return sortedFutureEvents[0];
+      }
+    };
+  }
+});
+
+// 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";
+function EventServiceProvider({
+  children,
+  supabaseClient,
+  user,
+  session,
+  appName,
+  selectedOrganisation,
+  setSelectedEventId
+}) {
+  const eventService = useMemo4(
+    () => new EventService(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId),
+    [supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]
+  );
+  useEffect4(() => {
+    eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
+  }, [eventService, supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
+  useEffect4(() => {
+    eventService.initialize().catch((error) => {
+      console.error("[EventServiceProvider] Failed to initialize event service:", error);
+    });
+    return () => {
+      eventService.cleanup();
+    };
+  }, [eventService]);
+  const contextValue = useMemo4(() => ({
+    eventService
+  }), [eventService]);
+  return /* @__PURE__ */ jsx4(EventServiceContext.Provider, { value: contextValue, children });
+}
+var EventServiceContext, useEventService;
+var init_EventServiceProvider = __esm({
+  "src/providers/services/EventServiceProvider.tsx"() {
+    "use strict";
+    init_EventService();
+    EventServiceContext = createContext4(null);
+    useEventService = () => {
+      const context = useContext4(EventServiceContext);
+      if (!context) {
+        throw new Error("useEventService must be used within EventServiceProvider");
+      }
+      return context.eventService;
+    };
+  }
+});
+
+// src/services/InactivityService.ts
+var InactivityService;
+var init_InactivityService = __esm({
+  "src/services/InactivityService.ts"() {
+    "use strict";
+    init_BaseService();
+    InactivityService = class extends BaseService {
+      constructor(supabaseClient, user, session, idleTimeoutMs = 30 * 60 * 1e3, warnBeforeMs = 60 * 1e3, onIdleLogout) {
+        super();
+        this._showInactivityWarning = false;
+        this._inactivityTimeRemaining = 0;
+        this._isIdle = false;
+        this._timeRemaining = 0;
+        this._showWarning = false;
+        this._isTracking = false;
+        // Dependencies
+        this.supabaseClient = null;
+        this.user = null;
+        this.session = null;
+        this.idleTimeoutMs = 30 * 60 * 1e3;
+        // 30 minutes
+        this.warnBeforeMs = 60 * 1e3;
+        // 60 seconds
+        this.onIdleLogout = null;
+        // Internal state management
+        this.inactivityTracker = null;
+        this.isInactivityEnabled = true;
+        this.supabaseClient = supabaseClient;
+        this.user = user;
+        this.session = session;
+        this.idleTimeoutMs = idleTimeoutMs;
+        this.warnBeforeMs = warnBeforeMs;
+        this.onIdleLogout = onIdleLogout;
+        this._timeRemaining = idleTimeoutMs;
+      }
+      // Interface implementation
+      isIdle() {
+        return this._isIdle;
+      }
+      getTimeRemaining() {
+        return this._timeRemaining;
+      }
+      isWarningShown() {
+        return this._showWarning;
+      }
+      isTracking() {
+        return this._isTracking;
+      }
+      getShowInactivityWarning() {
+        return this._showInactivityWarning;
+      }
+      getInactivityTimeRemaining() {
+        return this._inactivityTimeRemaining;
+      }
+      // Additional getter methods that tests expect
+      getIsIdle() {
+        return this._isIdle;
+      }
+      getIsTracking() {
+        return this._isTracking;
+      }
+      getShowWarning() {
+        return this._showWarning;
+      }
+      // Additional methods for testing
+      setShowInactivityWarning(value) {
+        this._showInactivityWarning = value;
+        this.notify();
+      }
+      setInactivityTimeRemaining(value) {
+        this._inactivityTimeRemaining = value;
+        this.notify();
+      }
+      setIsIdle(value) {
+        this._isIdle = value;
+        this.notify();
+      }
+      setTimeRemaining(value) {
+        this._timeRemaining = value;
+        this.notify();
+      }
+      setShowWarning(value) {
+        this._showWarning = value;
+        this.notify();
+      }
+      setIsTracking(value) {
+        this._isTracking = value;
+        this.notify();
+      }
+      triggerWarning(timeRemaining) {
+        this._showInactivityWarning = true;
+        this._inactivityTimeRemaining = Math.ceil(timeRemaining / 1e3);
+        this._showWarning = true;
+        this.notify();
+      }
+      triggerIdle() {
+        this._isIdle = true;
+        this.handleIdleLogout();
+        this.notify();
+      }
+      // Update dependencies
+      updateDependencies(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout) {
+        this.supabaseClient = supabaseClient;
+        this.user = user;
+        this.session = session;
+        if (idleTimeoutMs !== void 0) this.idleTimeoutMs = idleTimeoutMs;
+        if (warnBeforeMs !== void 0) this.warnBeforeMs = warnBeforeMs;
+        if (onIdleLogout !== void 0) this.onIdleLogout = onIdleLogout;
+        this.notify();
+      }
+      // Inactivity methods
+      resetActivity() {
+        if (this.inactivityTracker) {
+          this.inactivityTracker.resetActivity();
+        }
+        this._isIdle = false;
+        this._showWarning = false;
+        this._showInactivityWarning = false;
+        this._inactivityTimeRemaining = 0;
+        this._timeRemaining = this.idleTimeoutMs;
+        this.notify();
+      }
+      startTracking() {
+        if (this.inactivityTracker) {
+          this.inactivityTracker.startTracking();
+        }
+        this._isTracking = true;
+        this.notify();
+      }
+      stopTracking() {
+        if (this.inactivityTracker) {
+          this.inactivityTracker.stopTracking();
+        }
+        this._isTracking = false;
+        this.notify();
+      }
+      async handleIdleLogout() {
+        this._showInactivityWarning = false;
+        this._inactivityTimeRemaining = 0;
+        this.stopTracking();
+        try {
+          if (this.supabaseClient) {
+            await this.supabaseClient.auth.signOut();
+          }
+        } catch (error) {
+          console.error("[InactivityService] Error during idle logout:", error);
+        }
+        this.onIdleLogout?.("inactivity");
+        this.notify();
+      }
+      handleStaySignedIn() {
+        this._showInactivityWarning = false;
+        this._inactivityTimeRemaining = 0;
+        this.resetActivity();
+        this.notify();
+      }
+      async handleSignOutNow() {
+        this._showInactivityWarning = false;
+        this._inactivityTimeRemaining = 0;
+        this.stopTracking();
+        try {
+          if (this.supabaseClient) {
+            await this.supabaseClient.auth.signOut();
+          }
+        } catch (error) {
+          console.error("[InactivityService] Error during manual sign out:", error);
+        }
+        this.onIdleLogout?.("inactivity");
+        this.notify();
+      }
+      // Lifecycle methods
+      async initialize() {
+        await super.initialize();
+        await this.setupInactivityTracker();
+      }
+      cleanup() {
+        if (this.inactivityTracker) {
+          this.inactivityTracker.cleanup?.();
+          this.inactivityTracker = null;
+        }
+        this._isTracking = false;
+        this._isIdle = false;
+        this._showWarning = false;
+        this._showInactivityWarning = false;
+        this._timeRemaining = 0;
+        this._inactivityTimeRemaining = 0;
+        super.cleanup();
+      }
+      async doInitialize() {
+        if (typeof window !== "undefined") {
+          const isProduction = import.meta.env.MODE === "production";
+          if (isProduction) {
+            console.warn("[InactivityService] Inactivity feature enabled in production");
+          }
+        }
+      }
+      doCleanup() {
+      }
+      async setupInactivityTracker() {
+        if (typeof window === "undefined") return;
+        this.isInactivityEnabled = this.user && this.session;
+        if (!this.isInactivityEnabled) {
+          return;
+        }
+        try {
+          const { useInactivityTracker } = await import("./useInactivityTracker-MRUU55XI.js");
+          this.inactivityTracker = {
+            isIdle: false,
+            timeRemaining: 0,
+            showWarning: false,
+            isTracking: false,
+            resetActivity: () => {
+              this._isIdle = false;
+              this._timeRemaining = 0;
+              this._showWarning = false;
+              this.notify();
+            },
+            startTracking: () => {
+              this._isTracking = true;
+              this.notify();
+            },
+            stopTracking: () => {
+              this._isTracking = false;
+              this.notify();
+            },
+            cleanup: () => {
+              this._isTracking = false;
+              this._isIdle = false;
+              this._showWarning = false;
+              this._timeRemaining = 0;
+            }
+          };
+          this.setupEventHandlers();
+        } catch (error) {
+          console.error("[InactivityService] Failed to setup inactivity tracker:", error);
+        }
+      }
+      setupEventHandlers() {
+        if (typeof window === "undefined") return;
+        let idleTimer = null;
+        let warningTimer = null;
+        let lastActivity = Date.now();
+        const resetTimers = () => {
+          lastActivity = Date.now();
+          if (idleTimer) {
+            clearTimeout(idleTimer);
+            idleTimer = null;
+          }
+          if (warningTimer) {
+            clearTimeout(warningTimer);
+            warningTimer = null;
+          }
+          this._showInactivityWarning = false;
+          this._inactivityTimeRemaining = 0;
+          this._isIdle = false;
+          this._showWarning = false;
+          this.notify();
+        };
+        const startIdleTimer = () => {
+          if (idleTimer) {
+            clearTimeout(idleTimer);
+          }
+          idleTimer = setTimeout(() => {
+            this._isIdle = true;
+            this._showWarning = true;
+            this.notify();
+            warningTimer = setTimeout(() => {
+              this.handleIdleLogout();
+            }, this.warnBeforeMs);
+          }, this.idleTimeoutMs - this.warnBeforeMs);
+        };
+        const startWarningTimer = () => {
+          if (warningTimer) {
+            clearTimeout(warningTimer);
+          }
+          warningTimer = setTimeout(() => {
+            this.handleIdleLogout();
+          }, this.warnBeforeMs);
+        };
+        const activityEvents = ["mousedown", "mousemove", "keypress", "scroll", "touchstart", "click"];
+        const handleActivity = () => {
+          resetTimers();
+          startIdleTimer();
+        };
+        activityEvents.forEach((event) => {
+          document.addEventListener(event, handleActivity, true);
+        });
+        startIdleTimer();
+        this.inactivityTracker.cleanup = () => {
+          if (idleTimer) {
+            clearTimeout(idleTimer);
+            idleTimer = null;
+          }
+          if (warningTimer) {
+            clearTimeout(warningTimer);
+            warningTimer = null;
+          }
+          activityEvents.forEach((event) => {
+            document.removeEventListener(event, handleActivity, true);
+          });
+          this._isTracking = false;
+          this._isIdle = false;
+          this._showWarning = false;
+          this._timeRemaining = 0;
+          this._showInactivityWarning = false;
+          this._inactivityTimeRemaining = 0;
+        };
+        this._isTracking = true;
+        this.notify();
+      }
+    };
+  }
+});
+
+// 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";
+function InactivityServiceProvider({
+  children,
+  supabaseClient,
+  user,
+  session,
+  idleTimeoutMs = 30 * 60 * 1e3,
+  warnBeforeMs = 60 * 1e3,
+  onIdleLogout
+}) {
+  const inactivityService = useMemo5(
+    () => new InactivityService(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout),
+    [supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout]
+  );
+  useEffect5(() => {
+    inactivityService.updateDependencies(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout);
+  }, [inactivityService, supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout]);
+  useEffect5(() => {
+    inactivityService.initialize().catch((error) => {
+      console.error("[InactivityServiceProvider] Failed to initialize inactivity service:", error);
+    });
+    return () => {
+      inactivityService.cleanup();
+    };
+  }, [inactivityService]);
+  const contextValue = useMemo5(() => ({
+    inactivityService
+  }), [inactivityService]);
+  return /* @__PURE__ */ jsx5(InactivityServiceContext.Provider, { value: contextValue, children });
+}
+var InactivityServiceContext, useInactivityService;
+var init_InactivityServiceProvider = __esm({
+  "src/providers/services/InactivityServiceProvider.tsx"() {
+    "use strict";
+    init_InactivityService();
+    InactivityServiceContext = createContext5(null);
+    useInactivityService = () => {
+      const context = useContext5(InactivityServiceContext);
+      if (!context) {
+        throw new Error("useInactivityService must be used within InactivityServiceProvider");
+      }
+      return context.inactivityService;
+    };
+  }
+});
+
+// src/hooks/services/useAuthService.ts
+import { useContext as useContext6, useReducer, useEffect as useEffect6 } from "react";
+function useAuthService2() {
+  const context = useContext6(AuthServiceContext);
+  if (!context) {
+    throw new Error("useAuthService must be used within AuthServiceProvider");
+  }
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  useEffect6(() => {
+    return context.authService.subscribe(() => forceUpdate());
+  }, [context.authService]);
+  return context.authService;
+}
+var init_useAuthService = __esm({
+  "src/hooks/services/useAuthService.ts"() {
+    "use strict";
+    init_AuthServiceProvider();
+  }
+});
+
+// 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";
+function useOrganisationService2() {
+  const context = useContext8(OrganisationServiceContext);
+  if (!context) {
+    throw new Error("useOrganisationService must be used within OrganisationServiceProvider");
+  }
+  const [, forceUpdate] = useReducer3((x) => x + 1, 0);
+  useEffect8(() => {
+    return context.organisationService.subscribe(() => forceUpdate());
+  }, [context.organisationService]);
+  return context.organisationService;
+}
+var init_useOrganisationService = __esm({
+  "src/hooks/services/useOrganisationService.ts"() {
+    "use strict";
+    init_OrganisationServiceProvider();
+  }
+});
+
+// src/hooks/services/useEventService.ts
+import { useContext as useContext9, useReducer as useReducer4, useEffect as useEffect9 } from "react";
+function useEventService2() {
+  const context = useContext9(EventServiceContext);
+  if (!context) {
+    throw new Error("useEventService must be used within EventServiceProvider");
+  }
+  const [, forceUpdate] = useReducer4((x) => x + 1, 0);
+  useEffect9(() => {
+    return context.eventService.subscribe(() => forceUpdate());
+  }, [context.eventService]);
+  return context.eventService;
+}
+var init_useEventService = __esm({
+  "src/hooks/services/useEventService.ts"() {
+    "use strict";
+    init_EventServiceProvider();
+  }
+});
+
+// src/hooks/services/useInactivityService.ts
+import { useContext as useContext10, useReducer as useReducer5, useEffect as useEffect10 } from "react";
+function useInactivityService2() {
+  const context = useContext10(InactivityServiceContext);
+  if (!context) {
+    throw new Error("useInactivityService must be used within InactivityServiceProvider");
+  }
+  const [, forceUpdate] = useReducer5((x) => x + 1, 0);
+  useEffect10(() => {
+    return context.inactivityService.subscribe(() => forceUpdate());
+  }, [context.inactivityService]);
+  return context.inactivityService;
+}
+var init_useInactivityService = __esm({
+  "src/hooks/services/useInactivityService.ts"() {
+    "use strict";
+    init_InactivityServiceProvider();
+  }
+});
+
+// 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";
+function UnifiedAuthContextProvider({
+  children,
+  appName,
+  ...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 });
+}
+function ServiceAwareProviders({
+  children,
+  supabaseClient,
+  appName,
+  persistState,
+  enablePersistence,
+  requireOrganisationContext,
+  enableRBAC,
+  idleTimeoutMs,
+  warnBeforeMs,
+  onIdleLogout,
+  renderInactivityWarning,
+  dangerouslyDisableInactivity
+}) {
+  const authService = useAuthService2();
+  return /* @__PURE__ */ jsx6(
+    RBACServiceProvider,
+    {
+      supabaseClient,
+      user: authService.getUser(),
+      session: authService.getSession(),
+      appName,
+      children: /* @__PURE__ */ jsx6(
+        OrganisationServiceProvider,
+        {
+          supabaseClient,
+          user: authService.getUser(),
+          session: authService.getSession(),
+          children: /* @__PURE__ */ jsx6(
+            EventServiceProvider,
+            {
+              supabaseClient,
+              user: authService.getUser(),
+              session: authService.getSession(),
+              appName,
+              selectedOrganisation: null,
+              setSelectedEventId: (eventId) => {
+              },
+              children: /* @__PURE__ */ jsx6(
+                InactivityServiceProvider,
+                {
+                  supabaseClient,
+                  user: authService.getUser(),
+                  session: authService.getSession(),
+                  idleTimeoutMs,
+                  warnBeforeMs,
+                  onIdleLogout,
+                  children: /* @__PURE__ */ jsx6(
+                    UnifiedAuthContextProvider,
+                    {
+                      appName,
+                      supabaseClient,
+                      persistState,
+                      enablePersistence,
+                      requireOrganisationContext,
+                      enableRBAC,
+                      idleTimeoutMs,
+                      warnBeforeMs,
+                      onIdleLogout,
+                      renderInactivityWarning,
+                      dangerouslyDisableInactivity,
+                      children
+                    }
+                  )
+                }
+              )
+            }
+          )
+        }
+      )
+    }
+  );
+}
+function UnifiedAuthProvider({
+  children,
+  supabaseClient,
+  appName,
+  persistState = true,
+  enablePersistence,
+  requireOrganisationContext = true,
+  enableRBAC = false,
+  idleTimeoutMs = 30 * 60 * 1e3,
+  // 30 minutes
+  warnBeforeMs = 60 * 1e3,
+  // 60 seconds
+  onIdleLogout,
+  renderInactivityWarning,
+  dangerouslyDisableInactivity = false
+}) {
+  return /* @__PURE__ */ jsx6(AuthServiceProvider, { supabaseClient, children: /* @__PURE__ */ jsx6(
+    ServiceAwareProviders,
+    {
+      supabaseClient,
+      appName,
+      persistState,
+      enablePersistence,
+      requireOrganisationContext,
+      enableRBAC,
+      idleTimeoutMs,
+      warnBeforeMs,
+      onIdleLogout,
+      renderInactivityWarning,
+      dangerouslyDisableInactivity,
+      children
+    }
+  ) });
+}
+var UnifiedAuthContext, useUnifiedAuth;
+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);
+    useUnifiedAuth = () => {
+      const context = useContext11(UnifiedAuthContext);
+      if (!context) {
+        throw new Error("useUnifiedAuth must be used within a UnifiedAuthProvider");
+      }
+      return context;
+    };
+  }
+});
+
+export {
+  AuthServiceContext,
+  AuthServiceProvider,
+  useAuthService,
+  init_AuthServiceProvider,
+  RBACServiceContext,
+  RBACServiceProvider,
+  useRBACService,
+  init_RBACServiceProvider,
+  OrganisationServiceContext,
+  OrganisationServiceProvider,
+  useOrganisationService,
+  init_OrganisationServiceProvider,
+  EventServiceContext,
+  EventServiceProvider,
+  useEventService,
+  init_EventServiceProvider,
+  InactivityServiceContext,
+  InactivityServiceProvider,
+  useInactivityService,
+  init_InactivityServiceProvider,
+  useAuthService2,
+  init_useAuthService,
+  useRBACService2,
+  init_useRBACService,
+  useOrganisationService2,
+  init_useOrganisationService,
+  useEventService2,
+  init_useEventService,
+  useInactivityService2,
+  init_useInactivityService,
+  useUnifiedAuth,
+  UnifiedAuthProvider,
+  init_UnifiedAuthProvider
+};
+//# sourceMappingURL=chunk-WN6XJWOS.js.map