@optifye/dashboard-core 6.12.49 → 6.12.51

package/dist/index.js

@@ -6085,6 +6085,10 @@ var workspaceService = {
   _workspaceCameraIpsInFlight: /* @__PURE__ */ new Map(),
   _workspaceCameraIpsCacheExpiryMs: 5 * 60 * 1e3,
   // 5 minutes cache
+  // Cache for workspace bulb IP configs
+  _workspaceLightConfigsCache: /* @__PURE__ */ new Map(),
+  _workspaceLightConfigsInFlight: /* @__PURE__ */ new Map(),
+  _workspaceLightConfigsCacheExpiryMs: 5 * 60 * 1e3,
   async getWorkspaces(lineId, options) {
     const enabledOnly = options?.enabledOnly ?? false;
     const force = options?.force ?? false;
@@ -6262,6 +6266,61 @@ var workspaceService = {
     this._workspaceCameraIpsInFlight.set(cacheKey, fetchPromise);
     return fetchPromise;
   },
+  async getWorkspaceLightConfigs(params) {
+    const workspaceIds = (params.workspaceIds || []).filter(Boolean);
+    const lineIds = (params.lineIds || []).filter(Boolean);
+    const force = params.force ?? false;
+    if (!workspaceIds.length && !lineIds.length) {
+      return {};
+    }
+    const workspaceKey = workspaceIds.slice().sort().join(",");
+    const lineKey = lineIds.slice().sort().join(",");
+    const cacheKey = workspaceKey ? `workspaces:${workspaceKey}` : `lines:${lineKey}`;
+    const now4 = Date.now();
+    const cached = this._workspaceLightConfigsCache.get(cacheKey);
+    if (!force && cached && now4 - cached.timestamp < this._workspaceLightConfigsCacheExpiryMs) {
+      return cached.lightConfigs;
+    }
+    const inFlight = this._workspaceLightConfigsInFlight.get(cacheKey);
+    if (!force && inFlight) {
+      return inFlight;
+    }
+    const fetchPromise = (async () => {
+      try {
+        const token = await getAuthToken2();
+        const apiUrl = getBackendUrl2();
+        const response = await fetch(`${apiUrl}/api/workspaces/light-configs`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            workspace_ids: workspaceIds.length ? workspaceIds : void 0,
+            line_ids: lineIds.length ? lineIds : void 0
+          })
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Backend API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        const lightConfigs = data.light_configs || {};
+        this._workspaceLightConfigsCache.set(cacheKey, {
+          lightConfigs,
+          timestamp: Date.now()
+        });
+        return lightConfigs;
+      } catch (error) {
+        console.error("Error fetching workspace light configs:", error);
+        throw error;
+      } finally {
+        this._workspaceLightConfigsInFlight.delete(cacheKey);
+      }
+    })();
+    this._workspaceLightConfigsInFlight.set(cacheKey, fetchPromise);
+    return fetchPromise;
+  },
   /**
    * Fetches workspace display names from the database
    * Returns a map of workspace_id -> display_name
@@ -6682,6 +6741,138 @@ var computeWorkspaceHealthSummary = (data, lastUpdated = (/* @__PURE__ */ new Da
     lastUpdated
   };
 };
+var normalizeHourBucket = (bucket) => {
+  if (Array.isArray(bucket)) return bucket;
+  if (bucket && typeof bucket === "object" && "values" in bucket && Array.isArray(bucket.values)) {
+    return bucket.values;
+  }
+  return void 0;
+};
+var normalizeOutputHourly = (outputHourlyRaw) => outputHourlyRaw && typeof outputHourlyRaw === "object" ? Object.fromEntries(
+  Object.entries(outputHourlyRaw).map(([key, value]) => [key, normalizeHourBucket(value) || []])
+) : {};
+var interpretUptimeValue = (value) => {
+  if (value === null || value === void 0) return "down";
+  if (typeof value === "string") {
+    return value.trim().toLowerCase() === "x" ? "down" : "up";
+  }
+  return "up";
+};
+var deriveStatusForMinute = (minuteOffset, minuteDate, outputHourly, outputArray, timezone) => {
+  const hourKey = dateFnsTz.formatInTimeZone(minuteDate, timezone, "H");
+  const minuteKey = Number.parseInt(dateFnsTz.formatInTimeZone(minuteDate, timezone, "m"), 10);
+  const hourBucket = outputHourly[hourKey];
+  if (Array.isArray(hourBucket)) {
+    const value = hourBucket[minuteKey];
+    if (value !== void 0) {
+      return interpretUptimeValue(value);
+    }
+  }
+  if (minuteOffset < outputArray.length) {
+    return interpretUptimeValue(outputArray[minuteOffset]);
+  }
+  return "down";
+};
+var hasCompletedTimelineData = (completedMinutes, shiftStartDate, outputHourly, outputArray, timezone) => {
+  if (completedMinutes <= 0) {
+    return false;
+  }
+  for (let minuteIndex = 0; minuteIndex < completedMinutes; minuteIndex += 1) {
+    const minuteDate = dateFns.addMinutes(shiftStartDate, minuteIndex);
+    const hourKey = dateFnsTz.formatInTimeZone(minuteDate, timezone, "H");
+    const minuteKey = Number.parseInt(dateFnsTz.formatInTimeZone(minuteDate, timezone, "m"), 10);
+    const hourBucket = outputHourly[hourKey];
+    if (Array.isArray(hourBucket) && hourBucket[minuteKey] !== void 0) {
+      return true;
+    }
+    if (minuteIndex < outputArray.length) {
+      return true;
+    }
+  }
+  return false;
+};
+var computeWorkspaceUptime = ({
+  totalMinutes,
+  completedMinutes,
+  shiftStartDate,
+  outputHourly,
+  outputArray,
+  timezone
+}) => {
+  const hasData = hasCompletedTimelineData(
+    completedMinutes,
+    shiftStartDate,
+    outputHourly,
+    outputArray,
+    timezone
+  );
+  if (!hasData) {
+    return {
+      hasData: false,
+      uptimeMinutes: 0,
+      downtimeMinutes: 0,
+      uptimePercentage: 0,
+      points: [],
+      downtimeSegments: []
+    };
+  }
+  const points = [];
+  let uptimeMinutes = 0;
+  let downtimeMinutes = 0;
+  for (let minuteIndex = 0; minuteIndex < totalMinutes; minuteIndex += 1) {
+    const minuteDate = dateFns.addMinutes(shiftStartDate, minuteIndex);
+    const timestamp = dateFnsTz.formatInTimeZone(minuteDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX");
+    const status = minuteIndex < completedMinutes ? deriveStatusForMinute(minuteIndex, minuteDate, outputHourly, outputArray, timezone) : "pending";
+    if (status === "up") {
+      uptimeMinutes += 1;
+    } else if (status === "down") {
+      downtimeMinutes += 1;
+    }
+    points.push({
+      minuteIndex,
+      timestamp,
+      status
+    });
+  }
+  const downtimeSegments = [];
+  let currentSegmentStart = null;
+  const pushSegment = (startIndex, endIndex) => {
+    if (endIndex <= startIndex) return;
+    const segmentStartDate = dateFns.addMinutes(shiftStartDate, startIndex);
+    const segmentEndDate = dateFns.addMinutes(shiftStartDate, endIndex);
+    downtimeSegments.push({
+      startMinuteIndex: startIndex,
+      endMinuteIndex: endIndex,
+      startTime: dateFnsTz.formatInTimeZone(segmentStartDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+      endTime: dateFnsTz.formatInTimeZone(segmentEndDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+      durationMinutes: endIndex - startIndex
+    });
+  };
+  for (let minuteIndex = 0; minuteIndex < completedMinutes; minuteIndex += 1) {
+    const point = points[minuteIndex];
+    if (point.status === "down") {
+      if (currentSegmentStart === null) {
+        currentSegmentStart = minuteIndex;
+      }
+    } else if (currentSegmentStart !== null) {
+      pushSegment(currentSegmentStart, minuteIndex);
+      currentSegmentStart = null;
+    }
+  }
+  if (currentSegmentStart !== null) {
+    pushSegment(currentSegmentStart, completedMinutes);
+  }
+  const completedWindow = Math.max(1, uptimeMinutes + downtimeMinutes);
+  const uptimePercentage = completedMinutes > 0 ? Number((uptimeMinutes / completedWindow * 100).toFixed(1)) : 100;
+  return {
+    hasData: true,
+    uptimeMinutes,
+    downtimeMinutes,
+    uptimePercentage,
+    points,
+    downtimeSegments
+  };
+};
 
 // src/lib/services/workspaceHealthService.ts
 var DATA_PROCESSING_DELAY_MINUTES = 5;
@@ -6708,6 +6899,92 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
   setCache(key, data) {
     this.cache.set(key, { data, timestamp: Date.now() });
   }
+  hasBackendUrl() {
+    return Boolean(process.env.NEXT_PUBLIC_BACKEND_URL);
+  }
+  async fetchBackendWorkspaceUptimeSummaries(companyId, lineIds, date, shiftId, timezone) {
+    if (!this.hasBackendUrl()) {
+      return null;
+    }
+    const supabase = _getSupabaseInstance();
+    if (!supabase) throw new Error("Supabase client not initialized");
+    const params = new URLSearchParams({
+      company_id: companyId,
+      date,
+      shift_id: String(shiftId),
+      timezone
+    });
+    const filteredLineIds = (lineIds || []).filter(Boolean);
+    if (filteredLineIds.length > 0) {
+      params.set("line_ids", filteredLineIds.join(","));
+    }
+    const cacheKey = `backend-uptime-summary:${companyId}:${filteredLineIds.join(",") || "all"}:${date}:${shiftId}:${timezone}`;
+    const cached = this.getFromCache(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    try {
+      const response = await fetchBackendJson(
+        supabase,
+        `/api/dashboard/workspace-uptime?${params.toString()}`,
+        {
+          retries: 1,
+          timeoutMs: 15e3,
+          sentry: {
+            capture: true,
+            surface: "workspace_health",
+            route: "GET /api/dashboard/workspace-uptime",
+            severity: "warning",
+            quotaKey: "workspace-health-uptime-summary"
+          }
+        }
+      );
+      const uptimeMap = /* @__PURE__ */ new Map();
+      for (const entry of response.uptimes || []) {
+        if (!entry.workspaceId || !entry.uptimeDetails) continue;
+        uptimeMap.set(this.getUptimeMapKey(entry.lineId, entry.workspaceId), entry.uptimeDetails);
+      }
+      this.setCache(cacheKey, uptimeMap);
+      return uptimeMap;
+    } catch (error) {
+      console.warn("[workspaceHealthService] Backend uptime summary failed; using frontend fallback", error);
+      return null;
+    }
+  }
+  async fetchBackendWorkspaceUptimeTimeline(workspaceId, companyId, lineId, date, shiftId, timezone) {
+    if (!this.hasBackendUrl()) {
+      return null;
+    }
+    const supabase = _getSupabaseInstance();
+    if (!supabase) throw new Error("Supabase client not initialized");
+    const params = new URLSearchParams({
+      company_id: companyId,
+      line_id: lineId,
+      date,
+      shift_id: String(shiftId),
+      timezone
+    });
+    try {
+      return await fetchBackendJson(
+        supabase,
+        `/api/dashboard/workspace/${workspaceId}/uptime-timeline?${params.toString()}`,
+        {
+          retries: 1,
+          timeoutMs: 15e3,
+          sentry: {
+            capture: true,
+            surface: "workspace_health",
+            route: "GET /api/dashboard/workspace/{workspace_id}/uptime-timeline",
+            severity: "warning",
+            quotaKey: "workspace-health-uptime-timeline"
+          }
+        }
+      );
+    } catch (error) {
+      console.warn("[workspaceHealthService] Backend uptime timeline failed; using frontend fallback", error);
+      return null;
+    }
+  }
   getShiftTiming(timezone, shiftConfig) {
     const currentShift = getCurrentShift(timezone, shiftConfig);
     const { shiftId, date, shiftName, startTime, endTime } = currentShift;
@@ -6791,15 +7068,21 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
       pendingMinutes
     };
   }
-  normalizeHourBucket(bucket) {
-    if (Array.isArray(bucket)) return bucket;
-    if (bucket && Array.isArray(bucket.values)) return bucket.values;
-    return void 0;
-  }
-  normalizeOutputHourly(outputHourlyRaw) {
-    return outputHourlyRaw && typeof outputHourlyRaw === "object" ? Object.fromEntries(
-      Object.entries(outputHourlyRaw).map(([key, value]) => [key, this.normalizeHourBucket(value) || []])
-    ) : {};
+  mergeOutputArrayValues(values) {
+    const numericValues = values.filter(
+      (value) => typeof value === "number" && Number.isFinite(value)
+    );
+    if (numericValues.length > 0) {
+      const total = numericValues.reduce((sum, value) => sum + value, 0);
+      return Number.isInteger(total) ? total : total;
+    }
+    if (values.length > 0 && values.every((value) => typeof value === "string" && value.trim().toLowerCase() === "x")) {
+      return "x";
+    }
+    if (values.some((value) => value === null || value === void 0)) {
+      return null;
+    }
+    return 0;
   }
   /**
    * Group multi-SKU `performance_metrics` rows by workspace and merge their
@@ -6833,21 +7116,16 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
       const primary = group[0];
       const mergedOutputHourly = mergeOutputHourly(
         group.map((record) => ({
-          output_hourly: this.normalizeOutputHourly(record.output_hourly || {})
+          output_hourly: normalizeOutputHourly(record.output_hourly || {})
         }))
       );
       const arrays = group.map((record) => Array.isArray(record.output_array) ? record.output_array : []).filter((arr) => arr.length > 0);
       let mergedArray = [];
       if (arrays.length > 0) {
         const maxLen = arrays.reduce((acc, arr) => Math.max(acc, arr.length), 0);
-        mergedArray = new Array(maxLen).fill(0);
         for (let i = 0; i < maxLen; i += 1) {
-          let sum = 0;
-          for (const arr of arrays) {
-            const value = i < arr.length ? arr[i] : 0;
-            if (typeof value === "number" && Number.isFinite(value)) sum += value;
-          }
-          mergedArray[i] = sum;
+          const values = arrays.filter((arr) => i < arr.length).map((arr) => arr[i]);
+          mergedArray[i] = this.mergeOutputArrayValues(values);
         }
       }
       return {
@@ -6857,45 +7135,392 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
       };
     });
   }
-  interpretUptimeValue(value) {
-    if (value === null || value === void 0) return "down";
-    if (typeof value === "string") {
-      return value.trim().toLowerCase() === "x" ? "down" : "up";
+  parseShiftTime(value) {
+    const [hourPart = "0", minutePart = "0"] = String(value || "00:00").split(":");
+    const hour = Number.parseInt(hourPart, 10);
+    const minute = Number.parseInt(minutePart, 10);
+    return {
+      hour: Number.isFinite(hour) ? hour : 0,
+      minute: Number.isFinite(minute) ? minute : 0
+    };
+  }
+  getShiftDurationMinutes(startTime, endTime) {
+    const start = this.parseShiftTime(startTime);
+    const end = this.parseShiftTime(endTime);
+    let duration = end.hour * 60 + end.minute - (start.hour * 60 + start.minute);
+    if (duration <= 0) {
+      duration += 24 * 60;
     }
-    return "up";
+    return duration;
   }
-  deriveStatusForMinute(minuteOffset, minuteDate, outputHourly, outputArray, timezone) {
-    const hourKey = dateFnsTz.formatInTimeZone(minuteDate, timezone, "H");
-    const minuteKey = Number.parseInt(dateFnsTz.formatInTimeZone(minuteDate, timezone, "m"), 10);
-    const hourBucket = outputHourly[hourKey];
-    if (Array.isArray(hourBucket)) {
-      const value = hourBucket[minuteKey];
-      if (value !== void 0) {
-        return this.interpretUptimeValue(value);
+  resolveLightShiftWindow(shiftConfig, timezone, overrideDate, overrideShiftId, now4 = /* @__PURE__ */ new Date()) {
+    const currentShift = getCurrentShift(timezone, shiftConfig);
+    const queryDate = overrideDate ?? currentShift.date;
+    const queryShiftId = overrideShiftId ?? currentShift.shiftId;
+    const targetShiftConfig = shiftConfig?.shifts?.find((shift) => shift.shiftId === queryShiftId);
+    const startTime = targetShiftConfig?.startTime || currentShift.startTime || "06:00";
+    const endTime = targetShiftConfig?.endTime || currentShift.endTime || "18:00";
+    const shiftLabel = targetShiftConfig?.shiftName || targetShiftConfig?.name || currentShift.shiftName || `Shift ${queryShiftId}`;
+    const shiftStartDate = dateFnsTz.fromZonedTime(`${queryDate}T${startTime}:00`, timezone);
+    const totalMinutes = this.getShiftDurationMinutes(startTime, endTime);
+    const shiftEndDate = dateFns.addMinutes(shiftStartDate, totalMinutes);
+    const boundedWindowEnd = new Date(Math.min(Math.max(now4.getTime(), shiftStartDate.getTime()), shiftEndDate.getTime()));
+    const completedMinutes = Math.max(
+      0,
+      Math.min(totalMinutes, Math.floor((boundedWindowEnd.getTime() - shiftStartDate.getTime()) / 6e4))
+    );
+    return {
+      shiftId: queryShiftId,
+      shiftLabel,
+      shiftStartDate,
+      shiftEndDate,
+      windowEndDate: boundedWindowEnd,
+      totalMinutes,
+      completedMinutes,
+      pendingMinutes: Math.max(0, totalMinutes - completedMinutes)
+    };
+  }
+  isLightStatus(status) {
+    return status === "up" || status === "down" || status === "unknown";
+  }
+  secondsBetween(start, end) {
+    return Math.max(0, Math.round((end.getTime() - start.getTime()) / 1e3));
+  }
+  roundPercent(value) {
+    return Number(value.toFixed(1));
+  }
+  emptyLightTimeline(shiftWindow, timezone, bulbIp = null) {
+    return {
+      shiftId: shiftWindow.shiftId,
+      shiftLabel: shiftWindow.shiftLabel,
+      shiftStart: dateFnsTz.formatInTimeZone(shiftWindow.shiftStartDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+      shiftEnd: dateFnsTz.formatInTimeZone(shiftWindow.shiftEndDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+      totalMinutes: shiftWindow.totalMinutes,
+      completedMinutes: shiftWindow.completedMinutes,
+      upSeconds: 0,
+      downSeconds: 0,
+      unknownSeconds: 0,
+      totalObservedSeconds: 0,
+      downtimeSeconds: 0,
+      uptimePercentage: null,
+      hasData: false,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      bulbIp,
+      points: [],
+      statusSegments: []
+    };
+  }
+  async resolveWorkspaceLightConfigs(workspaces) {
+    const supabase = _getSupabaseInstance();
+    if (!supabase) throw new Error("Supabase client not initialized");
+    const visibleWorkspaces = workspaces.filter((workspace) => workspace.workspace_id);
+    if (!visibleWorkspaces.length) return /* @__PURE__ */ new Map();
+    const workspaceIds = Array.from(new Set(visibleWorkspaces.map((workspace) => String(workspace.workspace_id))));
+    const configs = /* @__PURE__ */ new Map();
+    if (process.env.NEXT_PUBLIC_BACKEND_URL) {
+      try {
+        const backendConfigs = await workspaceService.getWorkspaceLightConfigs({ workspaceIds });
+        for (const [workspaceId, config] of Object.entries(backendConfigs)) {
+          if (!config?.bulb_ip) continue;
+          configs.set(workspaceId, {
+            healthWorkspaceId: workspaceId,
+            lineId: config.line_id,
+            workspaceDbId: config.workspace_id || workspaceId,
+            bulbIp: String(config.bulb_ip)
+          });
+        }
+        if (configs.size === workspaceIds.length) {
+          return configs;
+        }
+      } catch (error) {
+        console.error("[workspaceHealthService] Backend light config lookup failed, falling back to direct Supabase:", error);
       }
     }
-    if (minuteOffset < outputArray.length) {
-      return this.interpretUptimeValue(outputArray[minuteOffset]);
+    const unresolvedVisibleWorkspaces = visibleWorkspaces.filter(
+      (workspace) => !configs.has(String(workspace.workspace_id))
+    );
+    if (!unresolvedVisibleWorkspaces.length) return configs;
+    const fallbackWorkspaceIds = Array.from(new Set(unresolvedVisibleWorkspaces.map((workspace) => String(workspace.workspace_id))));
+    const fallbackLineIds = Array.from(new Set(unresolvedVisibleWorkspaces.map((workspace) => workspace.line_id).filter(Boolean).map(String)));
+    const fallbackVisiblePairs = new Set(unresolvedVisibleWorkspaces.map((workspace) => `${workspace.line_id || ""}::${workspace.workspace_id}`));
+    let workspaceRows = [];
+    try {
+      let query = supabase.from("workspaces").select("id, workspace_id, line_id, enable_bulb_light").in("workspace_id", fallbackWorkspaceIds);
+      if (fallbackLineIds.length) {
+        query = query.in("line_id", fallbackLineIds);
+      }
+      const { data, error } = await query;
+      if (error) throw error;
+      workspaceRows = Array.isArray(data) ? data : [];
+    } catch (error) {
+      console.error("[workspaceHealthService] Error resolving light workspace rows:", error);
+      return configs;
+    }
+    const dbIdToVisible = /* @__PURE__ */ new Map();
+    for (const row of workspaceRows) {
+      const healthWorkspaceId = row?.workspace_id ? String(row.workspace_id) : "";
+      const lineId = row?.line_id ? String(row.line_id) : "";
+      const dbId = row?.id ? String(row.id) : "";
+      if (!healthWorkspaceId || !dbId) continue;
+      if (fallbackLineIds.length && !fallbackVisiblePairs.has(`${lineId}::${healthWorkspaceId}`)) continue;
+      if (row?.enable_bulb_light === false) continue;
+      dbIdToVisible.set(dbId, { healthWorkspaceId, lineId });
+    }
+    const addMapping = (mapping, visible, workspaceDbId) => {
+      const bulbIp = mapping?.bulb_ip ? String(mapping.bulb_ip).trim() : "";
+      if (!bulbIp) return;
+      configs.set(visible.healthWorkspaceId, {
+        healthWorkspaceId: visible.healthWorkspaceId,
+        lineId: visible.lineId,
+        workspaceDbId,
+        bulbIp
+      });
+    };
+    const dbIds = Array.from(dbIdToVisible.keys());
+    if (dbIds.length) {
+      const { data, error } = await supabase.from("workspace_ip_mapping").select("workspace_id, bulb_ip").in("workspace_id", dbIds);
+      if (!error && Array.isArray(data)) {
+        for (const mapping of data) {
+          const dbId = mapping?.workspace_id ? String(mapping.workspace_id) : "";
+          const visible = dbIdToVisible.get(dbId);
+          if (visible) addMapping(mapping, visible, dbId);
+        }
+      } else if (error) {
+        console.error("[workspaceHealthService] Error resolving light IP mappings:", error);
+      }
+    }
+    const unresolvedVisibleIds = fallbackWorkspaceIds.filter((workspaceId) => !configs.has(workspaceId));
+    if (unresolvedVisibleIds.length) {
+      const visibleById = new Map(unresolvedVisibleWorkspaces.map((workspace) => [
+        String(workspace.workspace_id),
+        { healthWorkspaceId: String(workspace.workspace_id), lineId: workspace.line_id }
+      ]));
+      const { data, error } = await supabase.from("workspace_ip_mapping").select("workspace_id, bulb_ip").in("workspace_id", unresolvedVisibleIds);
+      if (!error && Array.isArray(data)) {
+        for (const mapping of data) {
+          const workspaceId = mapping?.workspace_id ? String(mapping.workspace_id) : "";
+          const visible = visibleById.get(workspaceId);
+          if (visible) addMapping(mapping, visible, null);
+        }
+      }
+    }
+    return configs;
+  }
+  async fetchLightIntervals(bulbIps, windowStart, windowEnd) {
+    if (!bulbIps.length || windowEnd <= windowStart) return [];
+    const supabase = _getSupabaseInstance();
+    if (!supabase) throw new Error("Supabase client not initialized");
+    const { data, error } = await supabase.from("factory_light_status_intervals").select("workspace_id, bulb_ip, status, started_at, ended_at, last_seen_at, last_error").in("bulb_ip", bulbIps).lt("started_at", windowEnd.toISOString()).or(`ended_at.is.null,ended_at.gt.${windowStart.toISOString()}`);
+    if (error) {
+      console.error("[workspaceHealthService] Error fetching light status intervals:", error);
+      throw error;
     }
-    return "down";
+    return Array.isArray(data) ? data : [];
   }
-  hasCompletedTimelineData(completedMinutes, shiftStartDate, outputHourly, outputArray, timezone) {
-    if (completedMinutes <= 0) {
-      return false;
+  getLightIntervalEffectiveRange(interval, windowStart, windowEnd) {
+    const startedAt = new Date(interval.started_at);
+    const endedAt = interval.ended_at ? new Date(interval.ended_at) : windowEnd;
+    const effectiveStart = new Date(Math.max(startedAt.getTime(), windowStart.getTime()));
+    const effectiveEnd = new Date(Math.min(endedAt.getTime(), windowEnd.getTime()));
+    if (effectiveEnd <= effectiveStart) return null;
+    return {
+      start: effectiveStart,
+      end: effectiveEnd,
+      seconds: this.secondsBetween(effectiveStart, effectiveEnd)
+    };
+  }
+  summarizeLightIntervals(intervals, windowStart, windowEnd, now4) {
+    let upSeconds = 0;
+    let downSeconds = 0;
+    let unknownSeconds = 0;
+    let currentInterval = null;
+    for (const interval of intervals) {
+      if (!this.isLightStatus(interval.status)) continue;
+      const range = this.getLightIntervalEffectiveRange(interval, windowStart, windowEnd);
+      if (!range) continue;
+      if (interval.status === "up") upSeconds += range.seconds;
+      if (interval.status === "down") downSeconds += range.seconds;
+      if (interval.status === "unknown") unknownSeconds += range.seconds;
+      if (interval.ended_at == null) {
+        currentInterval = interval;
+      }
+    }
+    const totalObservedSeconds = upSeconds + downSeconds + unknownSeconds;
+    return {
+      hasLightConfig: true,
+      bulbIp: null,
+      currentStatus: this.isLightStatus(currentInterval?.status) ? currentInterval.status : null,
+      currentStartedAt: currentInterval?.started_at || null,
+      lastSeenAt: currentInterval?.last_seen_at || null,
+      currentDurationSeconds: currentInterval?.started_at ? this.secondsBetween(new Date(currentInterval.started_at), now4) : null,
+      lastError: currentInterval?.last_error || null,
+      uptimePercent: totalObservedSeconds > 0 ? this.roundPercent(upSeconds / totalObservedSeconds * 100) : null,
+      upSeconds,
+      downSeconds,
+      unknownSeconds,
+      totalObservedSeconds
+    };
+  }
+  async summarizeResolvedLightConfigs(configs, shiftWindow, now4) {
+    if (!configs.size) return /* @__PURE__ */ new Map();
+    const bulbIps = Array.from(new Set(Array.from(configs.values()).map((config) => config.bulbIp)));
+    const intervals = await this.fetchLightIntervals(bulbIps, shiftWindow.shiftStartDate, shiftWindow.windowEndDate);
+    const intervalsByBulb = /* @__PURE__ */ new Map();
+    for (const interval of intervals) {
+      const bulbIp = interval.bulb_ip ? String(interval.bulb_ip) : "";
+      if (!bulbIp) continue;
+      if (!intervalsByBulb.has(bulbIp)) intervalsByBulb.set(bulbIp, []);
+      intervalsByBulb.get(bulbIp).push(interval);
+    }
+    const summaries = /* @__PURE__ */ new Map();
+    for (const config of configs.values()) {
+      const summary = this.summarizeLightIntervals(
+        intervalsByBulb.get(config.bulbIp) || [],
+        shiftWindow.shiftStartDate,
+        shiftWindow.windowEndDate,
+        now4
+      );
+      summaries.set(config.healthWorkspaceId, {
+        ...summary,
+        hasLightConfig: true,
+        bulbIp: config.bulbIp
+      });
     }
-    for (let minuteIndex = 0; minuteIndex < completedMinutes; minuteIndex++) {
-      const minuteDate = dateFns.addMinutes(shiftStartDate, minuteIndex);
-      const hourKey = dateFnsTz.formatInTimeZone(minuteDate, timezone, "H");
-      const minuteKey = Number.parseInt(dateFnsTz.formatInTimeZone(minuteDate, timezone, "m"), 10);
-      const hourBucket = outputHourly[hourKey];
-      if (Array.isArray(hourBucket) && hourBucket[minuteKey] !== void 0) {
-        return true;
+    return summaries;
+  }
+  async getWorkspaceLightSummaries(workspaces, passedShiftConfig, passedTimezone, overrideDate, overrideShiftId, now4 = /* @__PURE__ */ new Date(), lineShiftConfigs) {
+    const dashboardConfig = _getDashboardConfigInstance();
+    const shiftConfig = passedShiftConfig || dashboardConfig?.shiftConfig;
+    const timezone = passedTimezone || shiftConfig?.timezone || dashboardConfig?.dateTimeConfig?.defaultTimezone || "UTC";
+    if (lineShiftConfigs && lineShiftConfigs.size > 0) {
+      const resolvedConfigs = await this.resolveWorkspaceLightConfigs(workspaces);
+      if (!resolvedConfigs.size) return /* @__PURE__ */ new Map();
+      const groupedByLine = /* @__PURE__ */ new Map();
+      const fallbackConfigs = /* @__PURE__ */ new Map();
+      for (const workspace of workspaces) {
+        const workspaceId = workspace.workspace_id ? String(workspace.workspace_id) : "";
+        const config = workspaceId ? resolvedConfigs.get(workspaceId) : null;
+        if (!config) continue;
+        const lineId = workspace.line_id ? String(workspace.line_id) : "";
+        const lineShiftConfig = lineId ? lineShiftConfigs.get(lineId) : null;
+        if (!lineId || !lineShiftConfig) {
+          fallbackConfigs.set(config.healthWorkspaceId, config);
+          continue;
+        }
+        if (!groupedByLine.has(lineId)) groupedByLine.set(lineId, /* @__PURE__ */ new Map());
+        groupedByLine.get(lineId).set(config.healthWorkspaceId, config);
       }
-      if (minuteIndex < outputArray.length) {
-        return true;
+      const summaries = /* @__PURE__ */ new Map();
+      const summaryPromises = Array.from(groupedByLine.entries()).map(async ([lineId, lineConfigs]) => {
+        const lineShiftWindow = this.resolveLightShiftWindow(
+          lineShiftConfigs.get(lineId),
+          timezone,
+          overrideDate,
+          overrideShiftId,
+          now4
+        );
+        return this.summarizeResolvedLightConfigs(lineConfigs, lineShiftWindow, now4);
+      });
+      if (fallbackConfigs.size > 0) {
+        const fallbackShiftWindow = this.resolveLightShiftWindow(
+          shiftConfig,
+          timezone,
+          overrideDate,
+          overrideShiftId,
+          now4
+        );
+        summaryPromises.push(this.summarizeResolvedLightConfigs(fallbackConfigs, fallbackShiftWindow, now4));
       }
+      const resolvedSummaries = await Promise.all(summaryPromises);
+      for (const groupSummaries of resolvedSummaries) {
+        groupSummaries.forEach((summary, workspaceId) => summaries.set(workspaceId, summary));
+      }
+      return summaries;
     }
-    return false;
+    const shiftWindow = this.resolveLightShiftWindow(shiftConfig, timezone, overrideDate, overrideShiftId, now4);
+    const configs = await this.resolveWorkspaceLightConfigs(workspaces);
+    return this.summarizeResolvedLightConfigs(configs, shiftWindow, now4);
+  }
+  async getWorkspaceLightTimeline(workspaceId, lineId, passedShiftConfig, passedTimezone, overrideDate, overrideShiftId, now4 = /* @__PURE__ */ new Date()) {
+    if (!workspaceId) {
+      throw new Error("workspaceId is required to fetch light timeline");
+    }
+    const dashboardConfig = _getDashboardConfigInstance();
+    const shiftConfig = passedShiftConfig || dashboardConfig?.shiftConfig;
+    const timezone = passedTimezone || shiftConfig?.timezone || dashboardConfig?.dateTimeConfig?.defaultTimezone || "UTC";
+    const shiftWindow = this.resolveLightShiftWindow(shiftConfig, timezone, overrideDate, overrideShiftId, now4);
+    const configs = await this.resolveWorkspaceLightConfigs([{ workspace_id: workspaceId, line_id: lineId }]);
+    const config = configs.get(workspaceId);
+    if (!config) {
+      return this.emptyLightTimeline(shiftWindow, timezone);
+    }
+    const intervals = await this.fetchLightIntervals([config.bulbIp], shiftWindow.shiftStartDate, shiftWindow.windowEndDate);
+    const summary = this.summarizeLightIntervals(intervals, shiftWindow.shiftStartDate, shiftWindow.windowEndDate, now4);
+    const hasData = summary.totalObservedSeconds > 0;
+    const points = [];
+    if (hasData) {
+      for (let minuteIndex = 0; minuteIndex < shiftWindow.totalMinutes; minuteIndex++) {
+        const minuteStart = dateFns.addMinutes(shiftWindow.shiftStartDate, minuteIndex);
+        const minuteEnd = dateFns.addMinutes(minuteStart, 1);
+        const timestamp = dateFnsTz.formatInTimeZone(minuteStart, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX");
+        let status = "pending";
+        if (minuteIndex < shiftWindow.completedMinutes) {
+          const matchingInterval = intervals.find((interval) => {
+            if (!this.isLightStatus(interval.status)) return false;
+            const start = new Date(interval.started_at);
+            const end = interval.ended_at ? new Date(interval.ended_at) : shiftWindow.windowEndDate;
+            return start < minuteEnd && end > minuteStart;
+          });
+          status = this.isLightStatus(matchingInterval?.status) ? matchingInterval.status : "pending";
+        }
+        points.push({ minuteIndex, timestamp, status });
+      }
+    }
+    const statusSegments = intervals.filter((interval) => interval.status === "down" || interval.status === "unknown").reduce((segments, interval) => {
+      const range = this.getLightIntervalEffectiveRange(interval, shiftWindow.shiftStartDate, shiftWindow.windowEndDate);
+      if (!range || !this.isLightStatus(interval.status)) return segments;
+      const startMinuteIndex = Math.max(0, Math.floor((range.start.getTime() - shiftWindow.shiftStartDate.getTime()) / 6e4));
+      const endMinuteIndex = Math.min(
+        shiftWindow.totalMinutes,
+        Math.ceil((range.end.getTime() - shiftWindow.shiftStartDate.getTime()) / 6e4)
+      );
+      segments.push({
+        status: interval.status,
+        startMinuteIndex,
+        endMinuteIndex,
+        startTime: dateFnsTz.formatInTimeZone(range.start, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+        endTime: dateFnsTz.formatInTimeZone(range.end, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+        durationSeconds: range.seconds,
+        durationMinutes: Math.ceil(range.seconds / 60),
+        isCurrent: interval.ended_at == null,
+        lastError: interval.last_error || null
+      });
+      return segments;
+    }, []).sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+    return {
+      shiftId: shiftWindow.shiftId,
+      shiftLabel: shiftWindow.shiftLabel,
+      shiftStart: dateFnsTz.formatInTimeZone(shiftWindow.shiftStartDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+      shiftEnd: dateFnsTz.formatInTimeZone(shiftWindow.shiftEndDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
+      totalMinutes: shiftWindow.totalMinutes,
+      completedMinutes: shiftWindow.completedMinutes,
+      upSeconds: summary.upSeconds,
+      downSeconds: summary.downSeconds,
+      unknownSeconds: summary.unknownSeconds,
+      totalObservedSeconds: summary.totalObservedSeconds,
+      downtimeSeconds: summary.downSeconds,
+      uptimePercentage: summary.uptimePercent,
+      hasData,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      bulbIp: config.bulbIp,
+      currentStatus: summary.currentStatus,
+      currentStartedAt: summary.currentStartedAt,
+      currentDurationSeconds: summary.currentDurationSeconds,
+      lastSeenAt: summary.lastSeenAt,
+      lastError: summary.lastError,
+      points,
+      statusSegments
+    };
   }
   async getWorkspaceHealthStatus(options = {}) {
     const supabase = _getSupabaseInstance();
@@ -6930,7 +7555,8 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
           timezone,
           options.lineShiftConfigs,
           options.date,
-          options.shiftId
+          options.shiftId,
+          options.lineId
         );
       } catch (error2) {
         console.error("Error calculating uptime:", error2);
@@ -6995,6 +7621,27 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
     } catch (e) {
       console.error("Error filtering workspaces:", e);
     }
+    if (filteredData.length > 0) {
+      try {
+        const lightSummaries = await this.getWorkspaceLightSummaries(
+          filteredData,
+          shiftConfig,
+          timezone,
+          options.date,
+          options.shiftId,
+          /* @__PURE__ */ new Date(),
+          options.lineShiftConfigs
+        );
+        if (lightSummaries.size > 0) {
+          filteredData = filteredData.map((workspace) => {
+            const lightSummary = lightSummaries.get(workspace.workspace_id);
+            return lightSummary ? { ...workspace, lightSummary } : workspace;
+          });
+        }
+      } catch (error2) {
+        console.error("Error calculating light uptime summaries:", error2);
+      }
+    }
     if (options.status) {
       filteredData = filteredData.filter((item) => item.status === options.status);
     }
@@ -7023,7 +7670,7 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
     }
     return filteredData;
   }
-  async getWorkspaceUptimeTimeline(workspaceId, companyId, passedShiftConfig, passedTimezone, overrideDate, overrideShiftId) {
+  async getWorkspaceUptimeTimeline(workspaceId, companyId, passedShiftConfig, passedTimezone, overrideDate, overrideShiftId, lineId) {
     if (!workspaceId) {
       throw new Error("workspaceId is required to fetch uptime timeline");
     }
@@ -7042,6 +7689,19 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
     const currentTiming = this.getShiftTiming(timezone, shiftConfig);
     const queryDate = overrideDate ?? currentTiming.date;
     const queryShiftId = overrideShiftId ?? currentTiming.shiftId;
+    if (lineId) {
+      const backendTimeline = await this.fetchBackendWorkspaceUptimeTimeline(
+        workspaceId,
+        companyId,
+        lineId,
+        queryDate,
+        queryShiftId,
+        timezone
+      );
+      if (backendTimeline) {
+        return backendTimeline;
+      }
+    }
     let shiftStartDate;
     let shiftEndDate;
     let totalMinutes;
@@ -7090,18 +7750,17 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
     }
     const mergedRecords = this.mergeRecordsByWorkspace(Array.isArray(data) ? data : []);
     const record = mergedRecords.length > 0 ? mergedRecords[0] : null;
-    const outputHourly = this.normalizeOutputHourly(record?.output_hourly || {});
+    const outputHourly = normalizeOutputHourly(record?.output_hourly || {});
     const outputArray = Array.isArray(record?.output_array) ? record.output_array : [];
-    const hasData = Boolean(
-      record && this.hasCompletedTimelineData(
-        completedMinutes,
-        shiftStartDate,
-        outputHourly,
-        outputArray,
-        timezone
-      )
-    );
-    if (!hasData) {
+    const uptime = record ? computeWorkspaceUptime({
+      totalMinutes,
+      completedMinutes,
+      shiftStartDate,
+      outputHourly,
+      outputArray,
+      timezone
+    }) : null;
+    if (!uptime?.hasData) {
       return {
         shiftId: queryShiftId,
         shiftLabel,
@@ -7119,80 +7778,6 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
         downtimeSegments: []
       };
     }
-    const points = [];
-    let uptimeMinutes = 0;
-    let downtimeMinutes = 0;
-    const MIN_DOWNTIME_MINUTES = 2;
-    for (let minuteIndex = 0; minuteIndex < totalMinutes; minuteIndex++) {
-      const minuteDate = dateFns.addMinutes(shiftStartDate, minuteIndex);
-      const timestamp = dateFnsTz.formatInTimeZone(minuteDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX");
-      let status;
-      if (minuteIndex < completedMinutes) {
-        status = this.deriveStatusForMinute(
-          minuteIndex,
-          minuteDate,
-          outputHourly,
-          outputArray,
-          timezone
-        );
-        if (status === "up") {
-          uptimeMinutes += 1;
-        } else {
-          downtimeMinutes += 1;
-        }
-      } else {
-        status = "pending";
-      }
-      points.push({
-        minuteIndex,
-        timestamp,
-        status
-      });
-    }
-    const downtimeSegments = [];
-    let currentSegmentStart = null;
-    const pushSegment = (startIndex, endIndex) => {
-      if (endIndex <= startIndex) return;
-      const segmentStartDate = dateFns.addMinutes(shiftStartDate, startIndex);
-      const segmentEndDate = dateFns.addMinutes(shiftStartDate, endIndex);
-      downtimeSegments.push({
-        startMinuteIndex: startIndex,
-        endMinuteIndex: endIndex,
-        startTime: dateFnsTz.formatInTimeZone(segmentStartDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
-        endTime: dateFnsTz.formatInTimeZone(segmentEndDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
-        durationMinutes: endIndex - startIndex
-      });
-    };
-    for (let i = 0; i < completedMinutes; i++) {
-      const point = points[i];
-      if (point.status === "down") {
-        if (currentSegmentStart === null) {
-          currentSegmentStart = i;
-        }
-      } else if (currentSegmentStart !== null) {
-        pushSegment(currentSegmentStart, i);
-        currentSegmentStart = null;
-      }
-    }
-    if (currentSegmentStart !== null) {
-      pushSegment(currentSegmentStart, completedMinutes);
-    }
-    const filteredSegments = [];
-    downtimeSegments.forEach((segment) => {
-      if (segment.durationMinutes >= MIN_DOWNTIME_MINUTES) {
-        filteredSegments.push(segment);
-      } else {
-        for (let i = segment.startMinuteIndex; i < segment.endMinuteIndex; i++) {
-          if (points[i] && points[i].status === "down") {
-            points[i].status = "up";
-            downtimeMinutes = Math.max(0, downtimeMinutes - 1);
-            uptimeMinutes += 1;
-          }
-        }
-      }
-    });
-    const completedWindow = Math.max(1, uptimeMinutes + downtimeMinutes);
-    const uptimePercentage = completedMinutes > 0 ? Number((uptimeMinutes / completedWindow * 100).toFixed(1)) : 100;
     return {
       shiftId: queryShiftId,
       shiftLabel,
@@ -7200,14 +7785,14 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
       shiftEnd: dateFnsTz.formatInTimeZone(shiftEndDate, timezone, "yyyy-MM-dd'T'HH:mm:ssXXX"),
       totalMinutes,
       completedMinutes,
-      uptimeMinutes,
-      downtimeMinutes,
+      uptimeMinutes: uptime.uptimeMinutes,
+      downtimeMinutes: uptime.downtimeMinutes,
       pendingMinutes,
-      uptimePercentage,
+      uptimePercentage: uptime.uptimePercentage,
       hasData: true,
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      points,
-      downtimeSegments: filteredSegments
+      points: uptime.points,
+      downtimeSegments: uptime.downtimeSegments
     };
   }
   async getWorkspaceHealthById(workspaceId) {
@@ -7319,7 +7904,7 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
   getUptimeMapKey(lineId, workspaceId) {
     return lineId ? `${lineId}::${workspaceId}` : workspaceId;
   }
-  async calculateWorkspaceUptime(companyId, passedShiftConfig, timezone, lineShiftConfigs, overrideDate, overrideShiftId) {
+  async calculateWorkspaceUptime(companyId, passedShiftConfig, timezone, lineShiftConfigs, overrideDate, overrideShiftId, lineId) {
     const supabase = _getSupabaseInstance();
     if (!supabase) throw new Error("Supabase client not initialized");
     const dashboardConfig = _getDashboardConfigInstance();
@@ -7341,6 +7926,16 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
     const currentTiming = this.getShiftTiming(effectiveTimezone, shiftConfig);
     const queryDate = overrideDate ?? currentTiming.date;
     const queryShiftId = overrideShiftId ?? currentTiming.shiftId;
+    const backendUptime = await this.fetchBackendWorkspaceUptimeSummaries(
+      companyId,
+      lineId ? [lineId] : void 0,
+      queryDate,
+      queryShiftId,
+      effectiveTimezone
+    );
+    if (backendUptime) {
+      return backendUptime;
+    }
     let shiftStartDate = currentTiming.shiftStartDate;
     let completedMinutes = currentTiming.completedMinutes;
     const isHistoricalDate = overrideDate && overrideDate !== currentTiming.date;
@@ -7364,50 +7959,21 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
       const uptimeMap = /* @__PURE__ */ new Map();
       const mergedRecords = this.mergeRecordsByWorkspace(queryData || []);
       for (const record of mergedRecords) {
-        const outputHourly = this.normalizeOutputHourly(record.output_hourly || {});
+        const outputHourly = normalizeOutputHourly(record.output_hourly || {});
         const outputArray = Array.isArray(record.output_array) ? record.output_array : [];
-        let uptimeMinutes = 0;
-        let downtimeMinutes = 0;
-        const MIN_DOWNTIME_MINUTES = 2;
-        let currentDownRun = 0;
-        for (let minuteIndex = 0; minuteIndex < completedMinutes; minuteIndex++) {
-          const minuteDate = dateFns.addMinutes(shiftStartDate, minuteIndex);
-          const status = this.deriveStatusForMinute(
-            minuteIndex,
-            minuteDate,
-            outputHourly,
-            outputArray,
-            effectiveTimezone
-          );
-          if (status === "down") {
-            currentDownRun += 1;
-          } else {
-            if (currentDownRun > 0) {
-              if (currentDownRun >= MIN_DOWNTIME_MINUTES) {
-                downtimeMinutes += currentDownRun;
-              } else {
-                uptimeMinutes += currentDownRun;
-              }
-              currentDownRun = 0;
-            }
-            uptimeMinutes += 1;
-          }
-        }
-        if (currentDownRun > 0) {
-          if (currentDownRun >= MIN_DOWNTIME_MINUTES) {
-            downtimeMinutes += currentDownRun;
-          } else {
-            uptimeMinutes += currentDownRun;
-          }
-          currentDownRun = 0;
-        }
-        const completedWindow = uptimeMinutes + downtimeMinutes;
-        const percentage = completedWindow > 0 ? Number((uptimeMinutes / completedWindow * 100).toFixed(1)) : 100;
+        const uptime = computeWorkspaceUptime({
+          totalMinutes: completedMinutes,
+          completedMinutes,
+          shiftStartDate,
+          outputHourly,
+          outputArray,
+          timezone: effectiveTimezone
+        });
         const mapKey = this.getUptimeMapKey(record.line_id, record.workspace_id);
         uptimeMap.set(mapKey, {
           expectedMinutes: completedMinutes,
-          actualMinutes: uptimeMinutes,
-          percentage,
+          actualMinutes: uptime.uptimeMinutes,
+          percentage: completedMinutes > 0 ? uptime.uptimePercentage : 100,
           lastCalculated: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
@@ -7460,6 +8026,26 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
       }
       uniqueQueries.get(key).lineConfigs.push({ lineId, shiftStartDate, completedMinutes });
     });
+    const backendUptimeMap = /* @__PURE__ */ new Map();
+    let backendAvailable = true;
+    for (const { date, shiftId, lineConfigs } of uniqueQueries.values()) {
+      const lineIds = Array.from(new Set(lineConfigs.map((lc) => lc.lineId).filter(Boolean)));
+      const result = await this.fetchBackendWorkspaceUptimeSummaries(
+        companyId,
+        lineIds,
+        date,
+        shiftId,
+        timezone
+      );
+      if (result === null) {
+        backendAvailable = false;
+        break;
+      }
+      result.forEach((value, key) => backendUptimeMap.set(key, value));
+    }
+    if (backendAvailable) {
+      return backendUptimeMap;
+    }
     console.log(`[calculateWorkspaceUptimeMultiLine] Querying ${uniqueQueries.size} unique date/shift combinations for ${lineShiftConfigs.size} lines`);
     uniqueQueries.forEach((queryConfig, key) => {
       console.log(`[calculateWorkspaceUptimeMultiLine] Query batch ${key}:`, {
@@ -7511,49 +8097,21 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
           continue;
         }
         const { shiftStartDate, completedMinutes } = lineConfig;
-        const outputHourly = this.normalizeOutputHourly(record.output_hourly || {});
+        const outputHourly = normalizeOutputHourly(record.output_hourly || {});
         const outputArray = Array.isArray(record.output_array) ? record.output_array : [];
-        let uptimeMinutes = 0;
-        let downtimeMinutes = 0;
-        const MIN_DOWNTIME_MINUTES = 2;
-        let currentDownRun = 0;
-        for (let minuteIndex = 0; minuteIndex < completedMinutes; minuteIndex++) {
-          const minuteDate = dateFns.addMinutes(shiftStartDate, minuteIndex);
-          const status = this.deriveStatusForMinute(
-            minuteIndex,
-            minuteDate,
-            outputHourly,
-            outputArray,
-            timezone
-          );
-          if (status === "down") {
-            currentDownRun += 1;
-          } else {
-            if (currentDownRun > 0) {
-              if (currentDownRun >= MIN_DOWNTIME_MINUTES) {
-                downtimeMinutes += currentDownRun;
-              } else {
-                uptimeMinutes += currentDownRun;
-              }
-              currentDownRun = 0;
-            }
-            uptimeMinutes += 1;
-          }
-        }
-        if (currentDownRun > 0) {
-          if (currentDownRun >= MIN_DOWNTIME_MINUTES) {
-            downtimeMinutes += currentDownRun;
-          } else {
-            uptimeMinutes += currentDownRun;
-          }
-        }
-        const completedWindow = uptimeMinutes + downtimeMinutes;
-        const percentage = completedWindow > 0 ? Number((uptimeMinutes / completedWindow * 100).toFixed(1)) : 100;
+        const uptime = computeWorkspaceUptime({
+          totalMinutes: completedMinutes,
+          completedMinutes,
+          shiftStartDate,
+          outputHourly,
+          outputArray,
+          timezone
+        });
         const mapKey = this.getUptimeMapKey(record.line_id, record.workspace_id);
         uptimeMap.set(mapKey, {
           expectedMinutes: completedMinutes,
-          actualMinutes: uptimeMinutes,
-          percentage,
+          actualMinutes: uptime.uptimeMinutes,
+          percentage: completedMinutes > 0 ? uptime.uptimePercentage : 100,
           lastCalculated: (/* @__PURE__ */ new Date()).toISOString()
         });
         console.log(`[calculateWorkspaceUptimeMultiLine] Storing uptime:`, {
@@ -7562,8 +8120,8 @@ var WorkspaceHealthService = class _WorkspaceHealthService {
           workspaceId: record.workspace_id,
           workspaceDisplayName: record.workspace_display_name,
           expectedMinutes: completedMinutes,
-          actualMinutes: uptimeMinutes,
-          percentage
+          actualMinutes: uptime.uptimeMinutes,
+          percentage: completedMinutes > 0 ? uptime.uptimePercentage : 100
         });
       }
     }
@@ -13820,12 +14378,22 @@ var stripSeconds = (timeStr) => {
   if (!timeStr) return timeStr;
   return timeStr.substring(0, 5);
 };
+var normalizeOffDays = (value) => {
+  if (!value) return [];
+  if (Array.isArray(value)) {
+    return value.map((day) => String(day || "").trim().toLowerCase()).filter(Boolean);
+  }
+  if (Array.isArray(value.off_days)) return normalizeOffDays(value.off_days);
+  if (Array.isArray(value.offDays)) return normalizeOffDays(value.offDays);
+  return [];
+};
 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),
+    offDays: normalizeOffDays(row.off_days),
     breaks: (() => {
       const raw = Array.isArray(row.breaks) ? row.breaks : Array.isArray(row.breaks?.breaks) ? row.breaks.breaks : [];
       return raw.map((b) => ({
@@ -13885,7 +14453,7 @@ var fetchAndStoreShiftConfig = async (supabase, lineId, fallback) => {
   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);
+      const { data, error } = await supabase.from("line_operating_hours").select("line_id, shift_id, shift_name, start_time, end_time, breaks, timezone, off_days").eq("line_id", lineId);
       if (error) {
         throw new Error(`Failed to fetch shift config: ${error.message}`);
       }
@@ -14578,7 +15146,7 @@ var useMultiLineShiftConfigs = (lineIds, fallbackConfig) => {
           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);
+        const { data, error: fetchError } = await supabase.from("line_operating_hours").select("line_id, shift_id, shift_name, start_time, end_time, breaks, timezone, off_days").in("line_id", missingLineIds);
         if (fetchError) {
           console.error("[useMultiLineShiftConfigs] Error fetching shift configs:", fetchError);
           throw new Error(`Failed to fetch shift configs: ${fetchError.message}`);
@@ -20794,7 +21362,8 @@ var useWorkspaceUptimeTimeline = (options) => {
         effectiveShiftConfig,
         effectiveTimezone,
         overrideDate,
-        overrideShiftId
+        overrideShiftId,
+        lineId
       );
       setTimeline(data);
     } catch (err) {
@@ -20804,7 +21373,89 @@ var useWorkspaceUptimeTimeline = (options) => {
       setLoading(false);
       isFetchingRef.current = false;
     }
-  }, [enabled, workspaceId, companyId, effectiveShiftConfig, effectiveTimezone, shiftConfigPending, overrideDate, overrideShiftId]);
+  }, [enabled, workspaceId, companyId, effectiveShiftConfig, effectiveTimezone, shiftConfigPending, overrideDate, overrideShiftId, lineId]);
+  React125.useEffect(() => {
+    fetchTimeline();
+  }, [fetchTimeline]);
+  React125.useEffect(() => {
+    if (!refreshInterval || refreshInterval <= 0 || !enabled) {
+      return;
+    }
+    intervalRef.current = setInterval(() => {
+      fetchTimeline();
+    }, refreshInterval);
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    };
+  }, [refreshInterval, enabled, fetchTimeline]);
+  return {
+    timeline,
+    loading: loading || shiftConfigPending,
+    error,
+    refetch: fetchTimeline
+  };
+};
+var useWorkspaceLightTimeline = (options) => {
+  const {
+    workspaceId,
+    lineId,
+    enabled = true,
+    refreshInterval,
+    shiftConfig: passedShiftConfig,
+    timezone: passedTimezone,
+    date: overrideDate,
+    shiftId: overrideShiftId
+  } = options;
+  const { shiftConfig: dynamicShiftConfig, isLoading: isShiftConfigLoading } = useDynamicShiftConfig(lineId);
+  const appTimezone = useAppTimezone();
+  const shiftConfigPending = !passedShiftConfig && (!lineId || isShiftConfigLoading || !dynamicShiftConfig);
+  const effectiveShiftConfig = passedShiftConfig ?? (shiftConfigPending ? void 0 : dynamicShiftConfig);
+  const effectiveTimezone = passedTimezone || appTimezone || effectiveShiftConfig?.timezone || "UTC";
+  const [timeline, setTimeline] = React125.useState(null);
+  const [loading, setLoading] = React125.useState(false);
+  const [error, setError] = React125.useState(null);
+  const isFetchingRef = React125.useRef(false);
+  const intervalRef = React125.useRef(null);
+  React125.useEffect(() => {
+    setTimeline(null);
+    setError(null);
+    setLoading(enabled && Boolean(workspaceId));
+  }, [workspaceId, lineId, enabled]);
+  const fetchTimeline = React125.useCallback(async () => {
+    if (!enabled) return;
+    if (shiftConfigPending) {
+      setLoading(true);
+      return;
+    }
+    if (!effectiveShiftConfig || !workspaceId) {
+      setLoading(false);
+      setTimeline(null);
+      return;
+    }
+    if (isFetchingRef.current) return;
+    try {
+      isFetchingRef.current = true;
+      setLoading(true);
+      setError(null);
+      const data = await workspaceHealthService.getWorkspaceLightTimeline(
+        workspaceId,
+        lineId,
+        effectiveShiftConfig,
+        effectiveTimezone,
+        overrideDate,
+        overrideShiftId
+      );
+      setTimeline(data);
+    } catch (err) {
+      console.error("[useWorkspaceLightTimeline] Failed to fetch light timeline:", err);
+      setError({ message: err?.message || "Failed to load light timeline", code: err?.code || "FETCH_ERROR" });
+    } finally {
+      setLoading(false);
+      isFetchingRef.current = false;
+    }
+  }, [enabled, workspaceId, lineId, effectiveShiftConfig, effectiveTimezone, shiftConfigPending, overrideDate, overrideShiftId]);
   React125.useEffect(() => {
     fetchTimeline();
   }, [fetchTimeline]);
@@ -37808,7 +38459,12 @@ var HourlyOutputChartComponent = ({
   }, [idleBarState.visible, idleBarState.key, idleBarState.shouldAnimate]);
   const maxDataValue = Math.max(...data, 0);
   const numericChartTargets = chartData.map((d) => d.target).filter((target) => target !== null && Number.isFinite(target));
-  const maxTargetValue = Math.max(...numericChartTargets, pphThreshold, 0);
+  const hasAuthoritativeNumericTargets = hasHourlyTargetOutputProp && numericChartTargets.length > 0;
+  const maxTargetValue = Math.max(
+    ...numericChartTargets,
+    hasAuthoritativeNumericTargets ? 0 : pphThreshold,
+    0
+  );
   const maxYValue = Math.max(
     Math.ceil(maxTargetValue * 1.5),
     Math.ceil(maxDataValue * 1.15)
@@ -37963,14 +38619,9 @@ var HourlyOutputChartComponent = ({
     return /* @__PURE__ */ jsxRuntime.jsx("g", { children: lines });
   }, [hourlyTargetSegments, targetTimelineSegments, SHIFT_DURATION, pphThreshold, targetLineEndOffset, hasHourlyTargetOutputProp]);
   const renderLegend = () => {
-    const uniqueTargets = [...new Set(
-      chartData.map((d) => d.target).filter((target) => target !== null && Number.isFinite(target)).map((target) => Math.round(target))
-    )].sort((a, b) => a - b);
-    const unitLabel = hasHourlyTargetOutputProp ? "units" : "units/hr";
-    const targetText = uniqueTargets.length === 0 ? `Target` : uniqueTargets.length === 1 ? `Target: ${uniqueTargets[0]} ${unitLabel}` : `Target: ${uniqueTargets[0]} - ${uniqueTargets[uniqueTargets.length - 1]} ${unitLabel}`;
     return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center text-sm text-gray-600 bg-white py-1", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 border border-gray-100 rounded-full px-3 py-1", children: [
       /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-8 flex items-center", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-full border-t-2 border-[#E34329] border-dashed" }) }),
-      /* @__PURE__ */ jsxRuntime.jsx("span", { children: targetText })
+      /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Target" })
     ] }) });
   };
   return /* @__PURE__ */ jsxRuntime.jsxs(
@@ -52488,6 +53139,106 @@ var getOrdinal = (n) => {
   const v = n % 100;
   return n + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
 };
+var resolveDailyTargetOutput = (shiftData) => {
+  if (!shiftData || shiftData.hasData === false) return 0;
+  const target = Number(shiftData?.targetOutput || shiftData?.idealOutput || 0);
+  return Number.isFinite(target) && target > 0 ? target : 0;
+};
+var getUniqueRoundedTargets = (data) => Array.from(new Set(
+  data.map((entry) => Number(entry.targetOutput || 0)).filter((target) => Number.isFinite(target) && target > 0).map((target) => Math.round(target))
+)).sort((a, b) => a - b);
+var formatDailyTargetLegend = (targets) => {
+  if (targets.length === 0) return "";
+  if (targets.length === 1) return `Target: ${targets[0].toLocaleString()} units/day`;
+  return `Target: ${targets[0].toLocaleString()} - ${targets[targets.length - 1].toLocaleString()} units/day`;
+};
+var WEEKDAY_NAMES = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+var getShiftOffDays = (shiftConfig, selectedShiftId) => {
+  const shift = shiftConfig?.shifts?.find((candidate) => candidate.shiftId === selectedShiftId);
+  const raw = shift?.offDays || shift?.off_days || [];
+  return Array.isArray(raw) ? raw.map((day) => String(day || "").trim().toLowerCase()).filter(Boolean) : [];
+};
+var isScheduledOffDay = (dateKey, shiftConfig, selectedShiftId) => {
+  const offDays = getShiftOffDays(shiftConfig, selectedShiftId);
+  if (offDays.length === 0) return false;
+  const date = parseDateKeyToDate(dateKey);
+  return offDays.includes(WEEKDAY_NAMES[date.getDay()]);
+};
+var renderDailyOutputCapsules = (props, data) => {
+  const { offset, yAxisMap } = props;
+  if (!offset || !yAxisMap || data.length === 0) return null;
+  const { left, width } = offset;
+  const yAxis = yAxisMap.default || yAxisMap[0];
+  if (!Number.isFinite(left) || !Number.isFinite(width) || width <= 0 || !yAxis?.scale) {
+    return null;
+  }
+  const slotWidth = width / data.length;
+  const capsuleWidth = Math.max(10, Math.min(28, slotWidth * 0.44));
+  const radius = capsuleWidth / 2;
+  const baseY = yAxis.scale(0);
+  const capsules = [];
+  data.forEach((entry, index) => {
+    const target = Number(entry.targetOutput || 0);
+    const output = Number(entry.output || 0);
+    if ((!Number.isFinite(target) || target <= 0) && (!Number.isFinite(output) || output <= 0)) return;
+    const x = left + index * slotWidth + (slotWidth - capsuleWidth) / 2;
+    const targetTop = target > 0 ? yAxis.scale(target) : yAxis.scale(output);
+    const capsuleTop = Math.min(targetTop, baseY - 4);
+    const capsuleHeight = Math.max(baseY - capsuleTop, 4);
+    const fillValue = target > 0 ? Math.min(Math.max(output, 0), target) : Math.max(output, 0);
+    const fillTop = fillValue > 0 ? Math.max(yAxis.scale(fillValue), capsuleTop) : baseY;
+    const fillHeight = Math.max(baseY - fillTop, 0);
+    const fillColor = target > 0 ? output >= target ? "#00AB45" : "#E34329" : entry.color || "#6b7280";
+    const trackFill = output >= target ? "#f0fdf4" : "#fff5f3";
+    const trackStroke = output >= target ? "#00AB45" : "#E34329";
+    const clipId = `line-daily-output-capsule-${index}`;
+    capsules.push(
+      /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("defs", { children: /* @__PURE__ */ jsxRuntime.jsx("clipPath", { id: clipId, children: /* @__PURE__ */ jsxRuntime.jsx(
+          "rect",
+          {
+            x,
+            y: capsuleTop,
+            width: capsuleWidth,
+            height: capsuleHeight,
+            rx: radius,
+            ry: radius
+          }
+        ) }) }),
+        target > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+          "rect",
+          {
+            "data-testid": "daily-target-capsule-track",
+            x,
+            y: capsuleTop,
+            width: capsuleWidth,
+            height: capsuleHeight,
+            rx: radius,
+            ry: radius,
+            fill: trackFill,
+            stroke: trackStroke,
+            strokeWidth: 1.5
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "rect",
+          {
+            "data-testid": "daily-output-capsule-fill",
+            x,
+            y: fillTop,
+            width: capsuleWidth,
+            height: fillHeight,
+            rx: fillHeight >= capsuleHeight ? radius : 0,
+            ry: fillHeight >= capsuleHeight ? radius : 0,
+            fill: fillColor,
+            clipPath: target > 0 ? `url(#${clipId})` : void 0
+          }
+        )
+      ] }, `daily-output-capsule-${index}`)
+    );
+  });
+  return capsules.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx("g", { children: capsules }) : null;
+};
 var CustomTooltip2 = ({ active, payload, label, isUptimeMode }) => {
   if (!active || !payload || payload.length === 0) return null;
   if (isUptimeMode) {
@@ -52571,6 +53322,7 @@ var LineMonthlyHistory = ({
   legend,
   monitoringMode,
   lineAssembly = false,
+  shiftConfig,
   underperformingWorkspaces = {},
   lineId,
   selectedShiftId = 0,
@@ -52588,6 +53340,13 @@ var LineMonthlyHistory = ({
   const { isIdleTimeVlmEnabled } = useIdleTimeVlmConfig();
   const idleTimeVlmEnabled = isIdleTimeVlmEnabled(lineId);
   const isUptimeMode = monitoringMode === "uptime";
+  const [isMobile, setIsMobile] = React125.useState(false);
+  React125.useEffect(() => {
+    const checkMobile = () => setIsMobile(window.innerWidth < 640);
+    checkMobile();
+    window.addEventListener("resize", checkMobile);
+    return () => window.removeEventListener("resize", checkMobile);
+  }, []);
   const chartKey = React125.useMemo(() => `${lineId}-${month}-${year}-${selectedShiftId}-${rangeStart}-${rangeEnd}`, [lineId, month, year, selectedShiftId, rangeStart, rangeEnd]);
   const monthBounds = React125.useMemo(() => getMonthKeyBounds(year, month), [year, month]);
   const normalizedRange = React125.useMemo(() => {
@@ -52749,29 +53508,21 @@ var LineMonthlyHistory = ({
         });
       }
       const yAxisMax2 = maxHours > 0 ? 100 : 1;
-      return { data: dailyData2, maxOutput: 0, lastSetTarget: 0, yAxisMax: yAxisMax2 };
+      return { data: dailyData2, maxOutput: 0, targetValues: [], yAxisMax: yAxisMax2, targetLegend: "" };
     }
     const dailyData = [];
     let maxOutput = 0;
-    let lastSetTarget = 0;
-    for (let i = rangeDateKeys.length - 1; i >= 0; i--) {
-      const dayKey = rangeDateKeys[i];
-      const dayData = analysisMonthlyDataByKey.get(dayKey);
-      const shiftData = dayData ? getShiftData2(dayData, selectedShiftId) : null;
-      const idealOutput = shiftData ? shiftData.idealOutput || 0 : 0;
-      if (idealOutput > 0) {
-        lastSetTarget = idealOutput;
-        break;
-      }
-    }
+    let maxTarget = 0;
     for (const dayKey of rangeDateKeys) {
       const day = Number(dayKey.slice(-2));
       const dayData = analysisMonthlyDataByKey.get(dayKey);
+      const isOffDay = isScheduledOffDay(dayKey, shiftConfig, selectedShiftId);
       const shiftData = dayData ? getShiftData2(dayData, selectedShiftId) : null;
-      const output = shiftData && hasRealData(shiftData) ? shiftData.output || 0 : 0;
-      const idealOutput = shiftData ? shiftData.idealOutput || 0 : 0;
+      const output = !isOffDay && shiftData && hasRealData(shiftData) ? shiftData.output || 0 : 0;
+      const targetOutput = isOffDay ? 0 : resolveDailyTargetOutput(shiftData);
       if (output > maxOutput) maxOutput = output;
-      const color2 = output >= lastSetTarget ? "#00AB45" : "#E34329";
+      if (targetOutput > maxTarget) maxTarget = targetOutput;
+      const color2 = targetOutput > 0 && output >= targetOutput ? "#00AB45" : "#E34329";
       dailyData.push({
         hour: getOrdinal(day),
         // Using ordinal format (1st, 2nd, 3rd, etc.)
@@ -52779,17 +53530,25 @@ var LineMonthlyHistory = ({
         output,
         originalOutput: output,
         // For label display
-        idealOutput,
+        idealOutput: targetOutput,
+        targetOutput,
         color: color2
       });
     }
-    const calculatedMax = Math.max(maxOutput, lastSetTarget);
+    const calculatedMax = Math.max(maxOutput, maxTarget);
     const yAxisMax = calculatedMax > 0 ? calculatedMax * 1.1 : 100;
-    return { data: dailyData, maxOutput, lastSetTarget, yAxisMax };
-  }, [analysisMonthlyDataByKey, normalizedRange.endKey, normalizedRange.startKey, selectedShiftId, isUptimeMode, timezone]);
+    const targetValues = getUniqueRoundedTargets(dailyData);
+    return {
+      data: dailyData,
+      maxOutput,
+      targetValues,
+      yAxisMax,
+      targetLegend: formatDailyTargetLegend(targetValues)
+    };
+  }, [analysisMonthlyDataByKey, normalizedRange.endKey, normalizedRange.startKey, selectedShiftId, isUptimeMode, timezone, shiftConfig]);
   const yAxisTicks = React125.useMemo(() => {
     const max = chartData.yAxisMax;
-    const target = chartData.lastSetTarget;
+    const targets = chartData.targetValues || [];
     if (!max || max <= 0) return void 0;
     const desiredIntervals = 4;
     const roughStep = max / desiredIntervals;
@@ -52803,11 +53562,18 @@ var LineMonthlyHistory = ({
     for (let v = 0; v <= max; v += step) {
       ticks.push(Math.round(v));
     }
-    if (target > 0) {
-      ticks.push(Math.round(target));
-    }
+    targets.forEach((target) => ticks.push(Math.round(target)));
     return Array.from(new Set(ticks)).filter((v) => v >= 0 && v <= max).sort((a, b) => a - b);
-  }, [chartData.yAxisMax, chartData.lastSetTarget]);
+  }, [chartData.yAxisMax, chartData.targetValues]);
+  const visibleYAxisTicks = React125.useMemo(() => {
+    if (!isMobile || isUptimeMode || !yAxisTicks || yAxisTicks.length <= 3) return yAxisTicks;
+    const importantTicks = /* @__PURE__ */ new Set([
+      0,
+      Math.round(chartData.yAxisMax),
+      ...chartData.targetValues || []
+    ]);
+    return yAxisTicks.filter((tick) => importantTicks.has(Math.round(tick))).sort((a, b) => a - b).slice(-3);
+  }, [chartData.targetValues, chartData.yAxisMax, isMobile, isUptimeMode, yAxisTicks]);
   const pieChartData = React125.useMemo(() => {
     if (!isUptimeMode) return [];
     const validShifts = (analysisMonthlyData || []).map((day) => getShiftData2(day, selectedShiftId)).filter(
@@ -53126,36 +53892,35 @@ var LineMonthlyHistory = ({
         ] }),
         /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bg-white rounded-lg sm:rounded-xl shadow-sm border border-gray-100 p-2 sm:p-3 lg:p-4", children: [
           /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-xs sm:text-sm font-bold text-gray-700 mb-1 sm:mb-2 text-left", children: isUptimeMode ? "Daily Utilization" : "Daily Output" }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-[160px] sm:h-[180px] lg:h-[220px]", children: /* @__PURE__ */ jsxRuntime.jsx(recharts.ResponsiveContainer, { width: "100%", height: "100%", children: /* @__PURE__ */ jsxRuntime.jsxs(
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-[140px] sm:h-[180px] lg:h-[220px]", children: /* @__PURE__ */ jsxRuntime.jsx(recharts.ResponsiveContainer, { width: "100%", height: "100%", children: /* @__PURE__ */ jsxRuntime.jsxs(
             recharts.BarChart,
             {
               data: chartData.data,
-              margin: { top: 20, right: 10, bottom: 40, left: 10 },
+              margin: isMobile ? { top: 8, right: 4, bottom: 28, left: 0 } : { top: 20, right: 10, bottom: 40, left: 10 },
               children: [
                 /* @__PURE__ */ jsxRuntime.jsx(recharts.CartesianGrid, { strokeDasharray: "3 3", vertical: false, stroke: "#f3f4f6" }),
                 /* @__PURE__ */ jsxRuntime.jsx(
                   recharts.XAxis,
                   {
                     dataKey: "hour",
-                    tick: { fontSize: 10, fill: "#6b7280" },
-                    interval: 0,
+                    tick: { fontSize: isMobile ? 9 : 10, fill: "#6b7280" },
+                    interval: isMobile ? 3 : 0,
                     angle: -45,
                     textAnchor: "end",
-                    height: 60
+                    height: isMobile ? 42 : 60
                   }
                 ),
                 /* @__PURE__ */ jsxRuntime.jsx(
                   recharts.YAxis,
                   {
                     domain: [0, chartData.yAxisMax],
-                    width: 40,
-                    ticks: isUptimeMode ? [0, 25, 50, 75, 100] : yAxisTicks,
+                    width: isMobile ? 34 : 40,
+                    ticks: isUptimeMode ? [0, 25, 50, 75, 100] : visibleYAxisTicks,
                     tickFormatter: isUptimeMode ? (value) => `${value}%` : void 0,
                     tick: isUptimeMode ? void 0 : (props) => {
                       const { x, y, payload } = props;
                       const value = Math.round(payload.value);
-                      const targetValue = Math.round(chartData.lastSetTarget);
-                      const isTarget = value === targetValue && targetValue > 0;
+                      const isTarget = (chartData.targetValues || []).includes(value);
                       return /* @__PURE__ */ jsxRuntime.jsx(
                         "text",
                         {
@@ -53178,15 +53943,7 @@ var LineMonthlyHistory = ({
                     content: (props) => /* @__PURE__ */ jsxRuntime.jsx(CustomTooltip2, { ...props, isUptimeMode })
                   }
                 ),
-                !isUptimeMode && chartData.lastSetTarget > 0 && /* @__PURE__ */ jsxRuntime.jsx(
-                  recharts.ReferenceLine,
-                  {
-                    y: chartData.lastSetTarget,
-                    stroke: "#E34329",
-                    strokeDasharray: "5 5",
-                    strokeWidth: 2
-                  }
-                ),
+                !isUptimeMode && /* @__PURE__ */ jsxRuntime.jsx(recharts.Customized, { component: (props) => renderDailyOutputCapsules(props, chartData.data) }),
                 isUptimeMode ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
                   /* @__PURE__ */ jsxRuntime.jsx(
                     recharts.Bar,
@@ -53219,6 +53976,8 @@ var LineMonthlyHistory = ({
                   {
                     dataKey: "output",
                     radius: [4, 4, 0, 0],
+                    fill: "transparent",
+                    opacity: 0,
                     isAnimationActive: true,
                     animationBegin: 0,
                     animationDuration: 1e3,
@@ -53237,13 +53996,9 @@ var LineMonthlyHistory = ({
             },
             chartKey
           ) }) }),
-          !isUptimeMode && chartData.lastSetTarget > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center text-sm text-gray-600 bg-white py-1 pt-2", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 border border-gray-100 rounded-full px-3 py-1", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-8 flex items-center", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-full border-t-2 border-[#E34329] border-dashed" }) }),
-            /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
-              "Target: ",
-              Math.round(chartData.lastSetTarget),
-              " units/day"
-            ] })
+          !isUptimeMode && chartData.targetValues.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center text-sm text-gray-600 bg-white py-1 pt-2", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 border border-gray-100 rounded-full px-3 py-1", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative h-5 w-3 rounded-full border border-[#E34329] bg-[#fff5f3] overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute inset-x-0 bottom-0 h-1/2 bg-[#E34329]" }) }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { children: chartData.targetLegend })
           ] }) })
         ] })
       ] })
@@ -55166,6 +55921,106 @@ var formatCycleSeconds = (value) => {
   if (!Number.isFinite(value)) return "0.0s";
   return `${value.toFixed(1)}s`;
 };
+var resolveDailyTargetOutput2 = (shiftData) => {
+  if (!shiftData || shiftData.hasData === false) return 0;
+  const target = Number(shiftData?.targetOutput || shiftData?.idealOutput || 0);
+  return Number.isFinite(target) && target > 0 ? target : 0;
+};
+var getUniqueRoundedTargets2 = (data) => Array.from(new Set(
+  data.map((entry) => Number(entry.targetOutput || 0)).filter((target) => Number.isFinite(target) && target > 0).map((target) => Math.round(target))
+)).sort((a, b) => a - b);
+var formatDailyTargetLegend2 = (targets) => {
+  if (targets.length === 0) return "";
+  if (targets.length === 1) return `Target: ${targets[0].toLocaleString()} units/day`;
+  return `Target: ${targets[0].toLocaleString()} - ${targets[targets.length - 1].toLocaleString()} units/day`;
+};
+var WEEKDAY_NAMES2 = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+var getShiftOffDays2 = (shiftConfig, selectedShiftId) => {
+  const shift = shiftConfig?.shifts?.find((candidate) => candidate.shiftId === selectedShiftId);
+  const raw = shift?.offDays || shift?.off_days || [];
+  return Array.isArray(raw) ? raw.map((day) => String(day || "").trim().toLowerCase()).filter(Boolean) : [];
+};
+var isScheduledOffDay2 = (dateKey, shiftConfig, selectedShiftId) => {
+  const offDays = getShiftOffDays2(shiftConfig, selectedShiftId);
+  if (offDays.length === 0) return false;
+  const date = parseDateKeyToDate(dateKey);
+  return offDays.includes(WEEKDAY_NAMES2[date.getDay()]);
+};
+var renderDailyOutputCapsules2 = (props, data) => {
+  const { offset, yAxisMap } = props;
+  if (!offset || !yAxisMap || data.length === 0) return null;
+  const { left, width } = offset;
+  const yAxis = yAxisMap.default || yAxisMap[0];
+  if (!Number.isFinite(left) || !Number.isFinite(width) || width <= 0 || !yAxis?.scale) {
+    return null;
+  }
+  const slotWidth = width / data.length;
+  const capsuleWidth = Math.max(10, Math.min(28, slotWidth * 0.44));
+  const radius = capsuleWidth / 2;
+  const baseY = yAxis.scale(0);
+  const capsules = [];
+  data.forEach((entry, index) => {
+    const target = Number(entry.targetOutput || 0);
+    const output = Number(entry.output || 0);
+    if ((!Number.isFinite(target) || target <= 0) && (!Number.isFinite(output) || output <= 0)) return;
+    const x = left + index * slotWidth + (slotWidth - capsuleWidth) / 2;
+    const targetTop = target > 0 ? yAxis.scale(target) : yAxis.scale(output);
+    const capsuleTop = Math.min(targetTop, baseY - 4);
+    const capsuleHeight = Math.max(baseY - capsuleTop, 4);
+    const fillValue = target > 0 ? Math.min(Math.max(output, 0), target) : Math.max(output, 0);
+    const fillTop = fillValue > 0 ? Math.max(yAxis.scale(fillValue), capsuleTop) : baseY;
+    const fillHeight = Math.max(baseY - fillTop, 0);
+    const fillColor = target > 0 ? output >= target ? "#00AB45" : "#E34329" : entry.color || "#6b7280";
+    const trackFill = output >= target ? "#f0fdf4" : "#fff5f3";
+    const trackStroke = output >= target ? "#00AB45" : "#E34329";
+    const clipId = `workspace-daily-output-capsule-${index}`;
+    capsules.push(
+      /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("defs", { children: /* @__PURE__ */ jsxRuntime.jsx("clipPath", { id: clipId, children: /* @__PURE__ */ jsxRuntime.jsx(
+          "rect",
+          {
+            x,
+            y: capsuleTop,
+            width: capsuleWidth,
+            height: capsuleHeight,
+            rx: radius,
+            ry: radius
+          }
+        ) }) }),
+        target > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+          "rect",
+          {
+            "data-testid": "daily-target-capsule-track",
+            x,
+            y: capsuleTop,
+            width: capsuleWidth,
+            height: capsuleHeight,
+            rx: radius,
+            ry: radius,
+            fill: trackFill,
+            stroke: trackStroke,
+            strokeWidth: 1.5
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "rect",
+          {
+            "data-testid": "daily-output-capsule-fill",
+            x,
+            y: fillTop,
+            width: capsuleWidth,
+            height: fillHeight,
+            rx: fillHeight >= capsuleHeight ? radius : 0,
+            ry: fillHeight >= capsuleHeight ? radius : 0,
+            fill: fillColor,
+            clipPath: target > 0 ? `url(#${clipId})` : void 0
+          }
+        )
+      ] }, `daily-output-capsule-${index}`)
+    );
+  });
+  return capsules.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx("g", { children: capsules }) : null;
+};
 var CustomTooltip3 = ({ active, payload, label, isUptimeMode }) => {
   if (!active || !payload || payload.length === 0) return null;
   if (isUptimeMode) {
@@ -55345,28 +56200,20 @@ var WorkspaceMonthlyHistory = ({
         });
       }
       const yAxisMax2 = maxHours > 0 ? maxHours * 1.1 : 1;
-      return { data: dailyData, yAxisMax: yAxisMax2, lastSetTarget: 0 };
+      return { data: dailyData, yAxisMax: yAxisMax2, targetValues: [], targetLegend: "" };
     }
     let maxOutput = 0;
-    let lastSetTarget = 0;
-    for (let i = rangeDateKeys.length - 1; i >= 0; i--) {
-      const dateKey = rangeDateKeys[i];
-      const dayData = analysisMonthlyDataByKey.get(dateKey);
-      const shiftData = dayData ? getShiftData(dayData, selectedShiftId) : null;
-      const idealOutput = shiftData ? shiftData.idealOutput : 0;
-      if (idealOutput > 0) {
-        lastSetTarget = idealOutput;
-        break;
-      }
-    }
+    let maxTarget = 0;
     for (const dateKey of rangeDateKeys) {
       const dayData = analysisMonthlyDataByKey.get(dateKey);
       const dayNumber = Number(dateKey.slice(-2));
+      const isOffDay = isScheduledOffDay2(dateKey, shiftConfig, selectedShiftId);
       const shiftData = dayData ? getShiftData(dayData, selectedShiftId) : null;
-      const output = shiftData && hasRealData(shiftData) ? shiftData.output : 0;
-      const idealOutput = shiftData ? shiftData.idealOutput : 0;
+      const output = !isOffDay && shiftData && hasRealData(shiftData) ? shiftData.output : 0;
+      const targetOutput = isOffDay ? 0 : resolveDailyTargetOutput2(shiftData);
       if (output > maxOutput) maxOutput = output;
-      const color2 = output >= lastSetTarget ? "#00AB45" : "#E34329";
+      if (targetOutput > maxTarget) maxTarget = targetOutput;
+      const color2 = targetOutput > 0 && output >= targetOutput ? "#00AB45" : "#E34329";
       dailyData.push({
         hour: getOrdinal2(dayNumber),
         // Using ordinal format (1st, 2nd, 3rd, etc.)
@@ -55374,21 +56221,29 @@ var WorkspaceMonthlyHistory = ({
         output,
         originalOutput: output,
         // For label display
-        idealOutput,
+        idealOutput: targetOutput,
+        targetOutput,
         efficiency: shiftData && hasRealData(shiftData) ? shiftData.efficiency : 0,
         color: color2,
         idleMinutes: 0
         // Not used but keeps structure consistent
       });
     }
-    const calculatedMax = Math.max(maxOutput, lastSetTarget);
+    const calculatedMax = Math.max(maxOutput, maxTarget);
     const yAxisMax = calculatedMax > 0 ? calculatedMax * 1.1 : 100;
-    return { data: dailyData, maxOutput, lastSetTarget, yAxisMax };
-  }, [analysisMonthlyDataByKey, rangeDateKeys, selectedShiftId, isUptimeMode, shiftWorkSeconds]);
+    const targetValues = getUniqueRoundedTargets2(dailyData);
+    return {
+      data: dailyData,
+      maxOutput,
+      targetValues,
+      yAxisMax,
+      targetLegend: formatDailyTargetLegend2(targetValues)
+    };
+  }, [analysisMonthlyDataByKey, rangeDateKeys, selectedShiftId, isUptimeMode, shiftConfig, shiftWorkSeconds]);
   const yAxisTicks = React125.useMemo(() => {
     if (isUptimeMode) return void 0;
     const max = chartData.yAxisMax;
-    const target = chartData.lastSetTarget;
+    const targets = chartData.targetValues || [];
     if (!max || max <= 0) return void 0;
     const desiredIntervals = 4;
     const roughStep = max / desiredIntervals;
@@ -55402,7 +56257,7 @@ var WorkspaceMonthlyHistory = ({
     for (let v = 0; v <= max; v += step) {
       ticks.push(Math.round(v));
     }
-    if (target > 0) {
+    targets.forEach((target) => {
       const roundedTarget = Math.round(target);
       if (!ticks.includes(roundedTarget)) {
         let nearestIndex = -1;
@@ -55421,9 +56276,18 @@ var WorkspaceMonthlyHistory = ({
           ticks.push(roundedTarget);
         }
       }
-    }
+    });
     return ticks.filter((v) => v >= 0 && v <= max * 1.05).sort((a, b) => a - b);
-  }, [chartData.yAxisMax, chartData.lastSetTarget, isUptimeMode]);
+  }, [chartData.yAxisMax, chartData.targetValues, isUptimeMode]);
+  const visibleYAxisTicks = React125.useMemo(() => {
+    if (!isMobile || isUptimeMode || !yAxisTicks || yAxisTicks.length <= 3) return yAxisTicks;
+    const importantTicks = /* @__PURE__ */ new Set([
+      0,
+      Math.round(chartData.yAxisMax),
+      ...chartData.targetValues || []
+    ]);
+    return yAxisTicks.filter((tick) => importantTicks.has(Math.round(tick))).sort((a, b) => a - b).slice(-3);
+  }, [chartData.targetValues, chartData.yAxisMax, isMobile, isUptimeMode, yAxisTicks]);
   const pieChartData = React125.useMemo(() => {
     const aggregateMode = isUptimeMode ? "uptime" : "output";
     const validShifts = analysisMonthlyData.map((d) => getShiftData(d, selectedShiftId)).filter(
@@ -55813,22 +56677,22 @@ var WorkspaceMonthlyHistory = ({
         ] }),
         (!isAssemblyWorkspace || isUptimeMode) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bg-white rounded-lg shadow-sm border border-gray-100 p-4 flex-1", children: [
           /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-bold text-gray-700 mb-3 text-left", children: isUptimeMode ? "Daily Utilization" : "Daily Output" }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { style: { height: "220px" }, children: /* @__PURE__ */ jsxRuntime.jsx(recharts.ResponsiveContainer, { width: "100%", height: "100%", children: /* @__PURE__ */ jsxRuntime.jsxs(
+          /* @__PURE__ */ jsxRuntime.jsx("div", { style: { height: isMobile ? "150px" : "220px" }, children: /* @__PURE__ */ jsxRuntime.jsx(recharts.ResponsiveContainer, { width: "100%", height: "100%", children: /* @__PURE__ */ jsxRuntime.jsxs(
             recharts.BarChart,
             {
               data: chartData.data,
-              margin: { top: 20, right: 10, bottom: 40, left: 10 },
+              margin: isMobile ? { top: 8, right: 4, bottom: 28, left: 0 } : { top: 20, right: 10, bottom: 40, left: 10 },
               children: [
                 /* @__PURE__ */ jsxRuntime.jsx(recharts.CartesianGrid, { strokeDasharray: "3 3", vertical: false, stroke: "#f3f4f6" }),
                 /* @__PURE__ */ jsxRuntime.jsx(
                   recharts.XAxis,
                   {
                     dataKey: "hour",
-                    tick: { fontSize: 10, fill: "#6b7280" },
-                    interval: isMobile ? "preserveStartEnd" : 0,
+                    tick: { fontSize: isMobile ? 9 : 10, fill: "#6b7280" },
+                    interval: isMobile ? 3 : 0,
                     angle: -45,
                     textAnchor: "end",
-                    height: 60
+                    height: isMobile ? 42 : 60
                   }
                 ),
                 isUptimeMode ? /* @__PURE__ */ jsxRuntime.jsx(
@@ -55843,13 +56707,12 @@ var WorkspaceMonthlyHistory = ({
                   recharts.YAxis,
                   {
                     domain: [0, chartData.yAxisMax],
-                    width: 40,
-                    ticks: yAxisTicks,
+                    width: isMobile ? 34 : 40,
+                    ticks: visibleYAxisTicks,
                     tick: (props) => {
                       const { x, y, payload } = props;
                       const value = Math.round(payload.value);
-                      const targetValue = Math.round(chartData.lastSetTarget);
-                      const isTarget = value === targetValue && targetValue > 0;
+                      const isTarget = (chartData.targetValues || []).includes(value);
                       return /* @__PURE__ */ jsxRuntime.jsx(
                         "text",
                         {
@@ -55872,15 +56735,7 @@ var WorkspaceMonthlyHistory = ({
                     content: (props) => /* @__PURE__ */ jsxRuntime.jsx(CustomTooltip3, { ...props, isUptimeMode })
                   }
                 ),
-                !isUptimeMode && chartData.lastSetTarget > 0 && /* @__PURE__ */ jsxRuntime.jsx(
-                  recharts.ReferenceLine,
-                  {
-                    y: chartData.lastSetTarget,
-                    stroke: "#E34329",
-                    strokeDasharray: "5 5",
-                    strokeWidth: 2
-                  }
-                ),
+                !isUptimeMode && /* @__PURE__ */ jsxRuntime.jsx(recharts.Customized, { component: (props) => renderDailyOutputCapsules2(props, chartData.data) }),
                 isUptimeMode ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
                   /* @__PURE__ */ jsxRuntime.jsx(
                     recharts.Bar,
@@ -55913,6 +56768,8 @@ var WorkspaceMonthlyHistory = ({
                   {
                     dataKey: "output",
                     radius: [4, 4, 0, 0],
+                    fill: "transparent",
+                    opacity: 0,
                     isAnimationActive: true,
                     animationBegin: 0,
                     animationDuration: 1e3,
@@ -55956,13 +56813,9 @@ var WorkspaceMonthlyHistory = ({
               /* @__PURE__ */ jsxRuntime.jsx("span", { className: "w-2.5 h-2.5 rounded-full", style: { backgroundColor: "#e5e7eb" } }),
               /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-gray-600", children: "Idle" })
             ] })
-          ] }) : chartData.lastSetTarget > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-12 h-0.5 border-t-2 border-dashed", style: { borderColor: "#E34329" } }),
-            /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs text-gray-600", children: [
-              "Target: ",
-              Math.round(chartData.lastSetTarget),
-              " units/day"
-            ] })
+          ] }) : chartData.targetValues.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative h-5 w-3 rounded-full border border-[#E34329] bg-[#fff5f3] overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute inset-x-0 bottom-0 h-1/2 bg-[#E34329]" }) }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-gray-600", children: chartData.targetLegend })
           ] }) })
         ] })
       ] })
@@ -58029,7 +58882,14 @@ var WorkspaceHealthCard = ({
     event.stopPropagation();
     event.preventDefault();
     if (onViewDetails) {
-      onViewDetails(workspace);
+      onViewDetails(workspace, "camera", "card_button");
+    }
+  };
+  const handleLightChipClick = (event) => {
+    event.stopPropagation();
+    event.preventDefault();
+    if (onViewDetails) {
+      onViewDetails(workspace, "light", "light_chip");
     }
   };
   const handleKeyDown = (event) => {
@@ -58107,6 +58967,22 @@ var WorkspaceHealthCard = ({
     };
   };
   const downtimeConfig = getDowntimeConfig(workspace.uptimeDetails);
+  const hasLightConfig = Boolean(workspace.lightSummary?.hasLightConfig && workspace.lightSummary.bulbIp);
+  const lightStatus = workspace.lightSummary?.currentStatus || null;
+  const lightChipLabel = (() => {
+    if (!workspace.lightSummary) return "Light --";
+    if (lightStatus === "down") return "Light offline";
+    if (lightStatus === "unknown") return "Light unknown";
+    if (typeof workspace.lightSummary.uptimePercent === "number") {
+      return `Light ${workspace.lightSummary.uptimePercent.toFixed(1)}%`;
+    }
+    if (lightStatus === "up") return "Light operational";
+    return "Light --";
+  })();
+  const lightChipClassName = clsx(
+    "inline-flex items-center gap-1.5 rounded-full border px-2.5 py-1 text-xs font-semibold transition-all",
+    lightStatus === "down" ? "border-rose-200 bg-rose-50 text-rose-700 hover:bg-rose-100" : lightStatus === "unknown" ? "border-amber-200 bg-amber-50 text-amber-700 hover:bg-amber-100" : "border-emerald-200 bg-emerald-50 text-emerald-700 hover:bg-emerald-100"
+  );
   return /* @__PURE__ */ jsxRuntime.jsx(
     Card2,
     {
@@ -58176,6 +59052,20 @@ var WorkspaceHealthCard = ({
             /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium uppercase tracking-wide text-slate-500", children: "Camera IP:" }),
             /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium text-gray-700 dark:text-gray-300", children: "N/A" })
           ] }),
+          hasLightConfig && /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              type: "button",
+              onClick: handleLightChipClick,
+              className: lightChipClassName,
+              "aria-label": `Open light timeline for ${workspace.workspace_display_name || workspace.workspace_id}`,
+              title: workspace.lightSummary?.bulbIp ? `Bulb IP ${workspace.lightSummary.bulbIp}` : "Light timeline",
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Lightbulb, { className: "h-3.5 w-3.5" }),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { children: lightChipLabel })
+              ]
+            }
+          ),
           /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-3 pt-3 border-t border-slate-100 dark:border-slate-800", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
             /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium text-slate-500 uppercase tracking-wide", children: downtimeConfig.label }),
             /* @__PURE__ */ jsxRuntime.jsx("span", { className: clsx("text-sm font-semibold", downtimeConfig.className), children: downtimeConfig.text })
@@ -58245,7 +59135,7 @@ var CompactWorkspaceHealthCard = ({
     event.stopPropagation();
     event.preventDefault();
     if (onViewDetails) {
-      onViewDetails(workspace);
+      onViewDetails(workspace, "camera", "card_button");
     }
   };
   return /* @__PURE__ */ jsxRuntime.jsxs(
@@ -67592,6 +68482,17 @@ var setSessionSeenValue = (key) => {
 };
 var buildAllGreenCelebrationSeenKey = (identity) => `${ALL_GREEN_CELEBRATION_SEEN_PREFIX}${identity}`;
 var buildAllGreenMilestoneSeenKey = (identity, milestoneSeconds) => `${ALL_GREEN_MILESTONE_SEEN_PREFIX}${identity}:${milestoneSeconds}`;
+var LINE_SELECTOR_INDICATOR_VERSION = "incident_exclamation_v1";
+var LineSelectorIncidentIcon = ({ lineId }) => /* @__PURE__ */ jsxRuntime.jsx(
+  "span",
+  {
+    "data-testid": `line-selector-incident-icon-${lineId}`,
+    "aria-label": "Line needs attention",
+    role: "img",
+    className: "inline-flex h-5 w-5 flex-shrink-0 items-center justify-center rounded-full border border-rose-200 bg-white text-[13px] font-semibold leading-none text-rose-600 shadow-[0_1px_2px_rgba(15,23,42,0.06)]",
+    children: /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", className: "-mt-px", children: "!" })
+  }
+);
 var LoadingPageCmp = LoadingPage_default;
 var LoadingOverlayCmp = LoadingOverlay_default;
 function HomeView({
@@ -67931,25 +68832,49 @@ function HomeView({
   const currentIsCurrentScopeResolved = isBootstrapMonitorMode ? bootstrapMonitor.isCurrentScopeResolved : legacyIsCurrentScopeResolved;
   const currentMetricsError = isBootstrapMonitorMode ? bootstrapMonitor.error : legacyMetricsError;
   const currentRefetchMetrics = isBootstrapMonitorMode ? bootstrapMonitor.refetch : refetchLegacyMetrics;
-  const lineSelectorSignalStatusByLine = React125.useMemo(() => {
-    const statusByLine = /* @__PURE__ */ new Map();
+  const lineSelectorIndicatorByLine = React125.useMemo(() => {
+    const indicatorByLine = /* @__PURE__ */ new Map();
     const legend = currentEfficiencyLegend || DEFAULT_EFFICIENCY_LEGEND;
     const addRows = (rows) => {
       (rows || []).forEach((row) => {
         const lineId = typeof row?.line_id === "string" ? row.line_id : "";
-        if (!lineId || statusByLine.has(lineId)) {
+        if (!lineId) {
+          return;
+        }
+        if (row?.red_flow_incident?.active === true) {
+          indicatorByLine.set(lineId, "incident");
+          return;
+        }
+        if (indicatorByLine.get(lineId) === "incident") {
           return;
         }
         const status = getKpiSignalStatus(row?.line_signal, legend);
-        if (status) {
-          statusByLine.set(lineId, status);
+        if (status === "attention") {
+          indicatorByLine.set(lineId, "red");
         }
       });
     };
     addRows(currentSelectorLineMetrics);
     addRows(currentLineMetrics);
-    return statusByLine;
+    return indicatorByLine;
   }, [currentEfficiencyLegend, currentLineMetrics, currentSelectorLineMetrics]);
+  const lineSelectorIndicatorStats = React125.useMemo(() => {
+    let incidentLineCount = 0;
+    let redFlowLineCount = 0;
+    visibleLineIds.forEach((lineId) => {
+      const indicator = lineSelectorIndicatorByLine.get(lineId);
+      if (indicator === "incident") {
+        incidentLineCount += 1;
+      } else if (indicator === "red") {
+        redFlowLineCount += 1;
+      }
+    });
+    return {
+      incidentLineCount,
+      redFlowLineCount,
+      hasAnyIncident: incidentLineCount > 0
+    };
+  }, [lineSelectorIndicatorByLine, visibleLineIds]);
   const metricsDisplayNames = React125.useMemo(() => {
     const nextDisplayNames = {};
     currentWorkspaceMetrics.forEach((workspace) => {
@@ -68806,9 +69731,12 @@ function HomeView({
       new_line_ids: normalizedLineIds,
       selected_line_count: normalizedLineIds.length,
       selection_mode: isAllLinesSelection(normalizedLineIds) ? "all" : normalizedLineIds.length === 1 ? "single" : "custom",
+      incident_line_count: lineSelectorIndicatorStats.incidentLineCount,
+      red_flow_line_count: lineSelectorIndicatorStats.redFlowLineCount,
+      selector_indicator_version: LINE_SELECTOR_INDICATOR_VERSION,
       line_name: getLineSelectionLabel(normalizedLineIds)
     });
-  }, [factoryViewId, getLineSelectionLabel, getTrackedLineScope, selectedLineIds, selectedLineIdsKey, visibleLineIds]);
+  }, [factoryViewId, getLineSelectionLabel, getTrackedLineScope, lineSelectorIndicatorStats, selectedLineIds, selectedLineIdsKey, visibleLineIds]);
   React125.useCallback(() => {
     updateSelectedLineIds(visibleLineIds);
   }, [updateSelectedLineIds, visibleLineIds]);
@@ -68866,7 +69794,10 @@ function HomeView({
                 current_display_mode_label: getHomeDisplayModeLabel(displayMode),
                 selected_line_ids: selectedLineIds,
                 selected_line_count: selectedLineIds.length,
-                is_all_lines: isAllLinesSelection(selectedLineIds)
+                is_all_lines: isAllLinesSelection(selectedLineIds),
+                incident_line_count: lineSelectorIndicatorStats.incidentLineCount,
+                red_flow_line_count: lineSelectorIndicatorStats.redFlowLineCount,
+                selector_indicator_version: LINE_SELECTOR_INDICATOR_VERSION
               });
             }
           },
@@ -68907,8 +69838,8 @@ function HomeView({
         ] }),
         /* @__PURE__ */ jsxRuntime.jsx("div", { className: "max-h-56 space-y-0.5 overflow-y-auto pr-1", children: visibleLineIds.map((lineId) => {
           const isChecked = pendingSelectedLineIds.includes(lineId);
-          const signalStatus = lineSelectorSignalStatusByLine.get(lineId);
-          const signalDotClass = signalStatus === "stable" ? "bg-green-500" : signalStatus === "warning" ? "bg-yellow-400" : signalStatus === "attention" ? "bg-red-500" : "";
+          const selectorIndicator = lineSelectorIndicatorByLine.get(lineId);
+          const lineLabel = mergedLineNames[lineId] || `Line ${lineId.substring(0, 4)}`;
           return /* @__PURE__ */ jsxRuntime.jsxs(
             "label",
             {
@@ -68918,6 +69849,7 @@ function HomeView({
                   "input",
                   {
                     type: "checkbox",
+                    "aria-label": lineLabel,
                     className: "h-4 w-4 rounded border-slate-300 text-blue-600 focus:ring-blue-500",
                     checked: isChecked,
                     onChange: () => {
@@ -68933,12 +69865,12 @@ function HomeView({
                     }
                   }
                 ),
-                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-0 flex-1 truncate", children: mergedLineNames[lineId] || `Line ${lineId.substring(0, 4)}` }),
-                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex h-2.5 w-2.5 flex-shrink-0 items-center justify-center", children: signalStatus ? /* @__PURE__ */ jsxRuntime.jsx(
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-0 flex-1 truncate", children: lineLabel }),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex h-5 w-5 flex-shrink-0 items-center justify-center", children: selectorIndicator === "incident" ? /* @__PURE__ */ jsxRuntime.jsx(LineSelectorIncidentIcon, { lineId }) : selectorIndicator === "red" && !lineSelectorIndicatorStats.hasAnyIncident ? /* @__PURE__ */ jsxRuntime.jsx(
                   "span",
                   {
                     "data-testid": `line-selector-signal-dot-${lineId}`,
-                    className: `h-2 w-2 rounded-full ${signalDotClass}`,
+                    className: "h-2 w-2 rounded-full bg-red-500",
                     "aria-hidden": "true"
                   }
                 ) : null })
@@ -68970,7 +69902,8 @@ function HomeView({
     mergedLineNames,
     selectedLineIds,
     pendingSelectedLineIds,
-    lineSelectorSignalStatusByLine,
+    lineSelectorIndicatorByLine,
+    lineSelectorIndicatorStats,
     displayMode,
     slideshowActiveLineId,
     visibleLineIds,
@@ -83931,11 +84864,13 @@ var useWorkspaceHealth = (options) => {
 var STATUS_COLORS = {
   up: "bg-emerald-500",
   down: "bg-rose-500",
+  unknown: "bg-amber-400",
   pending: "bg-gray-200"
 };
 var STATUS_TITLES = {
   up: "Uptime",
   down: "Downtime",
+  unknown: "Unknown",
   pending: "Pending"
 };
 var formatTime4 = (date, timezone) => new Intl.DateTimeFormat("en-IN", {
@@ -83978,7 +84913,9 @@ var UptimeTimelineStrip = ({
   timezone,
   className = "",
   uptimePercentage = null,
-  downtimeMinutes = 0
+  downtimeMinutes = 0,
+  metricLabel = "uptime",
+  summaryText
 }) => {
   const segments = React125.useMemo(() => {
     if (!points.length || totalMinutes <= 0) return [];
@@ -84042,9 +84979,11 @@ var UptimeTimelineStrip = ({
     return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-full rounded-xl border border-dashed border-gray-200 bg-gray-50/50 p-6 text-center text-sm text-gray-600", children: "No uptime data available for this shift yet." });
   }
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `relative w-full ${className}`, children: [
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center mb-3 text-sm", children: typeof uptimePercentage === "number" ? /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-gray-900 font-semibold", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center mb-3 text-sm", children: summaryText ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-900 font-semibold", children: summaryText }) : typeof uptimePercentage === "number" ? /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-gray-900 font-semibold", children: [
       uptimePercentage.toFixed(1),
-      " % uptime ",
+      " % ",
+      metricLabel,
+      " ",
       downtimeMinutes > 0 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-gray-600 font-normal", children: [
         "(",
         formatDowntimeLabel(downtimeMinutes),
@@ -84112,6 +85051,27 @@ var formatDowntimeLabel2 = (minutes, includeSuffix = true) => {
   const label = formatDuration4(minutes);
   return includeSuffix ? `${label} down` : label;
 };
+var formatSecondsDuration = (seconds) => {
+  if (!seconds || seconds <= 0) return "0 min";
+  return formatDuration4(Math.max(1, Math.ceil(seconds / 60)));
+};
+var getLightStatusLabel = (status) => {
+  if (status === "up") return "operational";
+  if (status === "down") return "offline";
+  if (status === "unknown") return "unknown";
+  return "status unavailable";
+};
+var getLightDurationPrefix = (status) => {
+  if (status === "up") return "Operational";
+  if (status === "down") return "Offline";
+  if (status === "unknown") return "Unknown";
+  return "Current";
+};
+var formatLightError = (error) => {
+  if (!error) return null;
+  const cleaned = error.replace(/\s*\(after retry\)\s*$/i, "").trim();
+  return cleaned || null;
+};
 var formatTimeRange = (start, end, timezone) => {
   const formatter = new Intl.DateTimeFormat("en-IN", {
     hour: "numeric",
@@ -84127,12 +85087,15 @@ var WorkspaceUptimeDetailModal = ({
   onClose,
   shiftConfig: passedShiftConfig,
   date,
-  shiftId
+  shiftId,
+  initialMode = "camera"
 }) => {
   const timezone = useAppTimezone() || "UTC";
   const logsContainerRef = React125.useRef(null);
   const [showScrollIndicator, setShowScrollIndicator] = React125.useState(false);
+  const [activeMode, setActiveMode] = React125.useState(initialMode);
   const isHistorical = Boolean(date);
+  const hasLightTimeline = Boolean(workspace?.lightSummary?.hasLightConfig && workspace?.lightSummary?.bulbIp);
   const {
     timeline,
     loading,
@@ -84141,7 +85104,7 @@ var WorkspaceUptimeDetailModal = ({
   } = useWorkspaceUptimeTimeline({
     workspaceId: workspace?.workspace_id,
     companyId: workspace?.company_id,
-    enabled: isOpen && Boolean(workspace?.workspace_id && workspace?.company_id),
+    enabled: isOpen && activeMode === "camera" && Boolean(workspace?.workspace_id && workspace?.company_id),
     refreshInterval: isHistorical ? void 0 : 6e4,
     // Disable auto-refresh for historical
     lineId: workspace?.line_id,
@@ -84154,6 +85117,25 @@ var WorkspaceUptimeDetailModal = ({
     shiftId
     // Pass override shift ID for historical queries
   });
+  const {
+    timeline: lightTimeline,
+    loading: lightLoading,
+    error: lightError,
+    refetch: refetchLight
+  } = useWorkspaceLightTimeline({
+    workspaceId: workspace?.workspace_id,
+    enabled: isOpen && activeMode === "light" && hasLightTimeline && Boolean(workspace?.workspace_id),
+    refreshInterval: isHistorical ? void 0 : 6e4,
+    lineId: workspace?.line_id,
+    shiftConfig: passedShiftConfig || void 0,
+    timezone,
+    date,
+    shiftId
+  });
+  React125.useEffect(() => {
+    if (!isOpen) return;
+    setActiveMode(initialMode === "light" && hasLightTimeline ? "light" : "camera");
+  }, [hasLightTimeline, initialMode, isOpen]);
   React125.useEffect(() => {
     if (!isOpen || !workspace) return;
     const handleKeyDown = (event) => {
@@ -84166,13 +85148,21 @@ var WorkspaceUptimeDetailModal = ({
       window.removeEventListener("keydown", handleKeyDown);
     };
   }, [isOpen, onClose, workspace]);
-  const shiftStart = timeline ? new Date(timeline.shiftStart) : null;
-  const shiftEnd = timeline ? new Date(timeline.shiftEnd) : null;
+  const activeTimeline = activeMode === "light" ? lightTimeline : timeline;
+  const activeLoading = activeMode === "light" ? lightLoading : loading;
+  const activeError = activeMode === "light" ? lightError : error;
+  const activeRefetch = activeMode === "light" ? refetchLight : refetch;
+  const shiftStart = activeTimeline ? new Date(activeTimeline.shiftStart) : null;
+  const shiftEnd = activeTimeline ? new Date(activeTimeline.shiftEnd) : null;
   const downtimeSegments = timeline?.downtimeSegments || [];
   downtimeSegments.length;
   const downtimeMinutes = timeline?.downtimeMinutes ?? 0;
-  const hasTimelineData = Boolean(timeline?.hasData);
-  const uptimePercentage = hasTimelineData ? timeline?.uptimePercentage ?? workspace?.uptimePercentage ?? null : null;
+  const hasTimelineData = activeMode === "light" ? Boolean(lightTimeline?.hasData) : Boolean(timeline?.hasData);
+  const uptimePercentage = activeMode === "light" ? lightTimeline?.uptimePercentage ?? null : hasTimelineData ? timeline?.uptimePercentage ?? workspace?.uptimePercentage ?? null : null;
+  const lightStatus = lightTimeline?.currentStatus || workspace?.lightSummary?.currentStatus || null;
+  const lightStatusText = `Light ${getLightStatusLabel(lightStatus)}`;
+  const lightDurationText = lightTimeline?.currentDurationSeconds ? `${getLightDurationPrefix(lightStatus)} for ${formatSecondsDuration(lightTimeline.currentDurationSeconds)}` : null;
+  const lightLastError = formatLightError(lightTimeline?.lastError);
   const allInterruptionsSorted = React125.useMemo(
     () => [...downtimeSegments].sort(
       (a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime()
@@ -84194,7 +85184,7 @@ var WorkspaceUptimeDetailModal = ({
       container.addEventListener("scroll", checkScroll);
       return () => container.removeEventListener("scroll", checkScroll);
     }
-  }, [downtimeSegments]);
+  }, [downtimeSegments, lightTimeline?.statusSegments, activeMode]);
   const renderSegment = (segment) => {
     const start = new Date(segment.startTime);
     const end = new Date(segment.endTime);
@@ -84215,6 +85205,63 @@ var WorkspaceUptimeDetailModal = ({
       `${segment.startMinuteIndex}-${segment.endMinuteIndex}`
     );
   };
+  const renderLightSegment = (segment) => {
+    const start = new Date(segment.startTime);
+    const end = new Date(segment.endTime);
+    const startLabel = new Intl.DateTimeFormat("en-IN", {
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true,
+      timeZone: timezone
+    }).format(start);
+    const endLabel = segment.isCurrent ? "Now" : new Intl.DateTimeFormat("en-IN", {
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true,
+      timeZone: timezone
+    }).format(end);
+    const containerClasses = segment.status === "down" ? "border-rose-200 bg-rose-50" : "border-amber-200 bg-amber-50";
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: `rounded-lg border px-5 py-3 ${containerClasses}`,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-sm font-semibold text-gray-900", children: [
+            startLabel,
+            " - ",
+            endLabel
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-xs text-gray-600 mt-1", children: [
+            getLightDurationPrefix(segment.status),
+            " for ",
+            formatSecondsDuration(segment.durationSeconds)
+          ] }),
+          formatLightError(segment.lastError) && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-1 text-xs font-medium text-rose-700", children: formatLightError(segment.lastError) })
+        ]
+      },
+      `${segment.status}-${segment.startMinuteIndex}-${segment.endMinuteIndex}`
+    );
+  };
+  const handleModeChange = (mode) => {
+    if (mode === activeMode) return;
+    const previousMode = activeMode;
+    setActiveMode(mode);
+    trackCoreEvent("Health Timeline Mode Changed", {
+      previous_mode: previousMode,
+      selected_mode: mode,
+      source: "segmented_control",
+      workspace_id: workspace?.workspace_id,
+      line_id: workspace?.line_id
+    });
+  };
+  const handleRefresh = () => {
+    trackCoreEvent("Health Timeline Refreshed", {
+      mode: activeMode,
+      workspace_id: workspace?.workspace_id,
+      line_id: workspace?.line_id
+    });
+    activeRefetch();
+  };
   if (!isOpen || !workspace) {
     return null;
   }
@@ -84238,13 +85285,35 @@ var WorkspaceUptimeDetailModal = ({
               /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1 min-w-0 mr-4", children: [
                 /* @__PURE__ */ jsxRuntime.jsx("h2", { id: "uptime-detail-title", className: "text-2xl font-semibold text-gray-900 truncate mb-3", children: workspace.workspace_display_name || `Workspace ${workspace.workspace_id.slice(0, 6)}` }),
                 /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2.5 text-sm text-gray-600", children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium text-gray-900", children: timeline?.shiftLabel || "Current Shift" }),
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium text-gray-900", children: activeTimeline?.shiftLabel || "Current Shift" }),
                   shiftStart && shiftEnd && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
                     /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-300", children: "\u2022" }),
                     /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-600", children: formatTimeRange(shiftStart, shiftEnd, timezone) })
                   ] })
                 ] }),
-                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mt-2 flex flex-wrap items-center gap-2", children: [
+                hasLightTimeline && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mt-3 inline-flex rounded-lg border border-gray-200 bg-gray-50 p-0.5", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: () => handleModeChange("camera"),
+                      "aria-pressed": activeMode === "camera",
+                      className: `rounded-md px-3 py-1.5 text-sm font-medium transition-colors ${activeMode === "camera" ? "bg-white text-gray-900 shadow-sm" : "text-gray-600 hover:text-gray-900"}`,
+                      children: "Camera"
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: () => handleModeChange("light"),
+                      "aria-pressed": activeMode === "light",
+                      className: `rounded-md px-3 py-1.5 text-sm font-medium transition-colors ${activeMode === "light" ? "bg-white text-gray-900 shadow-sm" : "text-gray-600 hover:text-gray-900"}`,
+                      children: "Light"
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-2 flex flex-wrap items-center gap-2", children: activeMode === "camera" ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
                   /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
                     /* @__PURE__ */ jsxRuntime.jsx("div", { className: `w-2 h-2 rounded-full ${workspace.status === "healthy" ? "bg-emerald-500 animate-pulse" : workspace.status === "warning" ? "bg-amber-500" : "bg-rose-500"}` }),
                     /* @__PURE__ */ jsxRuntime.jsx("span", { className: `text-xs font-medium ${workspace.status === "healthy" ? "text-emerald-700" : workspace.status === "warning" ? "text-amber-700" : "text-rose-700"}`, children: workspace.status === "healthy" ? "Operational" : workspace.status === "warning" ? "Intermittent" : "Down" })
@@ -84261,17 +85330,37 @@ var WorkspaceUptimeDetailModal = ({
                       /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium text-slate-600 dark:text-slate-300 select-all", children: workspace.cameraIp })
                     ] })
                   ] })
-                ] })
+                ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                  /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: `w-2 h-2 rounded-full ${lightStatus === "up" ? "bg-emerald-500 animate-pulse" : lightStatus === "unknown" ? "bg-amber-500" : "bg-rose-500"}` }),
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { className: `text-xs font-medium ${lightStatus === "up" ? "text-emerald-700" : lightStatus === "unknown" ? "text-amber-700" : "text-rose-700"}`, children: lightStatusText })
+                  ] }),
+                  lightTimeline?.bulbIp && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-300", children: "\u2022" }),
+                    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5 bg-slate-50 px-2 py-0.5 rounded border border-slate-100", title: "Bulb IP", children: [
+                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Lightbulb, { className: "h-3 w-3 text-slate-400" }),
+                      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium text-slate-600 select-all", children: lightTimeline.bulbIp })
+                    ] })
+                  ] }),
+                  lightDurationText && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-300", children: "\u2022" }),
+                    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-gray-500", children: lightDurationText })
+                  ] }),
+                  lightLastError && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-300", children: "\u2022" }),
+                    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs font-medium text-rose-700", children: lightLastError })
+                  ] })
+                ] }) })
               ] }),
               /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 flex-shrink-0", children: [
                 /* @__PURE__ */ jsxRuntime.jsxs(
                   "button",
                   {
-                    onClick: refetch,
-                    disabled: loading,
+                    onClick: handleRefresh,
+                    disabled: activeLoading,
                     className: "inline-flex items-center gap-2 rounded-lg border border-gray-200 bg-white px-4 py-2 text-sm font-medium text-gray-700 hover:bg-gray-50 disabled:cursor-not-allowed disabled:opacity-50 transition-all duration-200 shadow-sm",
                     children: [
-                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: `h-4 w-4 ${loading ? "animate-spin" : ""}` }),
+                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: `h-4 w-4 ${activeLoading ? "animate-spin" : ""}` }),
                       /* @__PURE__ */ jsxRuntime.jsx("span", { className: "hidden sm:inline", children: "Refresh" })
                     ]
                   }
@@ -84287,31 +85376,63 @@ var WorkspaceUptimeDetailModal = ({
                 )
               ] })
             ] }),
-            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 overflow-y-auto", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-8 py-6 space-y-6", children: error ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "rounded-xl border border-rose-100 bg-rose-50 p-5 text-sm text-rose-700", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 overflow-y-auto", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-8 py-6 space-y-6", children: activeError ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "rounded-xl border border-rose-100 bg-rose-50 p-5 text-sm text-rose-700", children: [
               /* @__PURE__ */ jsxRuntime.jsx("p", { className: "font-semibold mb-1", children: "Unable to load uptime details" }),
-              /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-rose-600/90", children: error.message })
+              /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-rose-600/90", children: activeError.message })
             ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
               /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative pb-4 border-b border-gray-200", children: [
                 /* @__PURE__ */ jsxRuntime.jsx(
                   UptimeTimelineStrip_default,
                   {
-                    points: timeline?.points || [],
-                    totalMinutes: timeline?.totalMinutes || 0,
-                    shiftStart: timeline?.shiftStart || (/* @__PURE__ */ new Date()).toISOString(),
-                    shiftEnd: timeline?.shiftEnd || (/* @__PURE__ */ new Date()).toISOString(),
+                    points: activeTimeline?.points || [],
+                    totalMinutes: activeTimeline?.totalMinutes || 0,
+                    shiftStart: activeTimeline?.shiftStart || (/* @__PURE__ */ new Date()).toISOString(),
+                    shiftEnd: activeTimeline?.shiftEnd || (/* @__PURE__ */ new Date()).toISOString(),
                     timezone,
                     uptimePercentage,
-                    downtimeMinutes: hasTimelineData ? downtimeMinutes : 0
+                    downtimeMinutes: activeMode === "light" ? 0 : hasTimelineData ? downtimeMinutes : 0,
+                    metricLabel: activeMode === "light" ? "light uptime" : "uptime",
+                    summaryText: activeMode === "light" && typeof uptimePercentage === "number" ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                      uptimePercentage.toFixed(1),
+                      " % light uptime",
+                      (lightTimeline?.downSeconds || 0) > 0 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-gray-600 font-normal", children: [
+                        " (",
+                        formatSecondsDuration(lightTimeline?.downSeconds || 0),
+                        " offline)"
+                      ] }),
+                      (lightTimeline?.unknownSeconds || 0) > 0 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-gray-600 font-normal", children: [
+                        " (",
+                        formatSecondsDuration(lightTimeline?.unknownSeconds || 0),
+                        " unknown)"
+                      ] })
+                    ] }) : void 0
                   }
                 ),
-                loading && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-sm text-gray-600 mt-4", children: [
+                activeLoading && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-sm text-gray-600 mt-4", children: [
                   /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: "h-4 w-4 animate-spin text-gray-500" }),
                   /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Updating timeline\u2026" })
                 ] })
               ] }),
               /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "pt-4", children: [
-                /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-sm font-semibold text-gray-900 uppercase tracking-wider mb-3", children: "Downtime Logs" }),
-                !hasTimelineData ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-lg border border-gray-100 bg-gray-50/50 px-5 py-4 text-center", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-600", children: "No uptime data available for this shift." }) }) : downtimeSegments.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-lg border border-gray-100 bg-gray-50/50 px-5 py-4 text-center", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-600", children: "No downtime events recorded for this shift." }) }) : /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
+                /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-sm font-semibold text-gray-900 uppercase tracking-wider mb-3", children: activeMode === "light" ? "Light Status Logs" : "Downtime Logs" }),
+                activeMode === "light" ? !hasTimelineData ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-lg border border-gray-100 bg-gray-50/50 px-5 py-4 text-center", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-600", children: "No light status data available for this shift." }) }) : !lightTimeline?.statusSegments.length ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-lg border border-gray-100 bg-gray-50/50 px-5 py-4 text-center", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-600", children: "No light down or unknown events recorded for this shift." }) }) : /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "div",
+                    {
+                      ref: logsContainerRef,
+                      className: "max-h-[400px] overflow-y-auto space-y-2 pr-2",
+                      style: {
+                        scrollbarWidth: "thin",
+                        scrollbarColor: "#CBD5E0 #F7FAFC"
+                      },
+                      children: lightTimeline.statusSegments.map((segment) => renderLightSegment(segment))
+                    }
+                  ),
+                  showScrollIndicator && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute bottom-0 left-0 right-0 h-12 bg-gradient-to-t from-white via-white/80 to-transparent pointer-events-none flex items-end justify-center pb-2", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1 text-xs text-gray-500 animate-bounce", children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium", children: "Scroll for more" }),
+                    /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronDown, { className: "h-4 w-4" })
+                  ] }) })
+                ] }) : !hasTimelineData ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-lg border border-gray-100 bg-gray-50/50 px-5 py-4 text-center", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-600", children: "No uptime data available for this shift." }) }) : downtimeSegments.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-lg border border-gray-100 bg-gray-50/50 px-5 py-4 text-center", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-600", children: "No downtime events recorded for this shift." }) }) : /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
                   /* @__PURE__ */ jsxRuntime.jsx(
                     "div",
                     {
@@ -84358,6 +85479,7 @@ var WorkspaceHealthView = ({
   const timezone = useAppTimezone();
   const { shiftConfig, isLoading: isShiftConfigLoading } = useDynamicShiftConfig(effectiveLineIdForShiftConfig);
   const [selectedWorkspace, setSelectedWorkspace] = React125.useState(null);
+  const [selectedTimelineMode, setSelectedTimelineMode] = React125.useState("camera");
   const [selectedDate, setSelectedDate] = React125.useState(void 0);
   const [selectedShiftId, setSelectedShiftId] = React125.useState(void 0);
   const [showDatePicker, setShowDatePicker] = React125.useState(false);
@@ -84417,11 +85539,33 @@ var WorkspaceHealthView = ({
     },
     [router$1, onNavigate]
   );
-  const handleViewDetails = React125.useCallback((workspace) => {
+  const handleViewDetails = React125.useCallback((workspace, mode = "camera", source = "card_button") => {
+    const hasLightConfig = Boolean(workspace.lightSummary?.hasLightConfig && workspace.lightSummary?.bulbIp);
+    if (source === "light_chip") {
+      trackCoreEvent("Health Light Chip Clicked", {
+        workspace_id: workspace.workspace_id,
+        line_id: workspace.line_id,
+        light_status: workspace.lightSummary?.currentStatus || null,
+        uptime_percent: workspace.lightSummary?.uptimePercent ?? null,
+        bulb_ip_present: Boolean(workspace.lightSummary?.bulbIp)
+      });
+    }
+    trackCoreEvent("Health Timeline Opened", {
+      source,
+      initial_mode: mode,
+      workspace_id: workspace.workspace_id,
+      line_id: workspace.line_id,
+      has_light_config: hasLightConfig,
+      light_status: workspace.lightSummary?.currentStatus || null,
+      selected_date: selectedDate || operationalDate,
+      selected_shift_id: selectedShiftId ?? currentShiftDetails.shiftId
+    });
+    setSelectedTimelineMode(mode);
     setSelectedWorkspace(workspace);
-  }, []);
+  }, [currentShiftDetails.shiftId, operationalDate, selectedDate, selectedShiftId]);
   const handleCloseDetails = React125.useCallback(() => {
     setSelectedWorkspace(null);
+    setSelectedTimelineMode("camera");
   }, []);
   const getStatusIcon = (status) => {
     switch (status) {
@@ -84679,7 +85823,8 @@ var WorkspaceHealthView = ({
         onClose: handleCloseDetails,
         shiftConfig: modalShiftConfig,
         date: selectedDate,
-        shiftId: selectedShiftId
+        shiftId: selectedShiftId,
+        initialMode: selectedTimelineMode
       }
     )
   ] });
@@ -93495,6 +94640,7 @@ exports.useWorkspaceHealthById = useWorkspaceHealthById;
 exports.useWorkspaceHealthLastSeen = useWorkspaceHealthLastSeen;
 exports.useWorkspaceHealthStatus = useWorkspaceHealthStatus;
 exports.useWorkspaceHourSummary = useWorkspaceHourSummary;
+exports.useWorkspaceLightTimeline = useWorkspaceLightTimeline;
 exports.useWorkspaceMetrics = useWorkspaceMetrics;
 exports.useWorkspaceNavigation = useWorkspaceNavigation;
 exports.useWorkspaceOperators = useWorkspaceOperators;