@optifye/dashboard-core 6.10.0 → 6.10.2

package/dist/index.js

@@ -1847,22 +1847,112 @@ var qualityService = {
   }
 };
 
-// src/lib/services/workspaceService.ts
+// src/lib/services/backendClient.ts
+var ACCESS_TOKEN_REFRESH_BUFFER_MS = 6e4;
+var cachedAccessToken = null;
+var cachedAccessTokenExpiresAtMs = null;
+var cachedUserId = null;
+var inFlightRequests = /* @__PURE__ */ new Map();
+var authListenerSubscription = null;
+var authListenerSupabase = null;
+var clearBackendClientCaches = () => {
+  cachedAccessToken = null;
+  cachedAccessTokenExpiresAtMs = null;
+  cachedUserId = null;
+  inFlightRequests.clear();
+};
+var initBackendClientAuthListener = (supabase) => {
+  if (authListenerSupabase === supabase && authListenerSubscription) return;
+  if (authListenerSubscription) {
+    authListenerSubscription.unsubscribe();
+    authListenerSubscription = null;
+  }
+  authListenerSupabase = supabase;
+  const { data } = supabase.auth.onAuthStateChange(() => {
+    clearBackendClientCaches();
+  });
+  authListenerSubscription = data.subscription;
+};
 var getBackendUrl = () => {
   const url = process.env.NEXT_PUBLIC_BACKEND_URL;
   if (!url) {
     throw new Error("Backend URL is not configured. Please set NEXT_PUBLIC_BACKEND_URL in your environment.");
   }
-  return url;
+  return url.replace(/\/$/, "");
 };
-var getAuthToken = async () => {
-  const supabase = _getSupabaseInstance();
-  if (!supabase) throw new Error("Supabase client not initialized");
-  const { data: { session } } = await supabase.auth.getSession();
+var getAuthToken = async (supabase) => {
+  const now2 = Date.now();
+  if (cachedAccessToken && cachedAccessTokenExpiresAtMs && now2 < cachedAccessTokenExpiresAtMs - ACCESS_TOKEN_REFRESH_BUFFER_MS) {
+    return cachedAccessToken;
+  }
+  const {
+    data: { session }
+  } = await supabase.auth.getSession();
   if (!session?.access_token) {
+    clearBackendClientCaches();
     throw new Error("No authentication token available. Please log in.");
   }
-  return session.access_token;
+  cachedAccessToken = session.access_token;
+  cachedUserId = session.user?.id || null;
+  const expiresAtSeconds = session?.expires_at;
+  cachedAccessTokenExpiresAtMs = typeof expiresAtSeconds === "number" ? expiresAtSeconds * 1e3 : now2 + 5 * 60 * 1e3;
+  return cachedAccessToken;
+};
+var defaultDedupeKey = (method, url, body) => {
+  const bodyKey = body === void 0 ? "" : typeof body === "string" ? body : JSON.stringify(body);
+  return `${cachedUserId || "anon"}::${method.toUpperCase()}::${url}::${bodyKey}`;
+};
+var fetchBackendJson = async (supabase, endpoint, options = {}) => {
+  const baseUrl = getBackendUrl();
+  const url = endpoint.startsWith("http") ? endpoint : `${baseUrl}${endpoint.startsWith("/") ? "" : "/"}${endpoint}`;
+  const method = (options.method || "GET").toString();
+  const bodyForKey = options.body;
+  const dedupeKey = options.dedupeKey || defaultDedupeKey(method, url, bodyForKey);
+  const existing = inFlightRequests.get(dedupeKey);
+  if (existing) {
+    return existing;
+  }
+  const requestPromise = (async () => {
+    const headers = new Headers(options.headers || {});
+    if (!options.skipAuth) {
+      const token = await getAuthToken(supabase);
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    if (!headers.has("Content-Type") && options.body !== void 0) {
+      headers.set("Content-Type", "application/json");
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Backend API error (${response.status}): ${errorText}`);
+    }
+    if (response.status === 204) return void 0;
+    const text = await response.text();
+    return text ? JSON.parse(text) : void 0;
+  })();
+  inFlightRequests.set(dedupeKey, requestPromise);
+  try {
+    return await requestPromise;
+  } finally {
+    inFlightRequests.delete(dedupeKey);
+  }
+};
+
+// src/lib/services/workspaceService.ts
+var getBackendUrl2 = () => {
+  const url = process.env.NEXT_PUBLIC_BACKEND_URL;
+  if (!url) {
+    throw new Error("Backend URL is not configured. Please set NEXT_PUBLIC_BACKEND_URL in your environment.");
+  }
+  return url;
+};
+var getAuthToken2 = async () => {
+  const supabase = _getSupabaseInstance();
+  if (!supabase) throw new Error("Supabase client not initialized");
+  return getAuthToken(supabase);
 };
 var workspaceService = {
   // Cache for workspace display names to avoid repeated API calls
@@ -1870,26 +1960,56 @@ var workspaceService = {
   _cacheTimestamp: 0,
   _cacheExpiryMs: 5 * 60 * 1e3,
   // 5 minutes cache
-  async getWorkspaces(lineId) {
-    try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
-      const response = await fetch(`${apiUrl}/api/workspaces?line_id=${lineId}`, {
-        headers: {
-          "Authorization": `Bearer ${token}`,
-          "Content-Type": "application/json"
+  // Cache for workspace lists to avoid repeated API calls (line configuration changes infrequently)
+  _workspacesCache: /* @__PURE__ */ new Map(),
+  _workspacesInFlight: /* @__PURE__ */ new Map(),
+  _workspacesCacheExpiryMs: 10 * 60 * 1e3,
+  // 10 minutes cache
+  async getWorkspaces(lineId, options) {
+    const enabledOnly = options?.enabledOnly ?? false;
+    const force = options?.force ?? false;
+    const cacheKey = `${lineId}::enabledOnly=${enabledOnly}`;
+    const now2 = Date.now();
+    const cached = this._workspacesCache.get(cacheKey);
+    if (!force && cached && now2 - cached.timestamp < this._workspacesCacheExpiryMs) {
+      return cached.workspaces;
+    }
+    const inFlight = this._workspacesInFlight.get(cacheKey);
+    if (!force && inFlight) {
+      return inFlight;
+    }
+    const fetchPromise = (async () => {
+      try {
+        const token = await getAuthToken2();
+        const apiUrl = getBackendUrl2();
+        const params = new URLSearchParams({ line_id: lineId });
+        if (enabledOnly) params.set("enabled_only", "true");
+        const response = await fetch(`${apiUrl}/api/workspaces?${params.toString()}`, {
+          headers: {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Backend API error (${response.status}): ${errorText}`);
         }
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Backend API error (${response.status}): ${errorText}`);
+        const data = await response.json();
+        const workspaces = data.workspaces || [];
+        this._workspacesCache.set(cacheKey, { workspaces, timestamp: Date.now() });
+        return workspaces;
+      } catch (error) {
+        console.error("Error fetching workspaces:", error);
+        throw error;
+      } finally {
+        this._workspacesInFlight.delete(cacheKey);
       }
-      const data = await response.json();
-      return data.workspaces || [];
-    } catch (error) {
-      console.error("Error fetching workspaces:", error);
-      throw error;
-    }
+    })();
+    this._workspacesInFlight.set(cacheKey, fetchPromise);
+    return fetchPromise;
+  },
+  async getEnabledWorkspaces(lineId, options) {
+    return this.getWorkspaces(lineId, { enabledOnly: true, force: options?.force });
   },
   /**
    * Fetches workspace display names from the database
@@ -1897,8 +2017,8 @@ var workspaceService = {
    */
   async getWorkspaceDisplayNames(companyId, lineId) {
     try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
+      const token = await getAuthToken2();
+      const apiUrl = getBackendUrl2();
       const params = new URLSearchParams();
       if (companyId) params.append("company_id", companyId);
       if (lineId) params.append("line_id", lineId);
@@ -1957,16 +2077,39 @@ var workspaceService = {
     this._workspaceDisplayNamesCache.clear();
     this._cacheTimestamp = 0;
   },
+  clearWorkspacesCache() {
+    this._workspacesCache.clear();
+    this._workspacesInFlight.clear();
+  },
+  invalidateWorkspacesCacheForLine(lineId) {
+    const prefix = `${lineId}::`;
+    Array.from(this._workspacesCache.keys()).forEach((key) => {
+      if (key.startsWith(prefix)) this._workspacesCache.delete(key);
+    });
+    Array.from(this._workspacesInFlight.keys()).forEach((key) => {
+      if (key.startsWith(prefix)) this._workspacesInFlight.delete(key);
+    });
+  },
+  _patchCachedWorkspacesForLine(lineId, workspaceRowId, patch) {
+    const prefix = `${lineId}::`;
+    Array.from(this._workspacesCache.entries()).forEach(([key, entry]) => {
+      if (!key.startsWith(prefix)) return;
+      const nextWorkspaces = (entry.workspaces || []).map(
+        (ws) => ws?.id === workspaceRowId ? { ...ws, ...patch } : ws
+      );
+      this._workspacesCache.set(key, { workspaces: nextWorkspaces, timestamp: Date.now() });
+    });
+  },
   /**
    * Updates the display name for a workspace
    * @param workspaceId - The workspace UUID
    * @param displayName - The new display name
-   * @returns Promise<void>
+   * @returns Updated workspace record from backend
    */
   async updateWorkspaceDisplayName(workspaceId, displayName) {
     try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
+      const token = await getAuthToken2();
+      const apiUrl = getBackendUrl2();
       const response = await fetch(`${apiUrl}/api/workspaces/${workspaceId}/display-name`, {
         method: "PATCH",
         headers: {
@@ -1979,7 +2122,15 @@ var workspaceService = {
         const errorText = await response.text();
         throw new Error(`Backend API error (${response.status}): ${errorText}`);
       }
+      const data = await response.json();
       this.clearWorkspaceDisplayNamesCache();
+      const updatedWorkspace = data?.workspace || null;
+      if (updatedWorkspace?.line_id && updatedWorkspace?.id) {
+        this._patchCachedWorkspacesForLine(updatedWorkspace.line_id, updatedWorkspace.id, {
+          display_name: updatedWorkspace.display_name
+        });
+      }
+      return updatedWorkspace;
     } catch (error) {
       console.error(`Error updating workspace display name for ${workspaceId}:`, error);
       throw error;
@@ -1987,8 +2138,8 @@ var workspaceService = {
   },
   async updateWorkspaceAction(updates) {
     try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
+      const token = await getAuthToken2();
+      const apiUrl = getBackendUrl2();
       const response = await fetch(`${apiUrl}/api/workspaces/actions/update`, {
         method: "POST",
         headers: {
@@ -2001,6 +2152,7 @@ var workspaceService = {
         const errorText = await response.text();
         throw new Error(`Backend API error (${response.status}): ${errorText}`);
       }
+      this.clearWorkspacesCache();
     } catch (error) {
       console.error("Error updating workspace actions:", error);
       throw error;
@@ -2008,8 +2160,8 @@ var workspaceService = {
   },
   async updateActionThresholds(thresholds) {
     try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
+      const token = await getAuthToken2();
+      const apiUrl = getBackendUrl2();
       const response = await fetch(`${apiUrl}/api/workspaces/action-thresholds/update`, {
         method: "POST",
         headers: {
@@ -2029,8 +2181,8 @@ var workspaceService = {
   },
   async getActionThresholds(lineId, date, shiftId = 0) {
     try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
+      const token = await getAuthToken2();
+      const apiUrl = getBackendUrl2();
       const response = await fetch(
         `${apiUrl}/api/workspaces/action-thresholds?line_id=${lineId}&date=${date}&shift_id=${shiftId}`,
         {
@@ -2085,8 +2237,8 @@ var workspaceService = {
     const totalPPH = outputWorkspaces.reduce((sum, ws) => sum + (ws.action_pph_threshold || 0), 0);
     const operationalDate = getOperationalDate(defaultTimezone || "UTC");
     try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
+      const token = await getAuthToken2();
+      const apiUrl = getBackendUrl2();
       const response = await fetch(
         `${apiUrl}/api/workspaces/line-thresholds?line_id=${lineId}`,
         {
@@ -2117,8 +2269,8 @@ var workspaceService = {
   // Returns ShiftConfiguration array, which is the logical representation.
   async getShiftConfigurations(lineId) {
     try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
+      const token = await getAuthToken2();
+      const apiUrl = getBackendUrl2();
       const response = await fetch(
         `${apiUrl}/api/workspaces/shift-configurations?line_id=${lineId}`,
         {
@@ -2148,8 +2300,8 @@ var workspaceService = {
   },
   async updateShiftConfigurations(shiftConfig) {
     try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
+      const token = await getAuthToken2();
+      const apiUrl = getBackendUrl2();
       const response = await fetch(
         `${apiUrl}/api/workspaces/shift-configurations`,
         {
@@ -2186,8 +2338,8 @@ var workspaceService = {
    */
   async fetchBulkTargets(params) {
     try {
-      const token = await getAuthToken();
-      const apiUrl = getBackendUrl();
+      const token = await getAuthToken2();
+      const apiUrl = getBackendUrl2();
       const {
         companyId,
         lineIds,
@@ -2373,7 +2525,17 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
       }
     }
     const dataWithUptime = processedData.map((workspace) => {
-      const uptimeDetails = uptimeMap.get(workspace.workspace_id);
+      const mapKey = this.getUptimeMapKey(workspace.line_id, workspace.workspace_id);
+      const uptimeDetails = uptimeMap.get(mapKey);
+      console.log(`[getWorkspaceHealthStatus] Lookup:`, {
+        mapKey,
+        workspaceLineId: workspace.line_id,
+        workspaceId: workspace.workspace_id,
+        workspaceName: workspace.workspace_display_name,
+        found: !!uptimeDetails,
+        uptime: uptimeDetails?.percentage,
+        downtime: uptimeDetails ? Math.max(0, uptimeDetails.expectedMinutes - uptimeDetails.actualMinutes) : null
+      });
       if (uptimeDetails) {
         return {
           ...workspace,
@@ -2734,6 +2896,13 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
   clearCache() {
     this.cache.clear();
   }
+  /**
+   * Generate a composite key for the uptime map that includes line_id
+   * This prevents data collision when multiple lines have workspaces with the same workspace_id
+   */
+  getUptimeMapKey(lineId, workspaceId) {
+    return lineId ? `${lineId}::${workspaceId}` : workspaceId;
+  }
   async calculateWorkspaceUptime(companyId, passedShiftConfig, timezone, lineShiftConfigs, overrideDate, overrideShiftId) {
     const supabase = _getSupabaseInstance();
     if (!supabase) throw new Error("Supabase client not initialized");
@@ -2763,7 +2932,7 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
     const queryShiftId = overrideShiftId ?? currentShiftId;
     const tableName = `performance_metrics_${companyId.replace(/-/g, "_")}`;
     try {
-      const { data: queryData, error } = await supabase.from(tableName).select("workspace_id, workspace_display_name, output_hourly, output_array").eq("date", queryDate).eq("shift_id", queryShiftId);
+      const { data: queryData, error } = await supabase.from(tableName).select("workspace_id, workspace_display_name, output_hourly, output_array, line_id").eq("date", queryDate).eq("shift_id", queryShiftId);
       if (error) {
         console.error("Error fetching performance metrics:", error);
         return /* @__PURE__ */ new Map();
@@ -2809,7 +2978,8 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
         }
         const completedWindow = uptimeMinutes + downtimeMinutes;
         const percentage = completedWindow > 0 ? Number((uptimeMinutes / completedWindow * 100).toFixed(1)) : 100;
-        uptimeMap.set(record.workspace_id, {
+        const mapKey = this.getUptimeMapKey(record.line_id, record.workspace_id);
+        uptimeMap.set(mapKey, {
           expectedMinutes: completedMinutes,
           actualMinutes: uptimeMinutes,
           percentage,
@@ -2851,6 +3021,17 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
       uniqueQueries.get(key).lineConfigs.push({ lineId, shiftStartDate, completedMinutes });
     });
     console.log(`[calculateWorkspaceUptimeMultiLine] Querying ${uniqueQueries.size} unique date/shift combinations for ${lineShiftConfigs.size} lines`);
+    uniqueQueries.forEach((queryConfig, key) => {
+      console.log(`[calculateWorkspaceUptimeMultiLine] Query batch ${key}:`, {
+        date: queryConfig.date,
+        shiftId: queryConfig.shiftId,
+        lineConfigs: queryConfig.lineConfigs.map((lc) => ({
+          lineId: lc.lineId,
+          completedMinutes: lc.completedMinutes,
+          shiftStartDate: lc.shiftStartDate.toISOString()
+        }))
+      });
+    });
     const queryPromises = Array.from(uniqueQueries.entries()).map(async ([key, { date, shiftId, lineConfigs }]) => {
       try {
         const { data, error } = await supabase.from(tableName).select("workspace_id, workspace_display_name, output_hourly, output_array, line_id").eq("date", date).eq("shift_id", shiftId);
@@ -2867,8 +3048,14 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
     const results = await Promise.all(queryPromises);
     for (const { records, lineConfigs } of results) {
       for (const record of records) {
-        const lineConfig = lineConfigs.find((lc) => {
-          return record.line_id && lineShiftConfigs.has(record.line_id);
+        const lineConfig = lineConfigs.find((lc) => lc.lineId === record.line_id);
+        console.log(`[calculateWorkspaceUptimeMultiLine] Record match:`, {
+          recordLineId: record.line_id,
+          recordWorkspaceId: record.workspace_id,
+          recordWorkspaceDisplayName: record.workspace_display_name,
+          availableLineIds: lineConfigs.map((lc) => lc.lineId),
+          matchFound: !!lineConfig,
+          matchedLineId: lineConfig?.lineId || "FALLBACK to " + lineConfigs[0]?.lineId
         });
         const effectiveLineConfig = lineConfig || lineConfigs[0];
         if (!effectiveLineConfig) continue;
@@ -2911,12 +3098,22 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
         }
         const completedWindow = uptimeMinutes + downtimeMinutes;
         const percentage = completedWindow > 0 ? Number((uptimeMinutes / completedWindow * 100).toFixed(1)) : 100;
-        uptimeMap.set(record.workspace_id, {
+        const mapKey = this.getUptimeMapKey(record.line_id, record.workspace_id);
+        uptimeMap.set(mapKey, {
           expectedMinutes: completedMinutes,
           actualMinutes: uptimeMinutes,
           percentage,
           lastCalculated: (/* @__PURE__ */ new Date()).toISOString()
         });
+        console.log(`[calculateWorkspaceUptimeMultiLine] Storing uptime:`, {
+          mapKey,
+          lineId: record.line_id,
+          workspaceId: record.workspace_id,
+          workspaceDisplayName: record.workspace_display_name,
+          expectedMinutes: completedMinutes,
+          actualMinutes: uptimeMinutes,
+          percentage
+        });
       }
     }
     console.log(`[calculateWorkspaceUptimeMultiLine] Calculated uptime for ${uptimeMap.size} workspaces`);
@@ -4564,7 +4761,7 @@ var getSupabaseClient = () => {
   }
   return supabaseJs.createClient(url, key);
 };
-var getAuthToken2 = async () => {
+var getAuthToken3 = async () => {
   try {
     const supabase = getSupabaseClient();
     const { data: { session } } = await supabase.auth.getSession();
@@ -4598,7 +4795,7 @@ var S3ClipsSupabaseService = class {
    * Fetch with authentication and error handling
    */
   async fetchWithAuth(endpoint, body) {
-    const token = await getAuthToken2();
+    const token = await getAuthToken3();
     if (!token) {
       throw new Error("Authentication required");
     }
@@ -6308,7 +6505,7 @@ var IDLE_TIME_REASON_COLORS = {
     bg: "bg-amber-50",
     border: "border-amber-200"
   },
-  "Machine Maintenance": {
+  "Machine Downtime": {
     hex: "#3b82f6",
     // blue-500 - Scheduled/Technical
     text: "text-blue-600",
@@ -6744,6 +6941,7 @@ var SupabaseProvider = ({ client, children }) => {
   _setSupabaseInstance(client);
   React24.useEffect(() => {
     _setSupabaseInstance(client);
+    initBackendClientAuthListener(client);
   }, [client]);
   const contextValue = React24.useMemo(() => ({ supabase: client }), [client]);
   return /* @__PURE__ */ jsxRuntime.jsx(SupabaseContext.Provider, { value: contextValue, children });
@@ -7658,33 +7856,10 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId, options) => {
       console.log("[useWorkspaceDetailedMetrics] Using shift ID:", queryShiftId, "from input shift:", shiftId);
       console.log("[useWorkspaceDetailedMetrics] Using date:", queryDate, "from input date:", date);
       console.log(`[useWorkspaceDetailedMetrics] Fetching from backend API for workspace: ${workspaceId}, date: ${queryDate}, shift: ${queryShiftId}`);
-      const { data: { session } } = await supabase.auth.getSession();
-      if (!session?.access_token) {
-        throw new Error("No authentication token available");
-      }
-      const apiUrl = process.env.NEXT_PUBLIC_BACKEND_URL;
-      const response = await fetch(
-        `${apiUrl}/api/dashboard/workspace/${workspaceId}/metrics?date=${queryDate}&shift_id=${queryShiftId}&company_id=${companyId}`,
-        {
-          headers: {
-            "Authorization": `Bearer ${session.access_token}`,
-            "Content-Type": "application/json"
-          }
-        }
+      const backendData = await fetchBackendJson(
+        supabase,
+        `/api/dashboard/workspace/${workspaceId}/metrics?date=${queryDate}&shift_id=${queryShiftId}&company_id=${companyId}`
       );
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error("[useWorkspaceDetailedMetrics] Backend API error response:", errorText);
-        throw new Error(`Backend API error (${response.status}): ${errorText}`);
-      }
-      const responseText = await response.text();
-      let backendData;
-      try {
-        backendData = JSON.parse(responseText);
-      } catch (parseError) {
-        console.error("[useWorkspaceDetailedMetrics] Failed to parse response as JSON. Response text:", responseText.substring(0, 500));
-        throw new Error(`Invalid JSON response from backend. Received: ${responseText.substring(0, 100)}...`);
-      }
       const data = backendData.metrics;
       if (data && options?.shiftConfig) {
         const dynamicShiftName = getShiftNameById(
@@ -7698,20 +7873,10 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId, options) => {
       }
       if (!data && !date && shiftId === void 0) {
         console.log("[useWorkspaceDetailedMetrics] No data found for current date/shift, attempting to find most recent data...");
-        const fallbackResponse = await fetch(
-          `${apiUrl}/api/dashboard/workspace/${workspaceId}/metrics?company_id=${companyId}&latest=true`,
-          {
-            headers: {
-              "Authorization": `Bearer ${session.access_token}`,
-              "Content-Type": "application/json"
-            }
-          }
+        const fallbackData = await fetchBackendJson(
+          supabase,
+          `/api/dashboard/workspace/${workspaceId}/metrics?company_id=${companyId}&latest=true`
         );
-        if (!fallbackResponse.ok) {
-          const errorText = await fallbackResponse.text();
-          throw new Error(`Backend API error (${fallbackResponse.status}): ${errorText}`);
-        }
-        const fallbackData = await fallbackResponse.json();
         const recentData = fallbackData.metrics;
         if (recentData) {
           console.log(`[useWorkspaceDetailedMetrics] Found fallback data from date: ${recentData.date}, shift: ${recentData.shift_id}`);
@@ -8273,15 +8438,171 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId, options) => {
     // Force refresh without cache
   };
 };
+
+// src/lib/stores/shiftConfigStore.ts
+var shiftConfigsByLineId = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+var inFlightFetchesByLineId = /* @__PURE__ */ new Map();
+var subscriptionsByLineId = /* @__PURE__ */ new Map();
+var calculateBreakDuration = (startTime, endTime) => {
+  const [sh, sm] = startTime.split(":").map(Number);
+  const [eh, em] = endTime.split(":").map(Number);
+  let startMinutes = sh * 60 + sm;
+  let endMinutes = eh * 60 + em;
+  if (endMinutes < startMinutes) {
+    endMinutes += 24 * 60;
+  }
+  return endMinutes - startMinutes;
+};
+var stripSeconds = (timeStr) => {
+  if (!timeStr) return timeStr;
+  return timeStr.substring(0, 5);
+};
+var buildShiftConfigFromOperatingHoursRows = (rows, fallback) => {
+  const mapped = (rows || []).map((row) => ({
+    shiftId: row.shift_id,
+    shiftName: row.shift_name || `Shift ${row.shift_id}`,
+    startTime: stripSeconds(row.start_time),
+    endTime: stripSeconds(row.end_time),
+    breaks: (() => {
+      const raw = Array.isArray(row.breaks) ? row.breaks : Array.isArray(row.breaks?.breaks) ? row.breaks.breaks : [];
+      return raw.map((b) => ({
+        startTime: stripSeconds(b.start || b.startTime || "00:00"),
+        endTime: stripSeconds(b.end || b.endTime || "00:00"),
+        duration: calculateBreakDuration(
+          stripSeconds(b.start || b.startTime || "00:00"),
+          stripSeconds(b.end || b.endTime || "00:00")
+        ),
+        remarks: b.remarks || b.name || ""
+      }));
+    })(),
+    timezone: row.timezone || void 0
+  }));
+  const day = mapped.find((s) => s.shiftId === 0);
+  const night = mapped.find((s) => s.shiftId === 1);
+  return {
+    shifts: mapped,
+    timezone: mapped[0]?.timezone || fallback?.timezone,
+    dayShift: day ? { id: day.shiftId, startTime: day.startTime, endTime: day.endTime, name: day.shiftName } : fallback?.dayShift,
+    nightShift: night ? { id: night.shiftId, startTime: night.startTime, endTime: night.endTime, name: night.shiftName } : fallback?.nightShift,
+    transitionPeriodMinutes: fallback?.transitionPeriodMinutes || 0
+  };
+};
+var shiftConfigStore = {
+  get(lineId) {
+    return shiftConfigsByLineId.get(lineId);
+  },
+  set(lineId, config) {
+    shiftConfigsByLineId.set(lineId, config);
+    listeners.forEach((listener) => listener(lineId));
+  },
+  setFromOperatingHoursRows(lineId, rows, fallback) {
+    const config = buildShiftConfigFromOperatingHoursRows(rows, fallback);
+    this.set(lineId, config);
+    return config;
+  },
+  getMany(lineIds) {
+    const map = /* @__PURE__ */ new Map();
+    lineIds.forEach((lineId) => {
+      const config = shiftConfigsByLineId.get(lineId);
+      if (config) map.set(lineId, config);
+    });
+    return map;
+  },
+  subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  },
+  clear() {
+    shiftConfigsByLineId.clear();
+    listeners.forEach((listener) => listener("*"));
+  }
+};
+var fetchAndStoreShiftConfig = async (supabase, lineId, fallback) => {
+  const existing = inFlightFetchesByLineId.get(lineId);
+  if (existing) return existing;
+  const promise = (async () => {
+    try {
+      const { data, error } = await supabase.from("line_operating_hours").select("line_id, shift_id, shift_name, start_time, end_time, breaks, timezone").eq("line_id", lineId);
+      if (error) {
+        throw new Error(`Failed to fetch shift config: ${error.message}`);
+      }
+      if (!data || data.length === 0) {
+        if (fallback) {
+          shiftConfigStore.set(lineId, fallback);
+          return fallback;
+        }
+        return null;
+      }
+      return shiftConfigStore.setFromOperatingHoursRows(lineId, data, fallback);
+    } finally {
+      inFlightFetchesByLineId.delete(lineId);
+    }
+  })();
+  inFlightFetchesByLineId.set(lineId, promise);
+  return promise;
+};
+var ensureShiftConfigSubscription = (supabase, lineId, fallback) => {
+  const existing = subscriptionsByLineId.get(lineId);
+  if (existing && existing.supabase === supabase) {
+    existing.refCount += 1;
+    return () => {
+      const current = subscriptionsByLineId.get(lineId);
+      if (!current) return;
+      current.refCount -= 1;
+      if (current.refCount <= 0) {
+        current.channel.unsubscribe();
+        subscriptionsByLineId.delete(lineId);
+      }
+    };
+  }
+  if (existing) {
+    existing.channel.unsubscribe();
+    subscriptionsByLineId.delete(lineId);
+  }
+  const channel = supabase.channel(`shift_config_${lineId}`).on(
+    "postgres_changes",
+    {
+      event: "*",
+      schema: "public",
+      table: "line_operating_hours",
+      filter: `line_id=eq.${lineId}`
+    },
+    () => {
+      fetchAndStoreShiftConfig(supabase, lineId, fallback).catch((err) => {
+        console.error("[shiftConfigStore] Failed to refresh shift config", { lineId, err });
+      });
+    }
+  ).subscribe();
+  subscriptionsByLineId.set(lineId, { supabase, channel, refCount: 1 });
+  return () => {
+    const current = subscriptionsByLineId.get(lineId);
+    if (!current) return;
+    current.refCount -= 1;
+    if (current.refCount <= 0) {
+      current.channel.unsubscribe();
+      subscriptionsByLineId.delete(lineId);
+    }
+  };
+};
+
+// src/lib/hooks/useLineShiftConfig.ts
 var useLineShiftConfig = (lineId, fallbackConfig) => {
-  const [shiftConfig, setShiftConfig] = React24.useState(fallbackConfig || null);
-  const [isLoading, setIsLoading] = React24.useState(true);
+  const [shiftConfig, setShiftConfig] = React24.useState(() => {
+    if (!lineId || lineId === "factory" || lineId === "all") return fallbackConfig || null;
+    return shiftConfigStore.get(lineId) || fallbackConfig || null;
+  });
+  const [isLoading, setIsLoading] = React24.useState(() => {
+    if (!lineId || lineId === "factory" || lineId === "all") return false;
+    return !shiftConfigStore.get(lineId);
+  });
   const [error, setError] = React24.useState(null);
   const supabase = useSupabase();
   React24.useEffect(() => {
     if (!lineId || lineId === "factory" || lineId === "all") {
       setShiftConfig(fallbackConfig || null);
       setIsLoading(false);
+      setError(null);
       return;
     }
     const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -8289,98 +8610,49 @@ var useLineShiftConfig = (lineId, fallbackConfig) => {
       console.warn(`[useShiftConfig] Invalid line ID format: ${lineId}, using fallback`);
       setShiftConfig(fallbackConfig || null);
       setIsLoading(false);
+      setError(null);
       return;
     }
     let mounted = true;
-    const calculateBreakDuration2 = (startTime, endTime) => {
-      const [sh, sm] = startTime.split(":").map(Number);
-      const [eh, em] = endTime.split(":").map(Number);
-      let startMinutes = sh * 60 + sm;
-      let endMinutes = eh * 60 + em;
-      if (endMinutes < startMinutes) {
-        endMinutes += 24 * 60;
-      }
-      return endMinutes - startMinutes;
+    const syncFromStore = () => {
+      const stored = shiftConfigStore.get(lineId);
+      setShiftConfig(stored || fallbackConfig || null);
     };
-    const fetchShiftConfig = async () => {
+    syncFromStore();
+    const unsubscribeStore = shiftConfigStore.subscribe((changedLineId) => {
+      if (!mounted) return;
+      if (changedLineId === "*" || changedLineId === lineId) {
+        syncFromStore();
+      }
+    });
+    const unsubscribeRealtime = ensureShiftConfigSubscription(supabase, lineId, fallbackConfig);
+    const ensureLoaded = async () => {
       try {
-        setIsLoading(true);
-        setError(null);
-        console.log(`[useLineShiftConfig] \u{1F50D} Fetching shift config for line: ${lineId}`);
-        const { data: shiftsData, error: shiftsError } = await supabase.from("line_operating_hours").select("shift_id, shift_name, start_time, end_time, breaks, timezone").eq("line_id", lineId);
-        if (shiftsError) {
-          console.error(`[useLineShiftConfig] \u274C Error fetching shifts:`, shiftsError);
-          throw new Error(`Failed to fetch shift config: ${shiftsError.message}`);
-        }
-        if (!shiftsData || shiftsData.length === 0) {
-          console.warn(`[useLineShiftConfig] \u26A0\uFE0F No shift config found for line ${lineId}, using fallback`);
-          if (mounted) {
-            setShiftConfig(fallbackConfig || null);
-            setIsLoading(false);
-          }
+        const existing = shiftConfigStore.get(lineId);
+        if (existing) {
+          if (mounted) setIsLoading(false);
           return;
         }
-        const stripSeconds = (timeStr) => {
-          if (!timeStr) return timeStr;
-          return timeStr.substring(0, 5);
-        };
-        const mapped = shiftsData.map((shift) => ({
-          shiftId: shift.shift_id,
-          shiftName: shift.shift_name || `Shift ${shift.shift_id}`,
-          startTime: stripSeconds(shift.start_time),
-          endTime: stripSeconds(shift.end_time),
-          breaks: Array.isArray(shift.breaks) ? shift.breaks.map((b) => ({
-            startTime: b.start || b.startTime || "00:00",
-            endTime: b.end || b.endTime || "00:00",
-            duration: calculateBreakDuration2(
-              b.start || b.startTime || "00:00",
-              b.end || b.endTime || "00:00"
-            ),
-            remarks: b.remarks || b.name || ""
-          })) : [],
-          timezone: shift.timezone
-        }));
-        const day = mapped.find((s) => s.shiftId === 0);
-        const night = mapped.find((s) => s.shiftId === 1);
-        const config = {
-          shifts: mapped,
-          timezone: mapped[0]?.timezone,
-          dayShift: day ? { id: day.shiftId, startTime: day.startTime, endTime: day.endTime, name: day.shiftName } : fallbackConfig?.dayShift,
-          nightShift: night ? { id: night.shiftId, startTime: night.startTime, endTime: night.endTime, name: night.shiftName } : fallbackConfig?.nightShift,
-          transitionPeriodMinutes: fallbackConfig?.transitionPeriodMinutes || 0
-        };
-        console.log(`[useLineShiftConfig] \u2705 Built config from DB:`, config);
         if (mounted) {
-          setShiftConfig(config);
-          setIsLoading(false);
+          setIsLoading(true);
+          setError(null);
         }
+        await fetchAndStoreShiftConfig(supabase, lineId, fallbackConfig);
       } catch (err) {
         console.error("[useShiftConfig] Error fetching shift config:", err);
         if (mounted) {
           setError(err instanceof Error ? err.message : "Unknown error occurred");
-          setShiftConfig(fallbackConfig || null);
-          setIsLoading(false);
+          setShiftConfig(shiftConfigStore.get(lineId) || fallbackConfig || null);
         }
+      } finally {
+        if (mounted) setIsLoading(false);
       }
     };
-    fetchShiftConfig();
-    const subscription = supabase.channel(`shift_config_${lineId}`).on(
-      "postgres_changes",
-      {
-        event: "*",
-        // Listen to all events (INSERT, UPDATE, DELETE)
-        schema: "public",
-        table: "line_operating_hours",
-        filter: `line_id=eq.${lineId}`
-      },
-      (payload) => {
-        console.log("[useShiftConfig] Real-time update received:", payload);
-        fetchShiftConfig();
-      }
-    ).subscribe();
+    ensureLoaded();
     return () => {
       mounted = false;
-      subscription.unsubscribe();
+      unsubscribeStore();
+      unsubscribeRealtime();
     };
   }, [lineId, supabase]);
   return {
@@ -8471,8 +8743,8 @@ var useLineWorkspaceMetrics = (lineId, options) => {
         queryShiftId,
         metricsTable
       });
-      const workspaces2 = await workspaceService.getWorkspaces(lineId);
-      const enabledWorkspaceIds = workspaces2.filter((ws) => ws.enable === true).map((ws) => ws.id);
+      const enabledWorkspaces = await workspaceService.getEnabledWorkspaces(lineId);
+      const enabledWorkspaceIds = enabledWorkspaces.map((ws) => ws.id);
       if (enabledWorkspaceIds.length === 0) {
         setWorkspaces([]);
         setInitialized(true);
@@ -8570,14 +8842,6 @@ var useHistoricWorkspaceMetrics = (workspaceId, date, shiftId, options) => {
       isFetchingRef.current = true;
       setIsLoading(true);
       setError(null);
-      const { data: { session } } = await supabase.auth.getSession();
-      if (!session?.access_token) {
-        throw new Error("No authentication token available");
-      }
-      const apiUrl = process.env.NEXT_PUBLIC_BACKEND_URL;
-      if (!apiUrl) {
-        throw new Error("Backend URL is not configured. Please set NEXT_PUBLIC_BACKEND_URL in your environment.");
-      }
       const params = new URLSearchParams({
         company_id: entityConfig.companyId || "",
         date
@@ -8585,20 +8849,10 @@ var useHistoricWorkspaceMetrics = (workspaceId, date, shiftId, options) => {
       if (shiftId !== void 0) {
         params.append("shift_id", shiftId.toString());
       }
-      const response = await fetch(
-        `${apiUrl}/api/dashboard/workspace/${workspaceId}/metrics?${params.toString()}`,
-        {
-          headers: {
-            "Authorization": `Bearer ${session.access_token}`,
-            "Content-Type": "application/json"
-          }
-        }
+      const data = await fetchBackendJson(
+        supabase,
+        `/api/dashboard/workspace/${workspaceId}/metrics?${params.toString()}`
       );
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Backend API error (${response.status}): ${errorText}`);
-      }
-      const data = await response.json();
       const fetchedMetrics = data.metrics;
       if (!fetchedMetrics) {
         setMetrics(null);
@@ -8818,14 +9072,6 @@ var useLeaderboardMetrics = (date, shiftId, limit = 10, filter2 = "all") => {
       const currentShift = getCurrentShift(defaultTimezone, shiftConfig);
       const queryDate = date || currentShift.date;
       const queryShiftId = shiftId !== void 0 ? shiftId : currentShift.shiftId;
-      const { data: { session } } = await supabase.auth.getSession();
-      if (!session?.access_token) {
-        throw new Error("No authentication token available");
-      }
-      const apiUrl = process.env.NEXT_PUBLIC_BACKEND_URL;
-      if (!apiUrl) {
-        throw new Error("Backend URL is not configured. Please set NEXT_PUBLIC_BACKEND_URL in your environment.");
-      }
       const params = new URLSearchParams({
         date: queryDate,
         shift_id: queryShiftId.toString(),
@@ -8833,20 +9079,10 @@ var useLeaderboardMetrics = (date, shiftId, limit = 10, filter2 = "all") => {
         limit: limit.toString(),
         filter: filter2
       });
-      const response = await fetch(
-        `${apiUrl}/api/dashboard/leaderboard?${params.toString()}`,
-        {
-          headers: {
-            "Authorization": `Bearer ${session.access_token}`,
-            "Content-Type": "application/json"
-          }
-        }
+      const data = await fetchBackendJson(
+        supabase,
+        `/api/dashboard/leaderboard?${params.toString()}`
       );
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Backend API error (${response.status}): ${errorText}`);
-      }
-      const data = await response.json();
       setLeaderboard(data.leaderboard || []);
     } catch (err) {
       console.error("[useLeaderboardMetrics] Error fetching leaderboard:", err);
@@ -8867,27 +9103,201 @@ var useLeaderboardMetrics = (date, shiftId, limit = 10, filter2 = "all") => {
     refetch: fetchLeaderboard
   };
 };
+var useMultiLineShiftConfigs = (lineIds, fallbackConfig) => {
+  const [shiftConfigMap, setShiftConfigMap] = React24.useState(/* @__PURE__ */ new Map());
+  const [isLoading, setIsLoading] = React24.useState(true);
+  const [error, setError] = React24.useState(null);
+  const supabase = useSupabase();
+  const lineIdsKey = React24.useMemo(() => lineIds.slice().sort().join(","), [lineIds]);
+  React24.useEffect(() => {
+    if (!lineIds || lineIds.length === 0) {
+      setShiftConfigMap(/* @__PURE__ */ new Map());
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const validLineIds = lineIds.filter((id3) => uuidRegex.test(id3));
+    if (validLineIds.length === 0) {
+      console.warn("[useMultiLineShiftConfigs] No valid line IDs provided");
+      setShiftConfigMap(/* @__PURE__ */ new Map());
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+    let mounted = true;
+    const syncFromStore = (changedLineId) => {
+      setShiftConfigMap((prev) => {
+        const next = new Map(prev);
+        const updateLine = (lineId) => {
+          const config = shiftConfigStore.get(lineId) || fallbackConfig;
+          if (config) next.set(lineId, config);
+        };
+        if (!changedLineId || changedLineId === "*") {
+          validLineIds.forEach(updateLine);
+        } else if (validLineIds.includes(changedLineId)) {
+          updateLine(changedLineId);
+        }
+        return next;
+      });
+    };
+    const initialMap = /* @__PURE__ */ new Map();
+    validLineIds.forEach((lineId) => {
+      const config = shiftConfigStore.get(lineId) || fallbackConfig;
+      if (config) initialMap.set(lineId, config);
+    });
+    setShiftConfigMap(initialMap);
+    const unsubscribeStore = shiftConfigStore.subscribe((changedLineId) => {
+      if (!mounted) return;
+      if (changedLineId === "*" || validLineIds.includes(changedLineId)) {
+        syncFromStore(changedLineId);
+      }
+    });
+    const unsubscribeRealtimeList = validLineIds.map(
+      (lineId) => ensureShiftConfigSubscription(supabase, lineId, fallbackConfig)
+    );
+    const fetchAllConfigs = async () => {
+      try {
+        const missingLineIds = validLineIds.filter((lineId) => !shiftConfigStore.get(lineId));
+        if (missingLineIds.length === 0) {
+          if (mounted) {
+            setIsLoading(false);
+            setError(null);
+          }
+          return;
+        }
+        if (mounted) {
+          setIsLoading(true);
+          setError(null);
+        }
+        console.log(`[useMultiLineShiftConfigs] Fetching shift configs for ${missingLineIds.length} lines`);
+        const { data, error: fetchError } = await supabase.from("line_operating_hours").select("line_id, shift_id, shift_name, start_time, end_time, breaks, timezone").in("line_id", missingLineIds);
+        if (fetchError) {
+          console.error("[useMultiLineShiftConfigs] Error fetching shift configs:", fetchError);
+          throw new Error(`Failed to fetch shift configs: ${fetchError.message}`);
+        }
+        const lineShiftsMap = /* @__PURE__ */ new Map();
+        data?.forEach((row) => {
+          if (!lineShiftsMap.has(row.line_id)) {
+            lineShiftsMap.set(row.line_id, []);
+          }
+          lineShiftsMap.get(row.line_id).push(row);
+        });
+        lineShiftsMap.forEach((shifts, lineId) => {
+          shiftConfigStore.setFromOperatingHoursRows(lineId, shifts, fallbackConfig);
+        });
+        missingLineIds.forEach((lineId) => {
+          if (!lineShiftsMap.has(lineId) && fallbackConfig) {
+            console.warn(`[useMultiLineShiftConfigs] No config found for line ${lineId}, using fallback`);
+            shiftConfigStore.set(lineId, fallbackConfig);
+          }
+        });
+        console.log(`[useMultiLineShiftConfigs] Stored configs for ${lineShiftsMap.size} lines`);
+        if (mounted) {
+          setIsLoading(false);
+        }
+      } catch (err) {
+        console.error("[useMultiLineShiftConfigs] Error:", err);
+        if (mounted) {
+          setError(err instanceof Error ? err.message : "Failed to fetch shift configs");
+          setIsLoading(false);
+        }
+      }
+    };
+    fetchAllConfigs();
+    return () => {
+      mounted = false;
+      unsubscribeStore();
+      unsubscribeRealtimeList.forEach((unsub) => unsub());
+    };
+  }, [lineIdsKey, supabase]);
+  return {
+    shiftConfigMap,
+    isLoading,
+    error
+  };
+};
+
+// src/lib/utils/shiftGrouping.ts
+var getCurrentShiftForLine = (lineId, shiftConfig, timezone, now2 = /* @__PURE__ */ new Date()) => {
+  const currentShift = getCurrentShift(timezone, shiftConfig, now2);
+  return {
+    lineId,
+    shiftId: currentShift.shiftId,
+    date: currentShift.date,
+    shiftName: currentShift.shiftName || `Shift ${currentShift.shiftId}`
+  };
+};
+var groupLinesByShift = (shiftConfigMap, timezone, now2 = /* @__PURE__ */ new Date()) => {
+  const lineShiftInfos = [];
+  shiftConfigMap.forEach((shiftConfig, lineId) => {
+    const info = getCurrentShiftForLine(lineId, shiftConfig, timezone, now2);
+    lineShiftInfos.push(info);
+  });
+  const groupMap = /* @__PURE__ */ new Map();
+  lineShiftInfos.forEach((info) => {
+    const key = `${info.shiftId}-${info.date}`;
+    if (!groupMap.has(key)) {
+      groupMap.set(key, {
+        shiftId: info.shiftId,
+        date: info.date,
+        shiftName: info.shiftName,
+        lineIds: []
+      });
+    }
+    groupMap.get(key).lineIds.push(info.lineId);
+  });
+  return Array.from(groupMap.values()).sort((a, b) => a.shiftId - b.shiftId);
+};
+var areAllLinesOnSameShift = (shiftConfigMap, timezone, now2 = /* @__PURE__ */ new Date()) => {
+  if (shiftConfigMap.size <= 1) return true;
+  const groups = groupLinesByShift(shiftConfigMap, timezone, now2);
+  return groups.length === 1;
+};
+var getUniformShiftGroup = (shiftConfigMap, timezone, now2 = /* @__PURE__ */ new Date()) => {
+  const groups = groupLinesByShift(shiftConfigMap, timezone, now2);
+  return groups.length === 1 ? groups[0] : null;
+};
+
+// src/lib/hooks/useDashboardMetrics.ts
 var useDashboardMetrics = ({ onLineMetricsUpdate, lineId, userAccessibleLineIds }) => {
   const { supabaseUrl, supabaseKey } = useDashboardConfig();
   const entityConfig = useEntityConfig();
   const databaseConfig = useDatabaseConfig();
   const dateTimeConfig = useDateTimeConfig();
   const isFactoryView = lineId === (entityConfig.factoryViewId || "factory");
-  const firstLineId = React24.useMemo(() => {
-    const configuredLineIds = getConfiguredLineIds(entityConfig);
-    return configuredLineIds.length > 0 ? configuredLineIds[0] : void 0;
+  const appTimezone = useAppTimezone();
+  const defaultTimezone = appTimezone || dateTimeConfig?.defaultTimezone || "UTC";
+  const configuredLineIds = React24.useMemo(() => {
+    return getConfiguredLineIds(entityConfig);
   }, [entityConfig]);
-  const lineIdForShiftConfig = isFactoryView ? firstLineId : lineId;
-  const { shiftConfig, isLoading: shiftLoading, isFromDatabase } = useDynamicShiftConfig(lineIdForShiftConfig);
+  const { shiftConfig: staticShiftConfig } = useDashboardConfig();
+  const {
+    shiftConfigMap: multiLineShiftConfigMap,
+    isLoading: isMultiLineShiftConfigLoading
+  } = useMultiLineShiftConfigs(
+    isFactoryView ? configuredLineIds : [],
+    staticShiftConfig
+  );
+  const {
+    shiftConfig: singleLineShiftConfig,
+    isLoading: isSingleLineShiftConfigLoading,
+    isFromDatabase
+  } = useDynamicShiftConfig(isFactoryView ? void 0 : lineId);
+  const shiftLoading = isFactoryView ? isMultiLineShiftConfigLoading : isSingleLineShiftConfigLoading;
+  const shiftGroups = React24.useMemo(() => {
+    if (!isFactoryView) return [];
+    if (isMultiLineShiftConfigLoading || multiLineShiftConfigMap.size === 0) return [];
+    return groupLinesByShift(multiLineShiftConfigMap, defaultTimezone);
+  }, [isFactoryView, isMultiLineShiftConfigLoading, multiLineShiftConfigMap, defaultTimezone]);
+  const shiftConfig = isFactoryView ? null : singleLineShiftConfig;
   console.log(`[useDashboardMetrics] \u{1F3AF} Shift config for line ${lineId}:`, {
     isFactoryView,
-    lineIdForShiftConfig,
-    firstLineId,
     isFromDatabase,
-    shiftConfig: shiftConfig ? { shifts: shiftConfig.shifts?.length, timezone: shiftConfig.timezone } : null
+    shiftConfig: shiftConfig ? { shifts: shiftConfig.shifts?.length, timezone: shiftConfig.timezone } : null,
+    shiftGroupsCount: shiftGroups.length,
+    shiftGroups: shiftGroups.map((g) => ({ shiftId: g.shiftId, date: g.date, lineCount: g.lineIds.length }))
   });
-  const appTimezone = useAppTimezone();
-  const defaultTimezone = appTimezone || dateTimeConfig?.defaultTimezone || "UTC";
   const configuredLineMetricsTable = databaseConfig?.tables?.lineMetrics ?? "line_metrics";
   const schema = databaseConfig?.schema ?? "public";
   const supabase = useSupabase();
@@ -8924,16 +9334,6 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId, userAccessibleLineIds
     setIsLoading(true);
     setError(null);
     try {
-      const currentShiftDetails = getCurrentShift(defaultTimezone, shiftConfig);
-      const operationalDate = getOperationalDate(defaultTimezone);
-      const targetLineIds = currentLineIdToUse === (entityConfig.factoryViewId || "factory") ? userAccessibleLineIds || getConfiguredLineIds(entityConfig) : [currentLineIdToUse];
-      if (targetLineIds.length === 0 && currentLineIdToUse === (entityConfig.factoryViewId || "factory")) {
-        throw new Error("Factory view selected, but no lines are configured in entityConfig.");
-      }
-      if (targetLineIds.length === 0) {
-        throw new Error("No target line IDs available for fetching metrics.");
-      }
-      const isFactoryView2 = currentLineIdToUse === (entityConfig.factoryViewId || "factory");
       const { data: { session } } = await supabase.auth.getSession();
       console.log("[useDashboardMetrics] Session check:", {
         hasSession: !!session,
@@ -8947,42 +9347,98 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId, userAccessibleLineIds
       if (!apiUrl) {
         throw new Error("Backend URL is not configured. Please set NEXT_PUBLIC_BACKEND_URL in your environment.");
       }
-      const lineIdsParam = isFactoryView2 ? `line_ids=${targetLineIds.join(",")}` : `line_id=${targetLineIds[0]}`;
-      const url = `${apiUrl}/api/dashboard/metrics?${lineIdsParam}&date=${operationalDate}&shift_id=${currentShiftDetails.shiftId}&company_id=${entityConfig.companyId}`;
-      console.log("[useDashboardMetrics] Calling backend API:", {
-        url,
-        apiUrl,
-        lineIdsParam,
-        operationalDate,
-        shiftId: currentShiftDetails.shiftId,
-        companyId: entityConfig.companyId
-      });
-      const response = await fetch(url, {
-        method: "GET",
-        headers: {
-          "Authorization": `Bearer ${session.access_token}`,
-          "Content-Type": "application/json"
-        }
-      });
-      console.log("[useDashboardMetrics] Response status:", response.status, response.statusText);
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error("[useDashboardMetrics] Backend API error response:", errorText);
-        throw new Error(`Backend API error (${response.status}): ${errorText}`);
+      const factoryViewIdentifier = entityConfig.factoryViewId || "factory";
+      const isFactory = currentLineIdToUse === factoryViewIdentifier;
+      const targetLineIds = isFactory ? userAccessibleLineIds || configuredLineIds : [currentLineIdToUse];
+      if (targetLineIds.length === 0) {
+        throw new Error("No target line IDs available for fetching metrics.");
       }
-      const responseText = await response.text();
-      let backendData;
-      try {
-        backendData = JSON.parse(responseText);
-      } catch (parseError) {
-        console.error("[useDashboardMetrics] Failed to parse response as JSON. Response text:", responseText.substring(0, 500));
-        throw new Error(`Invalid JSON response from backend. Received: ${responseText.substring(0, 100)}...`);
+      let allWorkspaceMetrics = [];
+      let allLineMetrics = [];
+      if (isFactory && shiftGroups.length > 0) {
+        console.log(`[useDashboardMetrics] \u{1F3ED} Factory view: Fetching for ${shiftGroups.length} shift group(s)`);
+        const metricsPromises = shiftGroups.map(async (group) => {
+          const lineIdsParam = `line_ids=${group.lineIds.join(",")}`;
+          const url = `${apiUrl}/api/dashboard/metrics?${lineIdsParam}&date=${group.date}&shift_id=${group.shiftId}&company_id=${entityConfig.companyId}`;
+          console.log(`[useDashboardMetrics] \u{1F4CA} Fetching for shift ${group.shiftId} (${group.shiftName}):`, {
+            lineIds: group.lineIds,
+            date: group.date
+          });
+          const response = await fetch(url, {
+            method: "GET",
+            headers: {
+              "Authorization": `Bearer ${session.access_token}`,
+              "Content-Type": "application/json"
+            }
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`[useDashboardMetrics] Backend API error for shift ${group.shiftId}:`, errorText);
+            throw new Error(`Backend API error (${response.status}): ${errorText}`);
+          }
+          const responseText = await response.text();
+          try {
+            return JSON.parse(responseText);
+          } catch (parseError) {
+            console.error("[useDashboardMetrics] Failed to parse response:", responseText.substring(0, 500));
+            throw new Error(`Invalid JSON response from backend`);
+          }
+        });
+        const results = await Promise.all(metricsPromises);
+        results.forEach((result) => {
+          if (result.workspace_metrics) {
+            allWorkspaceMetrics.push(...result.workspace_metrics);
+          }
+          if (result.line_metrics) {
+            allLineMetrics.push(...result.line_metrics);
+          }
+        });
+        console.log(`[useDashboardMetrics] \u{1F4CA} Merged metrics from ${results.length} shift groups:`, {
+          workspaceCount: allWorkspaceMetrics.length,
+          lineMetricsCount: allLineMetrics.length
+        });
+      } else {
+        const currentShiftDetails = shiftConfig ? getCurrentShift(defaultTimezone, shiftConfig) : shiftGroups.length === 1 ? { date: shiftGroups[0].date, shiftId: shiftGroups[0].shiftId } : getCurrentShift(defaultTimezone, staticShiftConfig);
+        const operationalDate = currentShiftDetails.date;
+        const lineIdsParam = isFactory ? `line_ids=${targetLineIds.join(",")}` : `line_id=${targetLineIds[0]}`;
+        const url = `${apiUrl}/api/dashboard/metrics?${lineIdsParam}&date=${operationalDate}&shift_id=${currentShiftDetails.shiftId}&company_id=${entityConfig.companyId}`;
+        console.log("[useDashboardMetrics] Calling backend API:", {
+          url,
+          apiUrl,
+          lineIdsParam,
+          operationalDate,
+          shiftId: currentShiftDetails.shiftId,
+          companyId: entityConfig.companyId
+        });
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            "Authorization": `Bearer ${session.access_token}`,
+            "Content-Type": "application/json"
+          }
+        });
+        console.log("[useDashboardMetrics] Response status:", response.status, response.statusText);
+        if (!response.ok) {
+          const errorText = await response.text();
+          console.error("[useDashboardMetrics] Backend API error response:", errorText);
+          throw new Error(`Backend API error (${response.status}): ${errorText}`);
+        }
+        const responseText = await response.text();
+        let backendData;
+        try {
+          backendData = JSON.parse(responseText);
+        } catch (parseError) {
+          console.error("[useDashboardMetrics] Failed to parse response as JSON. Response text:", responseText.substring(0, 500));
+          throw new Error(`Invalid JSON response from backend. Received: ${responseText.substring(0, 100)}...`);
+        }
+        console.log("[useDashboardMetrics] Backend response:", {
+          workspaceCount: backendData.workspace_metrics?.length || 0,
+          lineCount: backendData.line_metrics?.length || 0
+        });
+        allWorkspaceMetrics = backendData.workspace_metrics || [];
+        allLineMetrics = backendData.line_metrics || [];
       }
-      console.log("[useDashboardMetrics] Backend response:", {
-        workspaceCount: backendData.workspace_metrics?.length || 0,
-        lineCount: backendData.line_metrics?.length || 0
-      });
-      const transformedWorkspaceData = (backendData.workspace_metrics || []).map((item) => ({
+      const transformedWorkspaceData = allWorkspaceMetrics.map((item) => ({
         company_id: item.company_id || entityConfig.companyId,
         line_id: item.line_id,
         shift_id: item.shift_id,
@@ -9005,7 +9461,7 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId, userAccessibleLineIds
       });
       const newMetricsState = {
         workspaceMetrics: transformedWorkspaceData,
-        lineMetrics: backendData.line_metrics || []
+        lineMetrics: allLineMetrics || []
       };
       console.log("[useDashboardMetrics] Setting metrics state:", {
         workspaceMetrics: newMetricsState.workspaceMetrics.length,
@@ -9026,9 +9482,12 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId, userAccessibleLineIds
     metrics2?.lineMetrics?.length || 0,
     companySpecificMetricsTable,
     entityConfig,
-    appTimezone,
     defaultTimezone,
     shiftConfig,
+    shiftGroups,
+    configuredLineIds,
+    staticShiftConfig,
+    userAccessibleLineIds,
     shiftLoading
   ]);
   const fetchAllMetricsRef = React24.useRef(fetchAllMetrics);
@@ -9052,32 +9511,70 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId, userAccessibleLineIds
     if (!currentLineIdToUse || !supabase || companySpecificMetricsTable.includes("unknown_company") || !entityConfig.companyId) {
       return;
     }
-    const currentShiftDetails = getCurrentShift(defaultTimezone, shiftConfig);
-    const operationalDateForSubscription = getOperationalDate(defaultTimezone);
-    const targetLineIds = currentLineIdToUse === (entityConfig.factoryViewId || "factory") ? userAccessibleLineIds || getConfiguredLineIds(entityConfig) : [currentLineIdToUse];
-    if (targetLineIds.length === 0) return;
-    const wsMetricsFilter = `line_id=in.(${targetLineIds.map((id3) => `"${id3}"`).join(",")})`;
-    const lineMetricsFilter = `line_id=in.(${targetLineIds.map((id3) => `"${id3}"`).join(",")})`;
+    const factoryViewIdentifier = entityConfig.factoryViewId || "factory";
+    const isFactory = currentLineIdToUse === factoryViewIdentifier;
     const channels = [];
-    const createSubscription = (table, filter2, channelNameBase, callback) => {
-      const channelName = `${channelNameBase}-${Date.now()}`.replace(/[^a-zA-Z0-9_-]/g, "");
-      const channel = supabase.channel(channelName).on(
-        "postgres_changes",
-        { event: "*", schema, table, filter: filter2 },
-        (payload) => {
-          const payloadData = payload.new;
-          if (payloadData?.date === operationalDateForSubscription && payloadData?.shift_id === currentShiftDetails.shiftId) {
-            callback();
+    if (isFactory && shiftGroups.length > 0) {
+      console.log(`[useDashboardMetrics] \u{1F4E1} Setting up subscriptions for ${shiftGroups.length} shift group(s)`);
+      shiftGroups.forEach((group, index) => {
+        const baseFilterParts = `date=eq.${group.date},shift_id=eq.${group.shiftId}`;
+        const lineIdFilterPart = `line_id=in.(${group.lineIds.map((id3) => `"${id3}"`).join(",")})`;
+        const filter2 = `${baseFilterParts},${lineIdFilterPart}`;
+        const wsChannelName = `dashboard-ws-g${index}-${group.date}-${group.shiftId}`.replace(/[^a-zA-Z0-9_-]/g, "");
+        const wsChannel = supabase.channel(wsChannelName).on(
+          "postgres_changes",
+          { event: "*", schema, table: companySpecificMetricsTable, filter: filter2 },
+          (payload) => {
+            const payloadData = payload.new || payload.old;
+            if (payloadData?.date === group.date && payloadData?.shift_id === group.shiftId) {
+              queueUpdate();
+            }
           }
-        }
-      ).subscribe();
-      channels.push(channel);
-    };
-    createSubscription(companySpecificMetricsTable, wsMetricsFilter, "dashboard-ws-metrics", queueUpdate);
-    createSubscription(configuredLineMetricsTable, lineMetricsFilter, "dashboard-line-metrics", () => {
-      queueUpdate();
-      onLineMetricsUpdateRef.current?.();
-    });
+        ).subscribe();
+        channels.push(wsChannel);
+        const lmChannelName = `dashboard-lm-g${index}-${group.date}-${group.shiftId}`.replace(/[^a-zA-Z0-9_-]/g, "");
+        const lmChannel = supabase.channel(lmChannelName).on(
+          "postgres_changes",
+          { event: "*", schema, table: configuredLineMetricsTable, filter: filter2 },
+          (payload) => {
+            const payloadData = payload.new || payload.old;
+            if (payloadData?.date === group.date && payloadData?.shift_id === group.shiftId) {
+              queueUpdate();
+              onLineMetricsUpdateRef.current?.();
+            }
+          }
+        ).subscribe();
+        channels.push(lmChannel);
+      });
+    } else {
+      const currentShiftDetails = shiftConfig ? getCurrentShift(defaultTimezone, shiftConfig) : getCurrentShift(defaultTimezone, staticShiftConfig);
+      const operationalDateForSubscription = currentShiftDetails.date;
+      const targetLineIds = [currentLineIdToUse];
+      if (targetLineIds.length === 0) return;
+      const baseFilterParts = `date=eq.${operationalDateForSubscription},shift_id=eq.${currentShiftDetails.shiftId}`;
+      const lineIdFilterPart = `line_id=in.(${targetLineIds.map((id3) => `"${id3}"`).join(",")})`;
+      const wsMetricsFilter = `${baseFilterParts},${lineIdFilterPart}`;
+      const lineMetricsFilter = `${baseFilterParts},${lineIdFilterPart}`;
+      const createSubscription = (table, filter2, channelNameBase, callback) => {
+        const channelName = `${channelNameBase}-${Date.now()}`.replace(/[^a-zA-Z0-9_-]/g, "");
+        const channel = supabase.channel(channelName).on(
+          "postgres_changes",
+          { event: "*", schema, table, filter: filter2 },
+          (payload) => {
+            const payloadData = payload.new;
+            if (payloadData?.date === operationalDateForSubscription && payloadData?.shift_id === currentShiftDetails.shiftId) {
+              callback();
+            }
+          }
+        ).subscribe();
+        channels.push(channel);
+      };
+      createSubscription(companySpecificMetricsTable, wsMetricsFilter, "dashboard-ws-metrics", queueUpdate);
+      createSubscription(configuredLineMetricsTable, lineMetricsFilter, "dashboard-line-metrics", () => {
+        queueUpdate();
+        onLineMetricsUpdateRef.current?.();
+      });
+    }
     return () => {
       channels.forEach((channel) => {
         supabase?.removeChannel(channel);
@@ -9091,9 +9588,10 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId, userAccessibleLineIds
     schema,
     entityConfig?.companyId,
     entityConfig?.factoryViewId,
-    appTimezone,
     defaultTimezone,
     shiftConfig,
+    staticShiftConfig,
+    shiftGroups,
     lineId,
     userAccessibleLineIds
   ]);
@@ -9111,20 +9609,37 @@ var useLineKPIs = ({ lineId, enabled }) => {
   const isFactoryView = lineId === (entityConfig.factoryViewId || "factory");
   const databaseConfig = useDatabaseConfig();
   const dateTimeConfig = useDateTimeConfig();
-  useShiftConfig();
-  const firstLineId = React24.useMemo(() => {
-    const configuredLineIds = getConfiguredLineIds(entityConfig);
-    return configuredLineIds.length > 0 ? configuredLineIds[0] : void 0;
+  const staticShiftConfig = useShiftConfig();
+  const appTimezone = useAppTimezone();
+  const timezone = appTimezone || dateTimeConfig.defaultTimezone || "UTC";
+  const configuredLineIds = React24.useMemo(() => {
+    return getConfiguredLineIds(entityConfig);
   }, [entityConfig]);
-  const lineIdForShiftConfig = isFactoryView ? firstLineId : lineId;
-  const { shiftConfig: dynamicShiftConfig, isFromDatabase, isLoading: isShiftConfigLoading } = useDynamicShiftConfig(lineIdForShiftConfig);
-  const shiftConfig = dynamicShiftConfig;
+  const {
+    shiftConfigMap: multiLineShiftConfigMap,
+    isLoading: isMultiLineShiftConfigLoading
+  } = useMultiLineShiftConfigs(
+    isFactoryView ? configuredLineIds : [],
+    staticShiftConfig
+  );
+  const {
+    shiftConfig: singleLineShiftConfig,
+    isFromDatabase,
+    isLoading: isSingleLineShiftConfigLoading
+  } = useDynamicShiftConfig(isFactoryView ? void 0 : lineId);
+  const isShiftConfigLoading = isFactoryView ? isMultiLineShiftConfigLoading : isSingleLineShiftConfigLoading;
+  const shiftGroups = React24.useMemo(() => {
+    if (!isFactoryView) return [];
+    if (isMultiLineShiftConfigLoading || multiLineShiftConfigMap.size === 0) return [];
+    return groupLinesByShift(multiLineShiftConfigMap, timezone);
+  }, [isFactoryView, isMultiLineShiftConfigLoading, multiLineShiftConfigMap, timezone]);
+  const shiftConfig = isFactoryView ? null : singleLineShiftConfig;
   console.log(`[useLineKPIs] \u{1F3AF} Shift config for line ${lineId}:`, {
     isFactoryView,
-    lineIdForShiftConfig,
-    firstLineId,
     isFromDatabase,
-    shiftConfig
+    shiftConfig,
+    shiftGroupsCount: shiftGroups.length,
+    shiftGroups: shiftGroups.map((g) => ({ shiftId: g.shiftId, date: g.date, lineCount: g.lineIds.length }))
   });
   const supabase = useSupabase();
   React24.useMemo(() => {
@@ -9138,8 +9653,6 @@ var useLineKPIs = ({ lineId, enabled }) => {
   const updateQueueRef = React24.useRef(false);
   const updateTimeoutRef = React24.useRef(null);
   const queueUpdateRef = React24.useRef(void 0);
-  const appTimezone = useAppTimezone();
-  const timezone = appTimezone || dateTimeConfig.defaultTimezone || "UTC";
   const schema = databaseConfig.schema ?? "public";
   const lineMetricsTable = databaseConfig.tables?.lineMetrics ?? "line_metrics";
   const companySpecificMetricsTable = React24.useMemo(
@@ -9158,8 +9671,6 @@ var useLineKPIs = ({ lineId, enabled }) => {
     setIsLoading(true);
     setError(null);
     try {
-      const currentShiftDetails = getCurrentShift(timezone, shiftConfig ?? void 0);
-      const operationalDate = currentShiftDetails.date;
       const { data: { session } } = await supabase.auth.getSession();
       if (!session?.access_token) {
         throw new Error("No authentication token available");
@@ -9170,33 +9681,68 @@ var useLineKPIs = ({ lineId, enabled }) => {
       }
       const factoryViewIdentifier = entityConfig.factoryViewId || "factory";
       const isFactory = currentLineId === factoryViewIdentifier;
-      const lineParam = isFactory ? `line_ids=${getConfiguredLineIds(entityConfig).join(",")}` : `line_id=${currentLineId}`;
-      const response = await fetch(
-        `${apiUrl}/api/dashboard/line-kpis?${lineParam}&date=${operationalDate}&shift_id=${currentShiftDetails.shiftId}&company_id=${entityConfig.companyId}`,
-        {
-          headers: {
-            "Authorization": `Bearer ${session.access_token}`,
-            "Content-Type": "application/json"
+      if (isFactory && shiftGroups.length > 0) {
+        console.log(`[useLineKPIs] \u{1F3ED} Factory view: Fetching KPIs for ${shiftGroups.length} shift group(s)`);
+        const kpiPromises = shiftGroups.map(async (group) => {
+          const lineIdsParam = `line_ids=${group.lineIds.join(",")}`;
+          const url = `${apiUrl}/api/dashboard/line-kpis?${lineIdsParam}&date=${group.date}&shift_id=${group.shiftId}&company_id=${entityConfig.companyId}`;
+          console.log(`[useLineKPIs] \u{1F4CA} Fetching for shift ${group.shiftId} (${group.shiftName}):`, {
+            lineIds: group.lineIds,
+            date: group.date
+          });
+          const response = await fetch(url, {
+            headers: {
+              "Authorization": `Bearer ${session.access_token}`,
+              "Content-Type": "application/json"
+            }
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`[useLineKPIs] Backend API error for shift ${group.shiftId}:`, errorText);
+            throw new Error(`Backend API error (${response.status}): ${errorText}`);
           }
-        }
-      );
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error("[useLineKPIs] Backend API error response:", errorText);
-        throw new Error(`Backend API error (${response.status}): ${errorText}`);
-      }
-      const responseText = await response.text();
-      let backendData;
-      try {
-        backendData = JSON.parse(responseText);
-      } catch (parseError) {
-        console.error("[useLineKPIs] Failed to parse response as JSON. Response text:", responseText.substring(0, 500));
-        throw new Error(`Invalid JSON response from backend. Received: ${responseText.substring(0, 100)}...`);
-      }
-      if (backendData.kpis) {
-        setKPIs(backendData.kpis);
+          const responseText = await response.text();
+          try {
+            return JSON.parse(responseText);
+          } catch (parseError) {
+            console.error("[useLineKPIs] Failed to parse response as JSON:", responseText.substring(0, 500));
+            throw new Error(`Invalid JSON response from backend`);
+          }
+        });
+        const results = await Promise.all(kpiPromises);
+        const aggregatedKPIs = aggregateKPIResults(results);
+        setKPIs(aggregatedKPIs);
       } else {
-        setKPIs(null);
+        const currentShiftDetails = shiftConfig ? getCurrentShift(timezone, shiftConfig) : shiftGroups.length === 1 ? { date: shiftGroups[0].date, shiftId: shiftGroups[0].shiftId } : getCurrentShift(timezone, staticShiftConfig);
+        const operationalDate = currentShiftDetails.date;
+        const lineParam = isFactory ? `line_ids=${configuredLineIds.join(",")}` : `line_id=${currentLineId}`;
+        const response = await fetch(
+          `${apiUrl}/api/dashboard/line-kpis?${lineParam}&date=${operationalDate}&shift_id=${currentShiftDetails.shiftId}&company_id=${entityConfig.companyId}`,
+          {
+            headers: {
+              "Authorization": `Bearer ${session.access_token}`,
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        if (!response.ok) {
+          const errorText = await response.text();
+          console.error("[useLineKPIs] Backend API error response:", errorText);
+          throw new Error(`Backend API error (${response.status}): ${errorText}`);
+        }
+        const responseText = await response.text();
+        let backendData;
+        try {
+          backendData = JSON.parse(responseText);
+        } catch (parseError) {
+          console.error("[useLineKPIs] Failed to parse response as JSON. Response text:", responseText.substring(0, 500));
+          throw new Error(`Invalid JSON response from backend. Received: ${responseText.substring(0, 100)}...`);
+        }
+        if (backendData.kpis) {
+          setKPIs(backendData.kpis);
+        } else {
+          setKPIs(null);
+        }
       }
     } catch (err) {
       console.error("[useLineKPIs] Error fetching KPIs:", err);
@@ -9207,7 +9753,80 @@ var useLineKPIs = ({ lineId, enabled }) => {
       isFetchingRef.current = false;
       updateQueueRef.current = false;
     }
-  }, [timezone, shiftConfig, entityConfig, supabase, enabled, isShiftConfigLoading]);
+  }, [timezone, shiftConfig, shiftGroups, configuredLineIds, staticShiftConfig, entityConfig, supabase, enabled, isShiftConfigLoading]);
+  const aggregateKPIResults = (results) => {
+    const validResults = results.filter((r2) => r2?.kpis);
+    if (validResults.length === 0) return null;
+    if (validResults.length === 1) return validResults[0].kpis;
+    let totalEfficiency = 0;
+    let totalEfficiencyWeight = 0;
+    let totalOutputCurrent = 0;
+    let totalOutputTarget = 0;
+    let totalIdealOutput = 0;
+    let totalUnderperformingCurrent = 0;
+    let totalUnderperformingTotal = 0;
+    let totalCycleTimeSum = 0;
+    let totalCycleTimeCount = 0;
+    let totalQualitySum = 0;
+    let totalQualityCount = 0;
+    validResults.forEach((result) => {
+      const kpis2 = result.kpis;
+      if (kpis2.efficiency?.value !== void 0) {
+        const weight = kpis2.outputProgress?.current || 1;
+        totalEfficiency += kpis2.efficiency.value * weight;
+        totalEfficiencyWeight += weight;
+      }
+      if (kpis2.outputProgress) {
+        totalOutputCurrent += kpis2.outputProgress.current || 0;
+        totalOutputTarget += kpis2.outputProgress.target || 0;
+        totalIdealOutput += kpis2.outputProgress.idealOutput || 0;
+      }
+      if (kpis2.underperformingWorkers) {
+        totalUnderperformingCurrent += kpis2.underperformingWorkers.current || 0;
+        totalUnderperformingTotal += kpis2.underperformingWorkers.total || 0;
+      }
+      if (kpis2.avgCycleTime?.value !== void 0) {
+        totalCycleTimeSum += kpis2.avgCycleTime.value;
+        totalCycleTimeCount++;
+      }
+      if (kpis2.qualityCompliance?.value !== void 0) {
+        totalQualitySum += kpis2.qualityCompliance.value;
+        totalQualityCount++;
+      }
+    });
+    const aggregated = {
+      efficiency: {
+        value: totalEfficiencyWeight > 0 ? totalEfficiency / totalEfficiencyWeight : 0,
+        change: 0
+        // Change not meaningful when aggregating across shifts
+      },
+      outputProgress: {
+        current: totalOutputCurrent,
+        target: totalOutputTarget,
+        change: 0,
+        // Change not meaningful when aggregating across shifts
+        idealOutput: totalIdealOutput
+      },
+      underperformingWorkers: {
+        current: totalUnderperformingCurrent,
+        total: totalUnderperformingTotal,
+        change: 0
+        // Change not meaningful when aggregating across shifts
+      },
+      avgCycleTime: {
+        value: totalCycleTimeCount > 0 ? totalCycleTimeSum / totalCycleTimeCount : 0,
+        change: 0
+        // Change not meaningful when aggregating across shifts
+      },
+      qualityCompliance: {
+        value: totalQualityCount > 0 ? totalQualitySum / totalQualityCount : 0,
+        change: 0
+        // Change not meaningful when aggregating across shifts
+      }
+    };
+    console.log("[useLineKPIs] \u{1F4CA} Aggregated KPIs from", validResults.length, "shift groups:", aggregated);
+    return aggregated;
+  };
   const queueUpdate = React24.useCallback(() => {
     if (updateTimeoutRef.current) {
       clearTimeout(updateTimeoutRef.current);
@@ -9227,40 +9846,66 @@ var useLineKPIs = ({ lineId, enabled }) => {
       return;
     }
     fetchKPIs();
-    const currentShiftDetails = getCurrentShift(timezone, shiftConfig ?? void 0);
-    const operationalDate = currentShiftDetails.date;
     const factoryViewIdentifier = entityConfig.factoryViewId || "factory";
-    const targetLineIds = currentLineId === factoryViewIdentifier ? getConfiguredLineIds(entityConfig) : [currentLineId];
-    if (targetLineIds.length === 0) {
-      console.warn("[useLineKPIs] No target line IDs for subscription. LineId:", currentLineId);
-      return;
-    }
-    const baseFilterParts = `date=eq.${operationalDate},shift_id=eq.${currentShiftDetails.shiftId}`;
-    const lineIdFilterPart = `line_id=in.(${targetLineIds.join(",")})`;
-    const lineMetricsFilter = `${baseFilterParts},${lineIdFilterPart}`;
-    const companyTableFilter = `${baseFilterParts},${lineIdFilterPart}`;
+    const isFactory = currentLineId === factoryViewIdentifier;
     const activeChannels = [];
-    const lmChannelName = `kpi-lm-${currentLineId}-${operationalDate}-${currentShiftDetails.shiftId}`.replace(/[^a-zA-Z0-9_-]/g, "");
-    const lmChannel = supabase.channel(lmChannelName).on(
-      "postgres_changes",
-      { event: "*", schema, table: lineMetricsTable, filter: lineMetricsFilter },
-      (payload) => {
-        const payloadData = payload.new || payload.old;
-        if (payloadData?.date === operationalDate && payloadData?.shift_id === currentShiftDetails.shiftId) {
-          queueUpdateRef.current?.();
+    if (isFactory && shiftGroups.length > 0) {
+      console.log(`[useLineKPIs] \u{1F4E1} Setting up subscriptions for ${shiftGroups.length} shift group(s)`);
+      shiftGroups.forEach((group, index) => {
+        const baseFilterParts = `date=eq.${group.date},shift_id=eq.${group.shiftId}`;
+        const lineIdFilterPart = `line_id=in.(${group.lineIds.join(",")})`;
+        const filter2 = `${baseFilterParts},${lineIdFilterPart}`;
+        const lmChannelName = `kpi-lm-factory-g${index}-${group.date}-${group.shiftId}`.replace(/[^a-zA-Z0-9_-]/g, "");
+        const lmChannel = supabase.channel(lmChannelName).on(
+          "postgres_changes",
+          { event: "*", schema, table: lineMetricsTable, filter: filter2 },
+          (payload) => {
+            const payloadData = payload.new || payload.old;
+            if (payloadData?.date === group.date && payloadData?.shift_id === group.shiftId) {
+              queueUpdateRef.current?.();
+            }
+          }
+        ).subscribe((status, err) => {
+          if (status === supabaseJs.REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR || status === supabaseJs.REALTIME_SUBSCRIBE_STATES.TIMED_OUT) {
+            console.error(`[useLineKPIs] Subscription to ${lineMetricsTable} (group ${index}) FAILED:`, status, err);
+          }
+        });
+        activeChannels.push(lmChannel);
+        if (companySpecificMetricsTable && !companySpecificMetricsTable.includes("unknown_company")) {
+          const csChannelName = `kpi-cs-factory-g${index}-${group.date}-${group.shiftId}`.replace(/[^a-zA-Z0-9_-]/g, "");
+          const csChannel = supabase.channel(csChannelName).on(
+            "postgres_changes",
+            { event: "*", schema, table: companySpecificMetricsTable, filter: filter2 },
+            (payload) => {
+              const payloadData = payload.new || payload.old;
+              if (payloadData?.date === group.date && payloadData?.shift_id === group.shiftId) {
+                queueUpdateRef.current?.();
+              }
+            }
+          ).subscribe((status, err) => {
+            if (status === supabaseJs.REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR || status === supabaseJs.REALTIME_SUBSCRIBE_STATES.TIMED_OUT) {
+              console.error(`[useLineKPIs] Subscription to ${companySpecificMetricsTable} (group ${index}) FAILED:`, status, err);
+            }
+          });
+          activeChannels.push(csChannel);
         }
+      });
+    } else {
+      const currentShiftDetails = shiftConfig ? getCurrentShift(timezone, shiftConfig) : getCurrentShift(timezone, staticShiftConfig);
+      const operationalDate = currentShiftDetails.date;
+      const targetLineIds = [currentLineId];
+      if (targetLineIds.length === 0) {
+        console.warn("[useLineKPIs] No target line IDs for subscription. LineId:", currentLineId);
+        return;
       }
-    ).subscribe((status, err) => {
-      if (status === supabaseJs.REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR || status === supabaseJs.REALTIME_SUBSCRIBE_STATES.TIMED_OUT) {
-        console.error(`[useLineKPIs] Subscription to ${lineMetricsTable} FAILED: ${status}`, err || "");
-      }
-    });
-    activeChannels.push(lmChannel);
-    if (companySpecificMetricsTable && !companySpecificMetricsTable.includes("unknown_company")) {
-      const csChannelName = `kpi-cs-${currentLineId}-${operationalDate}-${currentShiftDetails.shiftId}`.replace(/[^a-zA-Z0-9_-]/g, "");
-      const csChannel = supabase.channel(csChannelName).on(
+      const baseFilterParts = `date=eq.${operationalDate},shift_id=eq.${currentShiftDetails.shiftId}`;
+      const lineIdFilterPart = `line_id=in.(${targetLineIds.join(",")})`;
+      const lineMetricsFilter = `${baseFilterParts},${lineIdFilterPart}`;
+      const companyTableFilter = `${baseFilterParts},${lineIdFilterPart}`;
+      const lmChannelName = `kpi-lm-${currentLineId}-${operationalDate}-${currentShiftDetails.shiftId}`.replace(/[^a-zA-Z0-9_-]/g, "");
+      const lmChannel = supabase.channel(lmChannelName).on(
         "postgres_changes",
-        { event: "*", schema, table: companySpecificMetricsTable, filter: companyTableFilter },
+        { event: "*", schema, table: lineMetricsTable, filter: lineMetricsFilter },
         (payload) => {
           const payloadData = payload.new || payload.old;
           if (payloadData?.date === operationalDate && payloadData?.shift_id === currentShiftDetails.shiftId) {
@@ -9269,10 +9914,28 @@ var useLineKPIs = ({ lineId, enabled }) => {
         }
       ).subscribe((status, err) => {
         if (status === supabaseJs.REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR || status === supabaseJs.REALTIME_SUBSCRIBE_STATES.TIMED_OUT) {
-          console.error(`[useLineKPIs] Subscription to ${companySpecificMetricsTable} FAILED: ${status}`, err || "");
+          console.error(`[useLineKPIs] Subscription to ${lineMetricsTable} FAILED: ${status}`, err || "");
         }
       });
-      activeChannels.push(csChannel);
+      activeChannels.push(lmChannel);
+      if (companySpecificMetricsTable && !companySpecificMetricsTable.includes("unknown_company")) {
+        const csChannelName = `kpi-cs-${currentLineId}-${operationalDate}-${currentShiftDetails.shiftId}`.replace(/[^a-zA-Z0-9_-]/g, "");
+        const csChannel = supabase.channel(csChannelName).on(
+          "postgres_changes",
+          { event: "*", schema, table: companySpecificMetricsTable, filter: companyTableFilter },
+          (payload) => {
+            const payloadData = payload.new || payload.old;
+            if (payloadData?.date === operationalDate && payloadData?.shift_id === currentShiftDetails.shiftId) {
+              queueUpdateRef.current?.();
+            }
+          }
+        ).subscribe((status, err) => {
+          if (status === supabaseJs.REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR || status === supabaseJs.REALTIME_SUBSCRIBE_STATES.TIMED_OUT) {
+            console.error(`[useLineKPIs] Subscription to ${companySpecificMetricsTable} FAILED: ${status}`, err || "");
+          }
+        });
+        activeChannels.push(csChannel);
+      }
     }
     return () => {
       activeChannels.forEach((ch) => supabase.removeChannel(ch).catch((err) => console.error("[useLineKPIs] Error removing KPI channel:", err)));
@@ -9280,7 +9943,7 @@ var useLineKPIs = ({ lineId, enabled }) => {
         clearTimeout(updateTimeoutRef.current);
       }
     };
-  }, [lineId, supabase, entityConfig, schema, lineMetricsTable, companySpecificMetricsTable, timezone, shiftConfig, isShiftConfigLoading]);
+  }, [lineId, supabase, entityConfig, schema, lineMetricsTable, companySpecificMetricsTable, timezone, shiftConfig, staticShiftConfig, shiftGroups, isShiftConfigLoading]);
   return {
     kpis,
     isLoading,
@@ -9368,12 +10031,12 @@ var useRealtimeLineMetrics = ({
         const companyId = entityConfig.companyId;
         const metricsTablePrefix = getMetricsTablePrefix(companyId || "");
         const metricsTable = `${metricsTablePrefix}_${(companyId || "").replace(/-/g, "_")}`;
-        let enabledWorkspaceIds = [];
-        for (const lineId2 of targetLineIds) {
-          const workspaces = await workspaceService.getWorkspaces(lineId2);
-          const enabledIds = workspaces.filter((ws) => ws.enable === true).map((ws) => ws.id);
-          enabledWorkspaceIds.push(...enabledIds);
-        }
+        const enabledWorkspaceLists = await Promise.all(
+          targetLineIds.map((lineId2) => workspaceService.getEnabledWorkspaces(lineId2))
+        );
+        const enabledWorkspaceIds = Array.from(
+          new Set(enabledWorkspaceLists.flatMap((workspaces) => workspaces.map((ws) => ws.id)))
+        );
         const { data: workspaceData, error: workspaceError } = enabledWorkspaceIds.length > 0 ? await supabase.from(metricsTable).select(`
                 line_id,
                 workspace_id,
@@ -9433,8 +10096,8 @@ var useRealtimeLineMetrics = ({
         const companyId = entityConfig.companyId;
         const metricsTablePrefix = getMetricsTablePrefix(companyId || "");
         const metricsTable = `${metricsTablePrefix}_${(companyId || "").replace(/-/g, "_")}`;
-        const workspaces = await workspaceService.getWorkspaces(lineIdRef.current);
-        const enabledWorkspaceIds = workspaces.filter((ws) => ws.enable === true).map((ws) => ws.id);
+        const enabledWorkspaces = await workspaceService.getEnabledWorkspaces(lineIdRef.current);
+        const enabledWorkspaceIds = enabledWorkspaces.map((ws) => ws.id);
         const { data: workspaceData, error: workspaceError } = enabledWorkspaceIds.length > 0 ? await supabase.from(metricsTable).select(`
                 workspace_id,
                 workspace_name,
@@ -9554,20 +10217,23 @@ var useRealtimeLineMetrics = ({
     const companyId = entityConfig.companyId;
     const metricsTablePrefix = getMetricsTablePrefix();
     const metricsTable = `${metricsTablePrefix}_${(companyId || "").replace(/-/g, "_")}`;
+    const currentDate = urlDate || getOperationalDate(timezone || dateTimeConfig.defaultTimezone || "UTC");
+    const baseFilterParts = `date=eq.${currentDate},shift_id=eq.${shiftId}`;
+    const lineIdFilterPart = `line_id=in.(${targetLineIds.map((id3) => `"${id3}"`).join(",")})`;
+    const filter2 = `${baseFilterParts},${lineIdFilterPart}`;
     const lineMetricsChannel = supabase.channel(`line-metrics-${timestamp}`).on(
       "postgres_changes",
       {
         event: "*",
         schema: "public",
         table: "line_metrics",
-        filter: `line_id=in.(${targetLineIds.map((id3) => `"${id3}"`).join(",")})`
+        filter: filter2
       },
       async (payload) => {
         const payloadData = payload.new;
         if (process.env.NODE_ENV === "development") {
           console.log("Line metrics update received:", payloadData);
         }
-        const currentDate = urlDate || getOperationalDate(timezone || dateTimeConfig.defaultTimezone || "UTC");
         if (payloadData?.date === currentDate && payloadData?.shift_id === shiftId) {
           queueUpdate();
         }
@@ -9583,14 +10249,13 @@ var useRealtimeLineMetrics = ({
         event: "*",
         schema: "public",
         table: metricsTable,
-        filter: `line_id=in.(${targetLineIds.map((id3) => `"${id3}"`).join(",")})`
+        filter: filter2
       },
       async (payload) => {
         const payloadData = payload.new;
         if (process.env.NODE_ENV === "development") {
           console.log(`${metricsTablePrefix} update received:`, payloadData);
         }
-        const currentDate = urlDate || getOperationalDate(timezone || dateTimeConfig.defaultTimezone || "UTC");
         if (payloadData?.date === currentDate && payloadData?.shift_id === shiftId) {
           queueUpdate();
         }
@@ -9601,7 +10266,7 @@ var useRealtimeLineMetrics = ({
       }
     });
     channelsRef.current = [lineMetricsChannel, metricsChannel];
-  }, [supabase, queueUpdate, urlDate, shiftId, entityConfig, dateTimeConfig.defaultTimezone]);
+  }, [supabase, queueUpdate, urlDate, shiftId, entityConfig, timezone, dateTimeConfig.defaultTimezone]);
   const prevShiftIdRef = React24.useRef(void 0);
   React24.useEffect(() => {
     if (!lineId) return;
@@ -10380,34 +11045,16 @@ var useFactoryOverviewMetrics = (date, shiftId) => {
       if (lineIds.length === 0) {
         throw new Error("No lines configured in entityConfig");
       }
-      const { data: { session } } = await supabase.auth.getSession();
-      if (!session?.access_token) {
-        throw new Error("No authentication token available");
-      }
-      const apiUrl = process.env.NEXT_PUBLIC_BACKEND_URL;
-      if (!apiUrl) {
-        throw new Error("Backend URL is not configured. Please set NEXT_PUBLIC_BACKEND_URL in your environment.");
-      }
       const params = new URLSearchParams({
         line_ids: lineIds.join(","),
         date: queryDate,
         shift_id: queryShiftId.toString(),
         company_id: entityConfig.companyId || ""
       });
-      const response = await fetch(
-        `${apiUrl}/api/dashboard/factory-overview?${params.toString()}`,
-        {
-          headers: {
-            "Authorization": `Bearer ${session.access_token}`,
-            "Content-Type": "application/json"
-          }
-        }
+      const data = await fetchBackendJson(
+        supabase,
+        `/api/dashboard/factory-overview?${params.toString()}`
       );
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Backend API error (${response.status}): ${errorText}`);
-      }
-      const data = await response.json();
       setMetrics(data);
     } catch (err) {
       console.error("[useFactoryOverviewMetrics] Error fetching factory overview:", err);
@@ -10436,6 +11083,46 @@ var isInitialized = false;
 var isInitializing = false;
 var initializedWithLineIds = [];
 var initializationPromise = null;
+var workspaceDisplayNamesListeners = /* @__PURE__ */ new Set();
+var notifyWorkspaceDisplayNamesListeners = (changedLineId) => {
+  workspaceDisplayNamesListeners.forEach((listener) => {
+    try {
+      listener(changedLineId);
+    } catch (err) {
+      console.error("[workspaceDisplayNames] Listener error", err);
+    }
+  });
+};
+var subscribeWorkspaceDisplayNames = (listener) => {
+  workspaceDisplayNamesListeners.add(listener);
+  return () => workspaceDisplayNamesListeners.delete(listener);
+};
+var getAllWorkspaceDisplayNamesSnapshot = (lineId) => {
+  if (lineId && runtimeWorkspaceDisplayNames[lineId]) {
+    return { ...runtimeWorkspaceDisplayNames[lineId] };
+  }
+  if (lineId) return {};
+  const allNames = {};
+  Object.entries(runtimeWorkspaceDisplayNames).forEach(([cachedLineId, lineNames]) => {
+    Object.entries(lineNames).forEach(([workspaceId, displayName]) => {
+      allNames[`${cachedLineId}_${workspaceId}`] = displayName;
+    });
+  });
+  return allNames;
+};
+var upsertWorkspaceDisplayNameInCache = (params) => {
+  const { lineId, workspaceId, displayName, enabled } = params;
+  if (!lineId || !workspaceId) return;
+  if (!runtimeWorkspaceDisplayNames[lineId]) {
+    runtimeWorkspaceDisplayNames[lineId] = {};
+  }
+  if (enabled === false || !displayName) {
+    delete runtimeWorkspaceDisplayNames[lineId][workspaceId];
+  } else {
+    runtimeWorkspaceDisplayNames[lineId][workspaceId] = displayName;
+  }
+  notifyWorkspaceDisplayNamesListeners(lineId);
+};
 function getCurrentLineIds() {
   try {
     const config = _getDashboardConfigInstance();
@@ -10475,15 +11162,20 @@ async function initializeWorkspaceDisplayNames(explicitLineId) {
       console.log("\u{1F504} Target line IDs for workspace filtering:", targetLineIds);
       runtimeWorkspaceDisplayNames = {};
       if (targetLineIds.length > 0) {
-        for (const lineId of targetLineIds) {
-          console.log(`\u{1F504} Fetching workspaces for line: ${lineId}`);
-          const lineDisplayNamesMap = await workspaceService.getWorkspaceDisplayNames(void 0, lineId);
+        const results = await Promise.all(
+          targetLineIds.map(async (lineId) => {
+            console.log(`\u{1F504} Fetching workspaces for line: ${lineId}`);
+            const lineDisplayNamesMap = await workspaceService.getWorkspaceDisplayNames(void 0, lineId);
+            return { lineId, lineDisplayNamesMap };
+          })
+        );
+        results.forEach(({ lineId, lineDisplayNamesMap }) => {
           runtimeWorkspaceDisplayNames[lineId] = {};
           lineDisplayNamesMap.forEach((displayName, workspaceId) => {
             runtimeWorkspaceDisplayNames[lineId][workspaceId] = displayName;
           });
           console.log(`\u2705 Stored ${lineDisplayNamesMap.size} workspaces for line ${lineId}`);
-        }
+        });
       } else {
         console.warn("\u26A0\uFE0F No line IDs found, fetching all workspaces (less efficient)");
         const allWorkspacesMap = await workspaceService.getWorkspaceDisplayNames();
@@ -10496,6 +11188,7 @@ async function initializeWorkspaceDisplayNames(explicitLineId) {
       initializedWithLineIds = targetLineIds;
       console.log("\u2705 Workspace display names initialized from Supabase:", runtimeWorkspaceDisplayNames);
       console.log("\u2705 Initialized with line IDs:", initializedWithLineIds);
+      notifyWorkspaceDisplayNamesListeners(explicitLineId);
     } catch (error) {
       console.error("\u274C Failed to initialize workspace display names from Supabase:", error);
     } finally {
@@ -10518,6 +11211,7 @@ var preInitializeWorkspaceDisplayNames = async (lineId) => {
           runtimeWorkspaceDisplayNames[lineId][workspaceId] = displayName;
         });
         console.log(`\u2705 Added ${lineDisplayNamesMap.size} workspaces for line ${lineId}`);
+        notifyWorkspaceDisplayNamesListeners(lineId);
       } catch (error) {
         console.error(`\u274C Failed to fetch workspaces for line ${lineId}:`, error);
       }
@@ -10536,6 +11230,7 @@ var preInitializeWorkspaceDisplayNames = async (lineId) => {
           runtimeWorkspaceDisplayNames[lineId][workspaceId] = displayName;
         });
         console.log(`\u2705 Added ${lineDisplayNamesMap.size} workspaces for line ${lineId}`);
+        notifyWorkspaceDisplayNamesListeners(lineId);
       } catch (error) {
         console.error(`\u274C Failed to fetch workspaces for line ${lineId}:`, error);
       }
@@ -10575,6 +11270,7 @@ var getWorkspaceDisplayName = (workspaceId, lineId) => {
         runtimeWorkspaceDisplayNames[lineId][workspaceId2] = displayName2;
       });
       console.log(`\u2705 Added ${lineDisplayNamesMap.size} workspaces for line ${lineId} to cache`);
+      notifyWorkspaceDisplayNamesListeners(lineId);
     }).catch((error) => {
       console.error(`\u274C Failed to fetch workspaces for line ${lineId}:`, error);
     });
@@ -10615,6 +11311,7 @@ var getShortWorkspaceDisplayName = (workspaceId, lineId) => {
         runtimeWorkspaceDisplayNames[lineId][workspaceId2] = displayName2;
       });
       console.log(`\u2705 Added ${lineDisplayNamesMap.size} workspaces for line ${lineId} to cache`);
+      notifyWorkspaceDisplayNamesListeners(lineId);
     }).catch((error) => {
       console.error(`\u274C Failed to fetch workspaces for line ${lineId}:`, error);
     });
@@ -10656,6 +11353,9 @@ var getAllWorkspaceDisplayNamesAsync = async (companyId, lineId) => {
   while (isInitializing) {
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
+  if (lineId && isInitialized && !runtimeWorkspaceDisplayNames[lineId]) {
+    await preInitializeWorkspaceDisplayNames(lineId);
+  }
   if (lineId && runtimeWorkspaceDisplayNames[lineId]) {
     return { ...runtimeWorkspaceDisplayNames[lineId] };
   }
@@ -10688,6 +11388,7 @@ var refreshWorkspaceDisplayNames = async (companyId) => {
   runtimeWorkspaceDisplayNames = {};
   isInitialized = false;
   await initializeWorkspaceDisplayNames();
+  notifyWorkspaceDisplayNamesListeners();
 };
 var clearWorkspaceDisplayNamesCache = () => {
   workspaceService.clearWorkspaceDisplayNamesCache();
@@ -10696,6 +11397,7 @@ var clearWorkspaceDisplayNamesCache = () => {
   isInitializing = false;
   initializedWithLineIds = [];
   initializationPromise = null;
+  notifyWorkspaceDisplayNamesListeners();
 };
 
 // src/lib/hooks/useWorkspaceDisplayNames.ts
@@ -10718,6 +11420,23 @@ var useWorkspaceDisplayNames = (lineId, companyId) => {
   React24.useEffect(() => {
     fetchDisplayNames();
   }, [fetchDisplayNames]);
+  React24.useEffect(() => {
+    const snapshot = getAllWorkspaceDisplayNamesSnapshot(lineId);
+    if (Object.keys(snapshot).length > 0) {
+      setDisplayNames(snapshot);
+      setLoading(false);
+    }
+    const unsubscribe = subscribeWorkspaceDisplayNames((changedLineId) => {
+      if (!lineId) {
+        setDisplayNames(getAllWorkspaceDisplayNamesSnapshot());
+        return;
+      }
+      if (!changedLineId || changedLineId === "*" || changedLineId === lineId) {
+        setDisplayNames(getAllWorkspaceDisplayNamesSnapshot(lineId));
+      }
+    });
+    return unsubscribe;
+  }, [lineId]);
   return {
     displayNames,
     loading,
@@ -10726,7 +11445,7 @@ var useWorkspaceDisplayNames = (lineId, companyId) => {
   };
 };
 var useWorkspaceDisplayName = (workspaceId, lineId, companyId) => {
-  const [displayName, setDisplayName] = React24.useState(workspaceId);
+  const [displayName, setDisplayName] = React24.useState(() => getWorkspaceDisplayName(workspaceId, lineId));
   const [loading, setLoading] = React24.useState(true);
   const [error, setError] = React24.useState(null);
   const fetchDisplayName = React24.useCallback(async () => {
@@ -10745,6 +11464,18 @@ var useWorkspaceDisplayName = (workspaceId, lineId, companyId) => {
   React24.useEffect(() => {
     fetchDisplayName();
   }, [fetchDisplayName]);
+  React24.useEffect(() => {
+    const unsubscribe = subscribeWorkspaceDisplayNames((changedLineId) => {
+      if (!lineId) {
+        setDisplayName(getWorkspaceDisplayName(workspaceId));
+        return;
+      }
+      if (!changedLineId || changedLineId === "*" || changedLineId === lineId) {
+        setDisplayName(getWorkspaceDisplayName(workspaceId, lineId));
+      }
+    });
+    return unsubscribe;
+  }, [workspaceId, lineId]);
   return {
     displayName,
     loading,
@@ -10775,6 +11506,18 @@ var useWorkspaceDisplayNamesMap = (workspaceIds, lineId, companyId) => {
   React24.useEffect(() => {
     fetchDisplayNames();
   }, [fetchDisplayNames]);
+  React24.useEffect(() => {
+    const unsubscribe = subscribeWorkspaceDisplayNames((changedLineId) => {
+      if (lineId && changedLineId && changedLineId !== "*" && changedLineId !== lineId) return;
+      const snapshot = getAllWorkspaceDisplayNamesSnapshot(lineId);
+      const next = {};
+      workspaceIds.forEach((id3) => {
+        if (snapshot[id3]) next[id3] = snapshot[id3];
+      });
+      setDisplayNames(next);
+    });
+    return unsubscribe;
+  }, [workspaceIds, lineId]);
   return {
     displayNames,
     loading,
@@ -10953,10 +11696,26 @@ var useAllWorkspaceMetrics = (options) => {
   const dateTimeConfig = useDateTimeConfig();
   const staticShiftConfig = useShiftConfig();
   const timezone = useAppTimezone();
-  const configuredLineIds = React24.useMemo(() => getConfiguredLineIds(entityConfig), [entityConfig]);
-  const representativeLineId = options?.allowedLineIds?.[0] || configuredLineIds[0];
-  const { shiftConfig: dynamicShiftConfig, isLoading: isShiftConfigLoading } = useDynamicShiftConfig(representativeLineId);
-  const shiftConfig = dynamicShiftConfig || staticShiftConfig;
+  const configuredLineIds = React24.useMemo(() => {
+    const allLineIds = getConfiguredLineIds(entityConfig);
+    if (options?.allowedLineIds) {
+      return allLineIds.filter((id3) => options.allowedLineIds.includes(id3));
+    }
+    return allLineIds;
+  }, [entityConfig, options?.allowedLineIds]);
+  const {
+    shiftConfigMap: multiLineShiftConfigMap,
+    isLoading: isShiftConfigLoading
+  } = useMultiLineShiftConfigs(configuredLineIds, staticShiftConfig);
+  const shiftGroups = React24.useMemo(() => {
+    if (isShiftConfigLoading || multiLineShiftConfigMap.size === 0) return [];
+    return groupLinesByShift(multiLineShiftConfigMap, timezone || dateTimeConfig.defaultTimezone || "Asia/Kolkata");
+  }, [isShiftConfigLoading, multiLineShiftConfigMap, timezone, dateTimeConfig.defaultTimezone]);
+  console.log(`[useAllWorkspaceMetrics] \u{1F4CA} Shift groups:`, shiftGroups.map((g) => ({
+    shiftId: g.shiftId,
+    date: g.date,
+    lineIds: g.lineIds
+  })));
   const supabase = useSupabase();
   const [workspaces, setWorkspaces] = React24.useState([]);
   const [loading, setLoading] = React24.useState(true);
@@ -10964,19 +11723,29 @@ var useAllWorkspaceMetrics = (options) => {
   const [initialized, setInitialized] = React24.useState(false);
   const fetchTimeoutRef = React24.useRef(null);
   const isFetchingRef = React24.useRef(false);
-  const queryShiftId = React24.useMemo(() => {
+  const hasSpecificDateShift = options?.initialDate !== void 0 || options?.initialShiftId !== void 0;
+  const fallbackQueryShiftId = React24.useMemo(() => {
     if (options?.initialShiftId !== void 0) {
       return options.initialShiftId;
     }
+    if (shiftGroups.length > 0) {
+      return shiftGroups[0].shiftId;
+    }
     const currentShift = getCurrentShift(
       timezone || dateTimeConfig.defaultTimezone || "Asia/Kolkata",
-      shiftConfig
+      staticShiftConfig
     );
     return currentShift.shiftId;
-  }, [options?.initialShiftId, timezone, dateTimeConfig.defaultTimezone, shiftConfig]);
-  const queryDate = React24.useMemo(() => {
-    return options?.initialDate || getOperationalDate(timezone || dateTimeConfig.defaultTimezone || "UTC");
-  }, [options?.initialDate, timezone, dateTimeConfig.defaultTimezone]);
+  }, [options?.initialShiftId, shiftGroups, timezone, dateTimeConfig.defaultTimezone, staticShiftConfig]);
+  const fallbackQueryDate = React24.useMemo(() => {
+    if (options?.initialDate) {
+      return options.initialDate;
+    }
+    if (shiftGroups.length > 0) {
+      return shiftGroups[0].date;
+    }
+    return getOperationalDate(timezone || dateTimeConfig.defaultTimezone || "UTC");
+  }, [options?.initialDate, shiftGroups, timezone, dateTimeConfig.defaultTimezone]);
   const metricsTable = React24.useMemo(() => {
     const companyId = entityConfig.companyId;
     if (!companyId) return "";
@@ -10994,49 +11763,105 @@ var useAllWorkspaceMetrics = (options) => {
     }
     setError(null);
     try {
-      const allConfiguredLineIds = getConfiguredLineIds(entityConfig);
-      const configuredLineIds2 = options?.allowedLineIds ? allConfiguredLineIds.filter((id3) => options.allowedLineIds.includes(id3)) : allConfiguredLineIds;
-      let enabledWorkspaceIds = [];
-      for (const lineId of configuredLineIds2) {
-        const workspaces2 = await workspaceService.getWorkspaces(lineId);
-        const enabledIds = workspaces2.filter((ws) => ws.enable === true).map((ws) => ws.id);
-        enabledWorkspaceIds.push(...enabledIds);
-      }
-      if (enabledWorkspaceIds.length === 0) {
+      const lineWorkspaceMap = /* @__PURE__ */ new Map();
+      const allEnabledWorkspaceIdSet = /* @__PURE__ */ new Set();
+      const perLineEnabledIds = await Promise.all(
+        configuredLineIds.map(async (lineId) => {
+          const enabledWorkspaces = await workspaceService.getEnabledWorkspaces(lineId);
+          const enabledIds = enabledWorkspaces.map((ws) => ws.id);
+          return { lineId, enabledIds };
+        })
+      );
+      perLineEnabledIds.forEach(({ lineId, enabledIds }) => {
+        lineWorkspaceMap.set(lineId, enabledIds);
+        enabledIds.forEach((id3) => allEnabledWorkspaceIdSet.add(id3));
+      });
+      const allEnabledWorkspaceIds = Array.from(allEnabledWorkspaceIdSet);
+      if (allEnabledWorkspaceIds.length === 0) {
         setWorkspaces([]);
         setInitialized(true);
         setLoading(false);
         return;
       }
-      const { data, error: fetchError } = await supabase.from(metricsTable).select(`
-          workspace_name,
-          total_output,
-          avg_pph,
-          efficiency,
-          workspace_id,
-          avg_cycle_time,
-          performance_score,
-          trend_score,
-          line_id,
-          total_day_output
-        `).eq("date", queryDate).eq("shift_id", queryShiftId).in("workspace_id", enabledWorkspaceIds).order("efficiency", { ascending: false });
-      if (fetchError) throw fetchError;
-      const transformedData = (data || []).map((item) => ({
-        company_id: entityConfig.companyId || "unknown",
-        line_id: item.line_id,
-        shift_id: queryShiftId,
-        date: queryDate,
-        workspace_uuid: item.workspace_id,
-        workspace_name: item.workspace_name,
-        action_count: item.total_output || 0,
-        pph: item.avg_pph || 0,
-        performance_score: item.performance_score || 0,
-        avg_cycle_time: item.avg_cycle_time || 0,
-        trend: item.trend_score === 1 ? 2 : 0,
-        predicted_output: 0,
-        efficiency: item.efficiency || 0,
-        action_threshold: item.total_day_output || 0
-      }));
+      let transformedData = [];
+      if (hasSpecificDateShift) {
+        console.log(`[useAllWorkspaceMetrics] \u{1F4CA} Using specific date/shift: ${fallbackQueryDate} / ${fallbackQueryShiftId}`);
+        const { data, error: fetchError } = await supabase.from(metricsTable).select(`
+            workspace_name,
+            total_output,
+            avg_pph,
+            efficiency,
+            workspace_id,
+            avg_cycle_time,
+            performance_score,
+            trend_score,
+            line_id,
+            total_day_output
+          `).eq("date", fallbackQueryDate).eq("shift_id", fallbackQueryShiftId).in("workspace_id", allEnabledWorkspaceIds).order("efficiency", { ascending: false });
+        if (fetchError) throw fetchError;
+        transformedData = (data || []).map((item) => ({
+          company_id: entityConfig.companyId || "unknown",
+          line_id: item.line_id,
+          shift_id: fallbackQueryShiftId,
+          date: fallbackQueryDate,
+          workspace_uuid: item.workspace_id,
+          workspace_name: item.workspace_name,
+          action_count: item.total_output || 0,
+          pph: item.avg_pph || 0,
+          performance_score: item.performance_score || 0,
+          avg_cycle_time: item.avg_cycle_time || 0,
+          trend: item.trend_score === 1 ? 2 : 0,
+          predicted_output: 0,
+          efficiency: item.efficiency || 0,
+          action_threshold: item.total_day_output || 0
+        }));
+      } else if (shiftGroups.length > 0) {
+        console.log(`[useAllWorkspaceMetrics] \u{1F3ED} Fetching per-shift: ${shiftGroups.length} group(s)`);
+        const queryPromises = shiftGroups.map(async (group) => {
+          const groupWorkspaceIds = group.lineIds.flatMap(
+            (lineId) => lineWorkspaceMap.get(lineId) || []
+          );
+          if (groupWorkspaceIds.length === 0) {
+            return [];
+          }
+          console.log(`[useAllWorkspaceMetrics] \u{1F4CA} Fetching shift ${group.shiftId} (${group.shiftName}):`, {
+            lineIds: group.lineIds,
+            date: group.date,
+            workspaceCount: groupWorkspaceIds.length
+          });
+          const { data, error: fetchError } = await supabase.from(metricsTable).select(`
+              workspace_name,
+              total_output,
+              avg_pph,
+              efficiency,
+              workspace_id,
+              avg_cycle_time,
+              performance_score,
+              trend_score,
+              line_id,
+              total_day_output
+            `).eq("date", group.date).eq("shift_id", group.shiftId).in("workspace_id", groupWorkspaceIds);
+          if (fetchError) throw fetchError;
+          return (data || []).map((item) => ({
+            company_id: entityConfig.companyId || "unknown",
+            line_id: item.line_id,
+            shift_id: group.shiftId,
+            date: group.date,
+            workspace_uuid: item.workspace_id,
+            workspace_name: item.workspace_name,
+            action_count: item.total_output || 0,
+            pph: item.avg_pph || 0,
+            performance_score: item.performance_score || 0,
+            avg_cycle_time: item.avg_cycle_time || 0,
+            trend: item.trend_score === 1 ? 2 : 0,
+            predicted_output: 0,
+            efficiency: item.efficiency || 0,
+            action_threshold: item.total_day_output || 0
+          }));
+        });
+        const results = await Promise.all(queryPromises);
+        transformedData = results.flat().sort((a, b) => (b.efficiency || 0) - (a.efficiency || 0));
+      }
       setWorkspaces((prevWorkspaces) => {
         if (prevWorkspaces.length !== transformedData.length) {
           return transformedData;
@@ -11058,51 +11883,78 @@ var useAllWorkspaceMetrics = (options) => {
       setLoading(false);
       isFetchingRef.current = false;
     }
-  }, [queryDate, queryShiftId, metricsTable, supabase, entityConfig.companyId, entityConfig, options?.allowedLineIds, options?.enabled, isShiftConfigLoading]);
+  }, [fallbackQueryDate, fallbackQueryShiftId, hasSpecificDateShift, shiftGroups, metricsTable, supabase, entityConfig.companyId, configuredLineIds, options?.enabled, isShiftConfigLoading]);
   React24.useEffect(() => {
     if (!initialized) {
       fetchWorkspaceMetrics();
     }
+    const validDateShiftCombos = /* @__PURE__ */ new Set();
+    if (hasSpecificDateShift) {
+      validDateShiftCombos.add(`${fallbackQueryDate}-${fallbackQueryShiftId}`);
+    } else {
+      shiftGroups.forEach((group) => {
+        validDateShiftCombos.add(`${group.date}-${group.shiftId}`);
+      });
+    }
     const setupSubscription = () => {
-      const channel2 = supabase.channel(`all-workspace-metrics-${Date.now()}`).on(
-        "postgres_changes",
+      if (!metricsTable || configuredLineIds.length === 0) return [];
+      const groupsToSubscribe = hasSpecificDateShift || shiftGroups.length === 0 ? [
         {
-          event: "*",
-          schema,
-          table: metricsTable
-        },
-        async (payload) => {
-          const data = payload.new || payload.old;
-          if (data?.date !== queryDate || data?.shift_id !== queryShiftId) {
-            return;
-          }
-          if (fetchTimeoutRef.current) {
-            clearTimeout(fetchTimeoutRef.current);
-          }
-          fetchTimeoutRef.current = setTimeout(async () => {
-            if (!isFetchingRef.current) {
-              await fetchWorkspaceMetrics();
+          date: fallbackQueryDate,
+          shiftId: fallbackQueryShiftId,
+          lineIds: configuredLineIds
+        }
+      ] : shiftGroups.map((group) => ({
+        date: group.date,
+        shiftId: group.shiftId,
+        lineIds: group.lineIds
+      }));
+      return groupsToSubscribe.map((group, index) => {
+        const lineIdFilterPart = `line_id=in.(${group.lineIds.map((id3) => `"${id3}"`).join(",")})`;
+        const filter2 = `date=eq.${group.date},shift_id=eq.${group.shiftId},${lineIdFilterPart}`;
+        const channelName = `all-workspace-metrics-g${index}-${group.date}-${group.shiftId}-${Date.now()}`.replace(
+          /[^a-zA-Z0-9_-]/g,
+          ""
+        );
+        return supabase.channel(channelName).on(
+          "postgres_changes",
+          {
+            event: "*",
+            schema,
+            table: metricsTable,
+            filter: filter2
+          },
+          async (payload) => {
+            const data = payload.new || payload.old;
+            const dataKey = `${data?.date}-${data?.shift_id}`;
+            if (!validDateShiftCombos.has(dataKey)) {
+              return;
             }
-            fetchTimeoutRef.current = null;
-          }, 300);
-        }
-      ).subscribe();
-      return channel2;
+            if (fetchTimeoutRef.current) {
+              clearTimeout(fetchTimeoutRef.current);
+            }
+            fetchTimeoutRef.current = setTimeout(async () => {
+              if (!isFetchingRef.current) {
+                await fetchWorkspaceMetrics();
+              }
+              fetchTimeoutRef.current = null;
+            }, 300);
+          }
+        ).subscribe();
+      });
     };
-    const channel = setupSubscription();
+    const channels = setupSubscription();
     return () => {
       if (fetchTimeoutRef.current) {
         clearTimeout(fetchTimeoutRef.current);
         fetchTimeoutRef.current = null;
       }
-      if (channel) {
-        supabase.removeChannel(channel);
-      }
+      channels.forEach((channel) => supabase.removeChannel(channel));
     };
-  }, [queryDate, queryShiftId, metricsTable, fetchWorkspaceMetrics, initialized, supabase, schema, entityConfig.companyId]);
+  }, [fallbackQueryDate, fallbackQueryShiftId, hasSpecificDateShift, shiftGroups, metricsTable, fetchWorkspaceMetrics, initialized, supabase, schema, entityConfig.companyId, configuredLineIds]);
   React24.useEffect(() => {
     setInitialized(false);
-  }, [queryDate, queryShiftId]);
+  }, [fallbackQueryDate, fallbackQueryShiftId, shiftGroups]);
   const refreshWorkspaces = React24.useCallback(() => fetchWorkspaceMetrics(), [fetchWorkspaceMetrics]);
   return React24.useMemo(
     () => ({ workspaces, loading, error, refreshWorkspaces }),
@@ -11591,127 +12443,6 @@ function useClipTypesWithCounts(workspaceId, date, shiftId, totalOutput, options
     counts
   };
 }
-var useMultiLineShiftConfigs = (lineIds, fallbackConfig) => {
-  const [shiftConfigMap, setShiftConfigMap] = React24.useState(/* @__PURE__ */ new Map());
-  const [isLoading, setIsLoading] = React24.useState(true);
-  const [error, setError] = React24.useState(null);
-  const supabase = useSupabase();
-  const lineIdsKey = React24.useMemo(() => lineIds.sort().join(","), [lineIds]);
-  React24.useEffect(() => {
-    if (!lineIds || lineIds.length === 0) {
-      setShiftConfigMap(/* @__PURE__ */ new Map());
-      setIsLoading(false);
-      return;
-    }
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    const validLineIds = lineIds.filter((id3) => uuidRegex.test(id3));
-    if (validLineIds.length === 0) {
-      console.warn("[useMultiLineShiftConfigs] No valid line IDs provided");
-      setShiftConfigMap(/* @__PURE__ */ new Map());
-      setIsLoading(false);
-      return;
-    }
-    let mounted = true;
-    const calculateBreakDuration2 = (startTime, endTime) => {
-      const [sh, sm] = startTime.split(":").map(Number);
-      const [eh, em] = endTime.split(":").map(Number);
-      let startMinutes = sh * 60 + sm;
-      let endMinutes = eh * 60 + em;
-      if (endMinutes < startMinutes) {
-        endMinutes += 24 * 60;
-      }
-      return endMinutes - startMinutes;
-    };
-    const stripSeconds = (timeStr) => {
-      if (!timeStr) return timeStr;
-      return timeStr.substring(0, 5);
-    };
-    const buildShiftConfigFromRows = (shifts, fallback) => {
-      const mapped = shifts.map((shift) => ({
-        shiftId: shift.shift_id,
-        shiftName: shift.shift_name || `Shift ${shift.shift_id}`,
-        startTime: stripSeconds(shift.start_time),
-        endTime: stripSeconds(shift.end_time),
-        breaks: Array.isArray(shift.breaks) ? shift.breaks.map((b) => ({
-          startTime: b.start || b.startTime || "00:00",
-          endTime: b.end || b.endTime || "00:00",
-          duration: calculateBreakDuration2(
-            b.start || b.startTime || "00:00",
-            b.end || b.endTime || "00:00"
-          ),
-          remarks: b.remarks || b.name || ""
-        })) : [],
-        timezone: shift.timezone
-      }));
-      const day = mapped.find((s) => s.shiftId === 0);
-      const night = mapped.find((s) => s.shiftId === 1);
-      return {
-        shifts: mapped,
-        timezone: mapped[0]?.timezone,
-        dayShift: day ? { id: day.shiftId, startTime: day.startTime, endTime: day.endTime, name: day.shiftName } : fallback?.dayShift,
-        nightShift: night ? { id: night.shiftId, startTime: night.startTime, endTime: night.endTime, name: night.shiftName } : fallback?.nightShift,
-        transitionPeriodMinutes: fallback?.transitionPeriodMinutes || 0
-      };
-    };
-    const fetchAllConfigs = async () => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        console.log(`[useMultiLineShiftConfigs] Fetching shift configs for ${validLineIds.length} lines`);
-        const { data, error: fetchError } = await supabase.from("line_operating_hours").select("line_id, shift_id, shift_name, start_time, end_time, breaks, timezone").in("line_id", validLineIds);
-        if (fetchError) {
-          console.error("[useMultiLineShiftConfigs] Error fetching shift configs:", fetchError);
-          throw new Error(`Failed to fetch shift configs: ${fetchError.message}`);
-        }
-        const lineShiftsMap = /* @__PURE__ */ new Map();
-        data?.forEach((row) => {
-          if (!lineShiftsMap.has(row.line_id)) {
-            lineShiftsMap.set(row.line_id, []);
-          }
-          lineShiftsMap.get(row.line_id).push(row);
-        });
-        const configMap = /* @__PURE__ */ new Map();
-        lineShiftsMap.forEach((shifts, lineId) => {
-          const config = buildShiftConfigFromRows(shifts, fallbackConfig);
-          configMap.set(lineId, config);
-        });
-        validLineIds.forEach((lineId) => {
-          if (!configMap.has(lineId) && fallbackConfig) {
-            console.warn(`[useMultiLineShiftConfigs] No config found for line ${lineId}, using fallback`);
-            configMap.set(lineId, fallbackConfig);
-          }
-        });
-        console.log(`[useMultiLineShiftConfigs] Built configs for ${configMap.size} lines`);
-        if (mounted) {
-          setShiftConfigMap(configMap);
-          setIsLoading(false);
-        }
-      } catch (err) {
-        console.error("[useMultiLineShiftConfigs] Error:", err);
-        if (mounted) {
-          setError(err instanceof Error ? err.message : "Failed to fetch shift configs");
-          if (fallbackConfig) {
-            const fallbackMap = /* @__PURE__ */ new Map();
-            validLineIds.forEach((lineId) => {
-              fallbackMap.set(lineId, fallbackConfig);
-            });
-            setShiftConfigMap(fallbackMap);
-          }
-          setIsLoading(false);
-        }
-      }
-    };
-    fetchAllConfigs();
-    return () => {
-      mounted = false;
-    };
-  }, [lineIdsKey, supabase]);
-  return {
-    shiftConfigMap,
-    isLoading,
-    error
-  };
-};
 var MAX_RETRIES = 10;
 var RETRY_DELAY = 500;
 function useNavigation(customNavigate) {
@@ -12658,6 +13389,85 @@ function useLineSupervisor(lineId) {
     error
   };
 }
+var useSupervisorsByLineIds = (lineIds, options) => {
+  const supabase = useSupabase();
+  const enabled = options?.enabled ?? true;
+  const lineIdsKey = React24.useMemo(() => (lineIds || []).slice().sort().join(","), [lineIds]);
+  const targetLineIdSet = React24.useMemo(() => new Set(lineIds || []), [lineIdsKey]);
+  const [supervisorsByLineId, setSupervisorsByLineId] = React24.useState(/* @__PURE__ */ new Map());
+  const [supervisorNamesByLineId, setSupervisorNamesByLineId] = React24.useState(/* @__PURE__ */ new Map());
+  const [isLoading, setIsLoading] = React24.useState(true);
+  const [error, setError] = React24.useState(null);
+  const fetchSupervisors = React24.useCallback(async () => {
+    if (!enabled || !supabase) {
+      setIsLoading(false);
+      return;
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const { data, error: fetchError } = await supabase.from("user_roles").select("user_id, email, properties").eq("role_level", "supervisor");
+      if (fetchError) {
+        throw fetchError;
+      }
+      const nextSupervisorsByLineId = /* @__PURE__ */ new Map();
+      (data || []).forEach((row) => {
+        const assignedLineIds = row?.properties?.line_id || row?.properties?.line_ids || [];
+        if (!Array.isArray(assignedLineIds) || assignedLineIds.length === 0) return;
+        const email = row.email || "";
+        const displayName = (typeof email === "string" && email.includes("@") ? email.split("@")[0] : email) || email;
+        const supervisor = {
+          userId: row.user_id,
+          email,
+          displayName
+        };
+        assignedLineIds.forEach((lineId) => {
+          if (typeof lineId !== "string") return;
+          if (targetLineIdSet.size > 0 && !targetLineIdSet.has(lineId)) return;
+          const existing = nextSupervisorsByLineId.get(lineId) || [];
+          existing.push(supervisor);
+          nextSupervisorsByLineId.set(lineId, existing);
+        });
+      });
+      const nextSupervisorNamesByLineId = /* @__PURE__ */ new Map();
+      nextSupervisorsByLineId.forEach((supervisors, lineId) => {
+        nextSupervisorNamesByLineId.set(lineId, supervisors.map((s) => s.displayName).join(", "));
+      });
+      setSupervisorsByLineId(nextSupervisorsByLineId);
+      setSupervisorNamesByLineId(nextSupervisorNamesByLineId);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch supervisors"));
+      setSupervisorsByLineId(/* @__PURE__ */ new Map());
+      setSupervisorNamesByLineId(/* @__PURE__ */ new Map());
+    } finally {
+      setIsLoading(false);
+    }
+  }, [enabled, supabase, targetLineIdSet]);
+  React24.useEffect(() => {
+    fetchSupervisors();
+  }, [fetchSupervisors, lineIdsKey]);
+  React24.useEffect(() => {
+    if (!enabled || !supabase) return;
+    let channel = null;
+    channel = supabase.channel("supervisors-by-line").on(
+      "postgres_changes",
+      { event: "*", schema: "public", table: "user_roles", filter: "role_level=eq.supervisor" },
+      () => {
+        fetchSupervisors();
+      }
+    ).subscribe();
+    return () => {
+      if (channel) supabase.removeChannel(channel);
+    };
+  }, [enabled, supabase, fetchSupervisors]);
+  return {
+    supervisorNamesByLineId,
+    supervisorsByLineId,
+    isLoading,
+    error,
+    refetch: fetchSupervisors
+  };
+};
 function useIdleTimeReasons({
   workspaceId,
   lineId,
@@ -13063,6 +13873,102 @@ var getConfigurableShortWorkspaceDisplayName = (workspaceId, workspaceConfig, li
   return fullName;
 };
 
+// src/lib/utils/kpis.ts
+var toNumber = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+};
+var createDefaultKPIs = () => ({
+  underperformingWorkers: { current: 0, total: 0, change: 0 },
+  efficiency: { value: 0, change: 0 },
+  outputProgress: { current: 0, target: 0, idealOutput: 0, change: 0 },
+  avgCycleTime: { value: 0, change: 0 },
+  qualityCompliance: { value: 95, change: 0 }
+});
+var buildKPIsFromLineMetricsRow = (row) => {
+  if (!row) return createDefaultKPIs();
+  const avgEfficiency = toNumber(row.avg_efficiency);
+  const avgCycleTime = toNumber(row.avg_cycle_time);
+  const currentOutput = toNumber(row.current_output);
+  const lineThreshold = toNumber(row.line_threshold);
+  const idealOutput = toNumber(row.ideal_output) || lineThreshold || 0;
+  const underperformingWorkspaces = toNumber(row.underperforming_workspaces);
+  const totalWorkspaces = toNumber(row.total_workspaces);
+  return {
+    underperformingWorkers: {
+      current: underperformingWorkspaces,
+      total: totalWorkspaces,
+      change: 0
+    },
+    efficiency: {
+      value: avgEfficiency,
+      change: 0
+    },
+    outputProgress: {
+      current: currentOutput,
+      target: lineThreshold,
+      idealOutput,
+      change: 0
+    },
+    avgCycleTime: {
+      value: avgCycleTime,
+      change: 0
+    },
+    qualityCompliance: {
+      value: 95,
+      change: 0
+    }
+  };
+};
+var aggregateKPIsFromLineMetricsRows = (rows) => {
+  if (!rows || rows.length === 0) return createDefaultKPIs();
+  const currentOutputSum = rows.reduce((sum, row) => sum + toNumber(row.current_output), 0);
+  const lineThresholdSum = rows.reduce((sum, row) => sum + toNumber(row.line_threshold), 0);
+  const idealOutputSum = rows.reduce(
+    (sum, row) => sum + (toNumber(row.ideal_output) || toNumber(row.line_threshold)),
+    0
+  );
+  const totalWorkspacesAll = rows.reduce((sum, row) => sum + toNumber(row.total_workspaces), 0);
+  const weightedEfficiencySum = rows.reduce(
+    (sum, row) => sum + toNumber(row.avg_efficiency) * toNumber(row.total_workspaces),
+    0
+  );
+  const avgEfficiency = totalWorkspacesAll > 0 ? weightedEfficiencySum / totalWorkspacesAll : 0;
+  const numLines = rows.length;
+  const avgCycleTime = numLines > 0 ? rows.reduce((sum, row) => sum + toNumber(row.avg_cycle_time), 0) / numLines : 0;
+  const totalUnderperforming = rows.reduce((sum, row) => sum + toNumber(row.underperforming_workspaces), 0);
+  const totalWorkspaces = rows.reduce((sum, row) => sum + toNumber(row.total_workspaces), 0);
+  return {
+    underperformingWorkers: {
+      current: totalUnderperforming,
+      total: totalWorkspaces,
+      change: 0
+    },
+    efficiency: {
+      value: avgEfficiency,
+      change: 0
+    },
+    outputProgress: {
+      current: currentOutputSum,
+      target: lineThresholdSum,
+      idealOutput: idealOutputSum,
+      change: 0
+    },
+    avgCycleTime: {
+      value: avgCycleTime,
+      change: 0
+    },
+    qualityCompliance: {
+      value: 95,
+      change: 0
+    }
+  };
+};
+
 // ../../node_modules/clsx/dist/clsx.mjs
 function r(e) {
   var t, f, n = "";
@@ -28099,6 +29005,7 @@ if (typeof document !== "undefined") {
   }
 }
 var BASE_HLS_CONFIG = {
+  // Keep buffer small to reduce wasted downloads on slow links
   maxBufferLength: 3,
   maxMaxBufferLength: 8,
   maxBufferSize: 50 * 1e3 * 1e3,
@@ -28106,10 +29013,10 @@ var BASE_HLS_CONFIG = {
   manifestLoadingTimeOut: 15e3,
   manifestLoadingMaxRetry: 3,
   manifestLoadingRetryDelay: 500,
-  levelLoadingTimeOut: 6e4,
+  levelLoadingTimeOut: 2e4,
   levelLoadingMaxRetry: 5,
   levelLoadingRetryDelay: 500,
-  fragLoadingTimeOut: 6e4,
+  fragLoadingTimeOut: 2e4,
   fragLoadingMaxRetry: 5,
   fragLoadingRetryDelay: 500,
   startPosition: -1,
@@ -28122,7 +29029,10 @@ var BASE_HLS_CONFIG = {
   abrBandWidthFactor: 0.95,
   abrBandWidthUpFactor: 0.7,
   abrMaxWithRealBitrate: false,
-  abrEwmaDefaultEstimate: 5e7
+  // Favor a conservative first rendition on constrained networks
+  abrEwmaDefaultEstimate: 1e6,
+  startLevel: 0,
+  capLevelToPlayerSize: true
 };
 var HlsVideoPlayer = React24.forwardRef(({
   src,
@@ -29206,7 +30116,7 @@ var getSupabaseClient2 = () => {
   }
   return supabaseJs.createClient(url, key);
 };
-var getAuthToken3 = async () => {
+var getAuthToken4 = async () => {
   try {
     const supabase = getSupabaseClient2();
     const { data: { session } } = await supabase.auth.getSession();
@@ -29229,7 +30139,7 @@ function useWorkspaceCrop(workspaceId) {
       setIsLoading(true);
       setError(null);
       try {
-        const token = await getAuthToken3();
+        const token = await getAuthToken4();
         if (!token) {
           throw new Error("Authentication required");
         }
@@ -30278,7 +31188,7 @@ var FileManagerFilters = ({
   const ROOT_CAUSE_OPTIONS = [
     "Operator Absent",
     "Operator Idle",
-    "Machine Maintenance",
+    "Machine Downtime",
     "No Material"
   ];
   const getIdleTimeRootCause = React24.useCallback((clipId) => {
@@ -30318,7 +31228,7 @@ var FileManagerFilters = ({
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "Authorization": `Bearer ${await getAuthToken4()}`
+          "Authorization": `Bearer ${await getAuthToken5()}`
         },
         body: JSON.stringify({
           action: "clip-metadata",
@@ -30351,7 +31261,7 @@ var FileManagerFilters = ({
       });
     }
   }, [workspaceId, date, shift]);
-  const getAuthToken4 = async () => {
+  const getAuthToken5 = async () => {
     try {
       const { createClient: createClient5 } = await import('@supabase/supabase-js');
       const supabase = createClient5(
@@ -30377,7 +31287,7 @@ var FileManagerFilters = ({
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "Authorization": `Bearer ${await getAuthToken4()}`
+          "Authorization": `Bearer ${await getAuthToken5()}`
         },
         body: JSON.stringify({
           action: "percentile-clips",
@@ -32021,7 +32931,7 @@ var BottlenecksContent = ({
       fetchClipCounts();
     }
   }, [workspaceId, effectiveDateString, effectiveShiftId, s3ClipsService, fetchClipCounts, isEffectiveShiftReady]);
-  const getAuthToken4 = React24.useCallback(async () => {
+  const getAuthToken5 = React24.useCallback(async () => {
     try {
       const { createClient: createClient5 } = await import('@supabase/supabase-js');
       const supabase = createClient5(
@@ -32040,7 +32950,7 @@ var BottlenecksContent = ({
     const fetchTriageClips = async () => {
       setIsLoadingTriageClips(true);
       try {
-        const token = await getAuthToken4();
+        const token = await getAuthToken5();
         if (!token) {
           console.error("[BottlenecksContent] No auth token available");
           return;
@@ -32088,7 +32998,7 @@ var BottlenecksContent = ({
       }
     };
     fetchTriageClips();
-  }, [triageMode, workspaceId, effectiveDateString, effectiveShiftId, getAuthToken4, isEffectiveShiftReady]);
+  }, [triageMode, workspaceId, effectiveDateString, effectiveShiftId, getAuthToken5, isEffectiveShiftReady]);
   React24.useEffect(() => {
     if (!triageMode || triageClips.length === 0 || !session?.access_token) {
       return;
@@ -32419,7 +33329,20 @@ var BottlenecksContent = ({
       updateActiveFilter(categoryId);
     }
     try {
-      await loadCategoryMetadata(categoryId, false);
+      const metadataPromise = loadCategoryMetadata(categoryId, false).catch((err) => {
+        console.warn(`[BottlenecksContent] Metadata fetch error (non-blocking):`, err);
+        return null;
+      });
+      const video = await s3ClipsService.getClipById(clipId);
+      if (video) {
+        setPendingVideo(video);
+        setCurrentClipId(clipId);
+        setAllVideos([video]);
+        setCurrentIndex(0);
+      } else {
+        throw new Error(`Failed to load video data for clip ${clipId}`);
+      }
+      await metadataPromise;
       let metadataArray = categoryMetadataRef.current;
       const clipExistsInMetadata = metadataArray.some((clip) => clip.clipId === clipId);
       if (metadataArray.length === 0 || !clipExistsInMetadata) {
@@ -32436,16 +33359,7 @@ var BottlenecksContent = ({
       }
       setCurrentMetadataIndex(clickedClipIndex);
       currentMetadataIndexRef.current = clickedClipIndex;
-      const video = await s3ClipsService.getClipById(clipId);
-      if (video) {
-        setPendingVideo(video);
-        setCurrentClipId(clipId);
-        setAllVideos([video]);
-        setCurrentIndex(0);
-        console.log(`[BottlenecksContent] Loaded clip ${clipId} (${clickedClipIndex + 1}/${metadataArray.length})`);
-      } else {
-        throw new Error(`Failed to load video data for clip ${clipId}`);
-      }
+      console.log(`[BottlenecksContent] Loaded clip ${clipId} (${clickedClipIndex + 1}/${metadataArray.length})`);
     } catch (error2) {
       console.error(`[BottlenecksContent] Error loading clip by ID (${clipId}):`, error2);
       if (isMountedRef.current) {
@@ -35332,7 +36246,7 @@ var STATIC_COLORS = {
   // red-600 - Critical/Urgent
   "No Material": "#f59e0b",
   // amber-500 - Warning/Supply Chain
-  "Machine Maintenance": "#3b82f6",
+  "Machine Downtime": "#3b82f6",
   // blue-500 - Scheduled/Technical
   "Operator Idle": "#8b5cf6"
   // violet-500 - Low Priority/Behavioral
@@ -37717,7 +38631,7 @@ var WorkspaceWhatsAppShareButton = ({
     }
   );
 };
-var WorkspacePdfGenerator = ({ workspace, className }) => {
+var WorkspacePdfGenerator = ({ workspace, className, idleTimeReasons }) => {
   const [isGenerating, setIsGenerating] = React24.useState(false);
   const entityConfig = useEntityConfig();
   const generatePDF = async () => {
@@ -37792,8 +38706,10 @@ var WorkspacePdfGenerator = ({ workspace, className }) => {
         doc.roundedRect(22, y - 7, 165, 12, 2, 2, "S");
       };
       const perfOverviewStartY = 93;
+      const hasIdleTimeReason = idleTimeReasons && idleTimeReasons.length > 0;
+      const perfOverviewHeight = hasIdleTimeReason ? 80 : 70;
       doc.setFillColor(245, 245, 245);
-      doc.roundedRect(15, perfOverviewStartY, 180, 60, 3, 3, "F");
+      doc.roundedRect(15, perfOverviewStartY, 180, perfOverviewHeight, 3, 3, "F");
       doc.setFontSize(18);
       doc.setFont("helvetica", "bold");
       doc.setTextColor(40, 40, 40);
@@ -37817,32 +38733,68 @@ var WorkspacePdfGenerator = ({ workspace, className }) => {
       doc.text("PPH (Pieces Per Hour):", 25, kpiStartY + kpiSpacing * 2);
       doc.setFont("helvetica", "bold");
       doc.text(`${workspace.avg_pph.toFixed(1)} (Standard: ${workspace.pph_threshold.toFixed(1)})`, 120, kpiStartY + kpiSpacing * 2);
+      createKPIBox(kpiStartY + kpiSpacing * 3);
+      doc.setFont("helvetica", "normal");
+      doc.text("Total Idle Time:", 25, kpiStartY + kpiSpacing * 3);
+      doc.setFont("helvetica", "bold");
+      const idleTimeFormatted = formatIdleTime(workspace.idle_time);
+      doc.text(idleTimeFormatted, 120, kpiStartY + kpiSpacing * 3);
+      if (hasIdleTimeReason) {
+        createKPIBox(kpiStartY + kpiSpacing * 4);
+        doc.setFont("helvetica", "normal");
+        doc.text("Top Idle Reason:", 25, kpiStartY + kpiSpacing * 4);
+        doc.setFont("helvetica", "bold");
+        const topReason = idleTimeReasons[0];
+        const reasonName = topReason.name.replace(/_/g, " ");
+        const reasonText = `${reasonName} (${topReason.value.toFixed(1)}%)`;
+        doc.text(reasonText, 120, kpiStartY + kpiSpacing * 4);
+      }
+      const separatorBeforeHourlyY = hasIdleTimeReason ? 183 : 173;
       doc.setDrawColor(180, 180, 180);
       doc.setLineWidth(0.8);
-      doc.line(20, 163, 190, 163);
-      const hourlyPerfStartY = 168;
+      doc.line(20, separatorBeforeHourlyY, 190, separatorBeforeHourlyY);
+      const hourlyPerfStartY = hasIdleTimeReason ? 188 : 178;
       const hourlyData = workspace.hourly_action_counts || [];
       const hourlyTarget = workspace.pph_threshold;
-      const tableStartY = 199;
-      const rowHeight = 8;
+      const pageHeight = doc.internal.pageSize.height;
+      const maxContentY = pageHeight - 15;
+      const baseTableStartY = hasIdleTimeReason ? 219 : 209;
+      let tableStartY = baseTableStartY;
+      let rowHeight = 8;
+      let headerFontSize = 11;
+      let contentFontSize = 11;
+      let titleFontSize = 18;
       const bottomPadding = 8;
+      const estimatedEndY = tableStartY + hourlyData.length * rowHeight + bottomPadding;
+      if (estimatedEndY > maxContentY) {
+        rowHeight = 6.5;
+        headerFontSize = 9;
+        contentFontSize = 9;
+        titleFontSize = 16;
+        tableStartY = hasIdleTimeReason ? 215 : 205;
+      }
       const backgroundHeight = tableStartY - hourlyPerfStartY + hourlyData.length * rowHeight + bottomPadding;
       doc.setFillColor(245, 245, 245);
       doc.roundedRect(15, hourlyPerfStartY, 180, backgroundHeight, 3, 3, "F");
-      doc.setFontSize(18);
+      doc.setFontSize(titleFontSize);
       doc.setFont("helvetica", "bold");
       doc.setTextColor(40, 40, 40);
-      doc.text("Hourly Performance", 20, 178);
+      const hourlyTitleY = hasIdleTimeReason ? 198 : 188;
+      doc.text("Hourly Performance", 20, hourlyTitleY);
       doc.setTextColor(0, 0, 0);
-      doc.setFontSize(11);
+      doc.setFontSize(headerFontSize);
       doc.setFont("helvetica", "bold");
-      doc.text("Time Range", 25, 188);
-      doc.text("Output", 95, 188);
-      doc.text("Target", 135, 188);
-      doc.text("Status", 170, 188);
+      const baseHeaderY = hasIdleTimeReason ? 208 : 198;
+      const headerY = titleFontSize === 16 ? hasIdleTimeReason ? 206 : 196 : baseHeaderY;
+      doc.text("Time Range", 25, headerY);
+      doc.text("Output", 95, headerY);
+      doc.text("Target", 135, headerY);
+      doc.text("Status", 170, headerY);
       doc.setLineWidth(0.3);
       doc.setDrawColor(200, 200, 200);
-      doc.line(20, 191, 190, 191);
+      const separatorY = headerY + 3;
+      doc.line(20, separatorY, 190, separatorY);
+      doc.setFontSize(contentFontSize);
       doc.setFont("helvetica", "normal");
       let yPos = tableStartY;
       const workspaceDate = new Date(workspace.date);
@@ -45266,6 +46218,10 @@ function HomeView({
   const [diagnosisModalOpen, setDiagnosisModalOpen] = React24.useState(false);
   const [diagnoses, setDiagnoses] = React24.useState([]);
   const timezone = useAppTimezone();
+  const { shiftConfigMap: lineShiftConfigs } = useMultiLineShiftConfigs(
+    allLineIds,
+    dashboardConfig?.shiftConfig
+  );
   React24.useEffect(() => {
     const initDisplayNames = async () => {
       try {
@@ -45290,23 +46246,6 @@ function HomeView({
     loading: displayNamesLoading,
     error: displayNamesError
   } = useWorkspaceDisplayNames(displayNameLineId, void 0);
-  React24.useCallback(() => {
-    console.log("Refetching KPIs after line metrics update");
-  }, []);
-  const {
-    kpis,
-    isLoading: kpisLoading,
-    error: kpisError,
-    refetch: refetchKPIs
-  } = useLineKPIs({
-    lineId: selectedLineId
-  });
-  const onLineMetricsUpdate = React24.useCallback(() => {
-    const timer = setTimeout(() => {
-      refetchKPIs();
-    }, 1e3);
-    return () => clearTimeout(timer);
-  }, [refetchKPIs]);
   const {
     workspaceMetrics,
     lineMetrics,
@@ -45315,10 +46254,22 @@ function HomeView({
     refetch: refetchMetrics
   } = useDashboardMetrics({
     lineId: selectedLineId,
-    onLineMetricsUpdate,
     userAccessibleLineIds: allLineIds
     // Pass user's accessible lines for supervisor filtering
   });
+  const kpis = React24.useMemo(() => {
+    const lineMetricsRows = lineMetrics || [];
+    if (selectedLineId === factoryViewId) {
+      if (metricsLoading && lineMetricsRows.length === 0) return null;
+      return aggregateKPIsFromLineMetricsRows(lineMetricsRows);
+    }
+    const row = lineMetricsRows.find((r2) => r2?.line_id === selectedLineId);
+    if (!row) {
+      if (metricsLoading) return null;
+      return buildKPIsFromLineMetricsRow(null);
+    }
+    return buildKPIsFromLineMetricsRow(row);
+  }, [selectedLineId, factoryViewId, lineMetrics, metricsLoading]);
   const {
     activeBreaks: allActiveBreaks,
     isLoading: breaksLoading,
@@ -45363,12 +46314,18 @@ function HomeView({
             label: "Diagnose",
             onClick: async () => {
               console.log("\u{1F50D} Investigating bottleneck:", bottleneck.log_number);
-              const operationalDate = getOperationalDate(
-                timezone || dashboardConfig.dateTimeConfig?.defaultTimezone || "UTC"
-              );
               const tz = timezone || dashboardConfig.dateTimeConfig?.defaultTimezone || "UTC";
-              const shiftResult = getCurrentShift(tz, dashboardConfig?.shiftConfig);
+              const lineShiftConfig = bottleneck.line_id && lineShiftConfigs.get(bottleneck.line_id);
+              const effectiveShiftConfig = lineShiftConfig || dashboardConfig?.shiftConfig;
+              const shiftResult = getCurrentShift(tz, effectiveShiftConfig);
               const currentShift = shiftResult.shiftId;
+              const operationalDate = shiftResult.date;
+              console.log("\u{1F550} Using shift config for line:", {
+                lineId: bottleneck.line_id,
+                hasLineConfig: !!lineShiftConfig,
+                shiftId: currentShift,
+                date: operationalDate
+              });
               console.log("\u{1F3AC} [Investigate] Opening clips modal with data:", {
                 workspaceId: bottleneck.workspace_id,
                 ticketId: bottleneck.id,
@@ -45438,12 +46395,18 @@ function HomeView({
               state,
               priority: bottleneck.priority
             });
-            const operationalDate = getOperationalDate(
-              timezone || dashboardConfig.dateTimeConfig?.defaultTimezone || "UTC"
-            );
             const tz = timezone || dashboardConfig.dateTimeConfig?.defaultTimezone || "UTC";
-            const shiftResult = getCurrentShift(tz, dashboardConfig?.shiftConfig);
+            const lineShiftConfig = bottleneck.line_id && lineShiftConfigs.get(bottleneck.line_id);
+            const effectiveShiftConfig = lineShiftConfig || dashboardConfig?.shiftConfig;
+            const shiftResult = getCurrentShift(tz, effectiveShiftConfig);
             const currentShift = shiftResult.shiftId;
+            const operationalDate = shiftResult.date;
+            console.log("\u{1F550} Using shift config for line:", {
+              lineId: bottleneck.line_id,
+              hasLineConfig: !!lineShiftConfig,
+              shiftId: currentShift,
+              date: operationalDate
+            });
             setBottleneckModalData({
               workspaceId: bottleneck.workspace_id,
               workspaceName: bottleneck_workspace.workspace_name || "Unknown Workspace",
@@ -45500,7 +46463,7 @@ function HomeView({
       };
       setBottleneckNotification(errorNotification);
     }
-  }, [notificationService, timezone, dashboardConfig]);
+  }, [notificationService, timezone, dashboardConfig, lineShiftConfigs]);
   React24.useEffect(() => {
     const ticketsEnabled = dashboardConfig?.ticketsConfig?.enabled ?? true;
     if (!ticketsEnabled) {
@@ -45625,12 +46588,10 @@ function HomeView({
   React24.useEffect(() => {
     if (metricsError) {
       setErrorMessage(metricsError.message);
-    } else if (kpisError) {
-      setErrorMessage(kpisError.message);
     } else {
       setErrorMessage(null);
     }
-  }, [metricsError, kpisError]);
+  }, [metricsError]);
   const handleLineChange = React24.useCallback((value) => {
     setIsChangingFilter(true);
     setSelectedLineId(value);
@@ -45646,14 +46607,14 @@ function HomeView({
     }
   }, [LINE_FILTER_STORAGE_KEY]);
   React24.useEffect(() => {
-    if (!metricsLoading && !kpisLoading && isChangingFilter) {
+    if (!metricsLoading && isChangingFilter) {
       if (workspaceMetrics.length > 0 || selectedLineId === factoryViewId) {
         setIsChangingFilter(false);
       }
     }
-  }, [metricsLoading, kpisLoading, workspaceMetrics, isChangingFilter, selectedLineId, factoryViewId]);
+  }, [metricsLoading, workspaceMetrics, isChangingFilter, selectedLineId, factoryViewId]);
   React24.useEffect(() => {
-    if (!metricsLoading && !kpisLoading && !hasInitialDataLoaded) {
+    if (!metricsLoading && !hasInitialDataLoaded) {
       setHasInitialDataLoaded(true);
       trackCoreEvent("Home View Loaded", {
         default_line_id: defaultLineId,
@@ -45661,7 +46622,7 @@ function HomeView({
         is_supervisor: isSupervisor
       });
     }
-  }, [metricsLoading, kpisLoading, hasInitialDataLoaded, defaultLineId, factoryViewId, isSupervisor]);
+  }, [metricsLoading, hasInitialDataLoaded, defaultLineId, factoryViewId, isSupervisor]);
   const lineTitle = React24.useMemo(() => {
     return factoryName;
   }, [factoryName]);
@@ -45675,7 +46636,7 @@ function HomeView({
     ] });
   }, [availableLineIds, handleLineChange, selectedLineId, lineNames, factoryViewId, allLineIds.length]);
   const isInitialLoading = !isHydrated || displayNamesLoading || !displayNamesInitialized;
-  const isDataLoading = metricsLoading || kpisLoading;
+  const isDataLoading = metricsLoading;
   if (isInitialLoading) {
     return /* @__PURE__ */ jsxRuntime.jsx(LoadingPageCmp, { message: "Loading Dashboard..." });
   }
@@ -45819,7 +46780,7 @@ function withWorkspaceDisplayNames(Component3, options = {}) {
     const lineIdsKey = React24.useMemo(() => {
       if (!props.lineIds) return "";
       if (Array.isArray(props.lineIds)) {
-        return props.lineIds.sort().join(",");
+        return props.lineIds.slice().sort().join(",");
       }
       const values = Object.values(props.lineIds).filter(Boolean);
       return values.sort().join(",");
@@ -46942,9 +47903,15 @@ var KPIDetailView = ({
 };
 var KPIDetailViewWithDisplayNames = withSelectedLineDisplayNames(KPIDetailView);
 var KPIDetailView_default = KPIDetailViewWithDisplayNames;
-var LineCard = ({ line, onClick, supervisorEnabled = false }) => {
-  const { kpis, isLoading, error } = useLineKPIs({ lineId: line.id });
-  const { supervisorName } = useLineSupervisor(line.id);
+var LineCard = ({
+  line,
+  kpis,
+  isLoading,
+  error,
+  onClick,
+  supervisorEnabled = false,
+  supervisorName
+}) => {
   const isOnTrack = React24__namespace.default.useMemo(() => {
     if (!kpis) return null;
     return kpis.efficiency.value > 90;
@@ -47053,6 +48020,7 @@ var KPIsOverviewView = ({
   const [error, setError] = React24.useState(null);
   const supabase = useSupabase();
   const dashboardConfig = useDashboardConfig();
+  const entityConfig = useEntityConfig();
   const navigation = useNavigation(navigate);
   const dateTimeConfig = useDateTimeConfig();
   const representativeLineId = lineIds?.[0] || lines[0]?.id;
@@ -47060,6 +48028,27 @@ var KPIsOverviewView = ({
   const supervisorEnabled = dashboardConfig?.supervisorConfig?.enabled || false;
   const dbTimezone = useAppTimezone();
   const configuredTimezone = dbTimezone || dateTimeConfig.defaultTimezone || "UTC";
+  const factoryViewId = entityConfig.factoryViewId || "factory";
+  const {
+    lineMetrics,
+    isLoading: metricsLoading,
+    error: metricsError
+  } = useDashboardMetrics({
+    lineId: factoryViewId,
+    userAccessibleLineIds: lineIds
+  });
+  const defaultKPIs = React24__namespace.default.useMemo(() => createDefaultKPIs(), []);
+  const kpisByLineId = React24__namespace.default.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    lineMetrics.forEach((row) => {
+      if (row?.line_id) map.set(row.line_id, buildKPIsFromLineMetricsRow(row));
+    });
+    return map;
+  }, [lineMetrics]);
+  const visibleLineIds = React24__namespace.default.useMemo(() => lines.map((l) => l.id), [lines]);
+  const { supervisorNamesByLineId } = useSupervisorsByLineIds(visibleLineIds, {
+    enabled: supervisorEnabled && visibleLineIds.length > 0
+  });
   React24.useEffect(() => {
     trackCorePageView("KPIs Overview");
   }, []);
@@ -47277,8 +48266,12 @@ var KPIsOverviewView = ({
       LineCard,
       {
         line,
+        kpis: metricsError ? null : kpisByLineId.get(line.id) ?? (metricsLoading ? null : defaultKPIs),
+        isLoading: metricsLoading,
+        error: metricsError,
         onClick: (kpis) => handleLineClick(line, kpis),
-        supervisorEnabled
+        supervisorEnabled,
+        supervisorName: supervisorNamesByLineId.get(line.id) || null
       },
       line.id
     )) }) })
@@ -47443,6 +48436,7 @@ var LeaderboardDetailView = React24.memo(({
   const entityConfig = useEntityConfig();
   const [sortAscending, setSortAscending] = React24.useState(false);
   const timezone = useAppTimezone();
+  const staticShiftConfig = useShiftConfig();
   const [isMobile, setIsMobile] = React24.useState(false);
   React24__namespace.default.useEffect(() => {
     const checkMobile = () => setIsMobile(window.innerWidth < 640);
@@ -47471,9 +48465,27 @@ var LeaderboardDetailView = React24.memo(({
     () => typeof shift === "number" ? shift : typeof shift === "string" ? parseInt(shift) : void 0,
     [shift]
   );
-  const availableLineId = Object.keys(configuredLineNames)[0];
-  const effectiveLineId = lineId || userAccessibleLineIds?.[0] || availableLineId;
-  const { shiftConfig, isLoading: isShiftConfigLoading } = useDynamicShiftConfig(effectiveLineId);
+  const configuredLineIds = React24.useMemo(() => {
+    const allLineIds = getConfiguredLineIds(entityConfig);
+    if (userAccessibleLineIds) {
+      return allLineIds.filter((id3) => userAccessibleLineIds.includes(id3));
+    }
+    return allLineIds;
+  }, [entityConfig, userAccessibleLineIds]);
+  const shouldFetchShiftConfigs = !date && shiftId === void 0;
+  const {
+    shiftConfigMap: multiLineShiftConfigMap,
+    isLoading: isShiftConfigLoading
+  } = useMultiLineShiftConfigs(
+    shouldFetchShiftConfigs ? configuredLineIds : [],
+    staticShiftConfig
+  );
+  const shiftGroups = React24.useMemo(() => {
+    if (!shouldFetchShiftConfigs || isShiftConfigLoading || multiLineShiftConfigMap.size === 0) {
+      return [];
+    }
+    return groupLinesByShift(multiLineShiftConfigMap, timezone || "Asia/Kolkata");
+  }, [shouldFetchShiftConfigs, isShiftConfigLoading, multiLineShiftConfigMap, timezone]);
   const {
     workspaces,
     loading: workspacesLoading,
@@ -47481,21 +48493,28 @@ var LeaderboardDetailView = React24.memo(({
     refreshWorkspaces
   } = useAllWorkspaceMetrics({
     initialDate: date,
-    initialShiftId: typeof shift === "number" ? shift : typeof shift === "string" ? parseInt(shift) : void 0,
+    initialShiftId: shiftId,
     allowedLineIds: userAccessibleLineIds,
-    // Filter to user's accessible lines only
     enabled: !isShiftConfigLoading
-    // Pass enabled flag
   });
   const getShiftName = React24.useCallback((shiftId2) => {
     if (shiftId2 !== void 0) {
-      return getShiftNameById(shiftId2, timezone || "Asia/Kolkata", shiftConfig);
+      return getShiftNameById(shiftId2, timezone || "Asia/Kolkata", staticShiftConfig);
     }
-    const currentShift = getCurrentShift(timezone || "Asia/Kolkata", shiftConfig);
-    return currentShift.shiftName || getShiftNameById(currentShift.shiftId, timezone || "Asia/Kolkata", shiftConfig);
-  }, [timezone, shiftConfig]);
+    if (shiftGroups.length > 1) {
+      const shiftNames = shiftGroups.map((g) => g.shiftName).join(" & ");
+      return shiftNames;
+    } else if (shiftGroups.length === 1) {
+      return shiftGroups[0].shiftName;
+    }
+    const currentShift = getCurrentShift(timezone || "Asia/Kolkata", staticShiftConfig);
+    return currentShift.shiftName || getShiftNameById(currentShift.shiftId, timezone || "Asia/Kolkata", staticShiftConfig);
+  }, [timezone, staticShiftConfig, shiftGroups]);
   const getShiftIcon = React24.useCallback((shiftId2) => {
-    const effectiveShiftId = shiftId2 !== void 0 ? shiftId2 : getCurrentShift(timezone || "Asia/Kolkata", shiftConfig).shiftId;
+    if (shiftId2 === void 0 && shiftGroups.length > 1) {
+      return /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z" }) });
+    }
+    const effectiveShiftId = shiftId2 !== void 0 ? shiftId2 : shiftGroups.length === 1 ? shiftGroups[0].shiftId : getCurrentShift(timezone || "Asia/Kolkata", staticShiftConfig).shiftId;
     const shiftNameLower = getShiftName(effectiveShiftId).toLowerCase();
     if (shiftNameLower.includes("day") || shiftNameLower.includes("morning")) {
       return /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M12 3v1m0 16v1m9-9h-1M4 12H3m15.364 6.364l-.707-.707M6.343 6.343l-.707-.707m12.728 0l-.707.707M6.343 17.657l-.707.707M16 12a4 4 0 11-8 0 4 4 0 018 0z" }) });
@@ -47507,7 +48526,7 @@ var LeaderboardDetailView = React24.memo(({
       return /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M20.354 15.354A9 9 0 018.646 3.646 9.003 9.003 0 0012 21a9.003 9.003 0 008.354-5.646z" }) });
     }
     return /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z" }) });
-  }, [getShiftName]);
+  }, [getShiftName, shiftGroups, timezone, staticShiftConfig]);
   const formatDate2 = React24.useCallback((date2) => {
     return new Intl.DateTimeFormat("en-US", {
       weekday: "long",
@@ -48076,7 +49095,7 @@ var calculateShiftHours = (startTime, endTime, breaks = []) => {
   const hoursDiff = (endMinutes - startMinutes - totalBreakMinutes) / 60;
   return Number(hoursDiff.toFixed(1));
 };
-var calculateBreakDuration = (startTime, endTime) => {
+var calculateBreakDuration2 = (startTime, endTime) => {
   const [startHour, startMinute] = startTime.split(":").map(Number);
   const [endHour, endMinute] = endTime.split(":").map(Number);
   let startMinutes = startHour * 60 + startMinute;
@@ -48092,7 +49111,7 @@ var parseBreaksFromDB = (dbBreaks) => {
     return dbBreaks.map((breakItem) => ({
       startTime: breakItem.start || breakItem.startTime || "00:00",
       endTime: breakItem.end || breakItem.endTime || "00:00",
-      duration: calculateBreakDuration(
+      duration: calculateBreakDuration2(
         breakItem.start || breakItem.startTime || "00:00",
         breakItem.end || breakItem.endTime || "00:00"
       ),
@@ -48102,7 +49121,7 @@ var parseBreaksFromDB = (dbBreaks) => {
     return dbBreaks.breaks.map((breakItem) => ({
       startTime: breakItem.start || breakItem.startTime || "00:00",
       endTime: breakItem.end || breakItem.endTime || "00:00",
-      duration: calculateBreakDuration(
+      duration: calculateBreakDuration2(
         breakItem.start || breakItem.startTime || "00:00",
         breakItem.end || breakItem.endTime || "00:00"
       ),
@@ -48739,6 +49758,13 @@ var ShiftsView = ({
       if (nightResult.error) {
         throw new Error(`Failed to save night shift: ${nightResult.error.message}`);
       }
+      const updatedRows = [
+        ...dayResult.data || [],
+        ...nightResult.data || []
+      ];
+      if (updatedRows.length > 0) {
+        shiftConfigStore.setFromOperatingHoursRows(lineId, updatedRows, shiftConfigStore.get(lineId));
+      }
       setLineConfigs((prev) => prev.map(
         (config) => config.id === lineId ? { ...config, isSaving: false, saveSuccess: true } : config
       ));
@@ -49708,6 +50734,7 @@ var TargetsViewUI = ({
   onUpdateSelectedSKU,
   skuRequired = false
 }) => {
+  const { displayNames: workspaceDisplayNames } = useWorkspaceDisplayNames();
   if (isLoading) {
     return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex h-screen bg-gray-50", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 flex items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(OptifyeLogoLoader_default, { size: "lg", message: "Loading targets..." }) }) });
   }
@@ -49855,7 +50882,7 @@ var TargetsViewUI = ({
                 ] })
               ] }) }),
               /* @__PURE__ */ jsxRuntime.jsx("div", { className: "divide-y divide-gray-100", children: line.workspaces.map((workspace) => {
-                const formattedName = formatWorkspaceName(workspace.name, lineId);
+                const formattedName = workspaceDisplayNames[`${lineId}_${workspace.name}`] || formatWorkspaceName(workspace.name, lineId);
                 return /* @__PURE__ */ jsxRuntime.jsxs(
                   "div",
                   {
@@ -50579,8 +51606,17 @@ var TargetsView = ({
   };
   const handleUpdateWorkspaceDisplayName = React24.useCallback(async (workspaceId, displayName) => {
     try {
-      await workspaceService.updateWorkspaceDisplayName(workspaceId, displayName);
-      await forceRefreshWorkspaceDisplayNames();
+      const updated = await workspaceService.updateWorkspaceDisplayName(workspaceId, displayName);
+      if (updated?.line_id && updated?.workspace_id) {
+        upsertWorkspaceDisplayNameInCache({
+          lineId: updated.line_id,
+          workspaceId: updated.workspace_id,
+          displayName: updated?.display_name || displayName,
+          enabled: updated?.enable
+        });
+      } else {
+        await forceRefreshWorkspaceDisplayNames();
+      }
       sonner.toast.success("Workspace name updated successfully");
     } catch (error) {
       console.error("Error updating workspace display name:", error);
@@ -51259,7 +52295,13 @@ var WorkspaceDetailView = ({
                   }
                 )
               ] }),
-              activeTab === "overview" && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-1.5 lg:gap-2", children: renderHeaderActions ? renderHeaderActions(workspace) : /* @__PURE__ */ jsxRuntime.jsx(WorkspacePdfGenerator, { workspace }) }),
+              activeTab === "overview" && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-1.5 lg:gap-2", children: renderHeaderActions ? renderHeaderActions(workspace) : /* @__PURE__ */ jsxRuntime.jsx(
+                WorkspacePdfGenerator,
+                {
+                  workspace,
+                  idleTimeReasons: idleTimeChartData
+                }
+              ) }),
               activeTab === "monthly_history" && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-1.5 lg:gap-2", children: /* @__PURE__ */ jsxRuntime.jsx(
                 WorkspaceMonthlyPdfGenerator,
                 {
@@ -52314,6 +53356,7 @@ var WorkspaceHealthView = ({
   const [selectedWorkspace, setSelectedWorkspace] = React24.useState(null);
   const [selectedDate, setSelectedDate] = React24.useState(void 0);
   const [selectedShiftId, setSelectedShiftId] = React24.useState(void 0);
+  const [showDatePicker, setShowDatePicker] = React24.useState(false);
   const effectiveTimezone = timezone || "UTC";
   const currentShiftDetails = getCurrentShift(effectiveTimezone, shiftConfig);
   const operationalDate = currentShiftDetails.date;
@@ -52362,28 +53405,6 @@ var WorkspaceHealthView = ({
   const handleCloseDetails = React24.useCallback(() => {
     setSelectedWorkspace(null);
   }, []);
-  const handleExport = React24.useCallback(() => {
-    const csv = [
-      ["Workspace", "Line", "Company", "Status", "Last Heartbeat", "Consecutive Misses"],
-      ...workspaces.map((w) => [
-        w.workspace_display_name || "",
-        w.line_name || "",
-        w.company_name || "",
-        w.status,
-        w.last_heartbeat,
-        w.consecutive_misses?.toString() || "0"
-      ])
-    ].map((row) => row.join(",")).join("\n");
-    const blob = new Blob([csv], { type: "text/csv" });
-    const url = window.URL.createObjectURL(blob);
-    const a = document.createElement("a");
-    a.href = url;
-    a.download = `workspace-health-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.csv`;
-    document.body.appendChild(a);
-    a.click();
-    document.body.removeChild(a);
-    window.URL.revokeObjectURL(url);
-  }, [workspaces]);
   const getStatusIcon = (status) => {
     switch (status) {
       case "healthy":
@@ -52421,104 +53442,42 @@ var WorkspaceHealthView = ({
   }
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: clsx("min-h-screen bg-slate-50", className), children: [
-      /* @__PURE__ */ jsxRuntime.jsxs("header", { className: "sticky top-0 z-10 px-3 sm:px-4 md:px-5 lg:px-6 py-2 sm:py-2.5 lg:py-3 flex flex-col shadow-sm bg-white", children: [
-        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sm:hidden", children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between mb-1", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(
-              BackButtonMinimal,
-              {
-                onClick: () => router$1.push("/"),
-                text: "Back",
-                size: "sm",
-                "aria-label": "Navigate back to dashboard"
-              }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
-              /* @__PURE__ */ jsxRuntime.jsx(
-                "button",
-                {
-                  onClick: () => {
-                    refetch();
-                  },
-                  className: "p-1.5 text-gray-600 hover:bg-gray-100 rounded-lg transition-colors",
-                  "aria-label": "Refresh",
-                  children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: "h-4 w-4" })
-                }
-              ),
-              /* @__PURE__ */ jsxRuntime.jsx(
-                "button",
-                {
-                  onClick: handleExport,
-                  className: "p-1.5 text-gray-600 hover:bg-gray-100 rounded-lg transition-colors",
-                  "aria-label": "Export CSV",
-                  children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Download, { className: "h-4 w-4" })
-                }
-              )
-            ] })
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-center", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-center gap-2", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "text-base font-semibold text-gray-900", children: "System Health" }),
-            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex h-2 w-2", children: [
-              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "animate-ping absolute inline-flex h-full w-full rounded-full bg-emerald-400 opacity-75" }),
-              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "relative inline-flex rounded-full h-2 w-2 bg-emerald-500" })
-            ] })
-          ] }) })
+      /* @__PURE__ */ jsxRuntime.jsx("header", { className: "sticky top-0 z-10 bg-white border-b border-gray-200 shadow-sm", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-4 sm:px-6 lg:px-8 py-4", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-4", children: /* @__PURE__ */ jsxRuntime.jsx(
+          BackButtonMinimal,
+          {
+            onClick: () => router$1.push("/"),
+            text: "Back",
+            size: "default",
+            "aria-label": "Navigate back to dashboard"
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1 flex flex-col items-center", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "text-2xl lg:text-3xl font-semibold text-gray-900 text-center", children: "System Health" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-500 mt-1 text-center", children: "Monitor workspace connectivity and operational status" })
         ] }),
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "hidden sm:block", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex items-center", children: [
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute left-0 z-10", children: /* @__PURE__ */ jsxRuntime.jsx(
-            BackButtonMinimal,
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
             {
-              onClick: () => router$1.push("/"),
-              text: "Back",
-              size: "default",
-              "aria-label": "Navigate back to dashboard"
+              onClick: () => setShowDatePicker(!showDatePicker),
+              className: "p-2 text-gray-600 hover:bg-gray-100 rounded-lg transition-colors",
+              "aria-label": "Select date",
+              children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Calendar, { className: "h-5 w-5" })
             }
-          ) }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute left-1/2 transform -translate-x-1/2 max-w-[calc(100%-200px)]", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "text-lg md:text-xl lg:text-2xl xl:text-3xl font-semibold text-gray-900 truncate", children: "System Health" }),
-            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex h-2.5 w-2.5", children: [
-              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "animate-ping absolute inline-flex h-full w-full rounded-full bg-emerald-400 opacity-75" }),
-              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "relative inline-flex rounded-full h-2.5 w-2.5 bg-emerald-500" })
-            ] })
-          ] }) }),
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "absolute right-0 flex gap-2", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(
-              "button",
-              {
-                onClick: () => {
-                  refetch();
-                },
-                className: "p-2 text-gray-600 hover:bg-gray-100 rounded-lg transition-colors",
-                "aria-label": "Refresh",
-                children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: "h-5 w-5" })
-              }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsx(
-              "button",
-              {
-                onClick: handleExport,
-                className: "p-2 text-gray-600 hover:bg-gray-100 rounded-lg transition-colors",
-                "aria-label": "Export CSV",
-                children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Download, { className: "h-5 w-5" })
-              }
-            )
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-full h-8" })
-        ] }) }),
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-1 sm:mt-2", children: /* @__PURE__ */ jsxRuntime.jsx(
-          HealthDateShiftSelector,
-          {
-            selectedDate: selectedDate || operationalDate,
-            selectedShiftId: selectedShiftId ?? currentShiftDetails.shiftId,
-            shiftConfig,
-            timezone: effectiveTimezone,
-            onDateChange: setSelectedDate,
-            onShiftChange: setSelectedShiftId,
-            isCurrentShift: isViewingCurrentShift,
-            onReturnToLive: handleReturnToLive
-          }
-        ) })
-      ] }),
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              onClick: () => refetch(),
+              disabled: loading,
+              className: "p-2 text-gray-600 hover:bg-gray-100 rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed",
+              "aria-label": "Refresh",
+              children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: `h-5 w-5 ${loading ? "animate-spin" : ""}` })
+            }
+          )
+        ] })
+      ] }) }) }),
       /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "max-w-7xl mx-auto p-4 space-y-6", children: [
         summary && /* @__PURE__ */ jsxRuntime.jsxs(
           motion.div,
@@ -52594,6 +53553,72 @@ var WorkspaceHealthView = ({
         )
       ] })
     ] }),
+    showDatePicker && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "fixed inset-0 bg-black/20 z-40",
+          onClick: () => setShowDatePicker(false)
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "fixed top-20 right-4 md:right-8 z-50 bg-white rounded-lg shadow-xl border border-gray-200 p-4 w-80", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("label", { className: "block text-xs font-medium text-gray-500 mb-2", children: "Select Date" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              type: "date",
+              value: selectedDate || operationalDate,
+              max: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+              onChange: (e) => {
+                setSelectedDate(e.target.value);
+              },
+              className: "w-full px-3 py-2 border border-gray-200 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("label", { className: "block text-xs font-medium text-gray-500 mb-2", children: "Select Shift" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "select",
+            {
+              value: selectedShiftId ?? currentShiftDetails.shiftId,
+              onChange: (e) => setSelectedShiftId(Number(e.target.value)),
+              className: "w-full px-3 py-2 border border-gray-200 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 bg-white",
+              children: (shiftConfig?.shifts || []).map((shift) => /* @__PURE__ */ jsxRuntime.jsxs("option", { value: shift.shiftId, children: [
+                shift.shiftName,
+                " (",
+                shift.startTime,
+                " - ",
+                shift.endTime,
+                ")"
+              ] }, shift.shiftId))
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2 pt-2", children: [
+          !isViewingCurrentShift && /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              onClick: () => {
+                handleReturnToLive();
+                setShowDatePicker(false);
+              },
+              className: "flex-1 px-3 py-2 text-sm text-blue-600 bg-blue-50 rounded-lg hover:bg-blue-100 transition-colors",
+              children: "Return to Live"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              onClick: () => setShowDatePicker(false),
+              className: "flex-1 px-3 py-2 text-sm text-white bg-blue-600 rounded-lg hover:bg-blue-700 transition-colors",
+              children: "Done"
+            }
+          )
+        ] })
+      ] }) })
+    ] }),
     /* @__PURE__ */ jsxRuntime.jsx(
       WorkspaceUptimeDetailModal_default,
       {
@@ -53743,7 +54768,7 @@ function DailyBarChart({
               axisLine: false,
               tick: (props) => {
                 const { x, y, payload } = props;
-                if (payload.value === 0) return null;
+                if (payload.value === 0) return /* @__PURE__ */ jsxRuntime.jsx("g", {});
                 const hours = Math.round(payload.value / (1e3 * 60 * 60) * 10) / 10;
                 return /* @__PURE__ */ jsxRuntime.jsxs("text", { x, y, dy: 4, textAnchor: "end", className: "text-xs fill-gray-400", children: [
                   hours,
@@ -54098,7 +55123,7 @@ var UserManagementTable = ({
             }
           ),
           /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider", children: "Assignments" }),
-          showUsageStats && /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider", children: "Weekly usage" }),
+          showUsageStats && /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider", children: "Average Daily usage" }),
           /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-6 py-3 text-right text-xs font-medium text-gray-500 uppercase tracking-wider", children: "Actions" })
         ] }) }),
         /* @__PURE__ */ jsxRuntime.jsx("tbody", { className: "bg-white divide-y divide-gray-200", children: filteredAndSortedUsers.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("tr", { children: /* @__PURE__ */ jsxRuntime.jsx("td", { colSpan: showUsageStats ? 5 : 4, className: "px-6 py-12", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col items-center justify-center text-gray-400 gap-2", children: [
@@ -54110,12 +55135,25 @@ var UserManagementTable = ({
           const canChangeRole = permissions.canChangeRole(user);
           const canRemove = permissions.canRemoveUser(user);
           const hasActions = canChangeRole || canRemove;
+          const canShowUsageModal = showUsageStats && (user.role_level === "plant_head" || user.role_level === "supervisor");
+          const handleRowClick = (e) => {
+            const target = e.target;
+            if (target.closest("button") || target.closest("select") || target.closest("input") || target.closest('[role="button"]') || target.closest("[data-interactive]")) {
+              return;
+            }
+            if (canShowUsageModal) {
+              setUsageDetailUserId(user.user_id);
+              setShowUsageDetailModal(true);
+            }
+          };
           return /* @__PURE__ */ jsxRuntime.jsxs(
             "tr",
             {
+              onClick: handleRowClick,
               className: cn(
-                "hover:bg-gray-50 transition-colors",
-                isDeactivated && "opacity-60"
+                "transition-all duration-150",
+                isDeactivated && "opacity-60",
+                canShowUsageModal ? "cursor-pointer hover:bg-blue-50/50 hover:shadow-sm" : "hover:bg-gray-50"
               ),
               children: [
                 /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-6 py-4 whitespace-nowrap", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
@@ -54181,10 +55219,7 @@ var UserManagementTable = ({
                       setShowUsageDetailModal(true);
                     },
                     className: "group flex items-center gap-3 hover:bg-gray-50 -mx-2 px-2 py-1.5 rounded-lg transition-all duration-200",
-                    children: isUsageLoading ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "animate-pulse bg-gray-200 h-5 w-20 rounded" }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-                      /* @__PURE__ */ jsxRuntime.jsx("span", { className: `text-base font-semibold ${avgDailyUsage?.[user.user_id] && avgDailyUsage[user.user_id] > 0 ? "text-gray-900 group-hover:text-blue-600" : "text-gray-400"} transition-colors`, children: formatDuration3(avgDailyUsage?.[user.user_id] || 0) }),
-                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ArrowRight, { className: "w-4 h-4 text-gray-400 group-hover:text-blue-600 group-hover:translate-x-0.5 transition-all" })
-                    ] })
+                    children: isUsageLoading ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "animate-pulse bg-gray-200 h-5 w-20 rounded" }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: `text-base font-semibold ${avgDailyUsage?.[user.user_id] && avgDailyUsage[user.user_id] > 0 ? "text-gray-900 group-hover:text-blue-600" : "text-gray-400"} transition-colors`, children: formatDuration3(avgDailyUsage?.[user.user_id] || 0) })
                   }
                 ) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-gray-400", children: "-" }) }),
                 /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-6 py-4 whitespace-nowrap text-right", children: hasActions && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative", children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -54232,25 +55267,50 @@ var UserManagementTable = ({
             children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "py-1", children: [
               (() => {
                 const user = users.find((u) => u.user_id === openActionMenuId);
-                const isCurrentUser = user?.user_id === currentUserId;
-                const canChangeRole = user && permissions.canChangeRole(user);
-                return canChangeRole && /* @__PURE__ */ jsxRuntime.jsxs(
+                const canShowUsage = showUsageStats && user && (user.role_level === "plant_head" || user.role_level === "supervisor");
+                return canShowUsage && /* @__PURE__ */ jsxRuntime.jsxs(
                   "button",
                   {
                     onClick: () => {
                       if (user) {
-                        handleChangeRole(user);
+                        setUsageDetailUserId(user.user_id);
+                        setShowUsageDetailModal(true);
+                        handleCloseActionMenu();
                       }
                     },
-                    className: "w-full px-4 py-2 text-sm text-left text-gray-700 hover:bg-gray-100 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed",
-                    disabled: isCurrentUser,
+                    className: "w-full px-4 py-2 text-sm text-left text-gray-700 hover:bg-gray-100 flex items-center gap-2",
                     children: [
-                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.UserCog, { className: "w-4 h-4" }),
-                      "Change Role"
+                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.BarChart3, { className: "w-4 h-4" }),
+                      "View Detailed Usage"
                     ]
                   }
                 );
               })(),
+              (() => {
+                const user = users.find((u) => u.user_id === openActionMenuId);
+                const isCurrentUser = user?.user_id === currentUserId;
+                const canChangeRole = user && permissions.canChangeRole(user);
+                const canShowUsage = showUsageStats && user && (user.role_level === "plant_head" || user.role_level === "supervisor");
+                return canChangeRole && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                  canShowUsage && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-t border-gray-200 my-1" }),
+                  /* @__PURE__ */ jsxRuntime.jsxs(
+                    "button",
+                    {
+                      onClick: () => {
+                        if (user) {
+                          handleChangeRole(user);
+                        }
+                      },
+                      className: "w-full px-4 py-2 text-sm text-left text-gray-700 hover:bg-gray-100 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed",
+                      disabled: isCurrentUser,
+                      children: [
+                        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.UserCog, { className: "w-4 h-4" }),
+                        "Change Role"
+                      ]
+                    }
+                  )
+                ] });
+              })(),
               (() => {
                 const user = users.find((u) => u.user_id === openActionMenuId);
                 const isCurrentUser = user?.user_id === currentUserId;
@@ -54792,7 +55852,7 @@ var TeamManagementView = ({
     }, {});
   }, [usageData, usageDateRange.daysElapsed]);
   const pageTitle = user?.role_level === "optifye" ? "Platform Users" : "Team Management";
-  const pageDescription = user?.role_level === "optifye" ? "Manage users across all companies" : user?.role_level === "owner" ? "Manage your team members" : "Manage supervisors in your factory";
+  const pageDescription = user?.role_level === "optifye" ? "Manage users across all companies" : user?.role_level === "owner" ? "Manage team members and view their daily usage" : "Manage supervisors in your factory";
   const hasAccess = user ? user.role_level === void 0 || ["optifye", "owner", "plant_head"].includes(user.role_level) : false;
   const loadData = React24.useCallback(async () => {
     if (!supabase) {
@@ -56844,10 +57904,13 @@ exports.WorkspacePdfExportButton = WorkspacePdfExportButton;
 exports.WorkspacePdfGenerator = WorkspacePdfGenerator;
 exports.WorkspaceWhatsAppShareButton = WorkspaceWhatsAppShareButton;
 exports.actionService = actionService;
+exports.aggregateKPIsFromLineMetricsRows = aggregateKPIsFromLineMetricsRows;
 exports.apiUtils = apiUtils;
+exports.areAllLinesOnSameShift = areAllLinesOnSameShift;
 exports.authCoreService = authCoreService;
 exports.authOTPService = authOTPService;
 exports.authRateLimitService = authRateLimitService;
+exports.buildKPIsFromLineMetricsRow = buildKPIsFromLineMetricsRow;
 exports.checkRateLimit = checkRateLimit2;
 exports.clearAllRateLimits = clearAllRateLimits2;
 exports.clearRateLimit = clearRateLimit2;
@@ -56855,6 +57918,7 @@ exports.clearS3VideoCache = clearS3VideoCache;
 exports.clearS3VideoFromCache = clearS3VideoFromCache;
 exports.clearWorkspaceDisplayNamesCache = clearWorkspaceDisplayNamesCache;
 exports.cn = cn;
+exports.createDefaultKPIs = createDefaultKPIs;
 exports.createInvitationService = createInvitationService;
 exports.createLinesService = createLinesService;
 exports.createSessionTracker = createSessionTracker;
@@ -56879,6 +57943,7 @@ exports.fromUrlFriendlyName = fromUrlFriendlyName;
 exports.getAllLineDisplayNames = getAllLineDisplayNames;
 exports.getAllThreadMessages = getAllThreadMessages;
 exports.getAllWorkspaceDisplayNamesAsync = getAllWorkspaceDisplayNamesAsync;
+exports.getAllWorkspaceDisplayNamesSnapshot = getAllWorkspaceDisplayNamesSnapshot;
 exports.getAnonClient = getAnonClient;
 exports.getAvailableShiftIds = getAvailableShiftIds;
 exports.getBrowserName = getBrowserName;
@@ -56890,6 +57955,7 @@ exports.getConfiguredLineIds = getConfiguredLineIds;
 exports.getCoreSessionRecordingProperties = getCoreSessionRecordingProperties;
 exports.getCoreSessionReplayUrl = getCoreSessionReplayUrl;
 exports.getCurrentShift = getCurrentShift;
+exports.getCurrentShiftForLine = getCurrentShiftForLine;
 exports.getCurrentTimeInZone = getCurrentTimeInZone;
 exports.getDashboardHeaderTimeInZone = getDashboardHeaderTimeInZone;
 exports.getDaysDifferenceInZone = getDaysDifferenceInZone;
@@ -56912,6 +57978,7 @@ exports.getShortWorkspaceDisplayNameAsync = getShortWorkspaceDisplayNameAsync;
 exports.getStoredWorkspaceMappings = getStoredWorkspaceMappings;
 exports.getSubscriptionManager = getSubscriptionManager;
 exports.getThreadMessages = getThreadMessages;
+exports.getUniformShiftGroup = getUniformShiftGroup;
 exports.getUserThreads = getUserThreads;
 exports.getUserThreadsPaginated = getUserThreadsPaginated;
 exports.getWorkspaceDisplayName = getWorkspaceDisplayName;
@@ -56919,6 +57986,7 @@ exports.getWorkspaceDisplayNameAsync = getWorkspaceDisplayNameAsync;
 exports.getWorkspaceDisplayNamesMap = getWorkspaceDisplayNamesMap;
 exports.getWorkspaceFromUrl = getWorkspaceFromUrl;
 exports.getWorkspaceNavigationParams = getWorkspaceNavigationParams;
+exports.groupLinesByShift = groupLinesByShift;
 exports.hasAnyShiftData = hasAnyShiftData;
 exports.identifyCoreUser = identifyCoreUser;
 exports.initializeCoreMixpanel = initializeCoreMixpanel;
@@ -56960,12 +58028,14 @@ exports.startCoreSessionRecording = startCoreSessionRecording;
 exports.stopCoreSessionRecording = stopCoreSessionRecording;
 exports.storeWorkspaceMapping = storeWorkspaceMapping;
 exports.streamProxyConfig = streamProxyConfig;
+exports.subscribeWorkspaceDisplayNames = subscribeWorkspaceDisplayNames;
 exports.throttledReloadDashboard = throttledReloadDashboard;
 exports.toUrlFriendlyName = toUrlFriendlyName;
 exports.trackCoreEvent = trackCoreEvent;
 exports.trackCorePageView = trackCorePageView;
 exports.transformToChartData = transformToChartData;
 exports.updateThreadTitle = updateThreadTitle;
+exports.upsertWorkspaceDisplayNameInCache = upsertWorkspaceDisplayNameInCache;
 exports.useAccessControl = useAccessControl;
 exports.useActiveBreaks = useActiveBreaks;
 exports.useActiveLineId = useActiveLineId;
@@ -57029,6 +58099,7 @@ exports.useSubscriptionManager = useSubscriptionManager;
 exports.useSubscriptionManagerSafe = useSubscriptionManagerSafe;
 exports.useSupabase = useSupabase;
 exports.useSupabaseClient = useSupabaseClient;
+exports.useSupervisorsByLineIds = useSupervisorsByLineIds;
 exports.useTargets = useTargets;
 exports.useTeamManagementPermissions = useTeamManagementPermissions;
 exports.useTheme = useTheme;