@jmruthers/pace-core 0.5.181 → 0.5.183

package/dist/chunk-3JI76CYK.js

@@ -1,2444 +0,0 @@
-import {
-  init_organisationContext,
-  init_secureStorage,
-  secureStorage,
-  setOrganisationContext
-} from "./chunk-7QCC6MCP.js";
-import {
-  createLogger,
-  init_logger,
-  logger
-} from "./chunk-XDNLUEXI.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";
-    init_logger();
-    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) {
-            logger.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;
-      }
-      /**
-       * Reset initialization state (allows re-initialization)
-       * Use when dependencies change and service needs to re-initialize
-       */
-      resetInitialization() {
-        this.isInitialized = false;
-      }
-    };
-  }
-});
-
-// 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_logger();
-    AuthService = class extends BaseService {
-      constructor(supabaseClient, appName) {
-        super();
-        this.user = null;
-        this.session = null;
-        this.authLoading = false;
-        this.authError = null;
-        this.supabaseClient = null;
-        this.authStateSubscription = null;
-        this.sessionRestorationState = {
-          isRestoring: false,
-          restorationComplete: false,
-          restorationError: null
-        };
-        this.restorationTimeoutId = null;
-        this.restorationTimeoutMs = 5e3;
-        this.restorationStartTime = null;
-        this.appName = void 0;
-        this.supabaseClient = supabaseClient;
-        this.appName = appName;
-      }
-      // 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;
-      }
-      getSessionRestorationState() {
-        return { ...this.sessionRestorationState };
-      }
-      // 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;
-        }
-        this.clearRestorationTimeout();
-        this.restorationStartTime = null;
-        this.sessionRestorationState = {
-          isRestoring: false,
-          restorationComplete: false,
-          restorationError: null
-        };
-        this.authLoading = false;
-        super.cleanup();
-      }
-      async doInitialize() {
-        this.setupErrorHandlers();
-      }
-      doCleanup() {
-        this.removeErrorHandlers();
-      }
-      startSessionRestoration() {
-        this.clearRestorationTimeout();
-        this.sessionRestorationState = {
-          isRestoring: true,
-          restorationComplete: false,
-          restorationError: null
-        };
-        this.authLoading = true;
-        this.restorationStartTime = Date.now();
-        logger.debug("AuthService", "Starting session restoration at", this.restorationStartTime);
-        this.notify();
-        this.restorationTimeoutId = setTimeout(() => {
-          logger.warn("AuthService", "Session restoration timed out after", this.restorationTimeoutMs, "ms");
-          const timeoutError = new Error(`Session restoration timed out after ${this.restorationTimeoutMs}ms`);
-          timeoutError.name = "SessionRestorationTimeoutError";
-          this.finishSessionRestoration(timeoutError);
-        }, this.restorationTimeoutMs);
-      }
-      finishSessionRestoration(error) {
-        if (!this.sessionRestorationState.isRestoring && !error) {
-          return;
-        }
-        this.clearRestorationTimeout();
-        const completedAt = Date.now();
-        const duration = this.restorationStartTime ? completedAt - this.restorationStartTime : null;
-        this.restorationStartTime = null;
-        const restorationComplete = !error;
-        this.sessionRestorationState = {
-          isRestoring: false,
-          restorationComplete,
-          restorationError: error ?? null
-        };
-        this.authLoading = false;
-        if (error) {
-          logger.warn("AuthService", "Session restoration finished with error:", error, "duration(ms):", duration ?? "unknown");
-        } else {
-          logger.debug("AuthService", "Session restoration completed successfully in", duration ?? "unknown", "ms");
-        }
-        this.notify();
-      }
-      clearRestorationTimeout() {
-        if (this.restorationTimeoutId) {
-          clearTimeout(this.restorationTimeoutId);
-          this.restorationTimeoutId = null;
-        }
-      }
-      async setupAuthStateListener() {
-        if (!this.supabaseClient) {
-          this.authLoading = false;
-          this.notify();
-          return;
-        }
-        try {
-          this.authStateSubscription = this.supabaseClient.auth.onAuthStateChange(
-            (event, session) => {
-              try {
-                logger.debug("AuthService", "Auth state change event received:", event);
-                if (event === "SIGNED_OUT") {
-                  this.session = null;
-                  this.user = null;
-                  this.authError = null;
-                  if (session?.user) {
-                    this.trackSession("logout", session).catch((err) => {
-                      logger.warn("AuthService", "Failed to track logout session:", err);
-                    });
-                  }
-                } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
-                  this.session = session;
-                  this.user = session?.user ?? null;
-                  if (session) {
-                    this.authError = null;
-                  }
-                  if (event === "SIGNED_IN" && session?.user) {
-                    this.trackSession("login", session).catch((err) => {
-                      logger.warn("AuthService", "Failed to track login session:", err);
-                    });
-                  }
-                } else if (event === "INITIAL_SESSION") {
-                  if (session) {
-                    this.session = session;
-                    this.user = session.user ?? null;
-                    this.authError = null;
-                    const hasTimeoutError = this.sessionRestorationState.restorationError?.name === "SessionRestorationTimeoutError";
-                    if (this.sessionRestorationState.isRestoring || this.sessionRestorationState.restorationError || hasTimeoutError && session) {
-                      this.finishSessionRestoration();
-                      return;
-                    }
-                  }
-                  if (this.sessionRestorationState.isRestoring) {
-                    this.finishSessionRestoration();
-                    return;
-                  }
-                }
-                this.authLoading = false;
-                this.notify();
-              } catch (error) {
-                logger.warn("AuthService", "Error in auth state change handler:", error);
-                this.authLoading = false;
-                this.notify();
-              }
-            }
-          );
-        } catch (error) {
-          logger.error("AuthService", "Failed to setup auth state listener:", error);
-          throw error;
-        }
-      }
-      async restoreSession() {
-        if (!this.supabaseClient) {
-          const error = new Error("Supabase client not available during session restoration");
-          logger.error("AuthService", "Unable to restore session:", error);
-          this.finishSessionRestoration(error);
-          return;
-        }
-        this.startSessionRestoration();
-        try {
-          logger.debug("AuthService", "Fetching existing session from Supabase");
-          let currentSession = null;
-          let sessionError = null;
-          try {
-            const { data, error } = await this.supabaseClient.auth.getSession();
-            currentSession = data?.session ?? null;
-            sessionError = error ?? null;
-          } catch (error) {
-            logger.debug("AuthService", "getSession unavailable, treating as no active session");
-            currentSession = null;
-            sessionError = null;
-          }
-          if (sessionError) {
-            logger.debug("AuthService", "getSession returned error, attempting to fetch user anyway");
-            this.authError = sessionError;
-            try {
-              const { data, error } = await this.supabaseClient.auth.getUser();
-              const currentUser = data?.user ?? null;
-              const userError = error ?? null;
-              if (currentUser) {
-                this.user = currentUser;
-                this.session = null;
-              }
-              if (userError && !this.authError) {
-                this.authError = userError;
-              }
-            } catch (getUserError) {
-              logger.debug("AuthService", "getUser also failed:", getUserError);
-            }
-          }
-          if (currentSession) {
-            this.session = currentSession;
-            this.user = currentSession.user;
-            this.authError = null;
-          } else if (!sessionError) {
-            logger.debug("AuthService", "No active session found; treating as normal unauthenticated state");
-            this.session = null;
-            this.user = null;
-            this.authError = null;
-          }
-          this.finishSessionRestoration();
-        } catch (error) {
-          const restorationError = error instanceof Error ? error : new Error("Unknown error during auth initialization");
-          logger.error("AuthService", "Error during auth initialization:", restorationError);
-          if (restorationError instanceof AuthError) {
-            this.authError = restorationError;
-          }
-          this.finishSessionRestoration(restorationError);
-        }
-      }
-      /**
-       * Automatically track user session using rbac_session_track
-       * This method is called automatically on SIGNED_IN and SIGNED_OUT events.
-       * It's non-blocking and failures are logged as warnings.
-       */
-      async trackSession(sessionType, session) {
-        if (!this.supabaseClient || !session?.user) {
-          return;
-        }
-        try {
-          let appId = void 0;
-          if (this.appName) {
-            const { data, error: error2 } = await this.supabaseClient.from("rbac_apps").select("id").eq("name", this.appName).eq("is_active", true).single();
-            if (!error2 && data) {
-              appId = data.id;
-            }
-          }
-          const ipAddress = void 0;
-          const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : void 0;
-          const deviceFingerprint = void 0;
-          const { error } = await this.supabaseClient.rpc("rbac_session_track", {
-            p_user_id: session.user.id,
-            p_session_type: sessionType,
-            p_event_id: null,
-            // Event ID should come from context, not auth service
-            p_app_id: appId,
-            p_ip_address: ipAddress,
-            p_user_agent: userAgent,
-            p_device_fingerprint: deviceFingerprint
-          });
-          if (error) {
-            logger.warn("AuthService", `Failed to track ${sessionType} session:`, error);
-          } else {
-            logger.debug("AuthService", `Successfully tracked ${sessionType} session`);
-          }
-        } catch (error) {
-          logger.warn("AuthService", `Error tracking ${sessionType} session:`, error);
-        }
-      }
-      setupErrorHandlers() {
-        if (typeof window === "undefined") return;
-        const handleError = (event) => {
-          if (event.error?.message?.includes("AuthSessionMissingError") || event.error?.message?.includes("Auth session missing")) {
-            logger.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")) {
-            logger.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, useState } from "react";
-import { jsx } from "react/jsx-runtime";
-function AuthServiceProvider({ children, supabaseClient, appName }) {
-  const authService = useMemo(
-    () => new AuthService(supabaseClient, appName),
-    [supabaseClient, appName]
-  );
-  const [sessionRestoration, setSessionRestoration] = useState(
-    () => authService.getSessionRestorationState()
-  );
-  useEffect(() => {
-    const unsubscribe = authService.subscribe(() => {
-      const restorationState = authService.getSessionRestorationState();
-      setSessionRestoration(restorationState);
-      const isDev = typeof import.meta !== "undefined" && (import.meta.env.DEV || import.meta.env.MODE === "development");
-      if (isDev) {
-        logger.debug("AuthServiceProvider", "Session restoration state updated", restorationState);
-      }
-    });
-    return () => {
-      unsubscribe();
-    };
-  }, [authService]);
-  useEffect(() => {
-    authService.initialize().catch((error) => {
-      logger.error("AuthServiceProvider", "Failed to initialize auth service:", error);
-    });
-    return () => {
-      authService.cleanup();
-    };
-  }, [authService]);
-  const contextValue = useMemo(() => ({
-    authService,
-    sessionRestoration
-  }), [authService, sessionRestoration]);
-  return /* @__PURE__ */ jsx(AuthServiceContext.Provider, { value: contextValue, children });
-}
-var AuthServiceContext, useAuthService;
-var init_AuthServiceProvider = __esm({
-  "src/providers/services/AuthServiceProvider.tsx"() {
-    "use strict";
-    init_AuthService();
-    init_logger();
-    AuthServiceContext = createContext(null);
-    useAuthService = () => {
-      const context = useContext(AuthServiceContext);
-      if (!context) {
-        throw new Error("useAuthService must be used within AuthServiceProvider");
-      }
-      return context.authService;
-    };
-  }
-});
-
-// src/services/OrganisationService.ts
-var OrganisationService;
-var init_OrganisationService = __esm({
-  "src/services/OrganisationService.ts"() {
-    "use strict";
-    init_BaseService();
-    init_organisationContext();
-    init_logger();
-    OrganisationService = class extends BaseService {
-      constructor(supabaseClient, user, session) {
-        super();
-        this._selectedOrganisation = null;
-        this._organisations = [];
-        this._userMemberships = [];
-        this._roleMapState = /* @__PURE__ */ new Map();
-        this._isLoading = false;
-        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) {
-        const wasAuthenticated = !!(this.user && this.session);
-        const isAuthenticated = !!(user && session);
-        this.user = user;
-        this.session = session;
-        if (wasAuthenticated && !isAuthenticated) {
-          this.isInitialized = false;
-        }
-        this.notify();
-      }
-      // Organisation methods
-      async switchOrganisation(orgId) {
-        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);
-        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();
-        if (!this.isLoadingRef) {
-          await this.loadUserOrganisations();
-        }
-      }
-      cleanup() {
-        this.isLoadingRef = false;
-        this.hasFailedRef = false;
-        this.lastLoadTimeRef = 0;
-        if (this.abortControllerRef) {
-          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) {
-          logger.warn("OrganisationService", "No Supabase client or session available for setting organisation context");
-          this._isContextReady = false;
-          this.notify();
-          return;
-        }
-        try {
-          logger.debug("OrganisationService", "Setting database organisation context for:", organisation.id);
-          const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error("Context setting timeout after 5 seconds")), 5e3);
-          });
-          const contextPromise = setOrganisationContext(this.supabaseClient, organisation.id);
-          await Promise.race([contextPromise, timeoutPromise]);
-          logger.debug("OrganisationService", "Database organisation context set successfully");
-          this._isContextReady = true;
-          this.notify();
-        } catch (error) {
-          logger.error("OrganisationService", "Failed to set database organisation context:", error);
-          this._isContextReady = true;
-          this.notify();
-        }
-      }
-      async loadUserOrganisations() {
-        const callId = Math.random().toString(36).substr(2, 9);
-        logger.debug("OrganisationService", `Starting loadUserOrganisations call ${callId}`);
-        if (!this.user || !this.session || !this.supabaseClient) {
-          this._selectedOrganisation = null;
-          this._organisations = [];
-          this._userMemberships = [];
-          this._isLoading = false;
-          this._error = null;
-          this.notify();
-          return;
-        }
-        if (this.isLoadingRef) {
-          logger.debug("OrganisationService", "Already loading, skipping duplicate load");
-          this._isLoading = true;
-          this.notify();
-          return;
-        }
-        const now = Date.now();
-        if (now - this.lastLoadTimeRef < 2e3) {
-          logger.debug("OrganisationService", "Too soon since last load, skipping");
-          if (this._organisations.length > 0 || this._selectedOrganisation) {
-            this._isLoading = false;
-          } else {
-            this._isLoading = true;
-          }
-          this.notify();
-          return;
-        }
-        if (this.abortControllerRef) {
-          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 {
-          logger.debug("OrganisationService", "Supabase client ready:", {
-            isConnected: !!this.supabaseClient,
-            hasAuth: !!this.supabaseClient.auth,
-            hasRpc: !!this.supabaseClient.rpc
-          });
-          let memberships, membershipError;
-          try {
-            logger.debug("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]);
-            logger.debug("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) {
-            logger.error("OrganisationService", "Error loading memberships:", membershipError);
-            if (membershipError.message?.includes("timeout")) {
-              logger.debug("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) {
-                  logger.error("OrganisationService", "Fallback query also failed:", fallbackError);
-                  throw membershipError;
-                }
-                logger.debug("OrganisationService", "Fallback query successful, got", fallbackData?.length || 0, "memberships");
-                memberships = fallbackData || [];
-                membershipError = null;
-              } catch (fallbackErr) {
-                logger.error("OrganisationService", "Fallback query failed:", fallbackErr);
-                throw membershipError;
-              }
-            } else {
-              throw membershipError;
-            }
-          }
-          if (!memberships || memberships.length === 0) {
-            throw new Error("User has no active organisation memberships");
-          }
-          const organisationIds = memberships.map((m) => m.organisation_id).filter((id) => {
-            if (!id || typeof id !== "string") {
-              logger.warn("OrganisationService", "Invalid organisation ID (not string):", id);
-              return false;
-            }
-            const trimmedId = id.trim();
-            if (trimmedId === "") {
-              logger.warn("OrganisationService", "Empty organisation ID found");
-              return false;
-            }
-            const isValidUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmedId);
-            if (!isValidUuid) {
-              logger.warn("OrganisationService", "Invalid UUID format:", trimmedId);
-            }
-            return isValidUuid;
-          });
-          if (organisationIds.length === 0) {
-            logger.warn("OrganisationService", "No valid organisation IDs found in memberships:", memberships);
-            throw new Error("No valid organisation IDs found in memberships");
-          }
-          if (abortSignal.aborted) {
-            throw new Error("Request aborted");
-          }
-          const { data: allOrganisations, error: orgError } = await this.supabaseClient.from("organisations").select("id, name, display_name, subscription_tier, settings, is_active, parent_id, created_at, updated_at");
-          if (orgError) {
-            logger.error("OrganisationService", "Error loading organisations:", orgError);
-            throw orgError;
-          }
-          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");
-          }
-          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;
-                } else {
-                  logger.warn("OrganisationService", "Persisted organisation not found in active orgs, clearing cache");
-                  localStorage.removeItem("pace-core-selected-organisation");
-                }
-              } else {
-                logger.warn("OrganisationService", "Invalid persisted organisation ID, clearing cache");
-                localStorage.removeItem("pace-core-selected-organisation");
-              }
-            }
-          } catch (storageError) {
-            logger.warn("OrganisationService", "Failed to restore persisted organisation:", storageError);
-            localStorage.removeItem("pace-core-selected-organisation");
-          }
-          if (!initialOrg) {
-            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;
-              }
-            }
-          }
-          if (!initialOrg) {
-            initialOrg = activeOrgs[0];
-          }
-          if (!initialOrg) {
-            throw new Error("No valid organisation found for user");
-          }
-          this._selectedOrganisation = initialOrg;
-          localStorage.setItem("pace-core-selected-organisation", JSON.stringify(initialOrg));
-          await this.setDatabaseOrganisationContext(initialOrg);
-          this.retryCount = 0;
-          this.hasFailedRef = false;
-        } catch (err) {
-          logger.error("OrganisationService", "Failed to load organisations:", err);
-          this._error = err;
-          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 createContext2, useContext as useContext2, useMemo as useMemo2, useEffect as useEffect2, useRef } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-function OrganisationServiceProvider({
-  children,
-  supabaseClient,
-  user,
-  session
-}) {
-  const organisationServiceRef = useRef(null);
-  if (!organisationServiceRef.current) {
-    organisationServiceRef.current = new OrganisationService(supabaseClient, user, session);
-  }
-  const organisationService = organisationServiceRef.current;
-  useEffect2(() => {
-    organisationService.updateDependencies(user, session);
-    let isMounted = true;
-    organisationService.initialize().catch((error) => {
-      if (isMounted) {
-        logger.error("OrganisationServiceProvider", "Failed to initialize organisation service:", error);
-      }
-    });
-    return () => {
-      isMounted = false;
-    };
-  }, [organisationService, user, session]);
-  const contextValue = useMemo2(() => ({
-    organisationService
-  }), [organisationService]);
-  return /* @__PURE__ */ jsx2(OrganisationServiceContext.Provider, { value: contextValue, children });
-}
-var OrganisationServiceContext, useOrganisationService;
-var init_OrganisationServiceProvider = __esm({
-  "src/providers/services/OrganisationServiceProvider.tsx"() {
-    "use strict";
-    init_OrganisationService();
-    init_logger();
-    OrganisationServiceContext = createContext2(null);
-    useOrganisationService = () => {
-      const context = useContext2(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_logger();
-    init_secureStorage();
-    EventService = class extends BaseService {
-      constructor(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId) {
-        super();
-        this.events = [];
-        this.selectedEvent = null;
-        this._isLoading = false;
-        // Start as false to avoid blocking UI
-        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;
-      }
-      // Helper method to get user-scoped storage key
-      getStorageKey(userId) {
-        if (!userId) {
-          return "pace-core-selected-event-no-user";
-        }
-        return `pace-core-selected-event-${userId}`;
-      }
-      // Update dependencies
-      async updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId) {
-        const previousOrgId = this.selectedOrganisation?.id;
-        const newOrgId = selectedOrganisation?.id;
-        const previousUserId = this.user?.id || null;
-        const newUserId = user?.id || null;
-        if (previousUserId !== newUserId) {
-          if (previousUserId !== null) {
-            await this.clearEventSelectionForUser(previousUserId);
-          }
-          if (newUserId === null) {
-            this.selectedEvent = null;
-            this.setSelectedEventId?.(null);
-          }
-        }
-        this.supabaseClient = supabaseClient;
-        this.user = user;
-        this.session = session;
-        this.appName = appName;
-        this.selectedOrganisation = selectedOrganisation;
-        this.setSelectedEventId = setSelectedEventId;
-        if (previousOrgId !== newOrgId) {
-          this.resetInitialization();
-          this.isInitializedRef = false;
-          this.isFetchingRef = false;
-          if (previousOrgId !== null && newOrgId !== previousOrgId) {
-            this.events = [];
-            this.selectedEvent = null;
-          }
-        }
-        this.notify();
-      }
-      // Event state getters
-      getEvents() {
-        return this.events;
-      }
-      getSelectedEvent() {
-        return this.selectedEvent;
-      }
-      isLoading() {
-        return this._isLoading;
-      }
-      getError() {
-        return this.error;
-      }
-      // Event methods
-      setSelectedEvent(event) {
-        if (event) {
-          try {
-            if (this.selectedOrganisation && event.organisation_id !== this.selectedOrganisation.id) {
-              logger.error("EventService", "Event organisation_id does not match selected organisation", {
-                eventOrganisationId: event.organisation_id,
-                selectedOrganisationId: this.selectedOrganisation.id,
-                eventName: event.event_name
-              });
-              return;
-            }
-          } catch (error) {
-            logger.error("EventService", "Error during event validation:", error);
-          }
-          this.selectedEvent = event;
-          this.setSelectedEventId?.(event.event_id);
-          this.persistEventSelection(event.event_id).catch((error) => {
-            logger.warn("EventService", "Failed to persist event selection:", error);
-          });
-          this.userClearedEventRef = false;
-        } else {
-          this.selectedEvent = null;
-          this.setSelectedEventId?.(null);
-          this.clearEventSelection().catch((error) => {
-            logger.warn("EventService", "Failed to clear event selection:", error);
-          });
-          this.hasAutoSelectedRef = false;
-          this.userClearedEventRef = true;
-        }
-        this.notify();
-      }
-      async refreshEvents() {
-        this.isInitializedRef = false;
-        this.isFetchingRef = false;
-        await this.fetchEvents();
-      }
-      async loadPersistedEvent(events) {
-        try {
-          const userId = this.user?.id || null;
-          if (!userId) {
-            return false;
-          }
-          const storageKey = this.getStorageKey(userId);
-          const persistedEventId = await secureStorage.getItem(storageKey);
-          if (persistedEventId && events.length > 0) {
-            const persistedEvent = events.find((event) => event.event_id === persistedEventId);
-            if (persistedEvent) {
-              this.setSelectedEvent(persistedEvent);
-              return true;
-            } else {
-              await secureStorage.removeItem(storageKey);
-            }
-          }
-        } catch (error) {
-          logger.warn("EventService", "Failed to load persisted event:", error);
-        }
-        return false;
-      }
-      /**
-       * Restore persisted event after login screen has rendered
-       * This should be called explicitly from login page component
-       * 
-       * @returns Promise<boolean> - true if event was successfully restored, false otherwise
-       */
-      async restorePersistedEvent() {
-        if (this.events.length === 0) {
-          return false;
-        }
-        return await this.loadPersistedEvent(this.events);
-      }
-      async persistEventSelection(eventId) {
-        try {
-          const userId = this.user?.id || null;
-          const storageKey = this.getStorageKey(userId);
-          await secureStorage.setItem(storageKey, eventId, { encrypt: true });
-        } catch (error) {
-          logger.warn("EventService", "Failed to persist event selection:", error);
-        }
-      }
-      async clearEventSelection() {
-        try {
-          const userId = this.user?.id || null;
-          const storageKey = this.getStorageKey(userId);
-          await secureStorage.removeItem(storageKey);
-          this.selectedEvent = null;
-          this.setSelectedEventId?.(null);
-        } catch (error) {
-          logger.warn("EventService", "Failed to clear event selection:", error);
-        }
-      }
-      /**
-       * Clear event selection for a specific user (used when user logs out or changes)
-       */
-      async clearEventSelectionForUser(userId) {
-        try {
-          if (!userId) return;
-          const storageKey = this.getStorageKey(userId);
-          await secureStorage.removeItem(storageKey);
-        } catch (error) {
-          logger.warn("EventService", "Failed to clear event selection for user:", error);
-        }
-      }
-      autoSelectNextEvent(events) {
-        const nextEvent = this.getNextEventByDate(events);
-        if (nextEvent) {
-          this.setSelectedEvent(nextEvent);
-        }
-      }
-      // Lifecycle methods
-      async initialize() {
-        await super.initialize();
-        try {
-          if (typeof sessionStorage !== "undefined") {
-            sessionStorage.removeItem("pace-core-selected-event");
-          }
-          if (typeof localStorage !== "undefined") {
-            localStorage.removeItem("pace-core-selected-event");
-            localStorage.removeItem("_sec_pace-core-selected-event");
-          }
-        } catch (error) {
-          logger.warn("EventService", "Failed to clean up old storage keys:", error);
-        }
-        await this.fetchEvents(false);
-      }
-      cleanup() {
-        super.cleanup();
-      }
-      async doInitialize() {
-        await this.fetchEvents();
-      }
-      doCleanup() {
-      }
-      async fetchEvents(skipLoadPersisted = false) {
-        if (!this.user || !this.session || !this.supabaseClient || !this.appName || !this.selectedOrganisation) {
-          this.notify();
-          return;
-        }
-        this._isLoading = true;
-        this.notify();
-        if (this.isFetchingRef) {
-          return;
-        }
-        this.isFetchingRef = true;
-        let isMounted = true;
-        try {
-          logger.debug("EventService", "Fetching events with params:", {
-            p_user_id: this.user.id,
-            p_organisation_id: this.selectedOrganisation.id,
-            p_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
-          });
-          logger.debug("EventService", "RPC call completed:", {
-            hasData: !!data,
-            dataLength: Array.isArray(data) ? data.length : 0,
-            hasError: !!rpcError,
-            errorMessage: rpcError?.message || "No error"
-          });
-          if (rpcError) {
-            logger.error("EventService", "RPC error fetching events:", rpcError);
-            throw new Error(rpcError.message || "Failed to fetch events");
-          }
-          if (isMounted) {
-            const eventsData = data || [];
-            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_code: event.event_code,
-              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;
-            if (!skipLoadPersisted) {
-              const persistedEventLoaded = await this.loadPersistedEvent(transformedEvents);
-              if (!persistedEventLoaded && !this.userClearedEventRef) {
-                const nextEvent = this.getNextEventByDate(transformedEvents);
-                if (nextEvent) {
-                  this.hasAutoSelectedRef = true;
-                  this.setSelectedEvent(nextEvent);
-                }
-              }
-            } else {
-              if (!this.userClearedEventRef) {
-                const nextEvent = this.getNextEventByDate(transformedEvents);
-                if (nextEvent) {
-                  this.hasAutoSelectedRef = true;
-                  this.setSelectedEvent(nextEvent);
-                }
-              }
-            }
-          }
-        } catch (err) {
-          logger.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 startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
-        const futureEvents = eventsToUse.filter((event) => {
-          if (!event.event_date) return false;
-          const eventDate = new Date(event.event_date);
-          const startOfEventDate = new Date(eventDate.getFullYear(), eventDate.getMonth(), eventDate.getDate()).getTime();
-          return startOfEventDate >= startOfToday;
-        });
-        if (futureEvents.length > 0) {
-          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];
-        }
-        const pastEvents = eventsToUse.filter((event) => {
-          if (!event.event_date) return false;
-          const eventDate = new Date(event.event_date);
-          const startOfEventDate = new Date(eventDate.getFullYear(), eventDate.getMonth(), eventDate.getDate()).getTime();
-          return startOfEventDate < startOfToday;
-        });
-        if (pastEvents.length > 0) {
-          const sortedPastEvents = pastEvents.sort((a, b) => {
-            const dateA = new Date(a.event_date);
-            const dateB = new Date(b.event_date);
-            return dateB.getTime() - dateA.getTime();
-          });
-          return sortedPastEvents[0];
-        }
-        return null;
-      }
-    };
-  }
-});
-
-// src/providers/services/EventServiceProvider.tsx
-import { createContext as createContext3, useContext as useContext3, useMemo as useMemo3, useEffect as useEffect3, useRef as useRef2 } from "react";
-import { jsx as jsx3 } from "react/jsx-runtime";
-function EventServiceProvider({
-  children,
-  supabaseClient,
-  user,
-  session,
-  appName,
-  selectedOrganisation,
-  setSelectedEventId
-}) {
-  const eventServiceRef = useRef2(null);
-  if (!eventServiceRef.current) {
-    eventServiceRef.current = new EventService(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
-  }
-  const eventService = eventServiceRef.current;
-  useEffect3(() => {
-    let isMounted = true;
-    const updateAndInitialize = async () => {
-      await eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
-      if (!isMounted) return;
-      await eventService.initialize().catch((error) => {
-        if (isMounted) {
-          logger.error("EventServiceProvider", "Failed to initialize event service:", error);
-        }
-      });
-    };
-    updateAndInitialize();
-    return () => {
-      isMounted = false;
-    };
-  }, [eventService, supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
-  const contextValue = useMemo3(() => ({
-    eventService
-  }), [eventService]);
-  return /* @__PURE__ */ jsx3(EventServiceContext.Provider, { value: contextValue, children });
-}
-var EventServiceContext, useEventService;
-var init_EventServiceProvider = __esm({
-  "src/providers/services/EventServiceProvider.tsx"() {
-    "use strict";
-    init_EventService();
-    init_logger();
-    EventServiceContext = createContext3(null);
-    useEventService = () => {
-      const context = useContext3(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();
-    init_logger();
-    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) {
-          logger.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) {
-          logger.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) {
-            logger.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-TO6ZOF35.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) {
-          logger.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 createContext4, useContext as useContext4, useMemo as useMemo4, useEffect as useEffect4, useRef as useRef3 } from "react";
-import { jsx as jsx4 } from "react/jsx-runtime";
-function InactivityServiceProvider({
-  children,
-  supabaseClient,
-  user,
-  session,
-  idleTimeoutMs = 30 * 60 * 1e3,
-  warnBeforeMs = 60 * 1e3,
-  onIdleLogout
-}) {
-  const inactivityServiceRef = useRef3(null);
-  if (!inactivityServiceRef.current) {
-    inactivityServiceRef.current = new InactivityService(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout);
-  }
-  const inactivityService = inactivityServiceRef.current;
-  useEffect4(() => {
-    inactivityService.updateDependencies(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout);
-    let isMounted = true;
-    inactivityService.initialize().catch((error) => {
-      if (isMounted) {
-        logger.error("InactivityServiceProvider", "Failed to initialize inactivity service:", error);
-      }
-    });
-    return () => {
-      isMounted = false;
-    };
-  }, [inactivityService, supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout]);
-  const contextValue = useMemo4(() => ({
-    inactivityService
-  }), [inactivityService]);
-  return /* @__PURE__ */ jsx4(InactivityServiceContext.Provider, { value: contextValue, children });
-}
-var InactivityServiceContext, useInactivityService;
-var init_InactivityServiceProvider = __esm({
-  "src/providers/services/InactivityServiceProvider.tsx"() {
-    "use strict";
-    init_InactivityService();
-    init_logger();
-    InactivityServiceContext = createContext4(null);
-    useInactivityService = () => {
-      const context = useContext4(InactivityServiceContext);
-      if (!context) {
-        throw new Error("useInactivityService must be used within InactivityServiceProvider");
-      }
-      return context.inactivityService;
-    };
-  }
-});
-
-// src/hooks/services/useAuthService.ts
-import { useContext as useContext5, useReducer, useEffect as useEffect5 } from "react";
-function useAuthService2() {
-  const context = useContext5(AuthServiceContext);
-  if (!context) {
-    throw new Error("useAuthService must be used within AuthServiceProvider");
-  }
-  const [, forceUpdate] = useReducer((x) => x + 1, 0);
-  useEffect5(() => {
-    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/useOrganisationService.ts
-import { useContext as useContext6, useReducer as useReducer2, useEffect as useEffect6 } from "react";
-function useOrganisationService2() {
-  const context = useContext6(OrganisationServiceContext);
-  if (!context) {
-    throw new Error("useOrganisationService must be used within OrganisationServiceProvider");
-  }
-  const [, forceUpdate] = useReducer2((x) => x + 1, 0);
-  useEffect6(() => {
-    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 useContext7, useReducer as useReducer3, useEffect as useEffect7 } from "react";
-function useEventService2() {
-  const context = useContext7(EventServiceContext);
-  if (!context) {
-    throw new Error("useEventService must be used within EventServiceProvider");
-  }
-  const [, forceUpdate] = useReducer3((x) => x + 1, 0);
-  useEffect7(() => {
-    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 useContext8, useReducer as useReducer4, useEffect as useEffect8 } from "react";
-function useInactivityService2() {
-  const context = useContext8(InactivityServiceContext);
-  if (!context) {
-    throw new Error("useInactivityService must be used within InactivityServiceProvider");
-  }
-  const [, forceUpdate] = useReducer4((x) => x + 1, 0);
-  useEffect8(() => {
-    return context.inactivityService.subscribe(() => forceUpdate());
-  }, [context.inactivityService]);
-  return context.inactivityService;
-}
-var init_useInactivityService = __esm({
-  "src/hooks/services/useInactivityService.ts"() {
-    "use strict";
-    init_InactivityServiceProvider();
-  }
-});
-
-// src/hooks/useSessionRestoration.ts
-import { useContext as useContext9, useMemo as useMemo5, useEffect as useEffect9, useState as useState2 } from "react";
-function useSessionRestoration() {
-  const context = useContext9(AuthServiceContext);
-  if (!context) {
-    throw new Error("useSessionRestoration must be used within AuthServiceProvider");
-  }
-  const { sessionRestoration } = context;
-  const [hasTimedOut, setHasTimedOut] = useState2(false);
-  useEffect9(() => {
-    let timeoutHandle = null;
-    if (sessionRestoration.isRestoring && !sessionRestoration.restorationComplete && !sessionRestoration.restorationError) {
-      setHasTimedOut(false);
-      timeoutHandle = setTimeout(() => {
-        log.warn("Session restoration timed out");
-        setHasTimedOut(true);
-      }, SESSION_RESTORATION_TIMEOUT_MS);
-    } else {
-      setHasTimedOut(false);
-    }
-    return () => {
-      if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-      }
-    };
-  }, [
-    sessionRestoration.isRestoring,
-    sessionRestoration.restorationComplete,
-    sessionRestoration.restorationError
-  ]);
-  return useMemo5(() => ({
-    ...sessionRestoration,
-    hasTimedOut,
-    timeoutMs: SESSION_RESTORATION_TIMEOUT_MS
-  }), [sessionRestoration, hasTimedOut]);
-}
-var log, SESSION_RESTORATION_TIMEOUT_MS;
-var init_useSessionRestoration = __esm({
-  "src/hooks/useSessionRestoration.ts"() {
-    "use strict";
-    init_AuthServiceProvider();
-    init_logger();
-    log = createLogger("useSessionRestoration");
-    SESSION_RESTORATION_TIMEOUT_MS = 5e3;
-  }
-});
-
-// src/providers/services/UnifiedAuthProvider.tsx
-import { createContext as createContext5, useContext as useContext10, useMemo as useMemo6, useCallback, useRef as useRef4 } from "react";
-import { jsx as jsx5 } from "react/jsx-runtime";
-function UnifiedAuthContextProvider({
-  children,
-  appName,
-  appConfig = { requires_event: true },
-  // Default to requiring events
-  ...props
-}) {
-  const authService = useAuthService2();
-  const organisationService = useOrganisationService2();
-  const inactivityService = useInactivityService2();
-  const sessionRestorationState = useSessionRestoration();
-  const {
-    hasTimedOut: sessionRestorationTimedOut,
-    timeoutMs: sessionRestorationTimeoutMs,
-    isRestoring,
-    restorationComplete,
-    restorationError
-  } = sessionRestorationState;
-  const sessionRestoration = useMemo6(() => ({
-    isRestoring,
-    restorationComplete,
-    restorationError
-  }), [isRestoring, restorationComplete, restorationError]);
-  let eventService;
-  try {
-    eventService = useEventService2();
-  } catch (error) {
-    eventService = {
-      getEvents: () => [],
-      getSelectedEvent: () => null,
-      isLoading: () => false,
-      getError: () => null,
-      setSelectedEvent: () => {
-      },
-      refreshEvents: async () => {
-      }
-    };
-  }
-  const currentUser = authService.getUser();
-  const currentSession = authService.getSession();
-  const isAuth = !!(currentUser && currentSession);
-  const authLoading = authService.isLoading();
-  const orgLoading = organisationService.isLoading();
-  const eventLoading = eventService.isLoading();
-  const restorationLoading = sessionRestoration.isRestoring && !sessionRestorationTimedOut && !sessionRestoration.restorationError;
-  const totalLoading = restorationLoading || authLoading || orgLoading || eventLoading;
-  const authError = authService.getError();
-  const supabase = authService.getSupabaseClient();
-  const selectedOrganisation = organisationService.getSelectedOrganisation();
-  const organisations = organisationService.getOrganisations();
-  const userMemberships = organisationService.getUserMemberships();
-  const organisationError = organisationService.getError();
-  const hasValidOrganisationContext = organisationService.hasValidOrganisationContext();
-  const isContextReady = organisationService.isContextReady();
-  const events = eventService.getEvents();
-  const selectedEvent = eventService.getSelectedEvent();
-  const eventError = eventService.getError();
-  const showInactivityWarning = inactivityService.getShowInactivityWarning();
-  const inactivityTimeRemaining = inactivityService.getInactivityTimeRemaining();
-  const isIdle = inactivityService.isIdle();
-  const timeRemaining = inactivityService.getTimeRemaining();
-  const showWarning = inactivityService.isWarningShown();
-  const isTracking = inactivityService.isTracking();
-  const hasErrors = !!(authError || organisationError || eventError || sessionRestoration.restorationError);
-  const signIn = useCallback((email, password) => authService.signIn(email, password), [authService]);
-  const signUp = useCallback((email, password) => authService.signUp(email, password), [authService]);
-  const signOut = useCallback(() => authService.signOut(), [authService]);
-  const resetPassword = useCallback((email) => authService.resetPassword(email), [authService]);
-  const updatePassword = useCallback((password) => authService.updatePassword(password), [authService]);
-  const refreshSession = useCallback(() => authService.refreshSession(), [authService]);
-  const switchOrganisation = useCallback((orgId) => organisationService.switchOrganisation(orgId), [organisationService]);
-  const getUserRole = useCallback((orgId) => organisationService.getUserRole(orgId), [organisationService]);
-  const validateOrganisationAccess = useCallback((orgId) => organisationService.validateOrganisationAccess(orgId), [organisationService]);
-  const refreshOrganisations = useCallback(() => organisationService.refreshOrganisations(), [organisationService]);
-  const ensureOrganisationContext = useCallback(() => organisationService.ensureOrganisationContext(), [organisationService]);
-  const isOrganisationSecure = useCallback(() => organisationService.isOrganisationSecure(), [organisationService]);
-  const getPrimaryOrganisation = useCallback(() => organisationService.getPrimaryOrganisation(), [organisationService]);
-  const setSelectedEvent = useCallback((event) => eventService.setSelectedEvent(event), [eventService]);
-  const refreshEvents = useCallback(() => eventService.refreshEvents(), [eventService]);
-  const resetActivity = useCallback(() => inactivityService.resetActivity(), [inactivityService]);
-  const startTracking = useCallback(() => inactivityService.startTracking(), [inactivityService]);
-  const stopTracking = useCallback(() => inactivityService.stopTracking(), [inactivityService]);
-  const handleIdleLogout = useCallback(() => inactivityService.handleIdleLogout(), [inactivityService]);
-  const handleStaySignedIn = useCallback(() => inactivityService.handleStaySignedIn(), [inactivityService]);
-  const handleSignOutNow = useCallback(() => inactivityService.handleSignOutNow(), [inactivityService]);
-  const prevStateRef = useRef4(null);
-  const isDev = import.meta.env.DEV || import.meta.env.MODE === "development";
-  if (isDev) {
-    const currentState = {
-      isAuthenticated: isAuth,
-      userEmail: currentUser?.email,
-      totalLoading
-    };
-    const prevState = prevStateRef.current;
-    if (!prevState || prevState.isAuthenticated !== currentState.isAuthenticated || prevState.userEmail !== currentState.userEmail || prevState.totalLoading !== currentState.totalLoading) {
-      logger.debug("UnifiedAuthContext", "Auth state changed:", {
-        isAuthenticated: isAuth,
-        user: currentUser?.email,
-        session: currentSession ? "exists" : "null",
-        totalLoading,
-        authLoading,
-        orgLoading,
-        eventLoading,
-        orgContextReady: isContextReady,
-        sessionRestoration,
-        sessionRestorationTimedOut
-      });
-      prevStateRef.current = currentState;
-    }
-  }
-  const contextValue = useMemo6(() => {
-    return {
-      // Auth state
-      user: currentUser,
-      session: currentSession,
-      isAuthenticated: isAuth,
-      authLoading,
-      authError,
-      error: authError,
-      // Alias for backward compatibility
-      supabase,
-      // Auth methods
-      signIn,
-      signUp,
-      signOut,
-      resetPassword,
-      updatePassword,
-      refreshSession,
-      // Organisation state
-      selectedOrganisation,
-      organisations,
-      userMemberships,
-      organisationLoading: orgLoading,
-      organisationError,
-      hasValidOrganisationContext,
-      isContextReady,
-      // Organisation methods
-      switchOrganisation,
-      getUserRole,
-      validateOrganisationAccess,
-      refreshOrganisations,
-      ensureOrganisationContext,
-      isOrganisationSecure,
-      getPrimaryOrganisation,
-      // Event state
-      events,
-      selectedEvent,
-      eventLoading,
-      eventError,
-      // Event methods
-      setSelectedEvent,
-      refreshEvents,
-      // Inactivity state
-      showInactivityWarning,
-      inactivityTimeRemaining,
-      isIdle,
-      timeRemaining,
-      showWarning,
-      isTracking,
-      // Inactivity methods
-      resetActivity,
-      startTracking,
-      stopTracking,
-      handleIdleLogout,
-      handleStaySignedIn,
-      handleSignOutNow,
-      // Additional unified properties
-      appName,
-      appConfig,
-      isLoading: totalLoading,
-      hasErrors,
-      sessionRestoration,
-      sessionRestorationTimedOut,
-      sessionRestorationTimeoutMs
-    };
-  }, [
-    // All primitive values extracted from services
-    // Note: Arrays/objects from services are stable references (same reference unless data changes)
-    currentUser,
-    currentSession,
-    isAuth,
-    authLoading,
-    authError,
-    supabase,
-    selectedOrganisation,
-    organisations,
-    userMemberships,
-    orgLoading,
-    organisationError,
-    hasValidOrganisationContext,
-    isContextReady,
-    events,
-    selectedEvent,
-    eventLoading,
-    eventError,
-    showInactivityWarning,
-    inactivityTimeRemaining,
-    isIdle,
-    timeRemaining,
-    showWarning,
-    isTracking,
-    totalLoading,
-    hasErrors,
-    appName,
-    appConfig,
-    sessionRestoration,
-    sessionRestorationTimedOut,
-    sessionRestorationTimeoutMs,
-    // Stable function references from useCallback (services are stable, so callbacks are too)
-    signIn,
-    signUp,
-    signOut,
-    resetPassword,
-    updatePassword,
-    refreshSession,
-    switchOrganisation,
-    getUserRole,
-    validateOrganisationAccess,
-    refreshOrganisations,
-    ensureOrganisationContext,
-    isOrganisationSecure,
-    getPrimaryOrganisation,
-    setSelectedEvent,
-    refreshEvents,
-    resetActivity,
-    startTracking,
-    stopTracking,
-    handleIdleLogout,
-    handleStaySignedIn,
-    handleSignOutNow
-  ]);
-  return /* @__PURE__ */ jsx5(UnifiedAuthContext.Provider, { value: contextValue, children });
-}
-function EventServiceProviderWrapper({
-  children,
-  supabaseClient,
-  user,
-  session,
-  appName
-}) {
-  const organisationService = useOrganisationService2();
-  const selectedOrganisation = organisationService.getSelectedOrganisation();
-  return /* @__PURE__ */ jsx5(
-    EventServiceProvider,
-    {
-      supabaseClient,
-      user,
-      session,
-      appName,
-      selectedOrganisation,
-      setSelectedEventId: () => {
-      },
-      children
-    }
-  );
-}
-function ServiceAwareProviders({
-  children,
-  supabaseClient,
-  appName,
-  appConfig,
-  persistState,
-  enablePersistence,
-  requireOrganisationContext,
-  idleTimeoutMs,
-  warnBeforeMs,
-  onIdleLogout,
-  renderInactivityWarning,
-  dangerouslyDisableInactivity
-}) {
-  const authService = useAuthService2();
-  return /* @__PURE__ */ jsx5(
-    OrganisationServiceProvider,
-    {
-      supabaseClient,
-      user: authService.getUser(),
-      session: authService.getSession(),
-      children: /* @__PURE__ */ jsx5(
-        EventServiceProviderWrapper,
-        {
-          supabaseClient,
-          user: authService.getUser(),
-          session: authService.getSession(),
-          appName,
-          children: /* @__PURE__ */ jsx5(
-            InactivityServiceProvider,
-            {
-              supabaseClient,
-              user: authService.getUser(),
-              session: authService.getSession(),
-              idleTimeoutMs,
-              warnBeforeMs,
-              onIdleLogout,
-              children: /* @__PURE__ */ jsx5(
-                UnifiedAuthContextProvider,
-                {
-                  appName,
-                  appConfig,
-                  supabaseClient,
-                  persistState,
-                  enablePersistence,
-                  requireOrganisationContext,
-                  idleTimeoutMs,
-                  warnBeforeMs,
-                  onIdleLogout,
-                  renderInactivityWarning,
-                  dangerouslyDisableInactivity,
-                  children
-                }
-              )
-            }
-          )
-        }
-      )
-    }
-  );
-}
-function UnifiedAuthProvider({
-  children,
-  supabaseClient,
-  appName,
-  appConfig = { requires_event: true },
-  // Default to requiring events
-  persistState = true,
-  enablePersistence,
-  requireOrganisationContext = true,
-  idleTimeoutMs = 30 * 60 * 1e3,
-  // 30 minutes
-  warnBeforeMs = 60 * 1e3,
-  // 60 seconds
-  onIdleLogout,
-  renderInactivityWarning,
-  dangerouslyDisableInactivity = false
-}) {
-  return /* @__PURE__ */ jsx5(AuthServiceProvider, { supabaseClient, appName, children: /* @__PURE__ */ jsx5(
-    ServiceAwareProviders,
-    {
-      supabaseClient,
-      appName,
-      appConfig,
-      persistState,
-      enablePersistence,
-      requireOrganisationContext,
-      idleTimeoutMs,
-      warnBeforeMs,
-      onIdleLogout,
-      renderInactivityWarning,
-      dangerouslyDisableInactivity,
-      children
-    }
-  ) });
-}
-var UnifiedAuthContext, useUnifiedAuth;
-var init_UnifiedAuthProvider = __esm({
-  "src/providers/services/UnifiedAuthProvider.tsx"() {
-    "use strict";
-    init_AuthServiceProvider();
-    init_OrganisationServiceProvider();
-    init_EventServiceProvider();
-    init_InactivityServiceProvider();
-    init_useAuthService();
-    init_useOrganisationService();
-    init_useEventService();
-    init_useInactivityService();
-    init_useSessionRestoration();
-    init_logger();
-    UnifiedAuthContext = createContext5(void 0);
-    useUnifiedAuth = () => {
-      const context = useContext10(UnifiedAuthContext);
-      if (!context) {
-        logger.error("useUnifiedAuth", "useUnifiedAuth must be used within a UnifiedAuthProvider");
-        throw new Error("useUnifiedAuth must be used within a UnifiedAuthProvider");
-      }
-      return context;
-    };
-  }
-});
-
-export {
-  AuthServiceContext,
-  AuthServiceProvider,
-  useAuthService,
-  init_AuthServiceProvider,
-  OrganisationServiceContext,
-  OrganisationServiceProvider,
-  useOrganisationService,
-  init_OrganisationServiceProvider,
-  EventServiceContext,
-  EventServiceProvider,
-  useEventService,
-  init_EventServiceProvider,
-  InactivityServiceContext,
-  InactivityServiceProvider,
-  useInactivityService,
-  init_InactivityServiceProvider,
-  useAuthService2,
-  init_useAuthService,
-  useOrganisationService2,
-  init_useOrganisationService,
-  useEventService2,
-  init_useEventService,
-  useInactivityService2,
-  init_useInactivityService,
-  useSessionRestoration,
-  init_useSessionRestoration,
-  useUnifiedAuth,
-  UnifiedAuthProvider,
-  init_UnifiedAuthProvider
-};
-//# sourceMappingURL=chunk-3JI76CYK.js.map