@jmruthers/pace-core 0.6.4 → 0.6.6

package/dist/{chunk-AVMLPIM7.js → chunk-FTCRZOG2.js}

@@ -1,28 +1,10 @@
-import {
-  isRBACInitialized,
-  setupRBAC
-} from "./chunk-3LPHPB62.js";
-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 useRef9, useEffect as useEffect10, useState as useState3, useReducer as useReducer5 } from "react";
-
-// src/providers/services/AuthServiceProvider.tsx
-import { createContext, useMemo, useEffect, useState, useRef } from "react";
-
-// src/services/AuthService.ts
-import { AuthError } from "@supabase/supabase-js";
+import { isRBACInitialized, setupRBAC } from './chunk-ZFYPMX46.js';
+import { assertOrganisationId, assertUserId } from './chunk-4SXLQIZO.js';
+import { secureStorage } from './chunk-HF6O3O37.js';
+import { createLogger, logger } from './chunk-TTRFSOKR.js';
+import { createContext, useRef, useEffect, useState, useMemo, useContext, useReducer, useCallback } from 'react';
+import { AuthError } from '@supabase/supabase-js';
+import { jsx } from 'react/jsx-runtime';
 
 // src/services/base/BaseService.ts
 var BaseService = class {
@@ -49,9 +31,6 @@ var BaseService = class {
    * This triggers React re-renders
    */
   notify() {
-    const serviceName = this.constructor.name;
-    const instanceId = this.instanceId || "unknown";
-    logger.debug("BaseService", `[${serviceName} ID:${instanceId}] Notifying ${this.subscribers.length} subscribers`);
     this.subscribers.forEach((callback) => {
       try {
         callback();
@@ -97,6 +76,7 @@ var BaseService = class {
 
 // src/services/AuthService.ts
 var _AuthService = class _AuthService extends BaseService {
+  // Track previous auth state to detect transitions
   constructor(supabaseClient, appName) {
     super();
     this.user = null;
@@ -111,26 +91,24 @@ var _AuthService = class _AuthService extends BaseService {
       restorationError: null
     };
     this.restorationTimeoutId = null;
-    this.restorationTimeoutMs = 5e3;
+    // Increased timeout to handle hard refresh scenarios where localStorage access
+    // and session restoration may take longer, especially with organisation/event context
+    this.restorationTimeoutMs = 1e4;
+    // 10 seconds (increased from 5)
     this.restorationStartTime = null;
     this.appName = void 0;
     this.errorHandler = null;
     this.unhandledRejectionHandler = null;
+    this.wasAuthenticatedRef = false;
     this.instanceId = ++_AuthService.instanceCount;
     this.supabaseClient = supabaseClient;
     this.appName = appName;
-    logger.debug("AuthService", `Instance created [ID:${this.instanceId}]`, { appName });
   }
   getInstanceId() {
     return this.instanceId;
   }
   // Auth state getters
   getUser() {
-    if (this.user) {
-      logger.debug("AuthService", `getUser() [ID:${this.instanceId}] returning user: ${this.user.id}`);
-    } else {
-      logger.debug("AuthService", `getUser() [ID:${this.instanceId}] returning null`);
-    }
     return this.user;
   }
   getSession() {
@@ -172,6 +150,10 @@ var _AuthService = class _AuthService extends BaseService {
         this.authError = null;
         this.user = data.user;
         this.session = data.session;
+        if (!this.wasAuthenticatedRef && data.user) {
+          this.clearPersistenceOnLogin(null, true);
+          this.wasAuthenticatedRef = true;
+        }
       }
       this.notify();
       return { user: data.user, session: data.session, error };
@@ -204,6 +186,10 @@ var _AuthService = class _AuthService extends BaseService {
         this.authError = null;
         this.user = data.user;
         this.session = data.session;
+        if (!this.wasAuthenticatedRef && data.user) {
+          this.clearPersistenceOnLogin(null, true);
+          this.wasAuthenticatedRef = true;
+        }
       }
       this.notify();
       return { user: data.user, session: data.session, error };
@@ -225,6 +211,11 @@ var _AuthService = class _AuthService extends BaseService {
     }
     try {
       const { error } = await this.supabaseClient.auth.signOut();
+      try {
+        sessionStorage.clear();
+      } catch (storageError) {
+        logger.warn("AuthService", "Failed to clear sessionStorage", { error: storageError });
+      }
       if (error) {
         this.authError = error;
       } else {
@@ -235,6 +226,11 @@ var _AuthService = class _AuthService extends BaseService {
       this.notify();
       return { user: null, session: null, error };
     } catch (error) {
+      try {
+        sessionStorage.clear();
+      } catch (storageError) {
+        logger.warn("AuthService", "Failed to clear sessionStorage", { error: storageError });
+      }
       const authError = error instanceof AuthError ? error : new AuthError(error instanceof Error ? error.message : "Authentication failed");
       this.authError = authError;
       this.user = null;
@@ -381,7 +377,7 @@ var _AuthService = class _AuthService extends BaseService {
     }
     this.clearRestorationTimeout();
     const completedAt = Date.now();
-    const duration = this.restorationStartTime ? completedAt - this.restorationStartTime : null;
+    this.restorationStartTime ? completedAt - this.restorationStartTime : null;
     this.restorationStartTime = null;
     const restorationComplete = !error;
     this.sessionRestorationState = {
@@ -401,6 +397,43 @@ var _AuthService = class _AuthService extends BaseService {
       this.restorationTimeoutId = null;
     }
   }
+  /**
+   * Clear pace-core persistence entries from sessionStorage
+   * This includes dialog, form, and datatable persistence
+   * 
+   * @param userId - Optional user ID to clear only that user's persistence.
+   *                 If not provided, clears all pace-core persistence (for user changes).
+   * @param clearUnscoped - If true, also clears old unscoped keys (without :user: prefix)
+   */
+  clearPersistenceOnLogin(userId, clearUnscoped = true) {
+    if (typeof window === "undefined" || !window.sessionStorage) {
+      return;
+    }
+    try {
+      const keysToRemove = [];
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key && (key.startsWith("pace-core:draft:") || key.startsWith("pace-core:dialog:"))) {
+          if (userId && !key.includes(`:user:${userId}`)) {
+            if (clearUnscoped && !key.includes(":user:")) {
+              keysToRemove.push(key);
+            }
+            continue;
+          }
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((key) => {
+        try {
+          sessionStorage.removeItem(key);
+        } catch (error) {
+          logger.warn("AuthService", `Failed to remove persistence key: ${key}`, error);
+        }
+      });
+    } catch (error) {
+      logger.warn("AuthService", `Failed to clear persistence [ID:${this.instanceId}]:`, error);
+    }
+  }
   async setupAuthStateListener() {
     if (!this.supabaseClient) {
       this.authLoading = false;
@@ -411,15 +444,16 @@ var _AuthService = class _AuthService extends BaseService {
       const subscription = this.supabaseClient.auth.onAuthStateChange(
         (event, session) => {
           try {
-            logger.debug("AuthService", `Auth state change [ID:${this.instanceId}]`, {
-              event,
-              hasSession: !!session,
-              userId: session?.user?.id
-            });
+            const wasAuthenticated = this.wasAuthenticatedRef;
+            const isNowAuthenticated = !!session?.user;
+            const previousUserId = this.user?.id || null;
+            const newUserId = session?.user?.id || null;
+            const userChanged = previousUserId !== null && newUserId !== null && previousUserId !== newUserId;
             if (event === "SIGNED_OUT") {
               this.session = null;
               this.user = null;
               this.authError = null;
+              this.wasAuthenticatedRef = false;
               if (session?.user) {
                 this.trackSession("logout", session).catch((err) => {
                   logger.warn("AuthService", `Failed to track logout session [ID:${this.instanceId}]:`, err);
@@ -431,6 +465,12 @@ var _AuthService = class _AuthService extends BaseService {
               if (session?.user) {
                 this.authError = null;
               }
+              if (!wasAuthenticated && isNowAuthenticated && event === "SIGNED_IN") {
+                this.clearPersistenceOnLogin(null, true);
+              } else if (userChanged && previousUserId) {
+                this.clearPersistenceOnLogin(previousUserId, true);
+              }
+              this.wasAuthenticatedRef = isNowAuthenticated;
               if (event === "SIGNED_IN" && session?.user) {
                 this.trackSession("login", session).catch((err) => {
                   logger.warn("AuthService", `Failed to track login session [ID:${this.instanceId}]:`, err);
@@ -438,32 +478,33 @@ var _AuthService = class _AuthService extends BaseService {
               }
             } else if (event === "INITIAL_SESSION") {
               if (session) {
+                const previousUserId2 = this.user?.id || null;
+                const newUserId2 = session.user?.id || null;
+                const userChanged2 = previousUserId2 !== null && newUserId2 !== null && previousUserId2 !== newUserId2;
                 this.session = session;
                 this.user = session.user ?? null;
                 this.authError = null;
+                if (userChanged2 && previousUserId2) {
+                  this.clearPersistenceOnLogin(previousUserId2, true);
+                } else if (!wasAuthenticated && !!session.user) {
+                  this.clearPersistenceOnLogin(null, true);
+                }
+                this.wasAuthenticatedRef = !!session.user;
                 const hasTimeoutError = this.sessionRestorationState.restorationError?.name === "SessionRestorationTimeoutError";
                 if (this.sessionRestorationState.isRestoring || this.sessionRestorationState.restorationError || hasTimeoutError && session) {
                   this.finishSessionRestoration();
                 }
               } else {
+                this.wasAuthenticatedRef = false;
                 if (this.sessionRestorationState.isRestoring) {
                   this.finishSessionRestoration();
                 }
               }
               this.authLoading = false;
-              logger.debug("AuthService", `State synchronized after INITIAL_SESSION [ID:${this.instanceId}]`, {
-                hasUser: !!this.user,
-                userId: this.user?.id
-              });
               this.notify();
               return;
             }
             this.authLoading = false;
-            logger.debug("AuthService", `State synchronized after event [ID:${this.instanceId}]`, {
-              event,
-              hasUser: !!this.user,
-              userId: this.user?.id
-            });
             this.notify();
           } catch (error) {
             logger.warn("AuthService", `Error in auth state change handler [ID:${this.instanceId}]:`, error);
@@ -607,9 +648,6 @@ var _AuthService = class _AuthService extends BaseService {
 };
 _AuthService.instanceCount = 0;
 var AuthService = _AuthService;
-
-// src/providers/services/AuthServiceProvider.tsx
-import { jsx } from "react/jsx-runtime";
 var AuthServiceContext = createContext(null);
 function AuthServiceProvider({ children, supabaseClient, appName }) {
   const authServiceRef = useRef(null);
@@ -646,9 +684,6 @@ function AuthServiceProvider({ children, supabaseClient, appName }) {
   return /* @__PURE__ */ jsx(AuthServiceContext.Provider, { value: contextValue, children });
 }
 
-// src/providers/services/OrganisationServiceProvider.tsx
-import { createContext as createContext2, useMemo as useMemo2, useEffect as useEffect2, useRef as useRef2 } from "react";
-
 // src/services/OrganisationService.ts
 var _OrganisationService = class _OrganisationService extends BaseService {
   constructor(supabaseClient, user, session) {
@@ -676,10 +711,6 @@ var _OrganisationService = class _OrganisationService extends BaseService {
     this.supabaseClient = supabaseClient;
     this.user = user;
     this.session = session;
-    logger.debug("OrganisationService", `Instance created [ID:${this.instanceId}]`, {
-      hasUser: !!user,
-      userId: user?.id
-    });
   }
   getInstanceId() {
     return this.instanceId;
@@ -761,12 +792,7 @@ var _OrganisationService = class _OrganisationService extends BaseService {
     const needsRetry = this._error !== null && !this.isLoadingRef;
     const isEmpty = newUserId !== null && this._organisations.length === 0 && !this.isLoadingRef;
     if (userChanged || needsRetry || isEmpty) {
-      if (userChanged) {
-        logger.debug("OrganisationService", `User changed [ID:${this.instanceId}], resetting initialization`, {
-          previousUserId,
-          newUserId
-        });
-      } else if (needsRetry) {
+      if (userChanged) ; else if (needsRetry) {
         logger.debug("OrganisationService", `Previous error detected [ID:${this.instanceId}], retrying initialization`);
       } else if (isEmpty) {
         logger.debug("OrganisationService", `No organisations found [ID:${this.instanceId}], retrying initialization`);
@@ -853,7 +879,6 @@ var _OrganisationService = class _OrganisationService extends BaseService {
   // Lifecycle methods
   async initialize() {
     if (!this.user) {
-      logger.debug("OrganisationService", "Skipping initialization - no user");
       return;
     }
     await super.initialize();
@@ -882,25 +907,8 @@ var _OrganisationService = class _OrganisationService extends BaseService {
   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();
-    }
+    this._isContextReady = true;
+    this.notify();
   }
   async loadUserOrganisations() {
     if (!this.user || !this.session || !this.supabaseClient) {
@@ -937,9 +945,6 @@ var _OrganisationService = class _OrganisationService extends BaseService {
     this._isLoading = true;
     this._error = null;
     this.notify();
-    logger.debug("OrganisationService", "Loading organisations for user", {
-      userId: this.user.id
-    });
     try {
       let memberships, membershipError, organisations = [];
       try {
@@ -998,10 +1003,6 @@ var _OrganisationService = class _OrganisationService extends BaseService {
           }
         });
         organisations = Array.from(organisationsMap.values());
-        logger.debug("OrganisationService", "Query results", {
-          membershipsCount: memberships.length,
-          organisationsCount: organisations.length
-        });
       } catch (queryError) {
         if (queryError instanceof Error) {
           membershipError = queryError;
@@ -1016,7 +1017,7 @@ var _OrganisationService = class _OrganisationService extends BaseService {
       let userIsSuperAdmin = false;
       if (this.user?.id) {
         try {
-          const { isSuperAdmin: checkSuperAdmin, isRBACInitialized: isRBACInitialized2, setupRBAC: setupRBAC2 } = await import("./api-6LVZTHDS.js");
+          const { isSuperAdmin: checkSuperAdmin, isRBACInitialized: isRBACInitialized2, setupRBAC: setupRBAC2 } = await import('./api-Y4MQWOFW.js');
           if (!isRBACInitialized2() && this.supabaseClient) {
             setupRBAC2(this.supabaseClient);
           }
@@ -1164,22 +1165,19 @@ var _OrganisationService = class _OrganisationService extends BaseService {
 };
 _OrganisationService.instanceCount = 0;
 var OrganisationService = _OrganisationService;
-
-// src/providers/services/OrganisationServiceProvider.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-var OrganisationServiceContext = createContext2(null);
+var OrganisationServiceContext = createContext(null);
 function OrganisationServiceProvider({
   children,
   supabaseClient,
   user,
   session
 }) {
-  const organisationServiceRef = useRef2(null);
+  const organisationServiceRef = useRef(null);
   if (!organisationServiceRef.current) {
     organisationServiceRef.current = new OrganisationService(supabaseClient, user, session);
   }
   const organisationService = organisationServiceRef.current;
-  useEffect2(() => {
+  useEffect(() => {
     organisationService.updateDependencies(user, session);
     let isMounted = true;
     organisationService.initialize().catch((error) => {
@@ -1196,20 +1194,17 @@ function OrganisationServiceProvider({
       isMounted = false;
     };
   }, [organisationService, user, session]);
-  useEffect2(() => {
+  useEffect(() => {
     return () => {
       organisationService.cleanup();
     };
   }, [organisationService]);
-  const contextValue = useMemo2(() => ({
+  const contextValue = useMemo(() => ({
     organisationService
   }), [organisationService]);
-  return /* @__PURE__ */ jsx2(OrganisationServiceContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx(OrganisationServiceContext.Provider, { value: contextValue, children });
 }
 
-// src/providers/services/EventServiceProvider.tsx
-import { createContext as createContext3, useMemo as useMemo3, useEffect as useEffect3, useRef as useRef3 } from "react";
-
 // src/services/EventService.ts
 var _EventService = class _EventService extends BaseService {
   constructor(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId) {
@@ -1241,11 +1236,6 @@ var _EventService = class _EventService extends BaseService {
     this.appName = appName;
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
-    logger.debug("EventService", `Instance created [ID:${this.instanceId}]`, {
-      appName,
-      hasUser: !!user,
-      userId: user?.id
-    });
   }
   getInstanceId() {
     return this.instanceId;
@@ -1263,7 +1253,7 @@ var _EventService = class _EventService extends BaseService {
     const newOrgId = selectedOrganisation?.id;
     const previousUserId = this.user?.id || null;
     const newUserId = user?.id || null;
-    const previousAppName = this.appName;
+    this.appName;
     if (previousUserId !== newUserId) {
       if (previousUserId !== null) {
         await this.clearEventSelectionForUser(previousUserId);
@@ -1277,11 +1267,6 @@ var _EventService = class _EventService extends BaseService {
       this.isFetchingRef = false;
       this.userClearedEventRef = false;
       this.hasAutoSelectedRef = false;
-      logger.debug("EventService", `User changed [ID:${this.instanceId}]`, {
-        previousUserId,
-        newUserId,
-        willInitialize: newUserId !== null
-      });
     }
     this.supabaseClient = supabaseClient;
     this.user = user;
@@ -1291,16 +1276,12 @@ var _EventService = class _EventService extends BaseService {
     this.setSelectedEventId = setSelectedEventId;
     if (user?.id) {
       try {
-        const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import("./api-6LVZTHDS.js");
+        const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import('./api-Y4MQWOFW.js');
         if (!isRBACInitialized2() && this.supabaseClient) {
           setupRBAC2(this.supabaseClient);
         }
         if (isRBACInitialized2()) {
           this.isSuperAdmin = await checkSuperAdmin(user.id);
-          logger.debug("EventService", "Super admin status updated in updateDependencies", {
-            userId: user.id,
-            isSuperAdmin: this.isSuperAdmin
-          });
         } else {
           logger.warn("EventService", "RBAC not initialized in updateDependencies, keeping existing super admin status", {
             userId: user.id,
@@ -1375,13 +1356,8 @@ var _EventService = class _EventService extends BaseService {
         logger.warn("EventService", "Failed to persist event selection:", error);
       });
       this.userClearedEventRef = false;
-      logger.debug("EventService", "Event selected", {
-        eventId: event.event_id,
-        eventName: event.event_name,
-        userClearedEventRef: this.userClearedEventRef
-      });
     } else {
-      const previousEventId = this.selectedEvent?.event_id;
+      this.selectedEvent?.event_id;
       this.selectedEvent = null;
       this.setSelectedEventId?.(null);
       this.clearEventSelection().catch((error) => {
@@ -1389,11 +1365,6 @@ var _EventService = class _EventService extends BaseService {
       });
       this.hasAutoSelectedRef = false;
       this.userClearedEventRef = true;
-      logger.debug("EventService", "Event cleared via setSelectedEvent(null)", {
-        previousEventId,
-        userClearedEventRef: this.userClearedEventRef,
-        stackTrace: new Error().stack
-      });
     }
     this.notify();
   }
@@ -1483,11 +1454,9 @@ var _EventService = class _EventService extends BaseService {
   }
   async doInitialize() {
     if (this.isInitializedRef) {
-      logger.debug("EventService", "Skipping initialization - already initialized");
       return;
     }
     if (this.isFetchingRef) {
-      logger.debug("EventService", "Skipping initialization - already fetching");
       return;
     }
     try {
@@ -1498,22 +1467,10 @@ var _EventService = class _EventService extends BaseService {
       logger.warn("EventService", "Failed to clean up old storage keys:", error);
     }
     if (!this.user) {
-      logger.debug("EventService", "Skipping initialization - no user");
       return;
     }
-    logger.debug("EventService", "Initializing", {
-      userId: this.user.id,
-      appName: this.appName,
-      hasSelectedOrganisation: !!this.selectedOrganisation,
-      hasSupabaseClient: !!this.supabaseClient,
-      hasSession: !!this.session
-    });
     await this.fetchEvents(false);
     this.isInitializedRef = true;
-    logger.debug("EventService", "Initialization complete", {
-      eventsCount: this.events.length,
-      hasError: !!this.error
-    });
   }
   doCleanup() {
   }
@@ -1533,17 +1490,13 @@ var _EventService = class _EventService extends BaseService {
       let organisationIdForRpc = null;
       let userIsSuperAdmin = this.isSuperAdmin;
       try {
-        const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import("./api-6LVZTHDS.js");
+        const { isRBACInitialized: isRBACInitialized2, isSuperAdmin: checkSuperAdmin, setupRBAC: setupRBAC2 } = await import('./api-Y4MQWOFW.js');
         if (!isRBACInitialized2() && this.supabaseClient) {
           setupRBAC2(this.supabaseClient);
         }
         if (isRBACInitialized2()) {
           userIsSuperAdmin = await checkSuperAdmin(this.user.id);
           this.isSuperAdmin = userIsSuperAdmin;
-          logger.debug("EventService", "Super admin check completed", {
-            userId: this.user.id,
-            isSuperAdmin: userIsSuperAdmin
-          });
         } else {
           if (this.isSuperAdmin) {
             userIsSuperAdmin = true;
@@ -1568,10 +1521,6 @@ var _EventService = class _EventService extends BaseService {
           } else if (this.selectedOrganisation) {
             organisationIdForRpc = this.selectedOrganisation.id;
           } else {
-            logger.debug("EventService", "No organisation context available, fetching all accessible events", {
-              hasSelectedEvent: !!this.selectedEvent,
-              hasSelectedOrganisation: !!this.selectedOrganisation
-            });
             organisationIdForRpc = null;
           }
         }
@@ -1597,24 +1546,11 @@ var _EventService = class _EventService extends BaseService {
           }
         }
       }
-      logger.debug("EventService", "Fetching events", {
-        userId: this.user.id,
-        organisationIdForRpc,
-        appName: this.appName,
-        hasSelectedEvent: !!this.selectedEvent,
-        hasSelectedOrganisation: !!this.selectedOrganisation,
-        isSuperAdmin: userIsSuperAdmin
-      });
       let { data, error: rpcError } = await this.supabaseClient.rpc("data_user_events_get", {
         p_user_id: this.user.id,
         p_organisation_id: organisationIdForRpc,
         p_app_name: this.appName
       });
-      logger.debug("EventService", "RPC response", {
-        dataLength: data?.length || 0,
-        hasError: !!rpcError,
-        error: rpcError
-      });
       if (rpcError) {
         logger.error("EventService", "RPC error fetching events:", rpcError);
         throw new Error(rpcError.message || "Failed to fetch events");
@@ -1657,76 +1593,40 @@ var _EventService = class _EventService extends BaseService {
             this.selectedEvent = null;
             this.setSelectedEventId?.(null);
             this.userClearedEventRef = previousUserClearedRef;
-            logger.debug("EventService", "Cleared selected event - no longer in events list", {
-              previousEventId: selectedEventId,
-              eventsCount: transformedEvents.length
-            });
           }
         }
         this.hasAutoSelectedRef = false;
         if (!skipLoadPersisted) {
           const persistedEventLoaded = await this.loadPersistedEvent(transformedEvents);
-          logger.debug("EventService", "Event selection check", {
-            persistedEventLoaded,
-            userClearedEventRef: this.userClearedEventRef,
-            eventsCount: transformedEvents.length,
-            hasSelectedEvent: !!this.selectedEvent
-          });
           if (!persistedEventLoaded && !this.userClearedEventRef) {
             const nextEvent = this.getNextEventByDate(transformedEvents);
-            logger.debug("EventService", "Auto-selection attempt", {
-              nextEventFound: !!nextEvent,
-              nextEventId: nextEvent?.event_id,
-              nextEventDate: nextEvent?.event_date
-            });
             if (nextEvent) {
               this.hasAutoSelectedRef = true;
               this.setSelectedEvent(nextEvent);
-              logger.debug("EventService", "Auto-selected next event", {
-                eventId: nextEvent.event_id,
-                eventName: nextEvent.event_name,
-                eventDate: nextEvent.event_date
-              });
-            } else {
-              logger.debug("EventService", "No next event found for auto-selection", {
-                eventsCount: transformedEvents.length,
-                eventsWithDates: transformedEvents.filter((e) => e.event_date).length
-              });
             }
           } else if (persistedEventLoaded) {
-            logger.debug("EventService", "Skipped auto-selection - persisted event loaded");
           } else if (this.userClearedEventRef) {
-            logger.debug("EventService", "Skipped auto-selection - user explicitly cleared event");
           }
         } else {
           if (!this.userClearedEventRef) {
             const nextEvent = this.getNextEventByDate(transformedEvents);
-            logger.debug("EventService", "Auto-selection attempt (skip persisted)", {
-              nextEventFound: !!nextEvent,
-              nextEventId: nextEvent?.event_id
-            });
             if (nextEvent) {
               this.hasAutoSelectedRef = true;
               this.setSelectedEvent(nextEvent);
-              logger.debug("EventService", "Auto-selected next event (skip persisted)", {
-                eventId: nextEvent.event_id,
-                eventName: nextEvent.event_name
-              });
             }
           } else {
-            logger.debug("EventService", "Skipped auto-selection (skip persisted) - user explicitly cleared event");
           }
         }
       }
     } 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;
@@ -1773,10 +1673,7 @@ var _EventService = class _EventService extends BaseService {
 };
 _EventService.instanceCount = 0;
 var EventService = _EventService;
-
-// src/providers/services/EventServiceProvider.tsx
-import { jsx as jsx3 } from "react/jsx-runtime";
-var EventServiceContext = createContext3(null);
+var EventServiceContext = createContext(null);
 function EventServiceProvider({
   children,
   supabaseClient,
@@ -1786,51 +1683,29 @@ function EventServiceProvider({
   selectedOrganisation,
   setSelectedEventId
 }) {
-  const eventServiceRef = useRef3(null);
-  const initializingRef = useRef3(false);
+  const eventServiceRef = useRef(null);
+  const initializingRef = useRef(false);
   if (!eventServiceRef.current) {
     eventServiceRef.current = new EventService(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
   }
   const eventService = eventServiceRef.current;
-  useEffect3(() => {
+  useEffect(() => {
     let isMounted = true;
-    logger.debug("EventServiceProvider", "useEffect triggered", {
-      hasUser: !!user,
-      userId: user?.id,
-      hasSession: !!session,
-      appName,
-      isInitializing: initializingRef.current
-    });
     if (initializingRef.current) {
-      logger.debug("EventServiceProvider", "Skipping - already initializing");
       return;
     }
     const updateAndInitialize = async () => {
       initializingRef.current = true;
       try {
-        logger.debug("EventServiceProvider", "Updating dependencies and initializing", {
-          hasUser: !!user,
-          userId: user?.id,
-          hasSession: !!session,
-          appName,
-          hasSelectedOrganisation: !!selectedOrganisation
-        });
         await eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
         if (!isMounted) return;
         if (user && session && supabaseClient && appName) {
-          logger.debug("EventServiceProvider", "Initializing event service");
           await eventService.initialize().catch((error) => {
             if (isMounted) {
               logger.error("EventServiceProvider", "Failed to initialize event service:", error);
             }
           });
         } else {
-          logger.debug("EventServiceProvider", "Skipping initialization - missing required dependencies", {
-            hasUser: !!user,
-            hasSession: !!session,
-            hasSupabaseClient: !!supabaseClient,
-            appName
-          });
         }
       } finally {
         initializingRef.current = false;
@@ -1842,20 +1717,17 @@ function EventServiceProvider({
       initializingRef.current = false;
     };
   }, [supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
-  useEffect3(() => {
+  useEffect(() => {
     return () => {
       eventService.cleanup();
     };
   }, [eventService]);
-  const contextValue = useMemo3(() => ({
+  const contextValue = useMemo(() => ({
     eventService
   }), [eventService]);
-  return /* @__PURE__ */ jsx3(EventServiceContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx(EventServiceContext.Provider, { value: contextValue, children });
 }
 
-// src/providers/services/InactivityServiceProvider.tsx
-import { createContext as createContext4, useMemo as useMemo4, useEffect as useEffect4, useRef as useRef4 } from "react";
-
 // src/services/InactivityService.ts
 var InactivityService = class extends BaseService {
   constructor(supabaseClient, user, session, idleTimeoutMs = 30 * 60 * 1e3, warnBeforeMs = 60 * 1e3, onIdleLogout) {
@@ -2006,6 +1878,11 @@ var InactivityService = class extends BaseService {
     } catch (error) {
       logger.error("InactivityService", "Error during idle logout:", error);
     }
+    try {
+      sessionStorage.clear();
+    } catch (storageError) {
+      logger.warn("InactivityService", "Failed to clear sessionStorage", { error: storageError });
+    }
     this.onIdleLogout?.("inactivity");
     this.notify();
   }
@@ -2026,6 +1903,11 @@ var InactivityService = class extends BaseService {
     } catch (error) {
       logger.error("InactivityService", "Error during manual sign out:", error);
     }
+    try {
+      sessionStorage.clear();
+    } catch (storageError) {
+      logger.warn("InactivityService", "Failed to clear sessionStorage", { error: storageError });
+    }
     this.onIdleLogout?.("inactivity");
     this.notify();
   }
@@ -2070,27 +1952,34 @@ var InactivityService = class extends BaseService {
   }
   setupEventHandlers() {
     if (typeof window === "undefined") return;
-    let idleTimer = null;
     let warningTimer = null;
+    let logoutTimer = null;
+    let countdownInterval = null;
     let lastActivity = Date.now();
-    let pollInterval = null;
     let prevIsIdle = false;
     let prevShowWarning = false;
     let prevShowInactivityWarning = false;
     let prevInactivityTimeRemaining = 0;
     let prevTimeRemaining = this.idleTimeoutMs;
-    const pollInactivityState = () => {
+    const getTimeUntilWarning = () => {
+      const timeSinceActivity = Date.now() - lastActivity;
+      return Math.max(0, this.idleTimeoutMs - this.warnBeforeMs - timeSinceActivity);
+    };
+    const getTimeUntilLogout = () => {
+      const timeSinceActivity = Date.now() - lastActivity;
+      return Math.max(0, this.idleTimeoutMs - timeSinceActivity);
+    };
+    const updateState = (forceNotify = false) => {
       const now = Date.now();
       const timeSinceActivity = now - lastActivity;
       const timeUntilIdle = this.idleTimeoutMs - timeSinceActivity;
-      const timeUntilWarning = this.idleTimeoutMs - this.warnBeforeMs - timeSinceActivity;
-      const newIsIdle = timeSinceActivity >= this.idleTimeoutMs - this.warnBeforeMs;
-      const newShowWarning = newIsIdle && timeSinceActivity < this.idleTimeoutMs;
+      const newIsIdle = timeSinceActivity >= this.idleTimeoutMs;
+      const newShowWarning = timeSinceActivity >= this.idleTimeoutMs - this.warnBeforeMs && !newIsIdle;
       const newShowInactivityWarning = newShowWarning;
-      const newInactivityTimeRemaining = newShowWarning ? Math.ceil((this.idleTimeoutMs - timeSinceActivity) / 1e3) : 0;
+      const newInactivityTimeRemaining = newShowWarning ? Math.ceil(timeUntilIdle / 1e3) : 0;
       const newTimeRemaining = Math.max(0, timeUntilIdle);
-      const stateChanged = prevIsIdle !== newIsIdle || prevShowWarning !== newShowWarning || prevShowInactivityWarning !== newShowInactivityWarning || prevInactivityTimeRemaining !== newInactivityTimeRemaining || prevTimeRemaining !== newTimeRemaining;
-      if (stateChanged) {
+      const stateChanged = prevIsIdle !== newIsIdle || prevShowWarning !== newShowWarning || prevShowInactivityWarning !== newShowInactivityWarning || newShowWarning && prevInactivityTimeRemaining !== newInactivityTimeRemaining || prevTimeRemaining !== newTimeRemaining;
+      if (stateChanged || forceNotify) {
         this._isIdle = newIsIdle;
         this._showWarning = newShowWarning;
         this._showInactivityWarning = newShowInactivityWarning;
@@ -2101,73 +1990,123 @@ var InactivityService = class extends BaseService {
         prevShowInactivityWarning = newShowInactivityWarning;
         prevInactivityTimeRemaining = newInactivityTimeRemaining;
         prevTimeRemaining = newTimeRemaining;
-        this.notify();
-        if (newIsIdle && timeSinceActivity >= this.idleTimeoutMs) {
+        if (stateChanged) {
+          this.notify();
+        }
+        if (newIsIdle) {
           this.handleIdleLogout();
         }
       }
-      if (idleTimer) {
-        clearTimeout(idleTimer);
-        idleTimer = null;
-      }
+    };
+    const scheduleNextCheck = () => {
       if (warningTimer) {
         clearTimeout(warningTimer);
         warningTimer = null;
       }
-      if (!newIsIdle && timeUntilIdle > 0) {
-        idleTimer = setTimeout(() => {
-          pollInactivityState();
-        }, Math.min(1e4, timeUntilIdle));
-      }
-      if (newShowWarning && timeUntilIdle > 0) {
-        warningTimer = setTimeout(() => {
+      if (logoutTimer) {
+        clearTimeout(logoutTimer);
+        logoutTimer = null;
+      }
+      if (countdownInterval) {
+        clearInterval(countdownInterval);
+        countdownInterval = null;
+      }
+      const timeUntilWarning = getTimeUntilWarning();
+      const timeUntilLogout = getTimeUntilLogout();
+      const timeSinceActivity = Date.now() - lastActivity;
+      if (timeSinceActivity >= this.idleTimeoutMs) {
+        return;
+      }
+      if (timeSinceActivity >= this.idleTimeoutMs - this.warnBeforeMs) {
+        updateState();
+        countdownInterval = setInterval(() => {
+          updateState();
+          if (Date.now() - lastActivity >= this.idleTimeoutMs) {
+            if (countdownInterval) {
+              clearInterval(countdownInterval);
+              countdownInterval = null;
+            }
+            this.handleIdleLogout();
+          }
+        }, 1e3);
+        logoutTimer = setTimeout(() => {
+          if (countdownInterval) {
+            clearInterval(countdownInterval);
+            countdownInterval = null;
+          }
           this.handleIdleLogout();
-        }, timeUntilIdle);
+        }, timeUntilLogout);
+      } else {
+        const timeUntilWarningMs = timeUntilWarning;
+        const adaptiveInterval = timeUntilWarningMs > 5 * 60 * 1e3 ? 60 * 1e3 : timeUntilWarningMs > 60 * 1e3 ? 10 * 1e3 : 1e3;
+        warningTimer = setTimeout(() => {
+          updateState();
+          scheduleNextCheck();
+        }, Math.min(adaptiveInterval, timeUntilWarningMs));
       }
     };
     const resetTimers = () => {
       lastActivity = Date.now();
-      if (idleTimer) {
-        clearTimeout(idleTimer);
-        idleTimer = null;
-      }
       if (warningTimer) {
         clearTimeout(warningTimer);
         warningTimer = null;
       }
+      if (logoutTimer) {
+        clearTimeout(logoutTimer);
+        logoutTimer = null;
+      }
+      if (countdownInterval) {
+        clearInterval(countdownInterval);
+        countdownInterval = null;
+      }
+      const hadWarning = this._showWarning || this._showInactivityWarning;
       this._showInactivityWarning = false;
       this._inactivityTimeRemaining = 0;
       this._isIdle = false;
       this._showWarning = false;
+      this._timeRemaining = this.idleTimeoutMs;
       prevIsIdle = false;
       prevShowWarning = false;
       prevShowInactivityWarning = false;
       prevInactivityTimeRemaining = 0;
       prevTimeRemaining = this.idleTimeoutMs;
+      if (hadWarning) {
+        this.notify();
+      }
+      scheduleNextCheck();
     };
     const activityEvents = ["mousedown", "mousemove", "keypress", "scroll", "touchstart", "click"];
+    let activityThrottleTimer = null;
     const handleActivity = () => {
-      resetTimers();
+      if (activityThrottleTimer) {
+        return;
+      }
+      activityThrottleTimer = setTimeout(() => {
+        activityThrottleTimer = null;
+        resetTimers();
+      }, 1e3);
     };
     activityEvents.forEach((event) => {
       document.addEventListener(event, handleActivity, true);
     });
-    pollInterval = setInterval(() => {
-      pollInactivityState();
-    }, 1e4);
-    pollInactivityState();
+    updateState(true);
+    scheduleNextCheck();
     this.cleanupHandlers = () => {
-      if (idleTimer) {
-        clearTimeout(idleTimer);
-        idleTimer = null;
-      }
       if (warningTimer) {
         clearTimeout(warningTimer);
         warningTimer = null;
       }
-      if (pollInterval) {
-        clearInterval(pollInterval);
-        pollInterval = null;
+      if (logoutTimer) {
+        clearTimeout(logoutTimer);
+        logoutTimer = null;
+      }
+      if (countdownInterval) {
+        clearInterval(countdownInterval);
+        countdownInterval = null;
+      }
+      if (activityThrottleTimer) {
+        clearTimeout(activityThrottleTimer);
+        activityThrottleTimer = null;
       }
       activityEvents.forEach((event) => {
         document.removeEventListener(event, handleActivity, true);
@@ -2180,13 +2119,9 @@ var InactivityService = class extends BaseService {
       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);
+var InactivityServiceContext = createContext(null);
 function InactivityServiceProvider({
   children,
   supabaseClient,
@@ -2198,12 +2133,12 @@ function InactivityServiceProvider({
   // REQUIRED: No default - must be explicitly provided
   onIdleLogout
 }) {
-  const inactivityServiceRef = useRef4(null);
+  const inactivityServiceRef = useRef(null);
   if (!inactivityServiceRef.current) {
     inactivityServiceRef.current = new InactivityService(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout);
   }
   const inactivityService = inactivityServiceRef.current;
-  useEffect4(() => {
+  useEffect(() => {
     inactivityService.updateDependencies(supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout);
     let isMounted = true;
     inactivityService.initialize().catch((error) => {
@@ -2215,27 +2150,24 @@ function InactivityServiceProvider({
       isMounted = false;
     };
   }, [inactivityService, supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout]);
-  useEffect4(() => {
+  useEffect(() => {
     return () => {
       inactivityService.cleanup();
     };
   }, [inactivityService]);
-  const contextValue = useMemo4(() => ({
+  const contextValue = useMemo(() => ({
     inactivityService
   }), [inactivityService]);
-  return /* @__PURE__ */ jsx4(InactivityServiceContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx(InactivityServiceContext.Provider, { value: contextValue, children });
 }
-
-// src/hooks/services/useAuthService.ts
-import { useContext, useReducer, useEffect as useEffect5, useRef as useRef5 } from "react";
 function useAuthService() {
   const context = useContext(AuthServiceContext);
   if (!context) {
     throw new Error("useAuthService must be used within AuthServiceProvider");
   }
   const [, forceUpdate] = useReducer((x) => x + 1, 0);
-  const timeoutRef = useRef5(null);
-  useEffect5(() => {
+  const timeoutRef = useRef(null);
+  useEffect(() => {
     const debouncedUpdate = () => {
       if (timeoutRef.current) {
         clearTimeout(timeoutRef.current);
@@ -2255,17 +2187,14 @@ function useAuthService() {
   }, [context.authService]);
   return context.authService;
 }
-
-// src/hooks/services/useOrganisationService.ts
-import { useContext as useContext2, useReducer as useReducer2, useEffect as useEffect6, useRef as useRef6 } from "react";
 function useOrganisationService() {
-  const context = useContext2(OrganisationServiceContext);
+  const context = useContext(OrganisationServiceContext);
   if (!context) {
     throw new Error("useOrganisationService must be used within OrganisationServiceProvider");
   }
-  const [, forceUpdate] = useReducer2((x) => x + 1, 0);
-  const timeoutRef = useRef6(null);
-  useEffect6(() => {
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
     const debouncedUpdate = () => {
       if (timeoutRef.current) {
         clearTimeout(timeoutRef.current);
@@ -2308,17 +2237,14 @@ function useOrganisations() {
     getPrimaryOrganisation: () => organisationService.getPrimaryOrganisation()
   };
 }
-
-// src/hooks/services/useEventService.ts
-import { useContext as useContext3, useReducer as useReducer3, useEffect as useEffect7, useRef as useRef7 } from "react";
 function useEventService() {
-  const context = useContext3(EventServiceContext);
+  const context = useContext(EventServiceContext);
   if (!context) {
     throw new Error("useEventService must be used within EventServiceProvider");
   }
-  const [, forceUpdate] = useReducer3((x) => x + 1, 0);
-  const timeoutRef = useRef7(null);
-  useEffect7(() => {
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
     const debouncedUpdate = () => {
       if (timeoutRef.current) {
         clearTimeout(timeoutRef.current);
@@ -2338,17 +2264,14 @@ function useEventService() {
   }, [context.eventService]);
   return context.eventService;
 }
-
-// src/hooks/services/useInactivityService.ts
-import { useContext as useContext4, useReducer as useReducer4, useEffect as useEffect8, useRef as useRef8 } from "react";
 function useInactivityService() {
-  const context = useContext4(InactivityServiceContext);
+  const context = useContext(InactivityServiceContext);
   if (!context) {
     throw new Error("useInactivityService must be used within InactivityServiceProvider");
   }
-  const [, forceUpdate] = useReducer4((x) => x + 1, 0);
-  const timeoutRef = useRef8(null);
-  useEffect8(() => {
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
     const debouncedUpdate = () => {
       if (timeoutRef.current) {
         clearTimeout(timeoutRef.current);
@@ -2368,19 +2291,16 @@ function useInactivityService() {
   }, [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;
+var SESSION_RESTORATION_TIMEOUT_MS = 1e4;
 function useSessionRestoration() {
-  const context = useContext5(AuthServiceContext);
+  const context = useContext(AuthServiceContext);
   if (!context) {
     throw new Error("useSessionRestoration must be used within AuthServiceProvider");
   }
   const { sessionRestoration } = context;
-  const [hasTimedOut, setHasTimedOut] = useState2(false);
-  useEffect9(() => {
+  const [hasTimedOut, setHasTimedOut] = useState(false);
+  useEffect(() => {
     let timeoutHandle = null;
     if (sessionRestoration.isRestoring && !sessionRestoration.restorationComplete && !sessionRestoration.restorationError) {
       setHasTimedOut(false);
@@ -2401,18 +2321,15 @@ function useSessionRestoration() {
     sessionRestoration.restorationComplete,
     sessionRestoration.restorationError
   ]);
-  return useMemo5(() => ({
+  return useMemo(() => ({
     ...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 UnifiedAuthContext = createContext(void 0);
 var useUnifiedAuth = () => {
-  const context = useContext6(UnifiedAuthContext);
+  const context = useContext(UnifiedAuthContext);
   if (!context) {
     logger.error("useUnifiedAuth", "useUnifiedAuth must be used within a UnifiedAuthProvider");
     throw new Error("useUnifiedAuth must be used within a UnifiedAuthProvider");
@@ -2436,46 +2353,21 @@ function UnifiedAuthContextProvider({
     restorationComplete,
     restorationError
   } = sessionRestorationState;
-  const sessionRestoration = useMemo6(() => ({
+  const sessionRestoration = useMemo(() => ({
     isRestoring,
     restorationComplete,
     restorationError
   }), [isRestoring, restorationComplete, restorationError]);
-  let eventService;
-  try {
-    eventService = useEventService();
-  } catch (error) {
-    eventService = {
-      getEvents: () => [],
-      getSelectedEvent: () => null,
-      isLoading: () => false,
-      getError: () => null,
-      setSelectedEvent: () => {
-      },
-      refreshEvents: async () => {
-      },
-      subscribe: () => () => {
-      }
-      // No-op subscribe/unsubscribe for fallback
-    };
-  }
+  const eventService = useEventService();
   const currentUser = authService.getUser();
   const currentSession = authService.getSession();
   const isAuth = !!(currentUser && currentSession);
-  const supabase = useMemo6(() => supabaseClientProp, [supabaseClientProp]);
-  const [appId, setAppId] = useState3(void 0);
-  useEffect10(() => {
-    logger.debug("UnifiedAuthContextProvider", `Rendering [AuthService ID:${authService.getInstanceId?.() || "unknown"}]`, {
-      hasUser: !!currentUser,
-      userId: currentUser?.id,
-      hasSession: !!currentSession,
-      isAuth
-    });
-  }, [currentUser?.id, currentSession?.access_token, isAuth, authService]);
-  const isResolvingAppIdRef = useRef9(false);
-  const resolvedAppIdRef = useRef9(void 0);
-  const resolvedUserIdRef = useRef9(void 0);
-  useEffect10(() => {
+  const supabase = useMemo(() => supabaseClientProp, [supabaseClientProp]);
+  const [appId, setAppId] = useState(void 0);
+  const isResolvingAppIdRef = useRef(false);
+  const resolvedAppIdRef = useRef(void 0);
+  const resolvedUserIdRef = useRef(void 0);
+  useEffect(() => {
     if (!isAuth) {
       resolvedAppIdRef.current = void 0;
       resolvedUserIdRef.current = void 0;
@@ -2494,7 +2386,7 @@ function UnifiedAuthContextProvider({
       resolvedUserIdRef.current = currentUserId;
       const userId = currentUserId;
       const appNameValue = appName;
-      import("./api-6LVZTHDS.js").then(async ({ resolveAppContext, setupRBAC: setupRBAC2 }) => {
+      import('./api-Y4MQWOFW.js').then(async ({ resolveAppContext, setupRBAC: setupRBAC2 }) => {
         try {
           setupRBAC2(supabase);
           const result = await resolveAppContext({
@@ -2524,8 +2416,8 @@ function UnifiedAuthContextProvider({
       });
     }
   }, [isAuth, currentUser?.id, supabase, appName]);
-  const [, forceUpdate] = useReducer5((x) => x + 1, 0);
-  const forceUpdateTimeoutRef = useRef9(null);
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  const forceUpdateTimeoutRef = useRef(null);
   const debouncedForceUpdate = useCallback(() => {
     if (forceUpdateTimeoutRef.current) {
       clearTimeout(forceUpdateTimeoutRef.current);
@@ -2535,17 +2427,17 @@ function UnifiedAuthContextProvider({
       forceUpdateTimeoutRef.current = null;
     }, 100);
   }, [forceUpdate]);
-  const authServiceRef = useRef9(authService);
-  const organisationServiceRef = useRef9(organisationService);
-  const eventServiceRef = useRef9(eventService);
-  const inactivityServiceRef = useRef9(inactivityService);
-  useEffect10(() => {
+  const authServiceRef = useRef(authService);
+  const organisationServiceRef = useRef(organisationService);
+  const eventServiceRef = useRef(eventService);
+  const inactivityServiceRef = useRef(inactivityService);
+  useEffect(() => {
     authServiceRef.current = authService;
     organisationServiceRef.current = organisationService;
     eventServiceRef.current = eventService;
     inactivityServiceRef.current = inactivityService;
   }, [authService, organisationService, eventService, inactivityService]);
-  useEffect10(() => {
+  useEffect(() => {
     const unsubscribeAuth = authServiceRef.current.subscribe(debouncedForceUpdate);
     const unsubscribeOrg = organisationServiceRef.current.subscribe(debouncedForceUpdate);
     const unsubscribeEvent = eventServiceRef.current.subscribe(debouncedForceUpdate);
@@ -2575,19 +2467,19 @@ function UnifiedAuthContextProvider({
   const rawEvents = eventService.getEvents();
   const rawOrganisations = organisationService.getOrganisations();
   const rawUserMemberships = organisationService.getUserMemberships();
-  const events = useMemo6(() => {
+  const events = useMemo(() => {
     return rawEvents;
   }, [
     // Create dependency string from event IDs - only changes when events actually change
     rawEvents.map((e) => e.event_id || e.id).join(",")
   ]);
-  const organisations = useMemo6(() => {
+  const organisations = useMemo(() => {
     return rawOrganisations;
   }, [
     // Create dependency string from organisation IDs - only changes when orgs actually change
     rawOrganisations.map((o) => o.id).join(",")
   ]);
-  const userMemberships = useMemo6(() => {
+  const userMemberships = useMemo(() => {
     return rawUserMemberships;
   }, [
     // Create dependency string from membership IDs - only changes when memberships actually change
@@ -2601,7 +2493,7 @@ function UnifiedAuthContextProvider({
   const timeRemaining = inactivityService.getTimeRemaining();
   const showWarning = inactivityService.isWarningShown();
   const isTracking = inactivityService.isTracking();
-  const inactivityState = useMemo6(() => ({
+  const inactivityState = useMemo(() => ({
     showInactivityWarning,
     inactivityTimeRemaining,
     isIdle,
@@ -2638,7 +2530,7 @@ function UnifiedAuthContextProvider({
   const handleIdleLogout = () => inactivityService.handleIdleLogout();
   const handleStaySignedIn = () => inactivityService.handleStaySignedIn();
   const handleSignOutNow = () => inactivityService.handleSignOutNow();
-  const prevStateRef = useRef9(null);
+  const prevStateRef = useRef(null);
   const isDev = import.meta.env.DEV || import.meta.env.MODE === "development";
   if (isDev) {
     const currentState = {
@@ -2651,7 +2543,7 @@ function UnifiedAuthContextProvider({
       prevStateRef.current = currentState;
     }
   }
-  const contextValue = useMemo6(() => {
+  const contextValue = useMemo(() => {
     return {
       // Auth state
       user: currentUser,
@@ -2769,7 +2661,7 @@ function UnifiedAuthContextProvider({
     handleStaySignedIn,
     handleSignOutNow
   ]);
-  return /* @__PURE__ */ jsx5(UnifiedAuthContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx(UnifiedAuthContext.Provider, { value: contextValue, children });
 }
 function EventServiceProviderWrapper({
   children,
@@ -2781,15 +2673,9 @@ function EventServiceProviderWrapper({
   const { selectedOrganisation } = useOrganisations();
   const setSelectedEventId = useCallback(() => {
   }, []);
-  useEffect10(() => {
-    logger.debug("EventServiceProviderWrapper", "Rendering with props", {
-      hasUser: !!user,
-      userId: user?.id,
-      hasSession: !!session,
-      selectedOrganisationId: selectedOrganisation?.id
-    });
+  useEffect(() => {
   }, [user?.id, session?.access_token, selectedOrganisation?.id]);
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx(
     EventServiceProvider,
     {
       supabaseClient,
@@ -2816,17 +2702,12 @@ function ServiceAwareProviders({
   dangerouslyDisableInactivity
 }) {
   const authService = useAuthService();
-  const [userState, setUserState] = useState3(() => authService.getUser());
-  const [sessionState, setSessionState] = useState3(() => authService.getSession());
-  useEffect10(() => {
+  const [userState, setUserState] = useState(() => authService.getUser());
+  const [sessionState, setSessionState] = useState(() => authService.getSession());
+  useEffect(() => {
     const unsubscribe = authService.subscribe(() => {
       const newUser = authService.getUser();
       const newSession = authService.getSession();
-      logger.debug("ServiceAwareProviders", "Auth service notified, updating state", {
-        hasUser: !!newUser,
-        userId: newUser?.id,
-        hasSession: !!newSession
-      });
       setUserState(newUser);
       setSessionState(newSession);
     });
@@ -2834,28 +2715,20 @@ function ServiceAwareProviders({
   }, [authService]);
   const user = userState;
   const session = sessionState;
-  useEffect10(() => {
-    logger.debug("ServiceAwareProviders", `User/session state [AuthService ID:${authService.getInstanceId?.() || "unknown"}]`, {
-      hasUser: !!user,
-      userId: user?.id,
-      hasSession: !!session,
-      sessionToken: session?.access_token ? "present" : "missing"
-    });
-  }, [user?.id, session?.access_token, authService]);
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx(
     OrganisationServiceProvider,
     {
       supabaseClient,
       user,
       session,
-      children: /* @__PURE__ */ jsx5(
+      children: /* @__PURE__ */ jsx(
         EventServiceProviderWrapper,
         {
           supabaseClient,
           user,
           session,
           appName,
-          children: /* @__PURE__ */ jsx5(
+          children: /* @__PURE__ */ jsx(
             InactivityServiceProvider,
             {
               supabaseClient,
@@ -2864,7 +2737,7 @@ function ServiceAwareProviders({
               idleTimeoutMs,
               warnBeforeMs,
               onIdleLogout,
-              children: /* @__PURE__ */ jsx5(
+              children: /* @__PURE__ */ jsx(
                 UnifiedAuthContextProvider,
                 {
                   appName,
@@ -2903,8 +2776,8 @@ function UnifiedAuthProvider({
   renderInactivityWarning,
   dangerouslyDisableInactivity = false
 }) {
-  const clientRef = useRef9(supabaseClient);
-  useEffect10(() => {
+  const clientRef = useRef(supabaseClient);
+  useEffect(() => {
     if (clientRef.current !== supabaseClient) {
       logger.warn("UnifiedAuthProvider", "Supabase client reference changed - this may indicate multiple client instances are being created", {
         previousClient: clientRef.current,
@@ -2912,8 +2785,6 @@ function UnifiedAuthProvider({
         note: 'Ensure you create the Supabase client once and reuse it. Creating multiple clients can cause performance issues and the "Multiple GoTrueClient instances" warning.'
       });
       clientRef.current = supabaseClient;
-    } else {
-      logger.debug("UnifiedAuthProvider", "Supabase client reference is stable");
     }
   }, [supabaseClient]);
   if (supabaseClient && !isRBACInitialized()) {
@@ -2924,7 +2795,7 @@ function UnifiedAuthProvider({
       logger.error("UnifiedAuthProvider", "Failed to initialize RBAC", err);
     }
   }
-  return /* @__PURE__ */ jsx5(AuthServiceProvider, { supabaseClient, appName, children: /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx(AuthServiceProvider, { supabaseClient, appName, children: /* @__PURE__ */ jsx(
     ServiceAwareProviders,
     {
       supabaseClient,
@@ -2942,23 +2813,4 @@ function UnifiedAuthProvider({
   ) });
 }
 
-export {
-  AuthServiceContext,
-  AuthServiceProvider,
-  OrganisationServiceContext,
-  OrganisationServiceProvider,
-  EventServiceContext,
-  EventServiceProvider,
-  InactivityServiceContext,
-  InactivityServiceProvider,
-  useAuthService,
-  useOrganisationService,
-  useOrganisations,
-  useEventService,
-  useInactivityService,
-  useSessionRestoration,
-  UnifiedAuthContext,
-  useUnifiedAuth,
-  UnifiedAuthProvider
-};
-//# sourceMappingURL=chunk-AVMLPIM7.js.map
+export { AuthServiceContext, AuthServiceProvider, EventServiceContext, EventServiceProvider, InactivityServiceContext, InactivityServiceProvider, OrganisationServiceContext, OrganisationServiceProvider, UnifiedAuthContext, UnifiedAuthProvider, useAuthService, useEventService, useInactivityService, useOrganisationService, useOrganisations, useSessionRestoration, useUnifiedAuth };