@optifye/dashboard-core 6.0.9 → 6.1.3

package/dist/index.js

@@ -5016,34 +5016,6 @@ var useWorkspaceOperators = (workspaceId, options) => {
     refetch: fetchData
   };
 };
-
-// src/lib/utils/dashboardReload.ts
-var createThrottledReload = (interval = 5e3) => {
-  let last = 0;
-  let queued = false;
-  const doReload = () => {
-    if (typeof window !== "undefined") {
-      window.location.reload();
-    }
-  };
-  return () => {
-    const now2 = Date.now();
-    if (now2 - last >= interval) {
-      last = now2;
-      doReload();
-    } else if (!queued) {
-      queued = true;
-      setTimeout(() => {
-        queued = false;
-        last = Date.now();
-        doReload();
-      }, interval - (now2 - last));
-    }
-  };
-};
-var throttledReloadDashboard = createThrottledReload(5e3);
-
-// src/lib/hooks/useHlsStream.ts
 var HLS_CONFIG = {
   maxBufferLength: 8,
   maxMaxBufferLength: 15,
@@ -5062,7 +5034,35 @@ var HLS_CONFIG = {
   liveSyncDurationCount: 2
   // Follow live edge aggressively
 };
+var failedUrls = /* @__PURE__ */ new Map();
+var MAX_FAILURES_PER_URL = 3;
+var FAILURE_EXPIRY_MS = 5 * 60 * 1e3;
+function resetFailedUrl(url) {
+  if (failedUrls.has(url)) {
+    console.log(`[HLS] Manually resetting failed URL: ${url}`);
+    failedUrls.delete(url);
+  }
+}
+function isUrlPermanentlyFailed(url) {
+  const failure = failedUrls.get(url);
+  return failure?.permanentlyFailed || false;
+}
 function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
+  const urlFailure = failedUrls.get(src);
+  const isPermanentlyFailed = urlFailure?.permanentlyFailed || false;
+  const cleanupFailedUrls = () => {
+    const now2 = Date.now();
+    const expiredUrls = [];
+    failedUrls.forEach((failure, url) => {
+      if (now2 - failure.timestamp > FAILURE_EXPIRY_MS) {
+        expiredUrls.push(url);
+      }
+    });
+    expiredUrls.forEach((url) => {
+      console.log(`[HLS] Removing expired failure entry for: ${url}`);
+      failedUrls.delete(url);
+    });
+  };
   const [restartKey, setRestartKey] = React19.useState(0);
   const hlsRef = React19.useRef(null);
   const stallCheckIntervalRef = React19.useRef(null);
@@ -5132,14 +5132,33 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
   };
   const hardRestart = (reason) => {
     console.warn(`[HLS] Hard restart: ${reason}`);
+    cleanupFailedUrls();
+    const failure = failedUrls.get(src);
+    const failureCount = failure ? failure.count : 0;
+    if (failureCount >= MAX_FAILURES_PER_URL) {
+      console.error(`[HLS] URL has failed ${failureCount} times. Marking as permanently failed: ${src}`);
+      failedUrls.set(src, {
+        count: failureCount,
+        timestamp: Date.now(),
+        permanentlyFailed: true
+      });
+      cleanup();
+      if (onFatalError) {
+        onFatalError();
+      }
+      return;
+    }
+    failedUrls.set(src, {
+      count: failureCount + 1,
+      timestamp: Date.now(),
+      permanentlyFailed: false
+    });
     cleanup();
     setRestartKey((k) => k + 1);
     softRestartCountRef.current = 0;
-    if (reason.includes("hard restart") || reason.includes("native video error")) {
+    if (reason.includes("404 hard restart")) {
       if (onFatalError) {
         onFatalError();
-      } else {
-        throttledReloadDashboard();
       }
     }
   };
@@ -5193,6 +5212,13 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
     }, 7e3);
   };
   React19.useEffect(() => {
+    if (isPermanentlyFailed) {
+      console.warn(`[HLS] URL is permanently failed, not attempting to load: ${src}`);
+      if (onFatalError) {
+        onFatalError();
+      }
+      return;
+    }
     if (!src || !shouldPlay) {
       cleanup();
       return;
@@ -5223,6 +5249,10 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
         }
       });
       hls.on(Hls2__default.default.Events.MANIFEST_PARSED, () => {
+        if (failedUrls.has(src)) {
+          console.log(`[HLS] Stream loaded successfully, resetting failure count for: ${src}`);
+          failedUrls.delete(src);
+        }
         video.play().catch((err) => {
           console.error("[HLS] Play failed:", err);
         });
@@ -5241,7 +5271,7 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
       console.error("[HLS] HLS not supported");
     }
     return cleanup;
-  }, [src, shouldPlay, restartKey, onFatalError]);
+  }, [src, shouldPlay, restartKey, onFatalError, isPermanentlyFailed]);
   return {
     restartKey,
     isNativeHls: isNativeHlsRef.current
@@ -6346,7 +6376,7 @@ function useNavigation(customNavigate) {
 }
 function useWorkspaceNavigation() {
   const { defaultTimezone } = useDateTimeConfig();
-  const getWorkspaceNavigationParams3 = React19.useCallback(
+  const getWorkspaceNavigationParams2 = React19.useCallback(
     (workspaceId, options) => {
       let dateToUse = options?.date;
       if (!dateToUse && options?.useCurrentDate) {
@@ -6362,7 +6392,7 @@ function useWorkspaceNavigation() {
     [defaultTimezone]
   );
   return {
-    getWorkspaceNavigationParams: getWorkspaceNavigationParams3
+    getWorkspaceNavigationParams: getWorkspaceNavigationParams2
   };
 }
 function useDateFormatter() {
@@ -9060,9 +9090,15 @@ var getStoredWorkspaceMappings = () => {
 var getDefaultTabForWorkspace = (workspaceId, displayName) => {
   return "overview";
 };
-var getWorkspaceNavigationParams = (workspaceId, displayName) => {
+var getWorkspaceNavigationParams = (workspaceId, displayName, lineId) => {
   const defaultTab = getDefaultTabForWorkspace();
-  return `?displayName=${encodeURIComponent(displayName)}&defaultTab=${defaultTab}`;
+  const params = new URLSearchParams();
+  params.set("displayName", displayName);
+  params.set("defaultTab", defaultTab);
+  if (lineId) {
+    params.set("lineId", lineId);
+  }
+  return `?${params.toString()}`;
 };
 
 // src/lib/utils/videoPreloader.ts
@@ -9383,6 +9419,115 @@ var clearS3VideoCache = () => {
 var preloadS3VideoUrl = s3VideoPreloader.preloadVideo;
 var preloadS3VideosUrl = s3VideoPreloader.preloadVideos;
 
+// src/lib/utils/dashboardReload.ts
+var reloadAttempts = [];
+var createThrottledReload = (interval = 5e3, maxReloads = 3) => {
+  const circuitBreakerWindow = 1e4;
+  const circuitBreakerThreshold = 5;
+  let last = 0;
+  let queued = false;
+  let reloadCount = 0;
+  let firstReloadTime = 0;
+  const resetWindow = 6e4;
+  const doReload = () => {
+    if (typeof window !== "undefined") {
+      const now2 = Date.now();
+      reloadAttempts.push(now2);
+      const cutoff = now2 - circuitBreakerWindow;
+      const recentAttempts = reloadAttempts.filter((t) => t > cutoff);
+      reloadAttempts.length = 0;
+      reloadAttempts.push(...recentAttempts);
+      if (recentAttempts.length >= circuitBreakerThreshold) {
+        console.error(`[Dashboard Reload] Circuit breaker triggered! ${recentAttempts.length} reload attempts in ${circuitBreakerWindow}ms`);
+        const errorDiv = document.createElement("div");
+        errorDiv.id = "reload-circuit-breaker";
+        errorDiv.style.cssText = `
+          position: fixed;
+          top: 20px;
+          left: 50%;
+          transform: translateX(-50%);
+          background: #dc2626;
+          color: white;
+          padding: 20px 32px;
+          border-radius: 12px;
+          z-index: 99999;
+          box-shadow: 0 10px 25px rgba(0, 0, 0, 0.3);
+          font-family: system-ui, -apple-system, sans-serif;
+        `;
+        errorDiv.innerHTML = `
+          <div style="display: flex; align-items: center; gap: 16px;">
+            <svg width="24" height="24" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path>
+            </svg>
+            <div>
+              <div style="font-weight: 600; font-size: 16px; margin-bottom: 4px;">Too many reload attempts detected</div>
+              <div style="font-size: 14px; opacity: 0.9;">Please check your network connection and refresh manually.</div>
+            </div>
+          </div>
+        `;
+        const existing = document.getElementById("reload-circuit-breaker");
+        if (existing) existing.remove();
+        document.body.appendChild(errorDiv);
+        return;
+      }
+      if (now2 - firstReloadTime > resetWindow) {
+        reloadCount = 0;
+        firstReloadTime = now2;
+      }
+      if (reloadCount === 0) {
+        firstReloadTime = now2;
+      }
+      reloadCount++;
+      if (reloadCount > maxReloads) {
+        console.error(`[Dashboard Reload] Maximum reload attempts (${maxReloads}) reached. Stopping to prevent infinite loop.`);
+        const errorDiv = document.createElement("div");
+        errorDiv.style.cssText = `
+          position: fixed;
+          top: 20px;
+          left: 50%;
+          transform: translateX(-50%);
+          background: #ef4444;
+          color: white;
+          padding: 16px 24px;
+          border-radius: 8px;
+          z-index: 9999;
+          box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        `;
+        errorDiv.innerHTML = `
+          <div style="display: flex; align-items: center; gap: 12px;">
+            <svg width="20" height="20" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+            </svg>
+            <span>Stream connection failed. Please refresh the page manually.</span>
+          </div>
+        `;
+        document.body.appendChild(errorDiv);
+        setTimeout(() => {
+          document.body.removeChild(errorDiv);
+        }, 1e4);
+        return;
+      }
+      console.warn(`[Dashboard Reload] Reloading dashboard (attempt ${reloadCount}/${maxReloads})`);
+      window.location.reload();
+    }
+  };
+  return () => {
+    const now2 = Date.now();
+    if (now2 - last >= interval) {
+      last = now2;
+      doReload();
+    } else if (!queued) {
+      queued = true;
+      setTimeout(() => {
+        queued = false;
+        last = Date.now();
+        doReload();
+      }, interval - (now2 - last));
+    }
+  };
+};
+var throttledReloadDashboard = createThrottledReload(5e3, 3);
+
 // src/lib/utils/index.ts
 var formatIdleTime = (idleTimeInSeconds) => {
   if (!idleTimeInSeconds || idleTimeInSeconds <= 0) {
@@ -18669,6 +18814,7 @@ var VideoGridView = React19__namespace.default.memo(({
   const [gridRows, setGridRows] = React19.useState(1);
   const [visibleWorkspaces, setVisibleWorkspaces] = React19.useState(/* @__PURE__ */ new Set());
   const [cardDimensions, setCardDimensions] = React19.useState({ width: 0, height: 0 });
+  const [failedStreams, setFailedStreams] = React19.useState(/* @__PURE__ */ new Set());
   const videoConfig = useVideoConfig();
   const { cropping, canvasConfig, hlsUrls } = videoConfig;
   const mergedVideoSources = {
@@ -18820,9 +18966,17 @@ var VideoGridView = React19__namespace.default.memo(({
       action_count: workspace.action_count
     });
     const displayName = getWorkspaceDisplayName(workspace.workspace_name, workspace.line_id);
-    const navParams = getWorkspaceNavigationParams(workspaceId, displayName);
+    const navParams = getWorkspaceNavigationParams(workspaceId, displayName, workspace.line_id);
     router$1.push(`/workspace/${workspaceId}${navParams}`);
   }, [router$1]);
+  const handleStreamError = React19.useCallback((workspaceId) => {
+    console.error(`[VideoGridView] Stream failed for workspace: ${workspaceId}`);
+    setFailedStreams((prev) => new Set(prev).add(workspaceId));
+    trackCoreEvent("Video Stream Error", {
+      workspace_id: workspaceId,
+      view_type: "video_grid"
+    });
+  }, []);
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `relative overflow-hidden h-full w-full ${className}`, children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className: "h-full w-full p-2", children: /* @__PURE__ */ jsxRuntime.jsx(
     "div",
     {
@@ -18859,9 +19013,9 @@ var VideoGridView = React19__namespace.default.memo(({
               {
                 workspace,
                 hlsUrl: getWorkspaceHlsUrl(workspace.workspace_name, workspace.line_id),
-                shouldPlay: isVisible,
+                shouldPlay: isVisible && !failedStreams.has(workspaceId),
                 onClick: () => handleWorkspaceClick(workspace),
-                onFatalError: throttledReloadDashboard,
+                onFatalError: () => handleStreamError(workspaceId),
                 isVeryLowEfficiency,
                 cropping: workspaceCropping,
                 canvasFps: canvasConfig?.fps,
@@ -24028,7 +24182,7 @@ var WorkspaceGridItem = React19__namespace.default.memo(({
     e.preventDefault();
     if (isInactive) return;
     const displayName = getWorkspaceDisplayName(data.workspace_name, data.line_id);
-    const navParams = getWorkspaceNavigationParams(data.workspace_id, displayName);
+    const navParams = getWorkspaceNavigationParams(data.workspace_id, displayName, data.line_id);
     navigate(`/workspace/${data.workspace_id}${navParams}`, {
       trackingEvent: {
         name: "Workspace Detail Clicked",
@@ -28769,6 +28923,73 @@ function HomeView({
 }
 var AuthenticatedHomeView = withAuth(React19__namespace.default.memo(HomeView));
 var HomeView_default = HomeView;
+function withWorkspaceDisplayNames(Component3, options = {}) {
+  const {
+    showLoading = true,
+    loadingMessage = "Initializing workspace data...",
+    initializeFor = "all"
+  } = options;
+  return function WithWorkspaceDisplayNamesWrapper(props) {
+    const [isInitialized2, setIsInitialized] = React19.useState(false);
+    const [error, setError] = React19.useState(null);
+    React19.useEffect(() => {
+      setIsInitialized(false);
+      setError(null);
+      const initializeDisplayNames = async () => {
+        try {
+          const { lineIds, selectedLineId, factoryViewId } = props;
+          let lineIdArray = [];
+          if (Array.isArray(lineIds)) {
+            lineIdArray = lineIds;
+          } else if (lineIds && typeof lineIds === "object") {
+            lineIdArray = Object.values(lineIds).filter((id3) => !!id3);
+          }
+          if (initializeFor === "specific" && selectedLineId) {
+            if (selectedLineId === factoryViewId && lineIdArray.length > 0) {
+              await Promise.all(
+                lineIdArray.map((lineId) => preInitializeWorkspaceDisplayNames(lineId))
+              );
+            } else {
+              await preInitializeWorkspaceDisplayNames(selectedLineId);
+            }
+          } else if (lineIdArray.length > 0) {
+            await Promise.all(
+              lineIdArray.map((lineId) => preInitializeWorkspaceDisplayNames(lineId))
+            );
+          } else {
+            await preInitializeWorkspaceDisplayNames();
+          }
+          setIsInitialized(true);
+        } catch (err) {
+          console.error("Failed to initialize workspace display names:", err);
+          setError(err);
+          setIsInitialized(true);
+        }
+      };
+      initializeDisplayNames();
+    }, [
+      Array.isArray(props.lineIds) ? props.lineIds.join(",") : JSON.stringify(props.lineIds),
+      props.selectedLineId,
+      props.factoryViewId,
+      initializeFor
+    ]);
+    if (!isInitialized2 && showLoading) {
+      return /* @__PURE__ */ jsxRuntime.jsx(LoadingPage, { message: loadingMessage });
+    }
+    if (error && showLoading) {
+      console.warn("Workspace display names initialization failed, proceeding anyway:", error);
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(Component3, { ...props });
+  };
+}
+var withAllWorkspaceDisplayNames = (Component3) => withWorkspaceDisplayNames(Component3, {
+  initializeFor: "all",
+  showLoading: true
+});
+var withSelectedLineDisplayNames = (Component3) => withWorkspaceDisplayNames(Component3, {
+  initializeFor: "specific",
+  showLoading: true
+});
 
 // src/views/kpi-detail-view.types.ts
 var pageVariants = {
@@ -28829,11 +29050,6 @@ var itemVariants = {
     }
   }
 };
-
-// src/lib/utils/navigation.ts
-function getWorkspaceNavigationParams2(workspaceUuid, displayName) {
-  return `?name=${encodeURIComponent(displayName || "")}`;
-}
 var formatLocalDate = (date) => {
   const options = {
     year: "numeric",
@@ -28949,7 +29165,7 @@ var BottomSection = React19.memo(({
               }
               const clickHandler = () => handleWorkspaceClick(ws, index);
               const displayName = getWorkspaceDisplayName(ws.workspace_name, lineId);
-              const navParams = wsUuid ? getWorkspaceNavigationParams2(wsUuid, displayName) : "";
+              const navParams = wsUuid ? getWorkspaceNavigationParams(wsUuid, displayName, lineId) : "";
               const dateShiftParams = urlDate ? `&date=${urlDate}&shift=${urlShift || "0"}` : "";
               const returnToParam = `&returnTo=${encodeURIComponent(`/kpis/${lineInfo?.line_id}`)}`;
               const fullUrl = `/workspace/${wsUuid}${navParams}${dateShiftParams}${returnToParam}`;
@@ -28983,7 +29199,7 @@ var BottomSection = React19.memo(({
               sortedByEfficiency.map((ws, index) => {
                 const clickHandler = () => handleWorkspaceClick(ws, index);
                 const displayName = getWorkspaceDisplayName(ws.workspace_name, lineId);
-                const navParams = ws.workspace_uuid ? getWorkspaceNavigationParams2(ws.workspace_uuid, displayName) : "";
+                const navParams = ws.workspace_uuid ? getWorkspaceNavigationParams(ws.workspace_uuid, displayName, lineId) : "";
                 const dateShiftParams = urlDate ? `&date=${urlDate}&shift=${urlShift || "0"}` : "";
                 const returnToParam = `&returnTo=${encodeURIComponent(`/kpis/${lineInfo?.line_id}`)}`;
                 const fullUrl = `/workspace/${ws.workspace_uuid}${navParams}${dateShiftParams}${returnToParam}`;
@@ -29598,7 +29814,8 @@ var KPIDetailView = ({
     ) }) })
   ] });
 };
-var KPIDetailView_default = KPIDetailView;
+var KPIDetailViewWithDisplayNames = withSelectedLineDisplayNames(KPIDetailView);
+var KPIDetailView_default = KPIDetailViewWithDisplayNames;
 var LineCard = ({ line, onClick }) => {
   const { kpis, isLoading, error } = useLineKPIs({ lineId: line.id });
   const isOnTrack = React19__namespace.default.useMemo(() => {
@@ -30088,7 +30305,7 @@ var LeaderboardDetailView = React19.memo(({
       action_threshold: workspace.action_threshold
     });
     const displayName = getWorkspaceDisplayName(workspace.workspace_name, workspace.line_id);
-    const navParams = workspace.workspace_uuid ? getWorkspaceNavigationParams(workspace.workspace_uuid, displayName) : "";
+    const navParams = workspace.workspace_uuid ? getWorkspaceNavigationParams(workspace.workspace_uuid, displayName, workspace.line_id) : "";
     const returnToParam = `&returnTo=${encodeURIComponent(`/leaderboard`)}`;
     if (onWorkspaceClick) {
       onWorkspaceClick(workspace, rank);
@@ -30222,7 +30439,8 @@ var LeaderboardDetailView = React19.memo(({
   return prevProps.lineId === nextProps.lineId && prevProps.date === nextProps.date && prevProps.shift === nextProps.shift && prevProps.line1Id === nextProps.line1Id && prevProps.line2Id === nextProps.line2Id && JSON.stringify(prevProps.lineNames) === JSON.stringify(nextProps.lineNames) && prevProps.className === nextProps.className && prevProps.onBackClick === nextProps.onBackClick && prevProps.onWorkspaceClick === nextProps.onWorkspaceClick;
 });
 LeaderboardDetailView.displayName = "LeaderboardDetailView";
-var LeaderboardDetailView_default = LeaderboardDetailView;
+var LeaderboardDetailViewWithDisplayNames = withAllWorkspaceDisplayNames(LeaderboardDetailView);
+var LeaderboardDetailView_default = LeaderboardDetailViewWithDisplayNames;
 function LoginView({
   logoSrc = "/optifye-logo.png",
   logoAlt = "Optifye",
@@ -32342,7 +32560,12 @@ var TargetsView = ({
       }
     }), {});
   }, [lineIds]);
-  const [lineWorkspaces, setLineWorkspaces] = React19.useState(initialLineWorkspaces);
+  const [allShiftsData, setAllShiftsData] = React19.useState({
+    0: initialLineWorkspaces,
+    // Day shift
+    1: initialLineWorkspaces
+    // Night shift (will be populated on first load)
+  });
   const [actionIds, setActionIds] = React19.useState(null);
   const [savingLines, setSavingLines] = React19.useState(
     () => lineIds.reduce((acc, id3) => ({ ...acc, [id3]: false }), {})
@@ -32354,6 +32577,13 @@ var TargetsView = ({
   const [isBulkConfigureOpen, setIsBulkConfigureOpen] = React19.useState(false);
   const [selectedWorkspaces, setSelectedWorkspaces] = React19.useState([]);
   const [selectedShift, setSelectedShift] = React19.useState(0);
+  const lineWorkspaces = allShiftsData[selectedShift] || initialLineWorkspaces;
+  const setLineWorkspaces = React19.useCallback((updater) => {
+    setAllShiftsData((prev) => ({
+      ...prev,
+      [selectedShift]: typeof updater === "function" ? updater(prev[selectedShift]) : updater
+    }));
+  }, [selectedShift]);
   const supabase = useSupabase();
   const auth = useAuth();
   userId || auth?.user?.id;
@@ -32361,70 +32591,120 @@ var TargetsView = ({
   const { skus, isLoading: skusLoading } = useSKUs(companyId);
   const skuEnabled = dashboardConfig?.skuConfig?.enabled || false;
   React19.useEffect(() => {
-    const fetchLineDetails = async () => {
+    let timeoutId;
+    let retryCount = 0;
+    const MAX_RETRIES2 = 2;
+    const LOADING_TIMEOUT = 15e3;
+    const fetchInitialData = async () => {
       if (!supabase || lineIds.length === 0) return;
-      const detailsPromises = lineIds.map(async (lineId) => {
-        try {
-          const { data, error } = await supabase.from("lines").select("factory_id").eq("id", lineId).single();
-          if (error) {
-            console.error(`Error fetching factory_id for line ${lineId}:`, error);
-            return { lineId, factoryId: void 0 };
-          }
-          return { lineId, factoryId: data?.factory_id };
-        } catch (err) {
-          console.error(`Exception fetching factory_id for line ${lineId}:`, err);
-          return { lineId, factoryId: void 0 };
+      setIsLoading(true);
+      timeoutId = setTimeout(() => {
+        console.error("Loading timeout reached");
+        if (retryCount < MAX_RETRIES2) {
+          retryCount++;
+          console.log(`Retrying... (attempt ${retryCount + 1}/${MAX_RETRIES2 + 1})`);
+          sonner.toast.warning("Loading is taking longer than expected. Retrying...");
+          fetchInitialData();
+        } else {
+          setIsLoading(false);
+          sonner.toast.error("Failed to load data. Please refresh the page.");
         }
-      });
-      const results = await Promise.all(detailsPromises);
-      setLineWorkspaces((prev) => {
-        const newWorkspaces = { ...prev };
-        let needsUpdate = false;
-        results.forEach((result) => {
-          if (result.factoryId && newWorkspaces[result.lineId] && newWorkspaces[result.lineId].factoryId !== result.factoryId) {
-            newWorkspaces[result.lineId].factoryId = result.factoryId;
-            needsUpdate = true;
-          }
-        });
-        return needsUpdate ? newWorkspaces : prev;
-      });
-    };
-    fetchLineDetails();
-  }, [supabase, lineIds]);
-  React19.useEffect(() => {
-    const fetchActions = async () => {
-      if (!supabase) {
-        console.error("Supabase client not available in fetchActions");
-        sonner.toast.error("Initialization error, please refresh.");
-        return;
-      }
+      }, LOADING_TIMEOUT);
       try {
-        const actions = await actionService.getActionsByName(
-          [ACTION_NAMES.ASSEMBLY, ACTION_NAMES.PACKAGING],
-          companyId
-        );
+        const [factoryResults, actions] = await Promise.all([
+          // Fetch factory IDs
+          Promise.all(lineIds.map(async (lineId) => {
+            try {
+              const { data, error } = await supabase.from("lines").select("factory_id").eq("id", lineId).single();
+              if (error) {
+                console.error(`Error fetching factory_id for line ${lineId}:`, error);
+                return { lineId, factoryId: void 0 };
+              }
+              return { lineId, factoryId: data?.factory_id };
+            } catch (err) {
+              console.error(`Exception fetching factory_id for line ${lineId}:`, err);
+              return { lineId, factoryId: void 0 };
+            }
+          })),
+          // Fetch action IDs
+          actionService.getActionsByName(
+            [ACTION_NAMES.ASSEMBLY, ACTION_NAMES.PACKAGING],
+            companyId
+          )
+        ]);
         const assemblyAction = actions.find((a) => a.action_name === ACTION_NAMES.ASSEMBLY);
         const packagingAction = actions.find((a) => a.action_name === ACTION_NAMES.PACKAGING);
         if (!assemblyAction || !packagingAction) {
           throw new Error("Could not find required actions");
         }
-        const ids = {
+        const actionIdsData = {
           assembly: assemblyAction.id,
           packaging: packagingAction.id
         };
-        console.log("Fetched Action IDs:", {
-          "Assembly Action ID": ids.assembly,
-          "Packaging Action ID": ids.packaging
+        setActionIds(actionIdsData);
+        const updatedLineWorkspaces = { ...initialLineWorkspaces };
+        factoryResults.forEach((result) => {
+          if (result.factoryId && updatedLineWorkspaces[result.lineId]) {
+            updatedLineWorkspaces[result.lineId].factoryId = result.factoryId;
+          }
         });
-        setActionIds(ids);
+        const currentDate = getOperationalDate();
+        for (const lineId of lineIds) {
+          if (!updatedLineWorkspaces[lineId]?.factoryId) {
+            console.warn(`Skipping workspace fetch for line ${lineId} - no factory ID`);
+            continue;
+          }
+          try {
+            const workspacesData = await workspaceService.getWorkspaces(lineId);
+            const actionThresholds = await workspaceService.getActionThresholds(
+              lineId,
+              currentDate,
+              selectedShift
+            );
+            const mappedWorkspaces = workspacesData.map((ws) => {
+              const threshold = actionThresholds.find((t) => t.workspace_id === ws.id);
+              return {
+                id: ws.id,
+                name: ws.workspace_id,
+                targetPPH: threshold?.pph_threshold ?? (ws.action_pph_threshold === null ? "" : ws.action_pph_threshold),
+                targetCycleTime: threshold?.ideal_cycle_time ?? (ws.action_cycle_time === null ? "" : ws.action_cycle_time),
+                targetDayOutput: threshold?.total_day_output ?? (ws.action_total_day_output === null ? "" : ws.action_total_day_output),
+                actionType: ws.action_id === actionIdsData.assembly ? "assembly" : ws.action_id === actionIdsData.packaging ? "packaging" : "assembly",
+                actionId: ws.action_id === actionIdsData.assembly ? actionIdsData.assembly : ws.action_id === actionIdsData.packaging ? actionIdsData.packaging : actionIdsData.assembly
+              };
+            }).sort((a, b) => a.name.localeCompare(b.name, void 0, { numeric: true }));
+            updatedLineWorkspaces[lineId].workspaces = mappedWorkspaces;
+          } catch (error) {
+            console.error(`Error fetching workspace data for line ${lineId}:`, error);
+          }
+        }
+        setLineWorkspaces(updatedLineWorkspaces);
+        await fetchAllShiftsData(updatedLineWorkspaces);
       } catch (error) {
-        console.error("Error fetching actions:", error);
-        sonner.toast.error("Failed to load action data");
+        console.error("Error fetching initial data:", error);
+        clearTimeout(timeoutId);
+        if (retryCount < MAX_RETRIES2) {
+          retryCount++;
+          console.log(`Error occurred, retrying... (attempt ${retryCount + 1}/${MAX_RETRIES2 + 1})`);
+          sonner.toast.warning("Error loading data. Retrying...");
+          setTimeout(() => fetchInitialData(), 1e3);
+        } else {
+          sonner.toast.error("Failed to load initial data");
+          setIsLoading(false);
+        }
+      } finally {
+        clearTimeout(timeoutId);
+        if (retryCount === 0 || retryCount >= MAX_RETRIES2) {
+          setIsLoading(false);
+        }
       }
     };
-    fetchActions();
-  }, [supabase, companyId]);
-  const fetchLineThresholds = React19.useCallback(async () => {
+    fetchInitialData();
+    return () => {
+      clearTimeout(timeoutId);
+    };
+  }, [supabase, lineIds, companyId]);
+  React19.useCallback(async (shiftId) => {
     try {
       if (!supabase) return;
       const currentDate = getOperationalDate();
@@ -32492,15 +32772,7 @@ var TargetsView = ({
               shiftEndTime: endTime,
               breaks,
               shiftHours: Number(shiftHours),
-              workspaces: (currentLineStateFromLoop?.workspaces || []).map((ws) => ({
-                ...ws,
-                targetPPH: ws.targetCycleTime !== "" ? calculatePPH(ws.targetCycleTime, breaks, Number(shiftHours)) : ws.targetPPH,
-                targetDayOutput: calculateDayOutput(
-                  ws.targetCycleTime !== "" ? calculatePPH(ws.targetCycleTime, breaks, Number(shiftHours)) : ws.targetPPH,
-                  Number(shiftHours),
-                  breaks
-                )
-              }))
+              workspaces: currentLineStateFromLoop?.workspaces || []
             };
             hasUpdates = true;
           }
@@ -32514,7 +32786,71 @@ var TargetsView = ({
     } catch (error) {
       console.error("Error in fetchLineThresholds outer try-catch:", error);
     }
-  }, [selectedShift, supabase, lineIds, lineWorkspaces]);
+  }, [selectedShift, supabase, lineIds, lineWorkspaces, allShiftsData]);
+  const fetchAllShiftsData = React19.useCallback(async (currentWorkspaces) => {
+    if (!supabase) return;
+    const currentDate = getOperationalDate();
+    const newAllShiftsData = {
+      0: JSON.parse(JSON.stringify(currentWorkspaces)),
+      // Deep clone for day shift
+      1: JSON.parse(JSON.stringify(currentWorkspaces))
+      // Deep clone for night shift
+    };
+    for (const shiftId of [0, 1]) {
+      for (const lineId of lineIds) {
+        try {
+          const { data: operatingHours, error: hoursError } = await supabase.from("line_operating_hours").select("start_time, end_time, breaks").eq("line_id", lineId).eq("shift_id", shiftId).maybeSingle();
+          if (hoursError) {
+            console.error(`Error fetching operating hours for line ${lineId}, shift ${shiftId}:`, hoursError);
+            continue;
+          }
+          let breaks = [];
+          if (operatingHours?.breaks) {
+            if (Array.isArray(operatingHours.breaks)) {
+              breaks = operatingHours.breaks.map((breakItem) => ({
+                startTime: breakItem.start || breakItem.startTime || "00:00",
+                endTime: breakItem.end || breakItem.endTime || "00:00",
+                duration: breakItem.duration || calculateShiftHours2(breakItem.start || breakItem.startTime || "00:00", breakItem.end || breakItem.endTime || "00:00", []) * 60
+              }));
+            }
+          }
+          const startTime = operatingHours?.start_time || "08:00";
+          const endTime = operatingHours?.end_time || "19:00";
+          const shiftHours = calculateShiftHours2(startTime, endTime, breaks);
+          const actionThresholds = await workspaceService.getActionThresholds(
+            lineId,
+            currentDate,
+            shiftId
+          );
+          const existingLine = newAllShiftsData[shiftId][lineId];
+          if (existingLine) {
+            newAllShiftsData[shiftId][lineId] = {
+              ...existingLine,
+              shiftStartTime: startTime,
+              shiftEndTime: endTime,
+              breaks,
+              shiftHours: Number(shiftHours),
+              workspaces: existingLine.workspaces.map((ws) => {
+                const threshold = actionThresholds.find((t) => t.workspace_id === ws.id);
+                if (threshold) {
+                  return {
+                    ...ws,
+                    targetPPH: threshold.pph_threshold,
+                    targetCycleTime: threshold.ideal_cycle_time,
+                    targetDayOutput: threshold.total_day_output
+                  };
+                }
+                return ws;
+              })
+            };
+          }
+        } catch (error) {
+          console.error(`Error fetching data for line ${lineId}, shift ${shiftId}:`, error);
+        }
+      }
+    }
+    setAllShiftsData(newAllShiftsData);
+  }, [supabase, lineIds]);
   const loadOperatingHours = React19.useCallback(async (lineId, shiftId) => {
     try {
       if (!supabase) return null;
@@ -32610,99 +32946,6 @@ var TargetsView = ({
       };
     }
   }, [supabase]);
-  React19.useEffect(() => {
-    const allFactoryIdsLoaded = lineIds.every((lineId) => lineWorkspaces[lineId]?.factoryId);
-    if (!actionIds || !allFactoryIdsLoaded) {
-      return;
-    }
-    const workspacesAlreadyLoadedForAnyLine = Object.values(lineWorkspaces).some(
-      (line) => line.workspaces && line.workspaces.length > 0
-    );
-    if (workspacesAlreadyLoadedForAnyLine) {
-      fetchLineThresholds();
-      return;
-    }
-    const fetchWorkspacesAndThenThresholds = async () => {
-      setIsLoading(true);
-      try {
-        if (!supabase) {
-          sonner.toast.error("Supabase client not available");
-          setIsLoading(false);
-          return;
-        }
-        console.log("Starting workspace fetch with actionIds and loaded factoryIds.");
-        const newUpdatedLineWorkspaces = { ...lineWorkspaces };
-        let workspacesHaveBeenUpdated = false;
-        for (const lineId of lineIds) {
-          if (!newUpdatedLineWorkspaces[lineId]?.factoryId) {
-            console.warn(`FactoryId for line ${lineId} missing during workspace fetch. Skipping its workspaces.`);
-            continue;
-          }
-          try {
-            const fetchedLineWorkspacesData = await workspaceService.getWorkspaces(lineId);
-            const mappedWorkspaces = fetchedLineWorkspacesData.map((ws) => ({
-              id: ws.id,
-              name: ws.workspace_id,
-              targetPPH: ws.action_pph_threshold === null ? "" : ws.action_pph_threshold,
-              targetCycleTime: ws.action_cycle_time === null ? "" : ws.action_cycle_time,
-              targetDayOutput: ws.action_total_day_output === null ? "" : ws.action_total_day_output,
-              actionType: ws.action_id === actionIds.assembly ? "assembly" : ws.action_id === actionIds.packaging ? "packaging" : "assembly",
-              actionId: ws.action_id === actionIds.assembly ? actionIds.assembly : ws.action_id === actionIds.packaging ? actionIds.packaging : actionIds.assembly
-            })).sort((a, b) => a.name.localeCompare(b.name, void 0, { numeric: true }));
-            if (JSON.stringify(mappedWorkspaces) !== JSON.stringify(newUpdatedLineWorkspaces[lineId].workspaces)) {
-              newUpdatedLineWorkspaces[lineId] = {
-                ...newUpdatedLineWorkspaces[lineId],
-                workspaces: mappedWorkspaces
-              };
-              workspacesHaveBeenUpdated = true;
-            }
-          } catch (error) {
-            console.error(`Error fetching workspaces for line ${lineId}:`, error);
-          }
-        }
-        if (workspacesHaveBeenUpdated) {
-          setLineWorkspaces(newUpdatedLineWorkspaces);
-        }
-        await fetchLineThresholds();
-      } catch (error) {
-        console.error("Error in fetchWorkspacesAndThenThresholds:", error);
-        sonner.toast.error("Failed to load workspace data");
-      } finally {
-        setIsLoading(false);
-      }
-    };
-    fetchWorkspacesAndThenThresholds();
-  }, [actionIds, supabase, lineIds, lineWorkspaces, fetchLineThresholds]);
-  React19.useEffect(() => {
-    if (Object.keys(lineWorkspaces).length > 0) {
-      const updatedLineWorkspaces = { ...lineWorkspaces };
-      let hasChanges = false;
-      Object.keys(updatedLineWorkspaces).forEach((lineId) => {
-        const line = updatedLineWorkspaces[lineId];
-        const shiftHours = calculateShiftHours2(line.shiftStartTime, line.shiftEndTime, line.breaks);
-        if (shiftHours !== line.shiftHours) {
-          hasChanges = true;
-          updatedLineWorkspaces[lineId] = {
-            ...line,
-            shiftHours,
-            workspaces: line.workspaces.map((ws) => {
-              const targetDayOutput = calculateDayOutput(ws.targetPPH, shiftHours, line.breaks);
-              if (targetDayOutput !== ws.targetDayOutput) {
-                return {
-                  ...ws,
-                  targetDayOutput
-                };
-              }
-              return ws;
-            })
-          };
-        }
-      });
-      if (hasChanges) {
-        setLineWorkspaces(updatedLineWorkspaces);
-      }
-    }
-  }, [selectedShift]);
   const toggleLineDropdown = React19.useCallback((lineId) => {
     setLineWorkspaces((prev) => {
       const newIsOpen = !prev[lineId].isOpen;
@@ -32786,6 +33029,16 @@ var TargetsView = ({
               updates.targetDayOutput = calculateDayOutput(value, shiftHours, prev[lineId].breaks);
             } else if (field === "targetDayOutput") {
               updates.targetDayOutput = value;
+              if (value !== "") {
+                const breaks = prev[lineId].breaks;
+                const totalBreakMinutes = breaks.reduce((total, b) => total + b.duration, 0);
+                const totalBreakHours = totalBreakMinutes / 60;
+                const realWorkHours = shiftHours - totalBreakHours;
+                const calculatedPPH = Math.round(value / realWorkHours);
+                updates.targetPPH = calculatedPPH;
+              } else {
+                updates.targetPPH = "";
+              }
             }
             updates[field] = value;
             return updates;
@@ -32919,14 +33172,15 @@ var TargetsView = ({
       console.log(`[handleSaveLine] workspaceThresholdUpdates for ${lineId}:`, workspaceThresholdUpdates);
       await workspaceService.updateActionThresholds(workspaceThresholdUpdates);
       console.log(`[handleSaveLine] Successfully updated action thresholds for ${lineId}`);
+      const packagingWorkspaces = lineDataToSave.workspaces.filter((ws) => ws.actionType === "packaging");
       const lineThresholdData = {
         factory_id: currentFactoryId,
         line_id: lineId,
         date: currentDate,
         shift_id: selectedShift,
         product_code: lineDataToSave.productId,
-        threshold_day_output: lineDataToSave.workspaces.reduce((acc, ws) => acc + (Number(ws.targetDayOutput) || 0), 0),
-        threshold_pph: lineDataToSave.workspaces.reduce((acc, ws) => acc + (Number(ws.targetPPH) || 0), 0),
+        threshold_day_output: packagingWorkspaces.reduce((acc, ws) => acc + (Number(ws.targetDayOutput) || 0), 0),
+        threshold_pph: packagingWorkspaces.reduce((acc, ws) => acc + (Number(ws.targetPPH) || 0), 0),
         ...skuEnabled && lineDataToSave.selectedSKU ? { sku_id: lineDataToSave.selectedSKU.id } : {}
       };
       console.log(`[handleSaveLine] lineThresholdData for upsert on ${lineId}:`, lineThresholdData);
@@ -33047,8 +33301,9 @@ var TargetsView = ({
     }
   );
 };
-var TargetsView_default = TargetsView;
-var AuthenticatedTargetsView = withAuth(TargetsView);
+var TargetsViewWithDisplayNames = withAllWorkspaceDisplayNames(TargetsView);
+var TargetsView_default = TargetsViewWithDisplayNames;
+var AuthenticatedTargetsView = withAuth(TargetsViewWithDisplayNames);
 
 // src/views/workspace-detail-view.utils.ts
 var formatISTDate2 = (date = /* @__PURE__ */ new Date(), options) => {
@@ -33064,8 +33319,8 @@ var formatISTDate2 = (date = /* @__PURE__ */ new Date(), options) => {
   });
   return formatter.format(date);
 };
-var formatWorkspaceName3 = (name) => {
-  return getWorkspaceDisplayName(name);
+var formatWorkspaceName3 = (name, lineId) => {
+  return getWorkspaceDisplayName(name, lineId);
 };
 var getDaysDifference = (date) => {
   const today = /* @__PURE__ */ new Date();
@@ -33102,9 +33357,11 @@ var WorkspaceDetailView = ({
   fromMonthly = false,
   sourceType,
   displayName,
+  lineId,
   defaultTab,
   returnUrl,
   lineIds = { line1: "", line2: "" },
+  selectedLineId,
   onNavigate,
   onTabChange,
   onDateSelect,
@@ -33267,7 +33524,8 @@ var WorkspaceDetailView = ({
     setSelectedMonth(newMonth);
     setSelectedYear(newYear);
   };
-  const formattedWorkspaceName = displayName || formatWorkspaceName3(workspace?.workspace_name || "");
+  const effectiveLineId = lineId || selectedLineId;
+  const formattedWorkspaceName = displayName || formatWorkspaceName3(workspace?.workspace_name || "", effectiveLineId);
   const shouldShowCycleTimeChart = showCycleTimeChart ?? formattedWorkspaceName.startsWith("FINAL ASSY");
   const handleBackNavigation = () => {
     if (returnUrl) {
@@ -33279,13 +33537,23 @@ var WorkspaceDetailView = ({
     if (date || shift) {
       setActiveTab("monthly_history");
       if (onNavigate) {
-        onNavigate(`/workspace/${workspaceId}?fromMonthly=true`);
+        const params = new URLSearchParams();
+        params.set("fromMonthly", "true");
+        if (effectiveLineId) {
+          params.set("lineId", effectiveLineId);
+        }
+        onNavigate(`/workspace/${workspaceId}?${params.toString()}`);
       }
     } else {
       if (previousView === "line_monthly_history") {
         setActiveTab("monthly_history");
         if (onNavigate) {
-          onNavigate(`/workspace/${workspaceId}?fromMonthly=true`);
+          const params = new URLSearchParams();
+          params.set("fromMonthly", "true");
+          if (effectiveLineId) {
+            params.set("lineId", effectiveLineId);
+          }
+          onNavigate(`/workspace/${workspaceId}?${params.toString()}`);
         }
       } else {
         if (onNavigate) {
@@ -33743,7 +34011,13 @@ var WorkspaceDetailView = ({
                   if (onDateSelect) {
                     onDateSelect(selectedDate, selectedShift);
                   } else if (onNavigate) {
-                    onNavigate(`/workspace/${workspaceId}?date=${selectedDate}&shift=${selectedShift === "day" ? "0" : "1"}`);
+                    const params = new URLSearchParams();
+                    params.set("date", selectedDate);
+                    params.set("shift", selectedShift === "day" ? "0" : "1");
+                    if (effectiveLineId) {
+                      params.set("lineId", effectiveLineId);
+                    }
+                    onNavigate(`/workspace/${workspaceId}?${params.toString()}`);
                   }
                 },
                 onMonthNavigate: (newMonth, newYear) => {
@@ -33770,7 +34044,12 @@ var WorkspaceDetailView = ({
     }
   );
 };
-var WrappedComponent = withAuth(WorkspaceDetailView);
+var WorkspaceDetailViewWithDisplayNames = withSelectedLineDisplayNames(WorkspaceDetailView);
+var WorkspaceDetailViewFinal = (props) => {
+  const componentKey = `${props.date || "live"}_${props.shift || "current"}`;
+  return /* @__PURE__ */ jsxRuntime.jsx(WorkspaceDetailViewWithDisplayNames, { ...props }, componentKey);
+};
+var WrappedComponent = withAuth(WorkspaceDetailViewFinal);
 var WorkspaceDetailView_default = WrappedComponent;
 var SKUManagementView = () => {
   const config = useDashboardConfig();
@@ -34344,6 +34623,7 @@ exports.identifyCoreUser = identifyCoreUser;
 exports.initializeCoreMixpanel = initializeCoreMixpanel;
 exports.isLegacyConfiguration = isLegacyConfiguration;
 exports.isTransitionPeriod = isTransitionPeriod;
+exports.isUrlPermanentlyFailed = isUrlPermanentlyFailed;
 exports.isValidFactoryViewConfiguration = isValidFactoryViewConfiguration;
 exports.isValidLineInfoPayload = isValidLineInfoPayload;
 exports.isValidWorkspaceDetailedMetricsPayload = isValidWorkspaceDetailedMetricsPayload;
@@ -34363,6 +34643,7 @@ exports.qualityService = qualityService;
 exports.realtimeService = realtimeService;
 exports.refreshWorkspaceDisplayNames = refreshWorkspaceDisplayNames;
 exports.resetCoreMixpanel = resetCoreMixpanel;
+exports.resetFailedUrl = resetFailedUrl;
 exports.resetSubscriptionManager = resetSubscriptionManager;
 exports.s3VideoPreloader = s3VideoPreloader;
 exports.skuService = skuService;