@jmruthers/pace-core 0.5.135 → 0.5.137

package/dist/{chunk-3CG5L6RN.js → chunk-YCWDTTUK.js}

@@ -1,11 +1,14 @@
 import {
   init_organisationContext,
+  init_secureStorage,
+  secureStorage,
   setOrganisationContext
-} from "./chunk-BDZUMRBD.js";
+} from "./chunk-7QCC6MCP.js";
 import {
-  init_secureStorage,
-  secureStorage
-} from "./chunk-UJI6WSMD.js";
+  createLogger,
+  init_logger,
+  logger
+} from "./chunk-XDNLUEXI.js";
 import {
   __esm
 } from "./chunk-PLDDJCW6.js";
@@ -15,6 +18,7 @@ var BaseService;
 var init_BaseService = __esm({
   "src/services/base/BaseService.ts"() {
     "use strict";
+    init_logger();
     BaseService = class {
       constructor() {
         this.subscribers = [];
@@ -43,7 +47,7 @@ var init_BaseService = __esm({
           try {
             callback();
           } catch (error) {
-            console.error("[BaseService] Error in subscriber callback:", error);
+            logger.error("BaseService", "Error in subscriber callback:", error);
           }
         });
       }
@@ -91,6 +95,7 @@ var init_AuthService = __esm({
   "src/services/AuthService.ts"() {
     "use strict";
     init_BaseService();
+    init_logger();
     AuthService = class extends BaseService {
       constructor(supabaseClient, appName) {
         super();
@@ -348,10 +353,10 @@ var init_AuthService = __esm({
         };
         this.authLoading = true;
         this.restorationStartTime = Date.now();
-        console.debug("[AuthService] Starting session restoration at", this.restorationStartTime);
+        logger.debug("AuthService", "Starting session restoration at", this.restorationStartTime);
         this.notify();
         this.restorationTimeoutId = setTimeout(() => {
-          console.warn("[AuthService] Session restoration timed out after", this.restorationTimeoutMs, "ms");
+          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);
@@ -373,9 +378,9 @@ var init_AuthService = __esm({
         };
         this.authLoading = false;
         if (error) {
-          console.warn("[AuthService] Session restoration finished with error:", error, "duration(ms):", duration ?? "unknown");
+          logger.warn("AuthService", "Session restoration finished with error:", error, "duration(ms):", duration ?? "unknown");
         } else {
-          console.debug("[AuthService] Session restoration completed successfully in", duration ?? "unknown", "ms");
+          logger.debug("AuthService", "Session restoration completed successfully in", duration ?? "unknown", "ms");
         }
         this.notify();
       }
@@ -395,14 +400,14 @@ var init_AuthService = __esm({
           this.authStateSubscription = this.supabaseClient.auth.onAuthStateChange(
             (event, session) => {
               try {
-                console.debug("[AuthService] Auth state change event received:", event);
+                logger.debug("AuthService", "Auth state change event received:", event);
                 if (event === "SIGNED_OUT") {
                   this.session = null;
                   this.user = null;
                   this.authError = null;
                   if (session?.user) {
                     this.trackSession("logout", session).catch((err) => {
-                      console.warn("[AuthService] Failed to track logout session:", err);
+                      logger.warn("AuthService", "Failed to track logout session:", err);
                     });
                   }
                 } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
@@ -413,7 +418,7 @@ var init_AuthService = __esm({
                   }
                   if (event === "SIGNED_IN" && session?.user) {
                     this.trackSession("login", session).catch((err) => {
-                      console.warn("[AuthService] Failed to track login session:", err);
+                      logger.warn("AuthService", "Failed to track login session:", err);
                     });
                   }
                 } else if (event === "INITIAL_SESSION") {
@@ -435,27 +440,27 @@ var init_AuthService = __esm({
                 this.authLoading = false;
                 this.notify();
               } catch (error) {
-                console.warn("[AuthService] Error in auth state change handler:", error);
+                logger.warn("AuthService", "Error in auth state change handler:", error);
                 this.authLoading = false;
                 this.notify();
               }
             }
           );
         } catch (error) {
-          console.error("[AuthService] Failed to setup auth state listener:", error);
+          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");
-          console.error("[AuthService] Unable to restore session:", error);
+          logger.error("AuthService", "Unable to restore session:", error);
           this.finishSessionRestoration(error);
           return;
         }
         this.startSessionRestoration();
         try {
-          console.debug("[AuthService] Fetching existing session from Supabase");
+          logger.debug("AuthService", "Fetching existing session from Supabase");
           let currentSession = null;
           let sessionError = null;
           try {
@@ -463,12 +468,12 @@ var init_AuthService = __esm({
             currentSession = data?.session ?? null;
             sessionError = error ?? null;
           } catch (error) {
-            console.debug("[AuthService] getSession unavailable, treating as no active session");
+            logger.debug("AuthService", "getSession unavailable, treating as no active session");
             currentSession = null;
             sessionError = null;
           }
           if (sessionError) {
-            console.debug("[AuthService] getSession returned error, attempting to fetch user anyway");
+            logger.debug("AuthService", "getSession returned error, attempting to fetch user anyway");
             this.authError = sessionError;
             try {
               const { data, error } = await this.supabaseClient.auth.getUser();
@@ -482,7 +487,7 @@ var init_AuthService = __esm({
                 this.authError = userError;
               }
             } catch (getUserError) {
-              console.debug("[AuthService] getUser also failed:", getUserError);
+              logger.debug("AuthService", "getUser also failed:", getUserError);
             }
           }
           if (currentSession) {
@@ -490,7 +495,7 @@ var init_AuthService = __esm({
             this.user = currentSession.user;
             this.authError = null;
           } else if (!sessionError) {
-            console.debug("[AuthService] No active session found; treating as normal unauthenticated state");
+            logger.debug("AuthService", "No active session found; treating as normal unauthenticated state");
             this.session = null;
             this.user = null;
             this.authError = null;
@@ -498,7 +503,7 @@ var init_AuthService = __esm({
           this.finishSessionRestoration();
         } catch (error) {
           const restorationError = error instanceof Error ? error : new Error("Unknown error during auth initialization");
-          console.error("[AuthService] Error during auth initialization:", restorationError);
+          logger.error("AuthService", "Error during auth initialization:", restorationError);
           if (restorationError instanceof AuthError) {
             this.authError = restorationError;
           }
@@ -536,26 +541,26 @@ var init_AuthService = __esm({
             p_device_fingerprint: deviceFingerprint
           });
           if (error) {
-            console.warn(`[AuthService] Failed to track ${sessionType} session:`, error);
+            logger.warn("AuthService", `Failed to track ${sessionType} session:`, error);
           } else {
-            console.debug(`[AuthService] Successfully tracked ${sessionType} session`);
+            logger.debug("AuthService", `Successfully tracked ${sessionType} session`);
           }
         } catch (error) {
-          console.warn(`[AuthService] Error tracking ${sessionType} session:`, error);
+          logger.warn("AuthService", `Error tracking ${sessionType} session:`, error);
         }
       }
       setupErrorHandlers() {
         if (typeof window === "undefined") return;
         const handleError = (event) => {
           if (event.error?.message?.includes("AuthSessionMissingError") || event.error?.message?.includes("Auth session missing")) {
-            console.warn("[AuthService] Suppressing AuthSessionMissingError during logout");
+            logger.warn("AuthService", "Suppressing AuthSessionMissingError during logout");
             event.preventDefault();
             return false;
           }
         };
         const handleUnhandledRejection = (event) => {
           if (event.reason?.message?.includes("AuthSessionMissingError") || event.reason?.message?.includes("Auth session missing")) {
-            console.warn("[AuthService] Suppressing unhandled AuthSessionMissingError");
+            logger.warn("AuthService", "Suppressing unhandled AuthSessionMissingError");
             event.preventDefault();
             return false;
           }
@@ -587,7 +592,7 @@ function AuthServiceProvider({ children, supabaseClient, appName }) {
       setSessionRestoration(restorationState);
       const isDev = typeof import.meta !== "undefined" && (import.meta.env.DEV || import.meta.env.MODE === "development");
       if (isDev) {
-        console.debug("[AuthServiceProvider] Session restoration state updated", restorationState);
+        logger.debug("AuthServiceProvider", "Session restoration state updated", restorationState);
       }
     });
     return () => {
@@ -596,7 +601,7 @@ function AuthServiceProvider({ children, supabaseClient, appName }) {
   }, [authService]);
   useEffect(() => {
     authService.initialize().catch((error) => {
-      console.error("[AuthServiceProvider] Failed to initialize auth service:", error);
+      logger.error("AuthServiceProvider", "Failed to initialize auth service:", error);
     });
     return () => {
       authService.cleanup();
@@ -613,6 +618,7 @@ var init_AuthServiceProvider = __esm({
   "src/providers/services/AuthServiceProvider.tsx"() {
     "use strict";
     init_AuthService();
+    init_logger();
     AuthServiceContext = createContext(null);
     useAuthService = () => {
       const context = useContext(AuthServiceContext);
@@ -631,6 +637,7 @@ var init_OrganisationService = __esm({
     "use strict";
     init_BaseService();
     init_organisationContext();
+    init_logger();
     OrganisationService = class extends BaseService {
       constructor(supabaseClient, user, session) {
         super();
@@ -815,30 +822,30 @@ var init_OrganisationService = __esm({
       }
       async setDatabaseOrganisationContext(organisation) {
         if (!this.supabaseClient || !this.session) {
-          console.warn("[OrganisationService] No Supabase client or session available for setting organisation context");
+          logger.warn("OrganisationService", "No Supabase client or session available for setting organisation context");
           this._isContextReady = false;
           this.notify();
           return;
         }
         try {
-          console.log("[OrganisationService] Setting database organisation context for:", organisation.id);
+          logger.debug("OrganisationService", "Setting database organisation context for:", organisation.id);
           const timeoutPromise = new Promise((_, reject) => {
             setTimeout(() => reject(new Error("Context setting timeout after 5 seconds")), 5e3);
           });
           const contextPromise = setOrganisationContext(this.supabaseClient, organisation.id);
           await Promise.race([contextPromise, timeoutPromise]);
-          console.log("[OrganisationService] Database organisation context set successfully");
+          logger.debug("OrganisationService", "Database organisation context set successfully");
           this._isContextReady = true;
           this.notify();
         } catch (error) {
-          console.error("[OrganisationService] Failed to set database organisation context:", error);
+          logger.error("OrganisationService", "Failed to set database organisation context:", error);
           this._isContextReady = true;
           this.notify();
         }
       }
       async loadUserOrganisations() {
         const callId = Math.random().toString(36).substr(2, 9);
-        console.log(`[OrganisationService] Starting loadUserOrganisations call ${callId}`);
+        logger.debug("OrganisationService", `Starting loadUserOrganisations call ${callId}`);
         if (!this.user || !this.session || !this.supabaseClient) {
           this._selectedOrganisation = null;
           this._organisations = [];
@@ -849,14 +856,14 @@ var init_OrganisationService = __esm({
           return;
         }
         if (this.isLoadingRef) {
-          console.log("OrganisationService", "Already loading, skipping duplicate load");
+          logger.debug("OrganisationService", "Already loading, skipping duplicate load");
           this._isLoading = true;
           this.notify();
           return;
         }
         const now = Date.now();
         if (now - this.lastLoadTimeRef < 2e3) {
-          console.log("OrganisationService", "Too soon since last load, skipping");
+          logger.debug("OrganisationService", "Too soon since last load, skipping");
           if (this._organisations.length > 0 || this._selectedOrganisation) {
             this._isLoading = false;
           } else {
@@ -876,14 +883,14 @@ var init_OrganisationService = __esm({
         this._error = null;
         this.notify();
         try {
-          console.log("[OrganisationService] Supabase client ready:", {
+          logger.debug("OrganisationService", "Supabase client ready:", {
             isConnected: !!this.supabaseClient,
             hasAuth: !!this.supabaseClient.auth,
             hasRpc: !!this.supabaseClient.rpc
           });
           let memberships, membershipError;
           try {
-            console.log("[OrganisationService] Making RPC call to data_user_organisation_roles_get...");
+            logger.debug("OrganisationService", "Making RPC call to data_user_organisation_roles_get...");
             const timeoutPromise = new Promise((_, reject) => {
               const timeoutId = setTimeout(() => reject(new Error("RPC call timeout after 10 seconds")), 1e4);
               abortSignal.addEventListener("abort", () => {
@@ -899,7 +906,7 @@ var init_OrganisationService = __esm({
               throw new Error("Request aborted");
             }
             const result = await Promise.race([rpcPromise, timeoutPromise]);
-            console.log("[OrganisationService] RPC call completed:", {
+            logger.debug("OrganisationService", "RPC call completed:", {
               hasData: !!result.data,
               hasError: !!result.error,
               dataLength: result.data?.length || 0,
@@ -913,9 +920,9 @@ var init_OrganisationService = __esm({
             membershipError = queryError;
           }
           if (membershipError) {
-            console.error("[OrganisationService] Error loading memberships:", membershipError);
+            logger.error("OrganisationService", "Error loading memberships:", membershipError);
             if (membershipError.message?.includes("timeout")) {
-              console.log("[OrganisationService] RPC timed out, trying direct database query as fallback...");
+              logger.debug("OrganisationService", "RPC timed out, trying direct database query as fallback...");
               try {
                 if (abortSignal.aborted) {
                   throw new Error("Request aborted");
@@ -946,14 +953,14 @@ var init_OrganisationService = __esm({
                 )
               `).eq("user_id", this.user.id).eq("status", "active").is("revoked_at", null).in("role", ["org_admin", "leader", "member"]);
                 if (fallbackError) {
-                  console.error("[OrganisationService] Fallback query also failed:", fallbackError);
+                  logger.error("OrganisationService", "Fallback query also failed:", fallbackError);
                   throw membershipError;
                 }
-                console.log("[OrganisationService] Fallback query successful, got", fallbackData?.length || 0, "memberships");
+                logger.debug("OrganisationService", "Fallback query successful, got", fallbackData?.length || 0, "memberships");
                 memberships = fallbackData || [];
                 membershipError = null;
               } catch (fallbackErr) {
-                console.error("[OrganisationService] Fallback query failed:", fallbackErr);
+                logger.error("OrganisationService", "Fallback query failed:", fallbackErr);
                 throw membershipError;
               }
             } else {
@@ -965,22 +972,22 @@ var init_OrganisationService = __esm({
           }
           const organisationIds = memberships.map((m) => m.organisation_id).filter((id) => {
             if (!id || typeof id !== "string") {
-              console.warn("[OrganisationService] Invalid organisation ID (not string):", id);
+              logger.warn("OrganisationService", "Invalid organisation ID (not string):", id);
               return false;
             }
             const trimmedId = id.trim();
             if (trimmedId === "") {
-              console.warn("[OrganisationService] Empty organisation ID found");
+              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) {
-              console.warn("[OrganisationService] Invalid UUID format:", trimmedId);
+              logger.warn("OrganisationService", "Invalid UUID format:", trimmedId);
             }
             return isValidUuid;
           });
           if (organisationIds.length === 0) {
-            console.warn("[OrganisationService] No valid organisation IDs found in memberships:", memberships);
+            logger.warn("OrganisationService", "No valid organisation IDs found in memberships:", memberships);
             throw new Error("No valid organisation IDs found in memberships");
           }
           if (abortSignal.aborted) {
@@ -988,7 +995,7 @@ var init_OrganisationService = __esm({
           }
           const { data: allOrganisations, error: orgError } = await this.supabaseClient.from("organisations").select("id, name, display_name, subscription_tier, settings, is_active, parent_id, created_at, updated_at");
           if (orgError) {
-            console.error("[OrganisationService] Error loading organisations:", orgError);
+            logger.error("OrganisationService", "Error loading organisations:", orgError);
             throw orgError;
           }
           const organisations = allOrganisations?.filter(
@@ -1016,16 +1023,16 @@ var init_OrganisationService = __esm({
                 if (validPersistedOrg) {
                   initialOrg = validPersistedOrg;
                 } else {
-                  console.warn("[OrganisationService] Persisted organisation not found in active orgs, clearing cache");
+                  logger.warn("OrganisationService", "Persisted organisation not found in active orgs, clearing cache");
                   localStorage.removeItem("pace-core-selected-organisation");
                 }
               } else {
-                console.warn("[OrganisationService] Invalid persisted organisation ID, clearing cache");
+                logger.warn("OrganisationService", "Invalid persisted organisation ID, clearing cache");
                 localStorage.removeItem("pace-core-selected-organisation");
               }
             }
           } catch (storageError) {
-            console.warn("[OrganisationService] Failed to restore persisted organisation:", storageError);
+            logger.warn("OrganisationService", "Failed to restore persisted organisation:", storageError);
             localStorage.removeItem("pace-core-selected-organisation");
           }
           if (!initialOrg) {
@@ -1049,7 +1056,7 @@ var init_OrganisationService = __esm({
           this.retryCount = 0;
           this.hasFailedRef = false;
         } catch (err) {
-          console.error("[OrganisationService] Failed to load organisations:", err);
+          logger.error("OrganisationService", "Failed to load organisations:", err);
           this._error = err;
           this.retryCount = this.retryCount + 1;
           this.hasFailedRef = true;
@@ -1094,7 +1101,7 @@ function OrganisationServiceProvider({
     let isMounted = true;
     organisationService.initialize().catch((error) => {
       if (isMounted) {
-        console.error("[OrganisationServiceProvider] Failed to initialize organisation service:", error);
+        logger.error("OrganisationServiceProvider", "Failed to initialize organisation service:", error);
       }
     });
     return () => {
@@ -1111,6 +1118,7 @@ var init_OrganisationServiceProvider = __esm({
   "src/providers/services/OrganisationServiceProvider.tsx"() {
     "use strict";
     init_OrganisationService();
+    init_logger();
     OrganisationServiceContext = createContext2(null);
     useOrganisationService = () => {
       const context = useContext2(OrganisationServiceContext);
@@ -1128,6 +1136,7 @@ var init_EventService = __esm({
   "src/services/EventService.ts"() {
     "use strict";
     init_BaseService();
+    init_logger();
     init_secureStorage();
     EventService = class extends BaseService {
       constructor(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId) {
@@ -1213,7 +1222,7 @@ var init_EventService = __esm({
         if (event) {
           try {
             if (this.selectedOrganisation && event.organisation_id !== this.selectedOrganisation.id) {
-              console.error("[EventService] Event organisation_id does not match selected organisation", {
+              logger.error("EventService", "Event organisation_id does not match selected organisation", {
                 eventOrganisationId: event.organisation_id,
                 selectedOrganisationId: this.selectedOrganisation.id,
                 eventName: event.event_name
@@ -1221,19 +1230,19 @@ var init_EventService = __esm({
               return;
             }
           } catch (error) {
-            console.error("[EventService] Error during event validation:", error);
+            logger.error("EventService", "Error during event validation:", error);
           }
           this.selectedEvent = event;
           this.setSelectedEventId?.(event.event_id);
           this.persistEventSelection(event.event_id).catch((error) => {
-            console.warn("[EventService] Failed to persist event selection:", error);
+            logger.warn("EventService", "Failed to persist event selection:", error);
           });
           this.userClearedEventRef = false;
         } else {
           this.selectedEvent = null;
           this.setSelectedEventId?.(null);
           this.clearEventSelection().catch((error) => {
-            console.warn("[EventService] Failed to clear event selection:", error);
+            logger.warn("EventService", "Failed to clear event selection:", error);
           });
           this.hasAutoSelectedRef = false;
           this.userClearedEventRef = true;
@@ -1263,7 +1272,7 @@ var init_EventService = __esm({
             }
           }
         } catch (error) {
-          console.warn("[EventService] Failed to load persisted event:", error);
+          logger.warn("EventService", "Failed to load persisted event:", error);
         }
         return false;
       }
@@ -1285,7 +1294,7 @@ var init_EventService = __esm({
           const storageKey = this.getStorageKey(userId);
           await secureStorage.setItem(storageKey, eventId, { encrypt: true });
         } catch (error) {
-          console.warn("[EventService] Failed to persist event selection:", error);
+          logger.warn("EventService", "Failed to persist event selection:", error);
         }
       }
       async clearEventSelection() {
@@ -1296,7 +1305,7 @@ var init_EventService = __esm({
           this.selectedEvent = null;
           this.setSelectedEventId?.(null);
         } catch (error) {
-          console.warn("[EventService] Failed to clear event selection:", error);
+          logger.warn("EventService", "Failed to clear event selection:", error);
         }
       }
       /**
@@ -1308,7 +1317,7 @@ var init_EventService = __esm({
           const storageKey = this.getStorageKey(userId);
           await secureStorage.removeItem(storageKey);
         } catch (error) {
-          console.warn("[EventService] Failed to clear event selection for user:", error);
+          logger.warn("EventService", "Failed to clear event selection for user:", error);
         }
       }
       autoSelectNextEvent(events) {
@@ -1329,7 +1338,7 @@ var init_EventService = __esm({
             localStorage.removeItem("_sec_pace-core-selected-event");
           }
         } catch (error) {
-          console.warn("[EventService] Failed to clean up old storage keys:", error);
+          logger.warn("EventService", "Failed to clean up old storage keys:", error);
         }
         await this.fetchEvents(false);
       }
@@ -1405,7 +1414,7 @@ var init_EventService = __esm({
             }
           }
         } catch (err) {
-          console.error("[EventService] Error fetching events:", err);
+          logger.error("EventService", "Error fetching events:", err);
           const _error = err instanceof Error ? err : new Error("Unknown error occurred");
           if (isMounted) {
             this.error = _error;
@@ -1470,7 +1479,7 @@ function EventServiceProvider({
       if (!isMounted) return;
       await eventService.initialize().catch((error) => {
         if (isMounted) {
-          console.error("[EventServiceProvider] Failed to initialize event service:", error);
+          logger.error("EventServiceProvider", "Failed to initialize event service:", error);
         }
       });
     };
@@ -1489,6 +1498,7 @@ var init_EventServiceProvider = __esm({
   "src/providers/services/EventServiceProvider.tsx"() {
     "use strict";
     init_EventService();
+    init_logger();
     EventServiceContext = createContext3(null);
     useEventService = () => {
       const context = useContext3(EventServiceContext);
@@ -1506,6 +1516,7 @@ var init_InactivityService = __esm({
   "src/services/InactivityService.ts"() {
     "use strict";
     init_BaseService();
+    init_logger();
     InactivityService = class extends BaseService {
       constructor(supabaseClient, user, session, idleTimeoutMs = 30 * 60 * 1e3, warnBeforeMs = 60 * 1e3, onIdleLogout) {
         super();
@@ -1645,7 +1656,7 @@ var init_InactivityService = __esm({
             await this.supabaseClient.auth.signOut();
           }
         } catch (error) {
-          console.error("[InactivityService] Error during idle logout:", error);
+          logger.error("InactivityService", "Error during idle logout:", error);
         }
         this.onIdleLogout?.("inactivity");
         this.notify();
@@ -1665,7 +1676,7 @@ var init_InactivityService = __esm({
             await this.supabaseClient.auth.signOut();
           }
         } catch (error) {
-          console.error("[InactivityService] Error during manual sign out:", error);
+          logger.error("InactivityService", "Error during manual sign out:", error);
         }
         this.onIdleLogout?.("inactivity");
         this.notify();
@@ -1692,7 +1703,7 @@ var init_InactivityService = __esm({
         if (typeof window !== "undefined") {
           const isProduction = import.meta.env.MODE === "production";
           if (isProduction) {
-            console.warn("[InactivityService] Inactivity feature enabled in production");
+            logger.warn("InactivityService", "Inactivity feature enabled in production");
           }
         }
       }
@@ -1705,7 +1716,7 @@ var init_InactivityService = __esm({
           return;
         }
         try {
-          const { useInactivityTracker } = await import("./useInactivityTracker-MRUU55XI.js");
+          const { useInactivityTracker } = await import("./useInactivityTracker-TO6ZOF35.js");
           this.inactivityTracker = {
             isIdle: false,
             timeRemaining: 0,
@@ -1734,7 +1745,7 @@ var init_InactivityService = __esm({
           };
           this.setupEventHandlers();
         } catch (error) {
-          console.error("[InactivityService] Failed to setup inactivity tracker:", error);
+          logger.error("InactivityService", "Failed to setup inactivity tracker:", error);
         }
       }
       setupEventHandlers() {
@@ -1836,7 +1847,7 @@ function InactivityServiceProvider({
     let isMounted = true;
     inactivityService.initialize().catch((error) => {
       if (isMounted) {
-        console.error("[InactivityServiceProvider] Failed to initialize inactivity service:", error);
+        logger.error("InactivityServiceProvider", "Failed to initialize inactivity service:", error);
       }
     });
     return () => {
@@ -1853,6 +1864,7 @@ var init_InactivityServiceProvider = __esm({
   "src/providers/services/InactivityServiceProvider.tsx"() {
     "use strict";
     init_InactivityService();
+    init_logger();
     InactivityServiceContext = createContext4(null);
     useInactivityService = () => {
       const context = useContext4(InactivityServiceContext);
@@ -1958,7 +1970,7 @@ function useSessionRestoration() {
     if (sessionRestoration.isRestoring && !sessionRestoration.restorationComplete && !sessionRestoration.restorationError) {
       setHasTimedOut(false);
       timeoutHandle = setTimeout(() => {
-        console.warn("[useSessionRestoration] Session restoration timed out");
+        log.warn("Session restoration timed out");
         setHasTimedOut(true);
       }, SESSION_RESTORATION_TIMEOUT_MS);
     } else {
@@ -1980,11 +1992,13 @@ function useSessionRestoration() {
     timeoutMs: SESSION_RESTORATION_TIMEOUT_MS
   }), [sessionRestoration, hasTimedOut]);
 }
-var SESSION_RESTORATION_TIMEOUT_MS;
+var log, SESSION_RESTORATION_TIMEOUT_MS;
 var init_useSessionRestoration = __esm({
   "src/hooks/useSessionRestoration.ts"() {
     "use strict";
     init_AuthServiceProvider();
+    init_logger();
+    log = createLogger("useSessionRestoration");
     SESSION_RESTORATION_TIMEOUT_MS = 5e3;
   }
 });
@@ -2087,7 +2101,7 @@ function UnifiedAuthContextProvider({
     };
     const prevState = prevStateRef.current;
     if (!prevState || prevState.isAuthenticated !== currentState.isAuthenticated || prevState.userEmail !== currentState.userEmail || prevState.totalLoading !== currentState.totalLoading) {
-      console.log("[UnifiedAuthContext] Auth state changed:", {
+      logger.debug("UnifiedAuthContext", "Auth state changed:", {
         isAuthenticated: isAuth,
         user: currentUser?.email,
         session: currentSession ? "exists" : "null",
@@ -2357,11 +2371,12 @@ var init_UnifiedAuthProvider = __esm({
     init_useEventService();
     init_useInactivityService();
     init_useSessionRestoration();
+    init_logger();
     UnifiedAuthContext = createContext5(void 0);
     useUnifiedAuth = () => {
       const context = useContext10(UnifiedAuthContext);
       if (!context) {
-        console.error("useUnifiedAuth must be used within a UnifiedAuthProvider");
+        logger.error("useUnifiedAuth", "useUnifiedAuth must be used within a UnifiedAuthProvider");
         throw new Error("useUnifiedAuth must be used within a UnifiedAuthProvider");
       }
       return context;
@@ -2400,4 +2415,4 @@ export {
   UnifiedAuthProvider,
   init_UnifiedAuthProvider
 };
-//# sourceMappingURL=chunk-3CG5L6RN.js.map
+//# sourceMappingURL=chunk-YCWDTTUK.js.map