@optifye/dashboard-core 6.11.21 → 6.11.23

package/dist/index.js

@@ -2232,6 +2232,61 @@ var clearAuthSnapshot = () => {
   safeStorageRemoveItem(AUTH_SNAPSHOT_STORAGE_KEY);
 };
 
+// src/lib/auth/authAuditLog.ts
+var TAB_ID = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID().slice(0, 8) : Math.random().toString(36).slice(2, 10);
+var FLUSH_INTERVAL_MS = 3e4;
+var MAX_QUEUE_SIZE = 50;
+var queue = [];
+var flushTimer = null;
+var apiBaseUrl = "";
+var getAccessToken = null;
+var initAuthAuditLog = (baseUrl, tokenGetter) => {
+  apiBaseUrl = baseUrl;
+  getAccessToken = tokenGetter;
+  if (typeof window === "undefined") return;
+  if (!flushTimer) {
+    flushTimer = setInterval(flushAuthAuditLog, FLUSH_INTERVAL_MS);
+    window.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") {
+        void flushAuthAuditLog();
+      }
+    });
+  }
+};
+var logAuthEvent = (eventType, details = {}) => {
+  queue.push({
+    event_type: eventType,
+    tab_id: TAB_ID,
+    details: {
+      ...details,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+  if (queue.length >= MAX_QUEUE_SIZE) {
+    void flushAuthAuditLog();
+  }
+};
+var flushAuthAuditLog = async () => {
+  if (queue.length === 0 || !apiBaseUrl || !getAccessToken) return;
+  const events = queue.splice(0, MAX_QUEUE_SIZE);
+  try {
+    const token = await getAccessToken();
+    if (!token) return;
+    const body = JSON.stringify({ events });
+    const url = `${apiBaseUrl}/api/auth/audit`;
+    await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body,
+      keepalive: document.visibilityState === "hidden"
+    });
+  } catch {
+  }
+};
+
 // src/lib/auth/session.ts
 var DEFAULT_MIN_VALIDITY_MS = 6e4;
 var refreshPromises = /* @__PURE__ */ new WeakMap();
@@ -2241,6 +2296,24 @@ var isInvalidRefreshTokenError = (error) => {
   if (!message.includes("refresh token")) return false;
   return message.includes("invalid") || message.includes("not found") || message.includes("revoked");
 };
+var getSessionFromStorage = () => {
+  if (typeof window === "undefined") return null;
+  try {
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith("sb-") && key?.endsWith("-auth-token")) {
+        const raw = localStorage.getItem(key);
+        if (!raw) continue;
+        const parsed = JSON.parse(raw);
+        if (parsed?.access_token && parsed?.refresh_token && parsed?.expires_at) {
+          return parsed;
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+};
 var isSessionValid = (session, minValidityMs = 0) => {
   if (!session) return false;
   if (!session.expires_at) return true;
@@ -2297,6 +2370,18 @@ var refreshSessionSingleFlight = async (supabase) => {
     }
     const invalidRefreshToken = isInvalidRefreshTokenError(refreshError);
     if (invalidRefreshToken) {
+      const storedSession = getSessionFromStorage();
+      if (storedSession && isSessionValid(storedSession, 0)) {
+        console.log("[Auth] Recovered session from localStorage after invalid refresh token (another tab refreshed)");
+        try {
+          await supabase.auth.setSession({
+            access_token: storedSession.access_token,
+            refresh_token: storedSession.refresh_token
+          });
+        } catch {
+        }
+        return { session: storedSession, error: null, invalidRefreshToken: false };
+      }
       try {
         await supabase.auth.signOut({ scope: "local" });
       } catch (error) {
@@ -6606,7 +6691,17 @@ function captureSentryException(error, extras) {
 }
 
 // src/lib/services/mixpanelService.ts
+var ROOT_DASHBOARD_EVENT_NAMES = {
+  operations_overview: "Operations Overview Page Clicked",
+  monitor: "Live Monitor Clicked"
+};
+var MIXPANEL_EVENT_NAME_ALIASES = {
+  "Operations Overview clicked": ROOT_DASHBOARD_EVENT_NAMES.operations_overview,
+  "monitor page clicked": ROOT_DASHBOARD_EVENT_NAMES.monitor
+};
+var MAX_QUEUED_MIXPANEL_ACTIONS = 200;
 var isMixpanelInitialized = false;
+var queuedMixpanelActions = [];
 var currentUserProperties;
 var MIXPANEL_WARNING_RATE_LIMIT = {
   windowMs: 10 * 60 * 1e3,
@@ -6634,6 +6729,52 @@ var reportMixpanelError = (key, error, extras) => {
   if (!shouldReportMixpanel(key, true)) return;
   captureSentryException(error, { ...baseMixpanelExtras(), ...extras });
 };
+var normalizeCoreEventName = (eventName) => {
+  const canonicalName = MIXPANEL_EVENT_NAME_ALIASES[eventName] || eventName;
+  if (canonicalName !== eventName) {
+    reportMixpanelWarning(`event_alias:${eventName}`, "Mixpanel event alias rewritten to canonical name", {
+      operation: "track_event",
+      originalEventName: eventName,
+      canonicalEventName: canonicalName
+    });
+  }
+  return canonicalName;
+};
+var queueMixpanelAction = (action) => {
+  if (queuedMixpanelActions.length >= MAX_QUEUED_MIXPANEL_ACTIONS) {
+    queuedMixpanelActions.shift();
+    reportMixpanelWarning("queue_overflow", "Mixpanel queue overflow, dropping oldest queued action", {
+      operation: "queue",
+      maxQueuedActions: MAX_QUEUED_MIXPANEL_ACTIONS
+    });
+  }
+  queuedMixpanelActions.push(action);
+};
+var flushQueuedMixpanelActions = () => {
+  if (!isMixpanelInitialized || queuedMixpanelActions.length === 0) return;
+  const pendingActions = queuedMixpanelActions.splice(0, queuedMixpanelActions.length);
+  pendingActions.forEach((action) => {
+    try {
+      if (action.type === "identify") {
+        mixpanel__default.default.identify(action.userId);
+        if (action.userProperties) {
+          mixpanel__default.default.people.set(action.userProperties);
+        }
+        return;
+      }
+      if (action.type === "page_view") {
+        mixpanel__default.default.track("Page View", { page: action.pageName, ...action.properties || {} });
+        return;
+      }
+      mixpanel__default.default.track(action.eventName, action.properties || {});
+    } catch (err) {
+      reportMixpanelError("flush_queued_action_failed", err, {
+        operation: "flush_queue",
+        actionType: action.type
+      });
+    }
+  });
+};
 var initializeCoreMixpanel = (token, debugOrOptions, trackPageViewArg) => {
   if (!token) {
     console.warn("Mixpanel token not provided for initialization. Mixpanel will not be enabled.");
@@ -6691,6 +6832,7 @@ var initializeCoreMixpanel = (token, debugOrOptions, trackPageViewArg) => {
   try {
     mixpanel__default.default.init(token, initOptions);
     isMixpanelInitialized = true;
+    flushQueuedMixpanelActions();
   } catch (err) {
     reportMixpanelError("init_failed", err, {
       operation: "init",
@@ -6706,7 +6848,12 @@ var initializeCoreMixpanel = (token, debugOrOptions, trackPageViewArg) => {
 };
 var trackCorePageView = (pageName, properties) => {
   if (!isMixpanelInitialized) {
-    reportMixpanelWarning("track_pageview_not_initialized", "Mixpanel not initialized: page view dropped", {
+    queueMixpanelAction({
+      type: "page_view",
+      pageName,
+      properties
+    });
+    reportMixpanelWarning("track_pageview_queued", "Mixpanel not initialized yet: page view queued", {
       operation: "track_pageview",
       pageName
     });
@@ -6722,10 +6869,20 @@ var trackCorePageView = (pageName, properties) => {
   }
 };
 var trackCoreEvent = (eventName, properties) => {
+  const normalizedEventName = normalizeCoreEventName(eventName);
   if (!isMixpanelInitialized) {
-    reportMixpanelWarning("track_event_not_initialized", "Mixpanel not initialized: event dropped", {
+    const mergedProps2 = {
+      ...currentUserProperties || {},
+      ...properties || {}
+    };
+    queueMixpanelAction({
+      type: "track",
+      eventName: normalizedEventName,
+      properties: mergedProps2
+    });
+    reportMixpanelWarning("track_event_queued", "Mixpanel not initialized yet: event queued", {
       operation: "track_event",
-      eventName
+      eventName: normalizedEventName
     });
     return;
   }
@@ -6736,11 +6893,11 @@ var trackCoreEvent = (eventName, properties) => {
     ...properties || {}
   };
   try {
-    mixpanel__default.default.track(eventName, mergedProps);
+    mixpanel__default.default.track(normalizedEventName, mergedProps);
   } catch (err) {
     reportMixpanelError("track_event_failed", err, {
       operation: "track_event",
-      eventName
+      eventName: normalizedEventName
     });
   }
 };
@@ -6791,8 +6948,14 @@ var getCoreSessionReplayUrl = () => {
   return null;
 };
 var identifyCoreUser = (userId, userProperties) => {
+  currentUserProperties = userProperties ? { ...userProperties } : void 0;
   if (!isMixpanelInitialized) {
-    reportMixpanelWarning("identify_not_initialized", "Mixpanel not initialized: identify dropped", {
+    queueMixpanelAction({
+      type: "identify",
+      userId,
+      userProperties: currentUserProperties
+    });
+    reportMixpanelWarning("identify_queued", "Mixpanel not initialized yet: identify queued", {
       operation: "identify",
       userIdPresent: Boolean(userId),
       hasUserProperties: Boolean(userProperties)
@@ -6812,17 +6975,20 @@ var identifyCoreUser = (userId, userProperties) => {
     });
     return;
   }
-  currentUserProperties = { ...userProperties };
+  currentUserProperties = userProperties ? { ...userProperties } : void 0;
 };
 var resetCoreMixpanel = () => {
-  if (!isMixpanelInitialized) return;
-  try {
-    mixpanel__default.default.reset();
-  } catch (err) {
-    reportMixpanelError("reset_failed", err, {
-      operation: "reset"
-    });
+  if (isMixpanelInitialized) {
+    try {
+      mixpanel__default.default.reset();
+    } catch (err) {
+      reportMixpanelError("reset_failed", err, {
+        operation: "reset"
+      });
+    }
   }
+  currentUserProperties = void 0;
+  queuedMixpanelActions.splice(0, queuedMixpanelActions.length);
 };
 
 // src/lib/services/sseClient.ts
@@ -10379,6 +10545,15 @@ var AuthProvider = ({ children }) => {
   const [error, setError] = React142.useState(null);
   const [authStatus, setAuthStatus] = React142.useState("loading");
   const [showOnboarding, setShowOnboarding] = React142.useState(false);
+  const auditInitRef = React142.useRef(false);
+  if (!auditInitRef.current && typeof window !== "undefined") {
+    const backendUrl = process.env.NEXT_PUBLIC_BACKEND_URL || "http://localhost:8000";
+    initAuthAuditLog(backendUrl, async () => {
+      const { data: { session: s } } = await supabase.auth.getSession();
+      return s?.access_token ?? null;
+    });
+    auditInitRef.current = true;
+  }
   const isFetchingRef = React142.useRef(false);
   const lastProcessedSessionRef = React142.useRef(null);
   const hasAuthenticatedRef = React142.useRef(false);
@@ -10542,6 +10717,7 @@ var AuthProvider = ({ children }) => {
           resetRecoveryState();
           if (refreshResult.invalidRefreshToken) {
             console.warn("[AuthContext] Refresh token invalid, redirecting to login");
+            logAuthEvent("forced_logout", { reason: "invalid_refresh_token", trigger: "fetchSession" });
             setAuthStatus("failed");
             clearSessionState();
             await handleAuthRequired(supabase, "session_expired");
@@ -10641,6 +10817,7 @@ var AuthProvider = ({ children }) => {
   const signOut = React142.useCallback(async () => {
     try {
       console.log("[AuthContext] Signing out");
+      logAuthEvent("sign_out_initiated", { trigger: "user_action" });
       setAuthStatus("loading");
       resetRecoveryState();
       clearAuthSnapshot();
@@ -10665,6 +10842,22 @@ var AuthProvider = ({ children }) => {
       return;
     }
     const monitorTokenExpiry = async () => {
+      const storedSession = getSessionFromStorage();
+      if (storedSession && isSessionValid(storedSession, 5 * 60 * 1e3)) {
+        if (storedSession.access_token !== session.access_token) {
+          console.log("[AuthContext] Adopting session refreshed by another tab");
+          logAuthEvent("cross_tab_refresh_adopted", { source: "monitorTokenExpiry" });
+          setTrackedSession(storedSession);
+          try {
+            await supabase.auth.setSession({
+              access_token: storedSession.access_token,
+              refresh_token: storedSession.refresh_token
+            });
+          } catch {
+          }
+        }
+        return;
+      }
       const expiresAt = session.expires_at;
       if (!expiresAt) {
         console.warn("[AuthContext] Session has no expiry time");
@@ -10677,13 +10870,16 @@ var AuthProvider = ({ children }) => {
       console.log(`[AuthContext] Token expires in ${minutesUntilExpiry} minutes`);
       if (minutesUntilExpiry < 5 && timeUntilExpiry > 0) {
         console.warn("[AuthContext] Token expiring soon, attempting refresh...");
+        logAuthEvent("token_refresh_started", { reason: "expiring_soon", minutesUntilExpiry });
         const refreshResult = await refreshSessionSingleFlight(supabase);
         if (isSessionValid(refreshResult.session, 0)) {
           setTrackedSession(refreshResult.session);
+          logAuthEvent("token_refresh_succeeded", { expiresAt: refreshResult.session?.expires_at });
           console.log("[AuthContext] Token refreshed successfully");
           return;
         }
         if (refreshResult.invalidRefreshToken) {
+          logAuthEvent("token_refresh_failed", { reason: "invalid_refresh_token", trigger: "proactive" });
           clearAuthSnapshot();
           resetRecoveryState();
           console.error("[AuthContext] Refresh token invalid during proactive refresh");
@@ -10692,13 +10888,16 @@ var AuthProvider = ({ children }) => {
       }
       if (timeUntilExpiry <= 0) {
         console.warn("[AuthContext] Token has expired, attempting refresh...");
+        logAuthEvent("token_refresh_started", { reason: "expired", minutesUntilExpiry });
         const refreshResult = await refreshSessionSingleFlight(supabase);
         if (isSessionValid(refreshResult.session, 0)) {
           setTrackedSession(refreshResult.session);
+          logAuthEvent("token_refresh_succeeded", { expiresAt: refreshResult.session?.expires_at });
           console.log("[AuthContext] Token refreshed after expiry");
           return;
         }
         if (refreshResult.invalidRefreshToken) {
+          logAuthEvent("token_refresh_failed", { reason: "invalid_refresh_token", trigger: "expired" });
           clearAuthSnapshot();
           resetRecoveryState();
           console.error("[AuthContext] Refresh token invalid after expiry");
@@ -10750,6 +10949,29 @@ var AuthProvider = ({ children }) => {
     window.addEventListener("rbac:refresh-scope", handleScopeRefresh);
     return () => window.removeEventListener("rbac:refresh-scope", handleScopeRefresh);
   }, [fetchSession, session]);
+  React142.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleStorageChange = (e) => {
+      if (!e.key?.startsWith("sb-") || !e.key?.endsWith("-auth-token")) return;
+      if (!e.newValue || !session) return;
+      try {
+        const stored = JSON.parse(e.newValue);
+        if (stored?.access_token && stored?.refresh_token && stored?.expires_at && stored.access_token !== session.access_token) {
+          console.log("[AuthContext] Cross-tab token update detected, syncing session");
+          logAuthEvent("cross_tab_refresh_adopted", { source: "storage_event" });
+          setTrackedSession(stored);
+          supabase.auth.setSession({
+            access_token: stored.access_token,
+            refresh_token: stored.refresh_token
+          }).catch(() => {
+          });
+        }
+      } catch {
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => window.removeEventListener("storage", handleStorageChange);
+  }, [session, setTrackedSession, supabase]);
   React142.useEffect(() => {
     if (typeof window === "undefined" || authStatus !== "recovering") {
       return;
@@ -10841,6 +11063,7 @@ var AuthProvider = ({ children }) => {
       }
       if (event === "SIGNED_OUT") {
         console.log("[AuthContext] User signed out");
+        logAuthEvent("signed_out", { trigger: "auth_state_change" });
         resetRecoveryState();
         clearAuthSnapshot();
         clearSessionState();
@@ -11117,7 +11340,7 @@ function useSessionTracking(options = {}) {
   const trackerRef = React142.useRef(null);
   const isTrackingRef = React142.useRef(false);
   const initRef = React142.useRef(false);
-  const getAccessToken = React142.useCallback(async () => {
+  const getAccessToken2 = React142.useCallback(async () => {
     return session?.access_token || null;
   }, [session?.access_token]);
   React142.useEffect(() => {
@@ -11125,14 +11348,14 @@ function useSessionTracking(options = {}) {
       return;
     }
     initRef.current = true;
-    const apiBaseUrl = config?.apiBaseUrl || process.env.NEXT_PUBLIC_API_BASE_URL || "";
-    if (!apiBaseUrl) {
+    const apiBaseUrl2 = config?.apiBaseUrl || process.env.NEXT_PUBLIC_API_BASE_URL || "";
+    if (!apiBaseUrl2) {
       console.warn("[useSessionTracking] No API base URL configured, session tracking disabled");
       return;
     }
     const tracker = createSessionTracker({
-      apiBaseUrl,
-      getAccessToken,
+      apiBaseUrl: apiBaseUrl2,
+      getAccessToken: getAccessToken2,
       onSessionStart: (sessionId) => {
         isTrackingRef.current = true;
         onSessionStart?.(sessionId);
@@ -11153,7 +11376,7 @@ function useSessionTracking(options = {}) {
       initRef.current = false;
       isTrackingRef.current = false;
     };
-  }, [enabled, isAuthenticated, user?.id, session?.access_token, config?.apiBaseUrl, getAccessToken, onSessionStart, onSessionEnd, user]);
+  }, [enabled, isAuthenticated, user?.id, session?.access_token, config?.apiBaseUrl, getAccessToken2, onSessionStart, onSessionEnd, user]);
   React142.useEffect(() => {
     if (!isAuthenticated && trackerRef.current && isTrackingRef.current) {
       trackerRef.current.endSession("logout");
@@ -19734,9 +19957,9 @@ function useUserUsage(userId, options = {}) {
   const [data, setData] = React142.useState(null);
   const [isLoading, setIsLoading] = React142.useState(true);
   const [error, setError] = React142.useState(null);
-  const apiBaseUrl = config?.apiBaseUrl || process.env.NEXT_PUBLIC_API_BASE_URL || "";
+  const apiBaseUrl2 = config?.apiBaseUrl || process.env.NEXT_PUBLIC_API_BASE_URL || "";
   const fetchData = React142.useCallback(async () => {
-    if (!userId || !apiBaseUrl || !session?.access_token) {
+    if (!userId || !apiBaseUrl2 || !session?.access_token) {
       setIsLoading(false);
       return;
     }
@@ -19746,7 +19969,7 @@ function useUserUsage(userId, options = {}) {
       const params = new URLSearchParams();
       if (startDate) params.append("start_date", startDate);
       if (endDate) params.append("end_date", endDate);
-      const url = `${apiBaseUrl}/api/usage/user/${userId}${params.toString() ? `?${params}` : ""}`;
+      const url = `${apiBaseUrl2}/api/usage/user/${userId}${params.toString() ? `?${params}` : ""}`;
       const response = await fetch(url, {
         headers: {
           "Authorization": `Bearer ${session.access_token}`
@@ -19764,7 +19987,7 @@ function useUserUsage(userId, options = {}) {
     } finally {
       setIsLoading(false);
     }
-  }, [userId, apiBaseUrl, session?.access_token, startDate, endDate]);
+  }, [userId, apiBaseUrl2, session?.access_token, startDate, endDate]);
   React142.useEffect(() => {
     if (enabled) {
       fetchData();
@@ -19786,12 +20009,12 @@ function useCompanyUsersUsage(companyId, options = {}) {
   const [isLoading, setIsLoading] = React142.useState(true);
   const [isTodayLoading, setIsTodayLoading] = React142.useState(true);
   const [error, setError] = React142.useState(null);
-  const apiBaseUrl = config?.apiBaseUrl || process.env.NEXT_PUBLIC_BACKEND_URL || "";
+  const apiBaseUrl2 = config?.apiBaseUrl || process.env.NEXT_PUBLIC_BACKEND_URL || "";
   const userRole = user?.role || user?.role_level;
   const canAccess = userRole === "owner" || userRole === "optifye";
-  const isEnabled = enabled && canAccess && !!apiBaseUrl;
+  const isEnabled = enabled && canAccess && !!apiBaseUrl2;
   const fetchOwnerReport = React142.useCallback(async () => {
-    if (!apiBaseUrl || !session?.access_token || !canAccess || !isEnabled) {
+    if (!apiBaseUrl2 || !session?.access_token || !canAccess || !isEnabled) {
       setIsLoading(false);
       return;
     }
@@ -19806,7 +20029,7 @@ function useCompanyUsersUsage(companyId, options = {}) {
       if (startDate) params.append("start_date", startDate);
       if (endDate) params.append("end_date", endDate);
       if (roleFilter) params.append("role_filter", roleFilter);
-      const url = `${apiBaseUrl}/api/usage/owner-report${params.toString() ? `?${params}` : ""}`;
+      const url = `${apiBaseUrl2}/api/usage/owner-report${params.toString() ? `?${params}` : ""}`;
       const response = await fetch(url, {
         headers: {
           "Authorization": `Bearer ${session.access_token}`
@@ -19824,15 +20047,15 @@ function useCompanyUsersUsage(companyId, options = {}) {
     } finally {
       setIsLoading(false);
     }
-  }, [apiBaseUrl, session?.access_token, canAccess, isEnabled, startDate, endDate, roleFilter]);
+  }, [apiBaseUrl2, session?.access_token, canAccess, isEnabled, startDate, endDate, roleFilter]);
   const fetchTodayUsage = React142.useCallback(async () => {
-    if (!apiBaseUrl || !session?.access_token || !canAccess || !isEnabled) {
+    if (!apiBaseUrl2 || !session?.access_token || !canAccess || !isEnabled) {
       setIsTodayLoading(false);
       return;
     }
     setIsTodayLoading(true);
     try {
-      const url = `${apiBaseUrl}/api/usage/today`;
+      const url = `${apiBaseUrl2}/api/usage/today`;
       const response = await fetch(url, {
         headers: {
           "Authorization": `Bearer ${session.access_token}`
@@ -19848,7 +20071,7 @@ function useCompanyUsersUsage(companyId, options = {}) {
     } finally {
       setIsTodayLoading(false);
     }
-  }, [apiBaseUrl, session?.access_token, canAccess, isEnabled]);
+  }, [apiBaseUrl2, session?.access_token, canAccess, isEnabled]);
   const fetchAll = React142.useCallback(async () => {
     await Promise.all([
       fetchOwnerReport(),
@@ -19918,9 +20141,9 @@ function useCompanyClipsCost() {
   const hasFetchedOnceRef = React142.useRef(false);
   const canViewClipsCost = user?.role_level === "owner" || user?.role_level === "optifye";
   const companyId = user?.properties?.company_id || user?.company_id || entityConfig.companyId;
-  const apiBaseUrl = config?.apiBaseUrl || process.env.NEXT_PUBLIC_API_BASE_URL || "";
+  const apiBaseUrl2 = config?.apiBaseUrl || process.env.NEXT_PUBLIC_API_BASE_URL || "";
   const fetchData = React142.useCallback(async () => {
-    if (!canViewClipsCost || !companyId || !supabase || !apiBaseUrl || !session?.access_token) {
+    if (!canViewClipsCost || !companyId || !supabase || !apiBaseUrl2 || !session?.access_token) {
       setIsLoading(false);
       setData(null);
       hasFetchedOnceRef.current = false;
@@ -19932,7 +20155,7 @@ function useCompanyClipsCost() {
     setError(null);
     try {
       const [statsResponse, linesResult] = await Promise.all([
-        fetch(`${apiBaseUrl}/api/classification/company-stats?company_id=${encodeURIComponent(companyId)}`, {
+        fetch(`${apiBaseUrl2}/api/classification/company-stats?company_id=${encodeURIComponent(companyId)}`, {
           headers: {
             "Authorization": `Bearer ${session.access_token}`
           }
@@ -19967,7 +20190,7 @@ function useCompanyClipsCost() {
       hasFetchedOnceRef.current = true;
       setIsLoading(false);
     }
-  }, [canViewClipsCost, companyId, supabase, apiBaseUrl, session?.access_token]);
+  }, [canViewClipsCost, companyId, supabase, apiBaseUrl2, session?.access_token]);
   React142.useEffect(() => {
     fetchData();
   }, [fetchData]);
@@ -23503,11 +23726,11 @@ function createRenderStep(runNextFrame) {
      */
     schedule: (callback, keepAlive = false, immediate = false) => {
       const addToCurrentFrame = immediate && isProcessing;
-      const queue = addToCurrentFrame ? thisFrame : nextFrame;
+      const queue2 = addToCurrentFrame ? thisFrame : nextFrame;
       if (keepAlive)
         toKeepAlive.add(callback);
-      if (!queue.has(callback))
-        queue.add(callback);
+      if (!queue2.has(callback))
+        queue2.add(callback);
       return callback;
     },
     /**
@@ -52675,7 +52898,7 @@ var SideNavBar = React142.memo(({
       transition-all duration-200 ease-out focus:outline-none focus-visible:ring-2 focus-visible:ring-blue-500 focus-visible:ring-offset-2`;
   }, [pathname]);
   const buildDashboardSurfaceTrackingEvent = React142.useCallback((source, destinationPath, dashboardSurface) => ({
-    name: dashboardSurface === "operations_overview" ? "Operations Overview clicked" : "monitor page clicked",
+    name: ROOT_DASHBOARD_EVENT_NAMES[dashboardSurface],
     properties: {
       source,
       destination_path: destinationPath,
@@ -53956,7 +54179,7 @@ var AwardNotificationManager = () => {
   const supabase = useSupabase();
   const { user } = useAuth();
   const router$1 = router.useRouter();
-  const [queue, setQueue] = React142.useState([]);
+  const [queue2, setQueue] = React142.useState([]);
   const [activeNotification, setActiveNotification] = React142.useState(null);
   const lastUserIdRef = React142.useRef(null);
   React142.useEffect(() => {
@@ -53977,10 +54200,10 @@ var AwardNotificationManager = () => {
     loadNotifications();
   }, [user, supabase]);
   React142.useEffect(() => {
-    if (!activeNotification && queue.length > 0) {
-      setActiveNotification(queue[0]);
+    if (!activeNotification && queue2.length > 0) {
+      setActiveNotification(queue2[0]);
     }
-  }, [queue, activeNotification]);
+  }, [queue2, activeNotification]);
   const dismissActive = async () => {
     if (!activeNotification) return;
     if (!activeNotification.id.startsWith("mock-")) {
@@ -79730,6 +79953,7 @@ exports.PrefetchEvents = PrefetchEvents;
 exports.PrefetchStatus = PrefetchStatus;
 exports.PrefetchTimeoutError = PrefetchTimeoutError;
 exports.ProfileView = ProfileView_default;
+exports.ROOT_DASHBOARD_EVENT_NAMES = ROOT_DASHBOARD_EVENT_NAMES;
 exports.RegistryProvider = RegistryProvider;
 exports.RoleBadge = RoleBadge;
 exports.S3ClipsService = S3ClipsSupabaseService;