@optifye/dashboard-core 6.0.8 → 6.1.0

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) {
@@ -18666,7 +18811,10 @@ var VideoGridView = React19__namespace.default.memo(({
   const containerRef = React19.useRef(null);
   const observerRef = React19.useRef(null);
   const [gridCols, setGridCols] = React19.useState(4);
+  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 = {
@@ -18727,35 +18875,51 @@ var VideoGridView = React19__namespace.default.memo(({
       setGridCols(1);
       return;
     }
-    let bestCols = 1;
-    let bestScore = 0;
+    const optimalLayouts = {
+      1: 1,
+      2: 2,
+      3: 3,
+      4: 2,
+      5: 3,
+      6: 3,
+      7: 4,
+      8: 4,
+      9: 3,
+      10: 5,
+      11: 4,
+      12: 4,
+      13: 5,
+      14: 5,
+      15: 5,
+      16: 4,
+      17: 6,
+      18: 6,
+      19: 5,
+      20: 5,
+      21: 7,
+      22: 6,
+      23: 6,
+      24: 6
+    };
+    let bestCols = optimalLayouts[count] || Math.ceil(Math.sqrt(count));
+    const containerAspectRatio = containerWidth / containerHeight;
     const targetAspectRatio = 16 / 9;
     const gap = 8;
-    const maxCols = Math.min(count, selectedLine ? 6 : 12);
-    for (let cols = 1; cols <= maxCols; cols++) {
-      const rows = Math.ceil(count / cols);
-      const availableWidth = containerWidth - gap * (cols - 1);
-      const availableHeight = containerHeight - gap * (rows - 1);
-      const cellWidth = availableWidth / cols;
-      const cellHeight = availableHeight / rows;
-      const minCellWidth = selectedLine ? containerWidth < 800 ? 120 : 150 : containerWidth < 800 ? 80 : 100;
-      const minCellHeight = selectedLine ? containerHeight < 600 ? 80 : 100 : containerHeight < 600 ? 60 : 80;
-      if (cellWidth < minCellWidth || cellHeight < minCellHeight) continue;
-      const totalUsedArea = cellWidth * cellHeight * count;
-      const totalAvailableArea = containerWidth * containerHeight;
-      const spaceUtilization = totalUsedArea / totalAvailableArea;
-      const actualAspectRatio = cellWidth / cellHeight;
-      const aspectRatioScore = 1 / (1 + Math.abs(actualAspectRatio - targetAspectRatio) * 0.3);
-      const score = spaceUtilization * 0.9 + aspectRatioScore * 0.1;
-      if (score > bestScore) {
-        bestScore = score;
-        bestCols = cols;
-      }
-    }
-    if (bestScore === 0) {
-      bestCols = Math.ceil(Math.sqrt(count));
+    if (containerAspectRatio > targetAspectRatio * 1.5 && count > 6) {
+      bestCols = Math.min(bestCols + 1, Math.ceil(count / 2));
+    }
+    const minCellWidth = selectedLine ? 150 : 100;
+    const availableWidth = containerWidth - gap * (bestCols - 1);
+    const cellWidth = availableWidth / bestCols;
+    if (cellWidth < minCellWidth && bestCols > 1) {
+      bestCols = Math.floor((containerWidth + gap) / (minCellWidth + gap));
     }
+    const rows = Math.ceil(count / bestCols);
     setGridCols(bestCols);
+    setGridRows(rows);
+    const cardWidth = (containerWidth - gap * (bestCols - 1)) / bestCols;
+    const cardHeight = (containerHeight - gap * (rows - 1)) / rows;
+    setCardDimensions({ width: Math.floor(cardWidth), height: Math.floor(cardHeight) });
   }, [filteredWorkspaces.length, selectedLine]);
   React19.useEffect(() => {
     calculateOptimalGrid();
@@ -18802,17 +18966,25 @@ 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",
     {
       className: "grid h-full w-full gap-2",
       style: {
         gridTemplateColumns: `repeat(${gridCols}, 1fr)`,
-        gridTemplateRows: `repeat(${Math.ceil(filteredWorkspaces.length / gridCols)}, 1fr)`,
-        minHeight: "100%"
+        gridTemplateRows: `repeat(${gridRows}, 1fr)`,
+        gridAutoFlow: "row"
       },
       children: filteredWorkspaces.sort((a, b) => {
         if (a.line_id !== b.line_id) {
@@ -18835,23 +19007,22 @@ var VideoGridView = React19__namespace.default.memo(({
           "div",
           {
             "data-workspace-id": workspaceId,
-            className: "workspace-card relative min-h-0 min-w-0",
-            style: { width: "100%", height: "100%" },
-            children: /* @__PURE__ */ jsxRuntime.jsx(
+            className: "workspace-card relative w-full h-full",
+            children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute inset-0", children: /* @__PURE__ */ jsxRuntime.jsx(
               VideoCard,
               {
                 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,
                 useRAF: canvasConfig?.useRAF,
                 compact: !selectedLine
               }
-            )
+            ) })
           },
           workspaceId
         );
@@ -24011,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",
@@ -28752,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 = {
@@ -28812,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",
@@ -28932,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}`;
@@ -28966,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}`;
@@ -29581,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(() => {
@@ -30071,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);
@@ -30205,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",
@@ -32325,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 }), {})
@@ -32337,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;
@@ -32407,7 +32654,7 @@ var TargetsView = ({
     };
     fetchActions();
   }, [supabase, companyId]);
-  const fetchLineThresholds = React19.useCallback(async () => {
+  React19.useCallback(async (shiftId) => {
     try {
       if (!supabase) return;
       const currentDate = getOperationalDate();
@@ -32475,15 +32722,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;
           }
@@ -32497,7 +32736,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;
@@ -32602,7 +32905,7 @@ var TargetsView = ({
       (line) => line.workspaces && line.workspaces.length > 0
     );
     if (workspacesAlreadyLoadedForAnyLine) {
-      fetchLineThresholds();
+      setIsLoading(false);
       return;
     }
     const fetchWorkspacesAndThenThresholds = async () => {
@@ -32623,7 +32926,7 @@ var TargetsView = ({
           }
           try {
             const fetchedLineWorkspacesData = await workspaceService.getWorkspaces(lineId);
-            const mappedWorkspaces = fetchedLineWorkspacesData.map((ws) => ({
+            let mappedWorkspaces = fetchedLineWorkspacesData.map((ws) => ({
               id: ws.id,
               name: ws.workspace_id,
               targetPPH: ws.action_pph_threshold === null ? "" : ws.action_pph_threshold,
@@ -32632,6 +32935,29 @@ var TargetsView = ({
               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 }));
+            const currentDate = getOperationalDate();
+            try {
+              const actionThresholds = await workspaceService.getActionThresholds(
+                lineId,
+                currentDate,
+                selectedShift
+              );
+              mappedWorkspaces = mappedWorkspaces.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;
+              });
+              console.log(`Merged action thresholds for line ${lineId}, found ${actionThresholds.length} saved thresholds`);
+            } catch (error) {
+              console.error(`Error fetching action thresholds for line ${lineId}:`, error);
+            }
             if (JSON.stringify(mappedWorkspaces) !== JSON.stringify(newUpdatedLineWorkspaces[lineId].workspaces)) {
               newUpdatedLineWorkspaces[lineId] = {
                 ...newUpdatedLineWorkspaces[lineId],
@@ -32646,7 +32972,7 @@ var TargetsView = ({
         if (workspacesHaveBeenUpdated) {
           setLineWorkspaces(newUpdatedLineWorkspaces);
         }
-        await fetchLineThresholds();
+        await fetchAllShiftsData(newUpdatedLineWorkspaces);
       } catch (error) {
         console.error("Error in fetchWorkspacesAndThenThresholds:", error);
         sonner.toast.error("Failed to load workspace data");
@@ -32655,37 +32981,7 @@ var TargetsView = ({
       }
     };
     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]);
+  }, [actionIds, supabase, lineIds]);
   const toggleLineDropdown = React19.useCallback((lineId) => {
     setLineWorkspaces((prev) => {
       const newIsOpen = !prev[lineId].isOpen;
@@ -32769,6 +33065,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;
@@ -33030,8 +33336,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) => {
@@ -33047,8 +33354,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();
@@ -33085,9 +33392,11 @@ var WorkspaceDetailView = ({
   fromMonthly = false,
   sourceType,
   displayName,
+  lineId,
   defaultTab,
   returnUrl,
   lineIds = { line1: "", line2: "" },
+  selectedLineId,
   onNavigate,
   onTabChange,
   onDateSelect,
@@ -33250,7 +33559,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) {
@@ -33262,13 +33572,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) {
@@ -33726,7 +34046,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) => {
@@ -33753,7 +34079,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();
@@ -34327,6 +34658,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;
@@ -34346,6 +34678,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;