@optifye/dashboard-core 6.12.50 → 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
         });
       }
     }
@@ -20804,7 +21362,8 @@ var useWorkspaceUptimeTimeline = (options) => {
         effectiveShiftConfig,
         effectiveTimezone,
         overrideDate,
-        overrideShiftId
+        overrideShiftId,
+        lineId
       );
       setTimeline(data);
     } catch (err) {
@@ -20814,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]);
@@ -58241,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) => {
@@ -58319,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,
     {
@@ -58388,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 })
@@ -58457,7 +59135,7 @@ var CompactWorkspaceHealthCard = ({
     event.stopPropagation();
     event.preventDefault();
     if (onViewDetails) {
-      onViewDetails(workspace);
+      onViewDetails(workspace, "camera", "card_button");
     }
   };
   return /* @__PURE__ */ jsxRuntime.jsxs(
@@ -84186,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", {
@@ -84233,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 [];
@@ -84297,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),
@@ -84367,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",
@@ -84382,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,
@@ -84396,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,
@@ -84409,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) => {
@@ -84421,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()
@@ -84449,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);
@@ -84470,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;
   }
@@ -84493,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" })
@@ -84516,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" })
                     ]
                   }
@@ -84542,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",
                     {
@@ -84613,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);
@@ -84672,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) {
@@ -84934,7 +85823,8 @@ var WorkspaceHealthView = ({
         onClose: handleCloseDetails,
         shiftConfig: modalShiftConfig,
         date: selectedDate,
-        shiftId: selectedShiftId
+        shiftId: selectedShiftId,
+        initialMode: selectedTimelineMode
       }
     )
   ] });
@@ -93750,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;