@jmruthers/pace-core 0.5.181 → 0.5.183

package/dist/chunk-FUEYYMX5.js

@@ -0,0 +1,2296 @@
+import {
+  assertOrganisationId,
+  assertUserId
+} from "./chunk-QXHPKYJV.js";
+import {
+  secureStorage,
+  setOrganisationContext
+} from "./chunk-VBXEHIUJ.js";
+import {
+  createLogger,
+  logger
+} from "./chunk-PWLANIRT.js";
+
+// src/providers/services/UnifiedAuthProvider.tsx
+import { createContext as createContext5, useContext as useContext6, useMemo as useMemo6, useCallback, useRef as useRef4, useEffect as useEffect10, useState as useState3 } from "react";
+
+// src/providers/services/AuthServiceProvider.tsx
+import { createContext, useMemo, useEffect, useState } from "react";
+
+// src/services/AuthService.ts
+import { AuthError } from "@supabase/supabase-js";
+
+// src/services/base/BaseService.ts
+var 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
+var 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.errorHandler = null;
+    this.unhandledRejectionHandler = null;
+    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) {
+      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();
+    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);
+    }
+    this.notify();
+  }
+  clearRestorationTimeout() {
+    if (this.restorationTimeoutId) {
+      clearTimeout(this.restorationTimeoutId);
+      this.restorationTimeoutId = null;
+    }
+  }
+  async setupAuthStateListener() {
+    if (!this.supabaseClient) {
+      this.authLoading = false;
+      this.notify();
+      return;
+    }
+    try {
+      const subscription = this.supabaseClient.auth.onAuthStateChange(
+        (event, session) => {
+          try {
+            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();
+          }
+        }
+      );
+      this.authStateSubscription = subscription.data.subscription;
+    } 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 {
+      let currentSession = null;
+      let sessionError = null;
+      try {
+        const { data, error } = await this.supabaseClient.auth.getSession();
+        currentSession = data?.session ?? null;
+        sessionError = error ?? null;
+      } catch (error) {
+        currentSession = null;
+        sessionError = null;
+      }
+      if (sessionError) {
+        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) {
+        }
+      }
+      if (currentSession) {
+        this.session = currentSession;
+        this.user = currentSession.user;
+        this.authError = null;
+      } else if (!sessionError) {
+        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);
+      }
+    } catch (error) {
+      logger.warn("AuthService", `Error tracking ${sessionType} session:`, error);
+    }
+  }
+  setupErrorHandlers() {
+    if (typeof window === "undefined") return;
+    this.errorHandler = (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;
+      }
+    };
+    this.unhandledRejectionHandler = (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", this.errorHandler);
+    window.addEventListener("unhandledrejection", this.unhandledRejectionHandler);
+  }
+  removeErrorHandlers() {
+    if (typeof window === "undefined") return;
+    if (this.errorHandler) {
+      window.removeEventListener("error", this.errorHandler);
+      this.errorHandler = null;
+    }
+    if (this.unhandledRejectionHandler) {
+      window.removeEventListener("unhandledrejection", this.unhandledRejectionHandler);
+      this.unhandledRejectionHandler = null;
+    }
+  }
+};
+
+// src/providers/services/AuthServiceProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var AuthServiceContext = createContext(null);
+function AuthServiceProvider({ children, supabaseClient, appName }) {
+  const authService = useMemo(
+    () => new AuthService(supabaseClient, appName),
+    [supabaseClient, appName]
+  );
+  const [sessionRestoration, setSessionRestoration] = useState(
+    () => authService.getSessionRestorationState()
+  );
+  useEffect(() => {
+    const unsubscribe = authService.subscribe(() => {
+      const restorationState = authService.getSessionRestorationState();
+      setSessionRestoration(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 });
+}
+
+// src/providers/services/OrganisationServiceProvider.tsx
+import { createContext as createContext2, useMemo as useMemo2, useEffect as useEffect2, useRef } from "react";
+
+// src/services/OrganisationService.ts
+var 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.resetInitialization();
+    }
+    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 {
+      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]);
+      this._isContextReady = true;
+      this.notify();
+    } catch (error) {
+      logger.error("OrganisationService", "Failed to set database organisation context:", error);
+      this._isContextReady = true;
+      this.notify();
+    }
+  }
+  async loadUserOrganisations() {
+    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) {
+      this._isLoading = true;
+      this.notify();
+      return;
+    }
+    const now = Date.now();
+    if (now - this.lastLoadTimeRef < 2e3) {
+      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 {
+      let memberships, membershipError;
+      try {
+        const timeoutPromise = new Promise((_, reject) => {
+          const timeoutId = setTimeout(() => reject(new Error("RPC call timeout after 10 seconds")), 1e4);
+          abortSignal.addEventListener("abort", () => {
+            clearTimeout(timeoutId);
+            reject(new Error("Request aborted"));
+          });
+        });
+        const rpcPromise = this.supabaseClient.rpc("data_user_organisation_roles_get", {
+          p_user_id: this.user.id,
+          p_organisation_id: null
+        });
+        if (abortSignal.aborted) {
+          throw new Error("Request aborted");
+        }
+        const result = await Promise.race([rpcPromise, timeoutPromise]);
+        memberships = result.data?.filter(
+          (role) => ["org_admin", "leader", "member"].includes(role.role)
+        ).map((m) => ({
+          ...m,
+          user_id: assertUserId(m.user_id),
+          organisation_id: assertOrganisationId(m.organisation_id)
+        })) || [];
+        membershipError = result.error;
+      } catch (queryError) {
+        membershipError = queryError instanceof Error ? queryError : new Error(String(queryError));
+      }
+      if (membershipError) {
+        logger.error("OrganisationService", "Error loading memberships:", membershipError);
+        if (membershipError.message?.includes("timeout")) {
+          try {
+            if (abortSignal.aborted) {
+              throw new Error("Request aborted");
+            }
+            const { data: fallbackData, error: fallbackError } = await this.supabaseClient.from("rbac_organisation_roles").select(`
+                id,
+                user_id,
+                organisation_id,
+                role,
+                status,
+                granted_at,
+                granted_by,
+                revoked_at,
+                revoked_by,
+                notes,
+                created_at,
+                updated_at,
+                organisations!inner(
+                  id,
+                  name,
+                  display_name,
+                  subscription_tier,
+                  settings,
+                  is_active,
+                  parent_id,
+                  created_at,
+                  updated_at
+                )
+              `).eq("user_id", this.user.id).eq("status", "active").is("revoked_at", null).in("role", ["org_admin", "leader", "member"]);
+            if (fallbackError) {
+              logger.error("OrganisationService", "Fallback query also failed:", fallbackError);
+              throw membershipError;
+            }
+            memberships = fallbackData?.map((m) => ({
+              ...m,
+              user_id: assertUserId(m.user_id),
+              organisation_id: assertOrganisationId(m.organisation_id)
+            })) || [];
+            membershipError = null;
+          } catch (fallbackErr) {
+            logger.error("OrganisationService", "Fallback query failed:", fallbackErr);
+            throw membershipError;
+          }
+        } 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 { jsx as jsx2 } from "react/jsx-runtime";
+var OrganisationServiceContext = createContext2(null);
+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]);
+  useEffect2(() => {
+    return () => {
+      organisationService.cleanup();
+    };
+  }, [organisationService]);
+  const contextValue = useMemo2(() => ({
+    organisationService
+  }), [organisationService]);
+  return /* @__PURE__ */ jsx2(OrganisationServiceContext.Provider, { value: contextValue, children });
+}
+
+// src/providers/services/EventServiceProvider.tsx
+import { createContext as createContext3, useMemo as useMemo3, useEffect as useEffect3, useRef as useRef2 } from "react";
+
+// src/services/EventService.ts
+var 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 !== null && previousOrgId !== newOrgId) {
+        this.events = [];
+        this.selectedEvent = null;
+      } else if (previousOrgId !== null && newOrgId === null) {
+        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();
+  }
+  cleanup() {
+    super.cleanup();
+  }
+  async doInitialize() {
+    if (this.isInitializedRef) {
+      return;
+    }
+    if (this.isFetchingRef) {
+      return;
+    }
+    try {
+      sessionStorage.removeItem("pace-core-selected-event");
+      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);
+    }
+    if (!this.user || !this.selectedOrganisation) {
+      return;
+    }
+    await this.fetchEvents(false);
+  }
+  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 {
+      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
+      });
+      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,
+          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: assertOrganisationId(event.organisation_id),
+          is_visible: event.is_visible,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        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 { jsx as jsx3 } from "react/jsx-runtime";
+var EventServiceContext = createContext3(null);
+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]);
+  useEffect3(() => {
+    return () => {
+      eventService.cleanup();
+    };
+  }, [eventService]);
+  const contextValue = useMemo3(() => ({
+    eventService
+  }), [eventService]);
+  return /* @__PURE__ */ jsx3(EventServiceContext.Provider, { value: contextValue, children });
+}
+
+// src/providers/services/InactivityServiceProvider.tsx
+import { createContext as createContext4, useMemo as useMemo4, useEffect as useEffect4, useRef as useRef3 } from "react";
+
+// src/services/InactivityService.ts
+var 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.cleanupHandlers = null;
+    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.cleanupHandlers) {
+      this.cleanupHandlers();
+      this.cleanupHandlers = null;
+    }
+    if (this.inactivityTracker) {
+      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;
+    }
+    this.setupEventHandlers();
+  }
+  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.cleanupHandlers = () => {
+      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 { jsx as jsx4 } from "react/jsx-runtime";
+var InactivityServiceContext = createContext4(null);
+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]);
+  useEffect4(() => {
+    return () => {
+      inactivityService.cleanup();
+    };
+  }, [inactivityService]);
+  const contextValue = useMemo4(() => ({
+    inactivityService
+  }), [inactivityService]);
+  return /* @__PURE__ */ jsx4(InactivityServiceContext.Provider, { value: contextValue, children });
+}
+
+// src/hooks/services/useAuthService.ts
+import { useContext, useReducer, useEffect as useEffect5 } from "react";
+function useAuthService() {
+  const context = useContext(AuthServiceContext);
+  if (!context) {
+    throw new Error("useAuthService must be used within AuthServiceProvider");
+  }
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  useEffect5(() => {
+    return context.authService.subscribe(() => forceUpdate());
+  }, [context.authService]);
+  return context.authService;
+}
+
+// src/hooks/services/useOrganisationService.ts
+import { useContext as useContext2, useReducer as useReducer2, useEffect as useEffect6 } from "react";
+function useOrganisationService() {
+  const context = useContext2(OrganisationServiceContext);
+  if (!context) {
+    throw new Error("useOrganisationService must be used within OrganisationServiceProvider");
+  }
+  const [, forceUpdate] = useReducer2((x) => x + 1, 0);
+  useEffect6(() => {
+    return context.organisationService.subscribe(() => forceUpdate());
+  }, [context.organisationService]);
+  return context.organisationService;
+}
+
+// src/hooks/services/useEventService.ts
+import { useContext as useContext3, useReducer as useReducer3, useEffect as useEffect7 } from "react";
+function useEventService() {
+  const context = useContext3(EventServiceContext);
+  if (!context) {
+    throw new Error("useEventService must be used within EventServiceProvider");
+  }
+  const [, forceUpdate] = useReducer3((x) => x + 1, 0);
+  useEffect7(() => {
+    return context.eventService.subscribe(() => forceUpdate());
+  }, [context.eventService]);
+  return context.eventService;
+}
+
+// src/hooks/services/useInactivityService.ts
+import { useContext as useContext4, useReducer as useReducer4, useEffect as useEffect8 } from "react";
+function useInactivityService() {
+  const context = useContext4(InactivityServiceContext);
+  if (!context) {
+    throw new Error("useInactivityService must be used within InactivityServiceProvider");
+  }
+  const [, forceUpdate] = useReducer4((x) => x + 1, 0);
+  useEffect8(() => {
+    return context.inactivityService.subscribe(() => forceUpdate());
+  }, [context.inactivityService]);
+  return context.inactivityService;
+}
+
+// src/hooks/useSessionRestoration.ts
+import { useContext as useContext5, useMemo as useMemo5, useEffect as useEffect9, useState as useState2 } from "react";
+var log = createLogger("useSessionRestoration");
+var SESSION_RESTORATION_TIMEOUT_MS = 5e3;
+function useSessionRestoration() {
+  const context = useContext5(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]);
+}
+
+// src/providers/services/UnifiedAuthProvider.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var UnifiedAuthContext = createContext5(void 0);
+var useUnifiedAuth = () => {
+  const context = useContext6(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;
+};
+function UnifiedAuthContextProvider({
+  children,
+  appName,
+  appConfig = { requires_event: true },
+  // Default to requiring events
+  ...props
+}) {
+  const authService = useAuthService();
+  const organisationService = useOrganisationService();
+  const inactivityService = useInactivityService();
+  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 = useEventService();
+  } 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 supabase = authService.getSupabaseClient();
+  const [appId, setAppId] = useState3(void 0);
+  const isResolvingAppIdRef = useRef4(false);
+  useEffect10(() => {
+    if (isAuth && currentUser?.id && supabase && appName && !appId && !isResolvingAppIdRef.current) {
+      isResolvingAppIdRef.current = true;
+      const userId = currentUser.id;
+      const appNameValue = appName;
+      import("./api-ROMBCNKU.js").then(async ({ resolveAppContext, setupRBAC }) => {
+        try {
+          setupRBAC(supabase);
+          const result = await resolveAppContext({
+            userId,
+            appName: appNameValue
+          });
+          if (result?.appId) {
+            setAppId(result.appId);
+            logger.debug("UnifiedAuthProvider", "appId resolved on login", {
+              appId: result.appId,
+              appName: appNameValue
+            });
+          }
+        } catch (error) {
+          logger.error("UnifiedAuthProvider", "Failed to resolve appId on login", {
+            error: error instanceof Error ? error.message : String(error),
+            appName: appNameValue,
+            userId
+          });
+        } finally {
+          isResolvingAppIdRef.current = false;
+        }
+      }).catch((importError) => {
+        logger.error("UnifiedAuthProvider", "Failed to import RBAC API", importError);
+        isResolvingAppIdRef.current = false;
+      });
+    }
+    if (!isAuth) {
+      setAppId(void 0);
+    }
+  }, [isAuth, currentUser?.id, supabase, appName, appId]);
+  const authLoading = authService.isLoading();
+  const orgLoading = organisationService.isLoading();
+  const eventLoading = eventService.isLoading();
+  const restorationLoading = sessionRestoration.isRestoring && !sessionRestorationTimedOut && !sessionRestoration.restorationError;
+  const totalLoading = restorationLoading || authLoading || orgLoading || eventLoading;
+  const authError = authService.getError();
+  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  const 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) {
+      prevStateRef.current = currentState;
+    }
+  }
+  const contextValue = useMemo6(() => {
+    return {
+      // Auth state
+      user: currentUser,
+      session: currentSession,
+      isAuthenticated: isAuth,
+      authLoading,
+      authError,
+      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,
+      appId,
+      // Resolved immediately on login
+      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,
+    appId,
+    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 = useOrganisationService();
+  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 = useAuthService();
+  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
+}) {
+  const clientRef = useRef4(supabaseClient);
+  useEffect10(() => {
+    if (clientRef.current !== supabaseClient) {
+      logger.warn("UnifiedAuthProvider", "Supabase client reference changed - this may indicate multiple client instances are being created", {
+        previousClient: clientRef.current,
+        newClient: supabaseClient,
+        note: 'Ensure you create the Supabase client once and reuse it. Creating multiple clients can cause performance issues and the "Multiple GoTrueClient instances" warning.'
+      });
+      clientRef.current = supabaseClient;
+    }
+  }, [supabaseClient]);
+  return /* @__PURE__ */ jsx5(AuthServiceProvider, { supabaseClient, appName, children: /* @__PURE__ */ jsx5(
+    ServiceAwareProviders,
+    {
+      supabaseClient,
+      appName,
+      appConfig,
+      persistState,
+      enablePersistence,
+      requireOrganisationContext,
+      idleTimeoutMs,
+      warnBeforeMs,
+      onIdleLogout,
+      renderInactivityWarning,
+      dangerouslyDisableInactivity,
+      children
+    }
+  ) });
+}
+
+export {
+  AuthServiceContext,
+  AuthServiceProvider,
+  OrganisationServiceContext,
+  OrganisationServiceProvider,
+  EventServiceContext,
+  EventServiceProvider,
+  InactivityServiceContext,
+  InactivityServiceProvider,
+  useAuthService,
+  useOrganisationService,
+  useEventService,
+  useInactivityService,
+  useSessionRestoration,
+  useUnifiedAuth,
+  UnifiedAuthProvider
+};
+//# sourceMappingURL=chunk-FUEYYMX5.js.map